Номер неинтересного (который я полностью не выдумывал только для этой задачи) создаются следующим образом:

1. Возьмите положительное целое число N
2. Создайте новое число O, добавив цифры N в конце N
3. Финальный неинтересный номер O * N

Например, для N = 12:

1. O = 1212
2. O * N = 1212 * 12
3. Финальный номер 14544

вход

Целое положительное число N (N> 0) или эквивалент вашего языка. Вам не нужно ловить неправильный ввод.

Выход

Соответствующий неинтересный номер.

Контрольные примеры

  1 -> 11
  2 -> 44
  3 -> 99
 10 -> 10100
174 -> 30306276

счет

Самый короткий код в байтах побеждает.

05AB1E , 3 байта

Ы*

Разъяснения

Ð    # triplicate input
 «   # conactenate
  *  # multiply

Попробуйте онлайн

JavaScript (ES6), 10 байт

_=>(_+_)*_

Должен быть вызван с аргументом как, а Stringне как Number.

Использование:

(_=>(_+_)*_)('3')
99

-3 байта благодаря предложению @Quill .

Java 8, 29 26 25 21 байт

Боже, благослови лямбду

c->new Long(c+""+c)*c

c-> Long.decode (с + "" + с) * с;

VIM, 11

C<C-r>=<C-r>"<C-r>"*<C-r>"<cr>

crcrcrcrcr ...

C       change (delete and enter insert mode) until the end of the line
<C-r>=  insert an expression via the special "expression register"
<C-r>"  insert the contents of the default register (what we just C'd)
<C-r>"  ... again
*       multiplied by
<C-r>"  the input (again)
<cr>    insert the result of this expression

Pyth, 5 4 байта

*s+`

Объяснение:

    Q    input
   `     representation, basically str(Q)
  +  Q   add Q to its own string form
 s       parse int
*     Q  multiply by input
         print

Проверьте это здесь .

Emacs, 17 байт

(*SPACEC-SPACEC-EM-YSPACEC-YC-Y)C-J

объяснение

• (*SPACEдобавляет (*в точке (перед номером);
• C-SPACEC-EM-Y Выберите и скопируйте номер;
• SPACE добавляет символ пробела в точке (после числа);
• C-YC-Y вставляет в два раза больше числа в точке;
• )добавляет )в конце;
• C-J интерпретирует строку как выражение LISP и печатает ее результат.

Exemple

Курсор представлен трубкой ( |)

