Un numero poco interessante (che non ho completamente compensato solo per questa sfida) è creato in questo modo:

1. Prendi un numero intero positivo N
2. Crea un nuovo numero O aggiungendo le cifre di N alla fine di N
3. Il numero finale non interessante è O * N

Ad esempio per N = 12:

1. O = 1212
2. O * N = 1212 * 12
3. Il numero finale è 14544

Ingresso

Un numero intero positivo N (N> 0) o equivalente della tua lingua. Non è necessario acquisire input errati.

Produzione

Il corrispondente numero non interessante.

Casi test

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

punteggio

Vince il codice più breve in byte.

05AB1E , 3 byte

Ы*

spiegato

Ð    # triplicate input
 «   # conactenate
  *  # multiply

Provalo online

JavaScript (ES6), 10 byte

_=>(_+_)*_

Deve essere chiamato con l'argomento come a String, non a Number.

Uso:

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

-3 byte grazie al suggerimento di @Quill .

Java 8, 29 26 25 21 byte

Dio benedica 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 byte

*s+`

Spiegazione:

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

Provalo qui .

Emacs, 17 byte

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

Spiegazione

• (*SPACEaggiunge (*al punto (prima del numero);
• C-SPACEC-EM-Y Seleziona e copia il numero;
• SPACE aggiunge un carattere spazio nel punto (dopo il numero);
• C-YC-Y incolla due volte il numero nel punto;
• )aggiunge )alla fine;
• C-J interpreta la linea come espressione LISP e ne stampa il risultato.

Esempio

Cursore rappresentato da una pipe ( |)

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

Risultato

(* 174 174174)
30306276|

C #, 19 23 byte

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

Senza stringhe, 47 byte

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

Python 2.7, 21 byte:

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

Bene, questa deve essere la risposta Python più breve che abbia mai scritto nel minor tempo possibile. È una funzione lambda anonima che può essere eseguita nominandola come preferisci e chiamandola come una normale funzione racchiusa print(). Ad esempio, se il tuo input è 12, e la funzione è stata nominata H, questa si chiamerebbe like print(H(12)).

Provalo online! (Ideone)

Si noti che questo funziona solo per valori superiori e uguali a 9223372036854775807da qualsiasi valore più alto e repr()inserisce La alla fine dell'intero. Pertanto, per valori maggiori di 9223372036854775807, questa versione da 24 byte sarebbe quella che funziona:

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

Prova questo online! (Ideone)

Gelatina, 4 byte

;DḌ×

Provalo online

Spiegazione

;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 68 54 53 52 44

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

Versione precedente (48 byte, nessuna funzione matematica), salvata 16 byte grazie a @LeakyNun, 1 byte grazie a @FryAmTheEggman, 4 byte grazie a @TobySpeight:

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

Chiama f()con un argomento, il numero, e restituisce il corrispondente numero non interessante.

Programma di test

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

Risultati del test:

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

Provalo online!

Dyalog APL , 7 byte

⊢×#⍎⍕,⍕

⍕ rappresentazione di stringhe

⍕, anteporre la rappresentazione di stringa

#⍎ make in number (nello spazio dei nomi di root)

⊢× moltiplicare per il numero originale

J, 7 byte

*,~&.":

Spiegazione

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

Retina , 27 20 byte

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

Diventa un po 'lento per input di grandi dimensioni, perché prima dell'ultimo stadio il risultato è rappresentato in modo unario.

Provalo online! (La prima riga abilita una suite di test separata da avanzamento riga.)

Spiegazione

Userò 2come input di esempio (perché le rappresentazioni unarie diventano un po 'ingombranti per input più grandi).

Fase 1: sostituzione

^
$_$*: $_

Abbinando l'inizio della stringa con ^semplicemente anteponiamo alcune cose. $_si riferisce alla stringa di input stessa e $*:significa che inseriamo molti punti. Quindi otteniamo:

:: 22

Fase 2: sostituzione

:
$_$*:

Ora abbiniamo ogni :e di nuovo lo sostituiamo con $_$*:. Ovviamente, questa volta $_non viene valutato un numero intero (ma :: 22nel nostro esempio), ma $*cerca solo il primo decimale nella stringa, quindi questo valuta l'input concatenato a se stesso ( Onella specifica della sfida). Finiremo con N*Odue punti, seguiti da O:

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

Fase 3: partita

:

Tutto ciò che rimane è contare le :s per convertire da unario a decimale, che è esattamente ciò che fa questo stadio.

CJam , 8 byte

ri_`_+i*

