Powstaje nieciekawa liczba (której absolutnie nie nadrobiłem tylko dla tego wyzwania):

1. Weź dodatnią liczbę całkowitą N
2. Utwórz nową liczbę O, dodając cyfry N na końcu N
3. Ostatnią nieciekawą liczbą jest O * N

Na przykład dla N = 12:

1. O = 1212
2. O * N = 1212 * 12
3. Ostateczny numer to 14544

Wejście

Dodatnia liczba całkowita N (N> 0) lub odpowiednik twojego języka. Nie musisz łapać niepoprawnych danych wejściowych.

Wydajność

Odpowiednia nieciekawa liczba.

Przypadki testowe

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

Punktacja

Najkrótszy kod w bajtach wygrywa.

05AB1E , 3 bajty

Ы*

Wyjaśniono

Ð    # triplicate input
 «   # conactenate
  *  # multiply

Wypróbuj online

JavaScript (ES6), 10 bajtów

_=>(_+_)*_

Musi zostać wywołany z argumentem jako, a Stringnie jako Number.

Stosowanie:

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

-3 bajty dzięki sugestii @Quill .

Java 8, 29 26 25 21 bajtów

Niech Bóg błogosławi lambda

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 bajtów

*s+`

Wyjaśnienie:

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

Sprawdź to tutaj .

Emacs, 17 bajtów

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

Wyjaśnienie

• (*SPACEdodaje (*w punkcie (przed liczbą);
• C-SPACEC-EM-Y Wybierz i skopiuj numer;
• SPACE dodaje znak spacji w punkcie (po numerze);
• C-YC-Y wkleja dwa razy liczbę w punkcie;
• )dodaje )na końcu;
• C-J interpretuje linię jako wyrażenie LISP i wypisuje jej wynik.

Przykład

Kursor reprezentowany przez potok ( |)

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

Wynik

(* 174 174174)
30306276|

C #, 19 23 bajtów

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

Bez ciągów 47 bajtów

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

Python 2.7, 21 bajtów:

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

Cóż, to musi być najkrótsza odpowiedź w języku Python, jaką kiedykolwiek napisałem w jak najkrótszym czasie. Jest to anonimowa funkcja lambda, którą można wykonać, nadając jej dowolne imię, a następnie wywołując ją jak zwykłą zapakowaną funkcję print(). Na przykład, jeśli dane wejściowe są 12, a funkcja została nazwana H, będzie to nazwane tak print(H(12)).

Wypróbuj online! (Ideone)

Zauważ, że działa to tylko dla wartości 9223372036854775807wyższych i równych od każdej wyższej wartości i repr()umieszcza Lna końcu liczby całkowitej. Dlatego dla wartości większych niż 9223372036854775807ta 24-bajtowa wersja byłaby tą, która działa:

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

Wypróbuj to online! (Ideone)

Galaretka, 4 bajty

;DḌ×

Wypróbuj online

Wyjaśnienie

;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

C 70 70 54 54 52 52 44

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

Poprzednia wersja (48 bajtów, bez funkcji matematycznych), zapisana 16 bajtów dzięki @LeakyNun, 1 bajt dzięki @FryAmTheEggman, 4 bajty dzięki @TobySpeight:

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

Zadzwoń f()z jednym argumentem, liczbą, i zwróci odpowiedni nieciekawy numer.

Program testowy

#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;
}

Wyniki testów:

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

Wypróbuj online!

Dyalog APL , 7 bajtów

⊢×#⍎⍕,⍕

⍕ reprezentacja ciągu

⍕, poprzedzająca reprezentacja ciągu

#⍎ make into number (w root namespace)

⊢× pomnóż przez oryginalny numer

J, 7 bajtów

*,~&.":

Wyjaśnienie

*,~&.":  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

Siatkówka , 27 20 bajtów

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

Robi się nieco powolny w przypadku dużych nakładów, ponieważ przed ostatnim etapem wynik jest reprezentowany w jedności.

Wypróbuj online! (Pierwszy wiersz włącza pakiet testowy oddzielony od linii).

Wyjaśnienie

Wykorzystam 2jako przykładowe dane wejściowe (ponieważ jedne reprezentacje stają się nieco niewygodne dla większych danych wejściowych).

Etap 1: Zmiana

^
$_$*: $_

Dopasowując początek łańcucha do ^, po prostu przygotowujemy kilka rzeczy. $_odnosi się do samego łańcucha wejściowego i $*:oznacza, że ​​wstawiamy tyle dwukropków. Otrzymujemy więc:

:: 22

Etap 2: Zmiana

:
$_$*:

Teraz dopasowujemy co :i ponownie go zastępujemy $_$*:. Oczywiście ten czas $_nie jest obliczany na liczbę całkowitą (ale :: 22w naszym przykładzie), ale $*po prostu szuka pierwszego miejsca po przecinku w ciągu znaków, więc ocenia to dane wejściowe skonkatenowane z samym sobą ( Ow specyfikacji wyzwania). N*OSkończymy z dwukropkami, a następnie O:

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

Etap 3: Mecz

:

Pozostało tylko policzenie :s do konwersji z jedności z powrotem na dziesiętne, co dokładnie robi ten etap.

CJam , 8 bajtów

ri_`_+i*