• |174
• (*SPACE (* |174
• C-SPACEC-EM-Y (* 174|
• SPACE (* 174 |
• C-YC-Y (* 174 174174|
• ) (* 174 174174)|
• C-J

Результат

(* 174 174174)
30306276|

C #, 19 23 байта

n=>int.Parse(""+n+n)*n;

Без строк, 47 байт

n=>{int i=1;while(i<=n)i*=10;return(i+1)*n*n;};

Python 2.7, 21 байт:

lambda f:int(`f`*2)*f

Ну, это должен быть самый короткий ответ Python, который я когда-либо писал за самое короткое время. Это анонимная лямбда-функция, которую можно выполнить, назвав ее как угодно, а затем вызвав ее, как обычную функцию, заключенную вprint() . Например, если ваш ввод 12и функция была названа H, это будет называться как print(H(12)).

Попробуйте онлайн! (Ideone)

Обратите внимание, что это работает только для значений выше и равно 9223372036854775807любому более высокому значению и repr()ставит a Lв конце целого числа. Следовательно, для значений больше, чем 9223372036854775807эта 24-байтовая версия будет работать:

lambda f:int(str(f)*2)*f

Попробуйте это онлайн! (Ideone)

Желе, 4 байта

;DḌ×

Попробуйте онлайн

объяснение

;DḌ×    Main link. argument : N

 D      Decimal; Yield the digits of N
;       Concatenate N and its digits
  Ḍ     Convert to integer; We get O
   ×    Multiply O and N

С 70 68 54 53 52 44

f(n){return(pow(10,(int)log10(n)+1)*n+n)*n;}

Предыдущая версия (48 байт, без математических функций), сэкономлено 16 байт благодаря @LeakyNun, 1 байт благодаря @FryAmTheEggman, 4 байта благодаря @TobySpeight:

f(n,d,i){for(i=d=n;d;d/=10)i*=10;return(i+n)*n;}

Вызов f() с одним аргументом номер, и он вернет соответствующий неинтересный номер.

Тестовая программа

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    while (*++argv) {
        int n = atoi(*argv);
        printf("%d -> %d\n", n, f(n));
    }
    return 0;
}

Результаты теста:

$ ./84712 1 2 3 4 10 174
1 -> 11
2 -> 44
3 -> 99
4 -> 176
10 -> 10100
174 -> 30306276

Попробуйте онлайн!

Dyalog APL , 7 байтов

⊢×#⍎⍕,⍕

⍕ строковое представление

⍕, предварительное представление строки

#⍎ превратить в число (в корневом пространстве имен)

⊢× умножить на оригинальное число

J 7 байт

*,~&.":

объяснение

*,~&.":  Input: n
     ":  Format n as a string
 ,~&.    Reflect and join the string to make "nn"
         and parse the string to get a number
*        Multiply that number by n

Сетчатка , 27 20 байт

^
$_$*: $_
:
$_$*:
:

Становится немного медленным для больших входов, потому что перед последним этапом результат представляется в унарном виде.

Попробуйте онлайн! (Первая строка включает набор тестов, разделенных переводом строки.)

объяснение

Я буду использовать 2 в качестве примера ввода (потому что унарные представления становятся немного громоздкими для больших входов).

Этап 1: Замена

^
$_$*: $_

Сопоставляя начало строки с, ^мы просто добавляем некоторые вещи. $_относится к самой входной строке и $*:означает, что мы вставляем столько двоеточий. Итак, мы получаем:

:: 22

Этап 2: Замена

:
$_$*:

Теперь мы сопоставляем каждое :и снова заменяем его $_$*:. Конечно, в этот раз $_вычисляется не целое число (но :: 22в нашем примере), а $*просто выполняется поиск первого десятичного числа в строке, поэтому он оценивает входные данные, сцепленные с самим собой ( Oв спецификации вызова). В итоге мы N*Oполучим двоеточия, а затем O:

:::::::::::::::::::::::::::::::::::::::::::: 22

Этап 3: Матч

:

Осталось только посчитать :s для преобразования из унарного обратно в десятичное, что и делает этот этап.

CJam , 8 байт

ri_`_+i*

Попробуйте онлайн!

r     e# Read input
i     e# Convert to integer
_     e# Duplicate
`     e# Convert to string
_     e# Duplicate
+     e# Concatenate
i     e# Convert to integer
*     e# Multiply. Implicitly display

Желе, 8 6 байт

ŒṘẋ2v×

Попробуйте онлайн!

объяснение

ŒṘẋ2v× - Main link. Left argument: the number to convert

     × - Multiply
    v  - an evaluation of the left argument
ŒṘ     - converted to string
  ẋ    - multiplied by
   2   - two and the left argument

Awk, 13 байт

$0=($0$0)*$0

Установите строку на 2 из себя умножается на себя

Брахилог , 7 байт

:?c:?*.

объяснение

:?c      Concatenate Input to itself
   :?*.  Output is that concatenation times Input

Python, 42 байта

Чисто арифметический подход, без строк!

f=lambda n,m=1:m<=n and f(n,m*10)or-~m*n*n

Идео это!

Matlab / Octave, 20 байтов

@(x)eval([x x 42 x])

Это анонимная функция, которая принимает входные данные в виде строки.

Пример использования:

>> f = @(x)eval([x x 42 x])
f = 
    @(x)eval([x,x,42,x])
>> f('12')
ans =
       14544

Или попробуйте онлайн с ideone .

объяснение

Код строит строку, конкатенируя входную строку дважды, затем символ *(который имеет код ASCII 42), затем строку снова. Связанная строка затем оценивается.

MATL , 6 байтов

tVthU*

Попробуйте онлайн!

tV     % Input number implicitly. Duplicate and convert to string
th     % Duplicate and concatenate the two equal strings
U      % Convert to number
*      % Multiply

зш, 13 байт

<<<$[$1$1*$1]

Принимает ввод в качестве аргумента командной строки, выводит в STDOUT.

Это работает только в Zsh, но вот 15 байт в Bash , используя echoвместо того , чтобы <<<:

echo $[$1$1*$1]

Perl, 11 байт

$_*=$_ x2

+ pиl флаги.

(беги с perl -ple '$_*=$_ x2')

-2 байта благодаря трубе.

Excel VBA, 35 байт

Sub вызывается с номером, msgbox возвращает ответ

Sub B(a)
MsgBox (a & a) * a
End Sub

Альтернативный Excel VBA, 42 байта

Число, указанное в формуле, возвращает ответ.

Function B(a)
B = (a & a) * a
End Function

Луа, 20 байт

Принимает аргумент командной строки и выводит через STDOUT

a=...print((a..a)*a)

И размазанный, как @LeakyNun спросил в комментарии :)

a=...       -- alias for the first argument
print(
     (a..a) -- concatenate a with itself, equivalent to a:rep(2)
     *a)    -- multiply the resulting number by a

Пайк, 5 4 байта

`+b*

Попробуй это здесь!

`    -    str(input)
 +   -   ^+input  (convert to string implicitly)
  b  -  int(^)
   * - ^*input

Также 5 байтов со строковыми входами

+bRb*
+]mbB

PHP, 25 24 байта

Короткие открывающие бирки полезны для удивительно немногих испытаний в гольф, к счастью, это одна из них. К сожалению, приоритет оператора является противоположностью порядка, в котором вы должны их выполнять, поэтому необходимо много скобок.

<?=($a=$argv[1])*"$a$a";

изменить: я понял, что, видя, как я использую скобки в любом случае, я могу эффективно пропустить оператор конкатенации, изменив письменный порядок операций вокруг.

постоянный ток, 11 10 байт

ddZAr^1+**

Я знал, что в конце концов я найду применение для Zкоманды!

Операция довольно проста - посчитайте цифры, возьмите 10, возведенных в эту степень, и добавьте одну. Это дает множитель, который объединяет число с самим собой. Тогда просто умножьте.

Ввод / вывод использует стек, как обычно для DC.

Полная программа

Вот что я использовал для тестов:

#!/usr/bin/dc
?
ddZAr^1+**
p

Две дополнительные команды дают нам конвейерный ввод-вывод.

тесты

$ for i in 1 2 3 10 174; do printf '%d -> ' $i; ./84712.dc <<<$i; done
1 -> 11
2 -> 44
3 -> 99
10 -> 10100
174 -> 30306276

Спасибо сэру Байдену XVII (1 байт).

Свинка, 11 байт

R I W I_I*I

Это одна из тех редких проблем, связанных с гольфом, где особенности эпидемического паротита могут оказаться очень полезными. Во-первых, все переменные являются строками, и все математические уравнения строго оцениваются слева направо (как в: не PEMDAS), поэтому 1 + 2 * 4 = 12 в Mumps вместо = 9, как PEMDAS. Итак, (едва) не одураченный

R I ;     Read from stdin to variable I
W I_I*I ; Write out I concatenated with I, then multiplied by I.

Слово предостережения - поскольку используемая мной разновидность Mumps (InterSystems Ensemble) не повторяет возврат каретки для stdin, входной и выходной номер будут объединены. Чтобы исправить это / повысить читаемость, вам нужно добавить два байта и добавить CR / LF вручную, таким образом:

R I W !,I_I*I

Однако, поскольку я не видел этого требования в правилах испытания, я почти уверен, что у меня все хорошо с более коротким кодом. Если я ошибаюсь, пожалуйста, не стесняйтесь LART меня, и я изменю свой ответ. :-)

PowerShell, 25 , 18 байт

Спасибо TessellatingHeckler за напоминание, как сильно PS любит конвейер.

Новые 18 байтов:

process{$_*"$_$_"}

Старые 25 байтов:

param($a);[int]"$a$a"*$a

Объяснение:

# new
process{$_*"$_$_"}
process{         } # runs code block once for each passed item
        $_*        # multiple the first parameter
           "$_$_"  # concatenate as a string for ease
                   # in this case, the order does the typecasting for us
# old
param($a);[int]"$a$a"*$a
param($a)                 # assigns the first passed parameter to variable $a
         ;                # line terminator
          [int]           # type cast string "$a$a" to int32
               "$a$a"     # convert $a$a to string for easy concatenation
                     *$a  # multiply by $a

Тестирование (сохранить как boring.ps1):

# new
12 | .\boring.ps1
14544
174 | .\boring.ps1
30306276

# old
.\boring.ps1 12
14544
.\boring.ps1 174
30306276

Определенно не победный ответ, но веселье независимо!

Пакетный, 27 20 18 байт

@cmd/cset/a%1%1*%1

Редактировать: 7 байтов сохранено благодаря @TessellatingHeckler. Сохранено еще 2 байта благодаря @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.