Provalo 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

Gelatina, 8 6 byte

ŒṘẋ2v×

Provalo online!

Spiegazione

ŒṘẋ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 byte

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

Imposta la linea su 2 di se stessa moltiplicata per se stessa

Brachylog , 7 byte

:?c:?*.

Spiegazione

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

Python, 42 byte

Approccio aritmetico puro, senza stringhe!

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

Ideone esso!

Matlab / Ottava, 20 byte

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

Questa è una funzione anonima che accetta l'input come stringa.

Esempio di utilizzo:

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

Oppure provalo online con ideone .

Spiegazione

Il codice crea una stringa concatenando due volte la stringa di input, quindi il carattere *(che ha il codice ASCII 42), quindi di nuovo la stringa. La stringa concatenata viene quindi valutata.

MATL , 6 byte

tVthU*

Provalo 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 byte

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

Accetta l'input come argomento della riga di comando, genera STDOUT.

This only works in zsh, but here's 15 bytes in Bash using echo instead of <<<:

echo $[$1$1*$1]

Perl, 11 bytes

$_*=$_ x2

+ the p and l flags.

(run with perl -ple '$_*=$_ x2')

-2 bytes thanks to pipe.

Excel VBA, 35 Bytes

Sub called with number, msgbox returns answer

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

Alternative Excel VBA, 42 Bytes

Number given in formula, returns answer.

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

Lua, 20 Bytes

Takes in a command-line argument, and outputs via STDOUT

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

And ungolfed as @LeakyNun asked in the comment :)

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 bytes

`+b*

Try it here!

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

Also 5 bytes with string inputs

+bRb*
+]mbB

PHP, 25 24 bytes

Short opening tags are useful for surprisingly few golfing challenges, luckily this is one of them. Unfortunately operator precedence is the opposite of the order you need to do them in so lots of brackets are needed.

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

edit: I realised that seeing as how I'm using brackets anyway I can effectively skip the concatenation operator by changing the written order of the operations around.

dc, 11 10 bytes

ddZAr^1+**

I knew that eventually I would find a use for the Z command!

Operation is fairly simple - count the digits, take 10 raised to that power and add one. This gives a multiplier that concatenates the number with itself. Then just multiply.

I/O uses the stack, as usual for dc.

Full program

This is what I used for the tests:

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

The two extra commands give us pipeline I/O.

Tests

$ 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

Thanks are due to Sir Biden XVII (1 byte).

Mumps, 11 bytes

R I W I_I*I

This is one of those rare golf challenges where the idiosyncrasies of Mumps can come in very handy. First, all variables are strings, and all math equations are strictly evaluated left-to-right (as in: not PEMDAS), so 1+2*4=12 in Mumps instead of =9 the way PEMDAS would. So, (barely) ungolfed:

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

Word of caution - because the flavour of Mumps that I'm using (InterSystems Ensemble) does not echo the carriage return for stdin, the input and output number will appear concatenated. To rectify that / increase readability, you'd need to add two bytes and add a manual CR/LF, thusly:

R I W !,I_I*I

However, as I didn't see that requirement in the rules of the challenge, I'm pretty sure that I'm good with the shorter code. If I'm mistaken, please feel free to LART me and I'll modify my answer. :-)

PowerShell, 25, 18 bytes

Thank you TessellatingHeckler for reminding me how much PS loves the pipeline.

New 18 bytes:

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

Old 25 bytes:

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

Explanation:

# 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

Testing (save as boring.ps1):

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

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

Definitely not the winning answer, but fun regardless!

Batch, 27 20 18 bytes

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

Edit: Saved 7 bytes thanks to @TessellatingHeckler. Saved a further 2 bytes thanks to @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.