Wypróbuj online!

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

Galaretka, 8 6 bajtów

ŒṘẋ2v×

Wypróbuj online!

Wyjaśnienie

ŒṘẋ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 bajtów

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

Ustaw linię na 2 z siebie pomnożoną przez siebie

Brachylog , 7 bajtów

:?c:?*.

Wyjaśnienie

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

Python, 42 bajty

Czyste podejście arytmetyczne, bez zobowiązań!

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

Ideone to!

Matlab / Octave, 20 bajtów

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

Jest to anonimowa funkcja, która przyjmuje dane wejściowe jako ciąg znaków.

Przykładowe zastosowanie:

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

Lub wypróbuj online z ideone .

Wyjaśnienie

Kod buduje ciąg, łącząc łańcuch wejściowy dwa razy, następnie znak *(który ma kod ASCII 42), a następnie ciąg ponownie. Połączony ciąg jest następnie oceniany.

MATL , 6 bajtów

tVthU*

Wypróbuj online!

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

zsh, 13 bajtów

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

Pobiera dane wejściowe jako argument wiersza poleceń, wysyła do STDOUT.

Działa to tylko w Zsh, ale tutaj jest 15 bajtów w Bash, używając echozamiast <<<:

echo $[$1$1*$1]

Perl, 11 bajtów

$_*=$_ x2

+ flagi pi l.

(biegnij z perl -ple '$_*=$_ x2')

-2 bajty dzięki potoku.

Excel VBA, 35 bajtów

Sub wywoływany z numerem msgbox zwraca odpowiedź

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

Alternatywny Excel VBA, 42 bajty

Liczba podana we wzorze zwraca odpowiedź.

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

Lua, 20 bajtów

Pobiera argument z wiersza poleceń i wysyła dane przez STDOUT

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

I nie golfił, jak @LeakyNun zapytał w komentarzu :)

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

Pyke, 5 4 bajtów

`+b*

Wypróbuj tutaj!

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

Również 5 bajtów z wejściowymi ciągami znaków

+bRb*
+]mbB

PHP, 25 24 bajtów

Tagi z krótkim otwieraniem są przydatne w zaskakująco niewielu wyzwaniach golfowych, na szczęście jest to jedno z nich. Niestety pierwszeństwo operatorów jest odwrotnością kolejności, w jakiej należy je wykonać, dlatego potrzeba wielu nawiasów.

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

edycja: Zrozumiałem, że widząc, jak i tak używam nawiasów, mogę skutecznie pominąć operatora konkatenacji, zmieniając zapisaną kolejność operacji.

dc, 11 10 bajtów

ddZAr^1+**

I wiedział , że w końcu znajdę zastosowanie do Zpolecenia!

Operacja jest dość prosta - policz cyfry, weź 10 podniesionych do tej mocy i dodaj jedną. Daje to mnożnik, który konkatenuje liczbę ze sobą. Następnie pomnóż.

I / O używa stosu, jak zwykle dla dc.

Pełny program

Oto, czego użyłem do testów:

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

Dwa dodatkowe polecenia dają nam potoki we / wy.

Testy

$ 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

Podziękowania należą się Sir Bidenowi XVII (1 bajt).

Świnka, 11 bajtów

R I W I_I*I

Jest to jedno z tych rzadkich wyzwań golfowych, w których osobliwości Mumps mogą być bardzo przydatne. Po pierwsze, wszystkie zmienne są łańcuchami, a wszystkie równania matematyczne są ściśle oceniane od lewej do prawej (jak w: nie PEMDAS), więc 1 + 2 * 4 = 12 w Śwince zamiast = 9, tak jak PEMDAS. Tak więc, (ledwo) nie golfił:

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

Słowo ostrzeżenia - ponieważ smak Mumpa, którego używam (InterSystems Ensemble), nie odzwierciedla echa powrotu karetki dla standardowego wejścia, numer wejścia i wyjścia będzie wyglądał na skonkatenowany. Aby to poprawić / zwiększyć czytelność, musisz dodać dwa bajty i dodać ręczną CR / LF, a zatem:

R I W !,I_I*I

Ponieważ jednak nie widziałem tego wymogu w regułach wyzwania, jestem całkiem pewien, że jestem dobry z krótszym kodem. Jeśli się mylę, nie krępuj się, aby LART mnie, a ja zmodyfikuję swoją odpowiedź. :-)

PowerShell, 25 , 18 bajtów

Dziękuję TessellatingHeckler za przypomnienie mi, jak bardzo PS kocha rurociąg.

Nowe 18 bajtów:

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

Stare 25 bajtów:

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

Wyjaśnienie:

# 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

Testowanie (zapisz jako nudne.ps1):

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

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

Zdecydowanie nie zwycięska odpowiedź, ale niezła zabawa!

Partia, 27 20 18 bajtów

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

Edycja: Zapisano 7 bajtów dzięki @TessellatingHeckler. Zaoszczędzono kolejne 2 bajty dzięki @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.