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

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 байт

_=>(_+_)*_

Необхідно викликати аргумент як a String, а не a Number.

Використання:

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

-3 байти завдяки пропозиції @Quill .

Java 8, 29 26 25 21 байт

Бог благословляє лямбду

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

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

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 і друкує його результат.

Приклад

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

• |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)).

Спробуйте в Інтернеті! (Ідеон)

Зауважте, що це працює лише для значень вгору і дорівнює 9223372036854775807тому, що будь-яке вище значення, і repr()ставить a Lв кінці цілого числа. Отже, для значень, більших за 9223372036854775807цю, 24-байтна версія буде такою, яка працює:

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

Спробуйте це в Інтернеті! (Ідеон)

Желе, 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

Спробуйте в Інтернеті!

Діалог 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

Пітон, 42 байти

Чистий арифметичний підхід, без струн!

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

Ідей це!

Матлаб / Октава, 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

zsh, 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

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

Число, вказане у формулі, повертає відповідь.

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

Луа, 20 байт

Приймає аргумент командного рядка та виводить через STDOUT

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

І ungolfed як @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";

редагувати: Я зрозумів, що розуміючи, як я в будь-якому випадку використовую дужки, я можу ефективно пропустити оператор конкатенації, змінивши письмовий порядок операцій навколо.

DC, 11 10 байт

ddZAr^1+**

Я знав, що зрештою знайду користь для Zкоманди!

Операція досить проста - порахуйте цифри, візьміть 10 піднятих до цієї потужності і додайте одну. Це дає множник, який поєднує число з собою. Тоді просто помножте.

Введення / виведення використовує стек, як зазвичай для постійного струму.

Повна програма

Це те, що я використовував для тестів:

#!/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.

Слово обережності - оскільки аромат свинки, який я використовую (InterSystems Ensemble), не перегукується з поверненням каретки для stdin, вхідний та вихідний номер видаватимуться об'єднаними. Щоб виправити це / збільшити читабельність, вам потрібно буде додати два байти та додати вручну CR / LF:

R I W !,I_I*I

Однак, оскільки я не бачив цієї вимоги в правилах виклику, я майже впевнений, що мені добре з коротшим кодом. Якщо я помиляюсь, будь ласка, не соромтесь ЛАСИТИ мене, і я модифікую свою відповідь. :-)

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

Тестування (зберегти як нудне.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 байт завдяки @TessellingHeckler. Збережено ще 2 байти завдяки @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.