Se crea un número poco interesante (que no compensé totalmente solo para este desafío) de esta manera:

1. Tome un entero positivo N
2. Cree un nuevo número O sumando los dígitos de N al final de N
3. El último número sin interés es O * N

Por ejemplo para N = 12:

1. O = 1212
2. O * N = 1212 * 12
3. El número final es 14544

Entrada

Un entero positivo N (N> 0) o el equivalente de su idioma. No tiene que atrapar entradas incorrectas.

Salida

El correspondiente número sin interés.

Casos de prueba

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

Tanteo

El código más corto en bytes gana.

05AB1E , 3 bytes

Ы*

Explicado

Ð    # triplicate input
 «   # conactenate
  *  # multiply

Pruébalo en línea

JavaScript (ES6), 10 bytes

_=>(_+_)*_

Necesita ser llamado con el argumento como a String, no comoNumber .

Uso:

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

-3 bytes gracias a la sugerencia de @Quill .

Java 8, 29 26 25 21 Bytes

Dios bendiga a 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 bytes

*s+`

Explicación:

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

Pruébalo aquí .

Emacs, 17 bytes

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

Explicación

• (*SPACEagrega (*en el punto (antes del número);
• C-SPACEC-EM-Y Seleccione y copie el número;
• SPACE agrega un carácter de espacio en el punto (después del número);
• C-YC-Y pega dos veces el número en el punto;
• )agrega )al final;
• C-J interpreta la línea como una expresión LISP e imprime su resultado.

Ejemplo

Cursor representado por una pipa ( |)

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

Resultado

(* 174 174174)
30306276|

C #, 19 23 bytes

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

Sin cadenas, 47 bytes.

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

Python 2.7, 21 bytes:

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

Bueno, esta tiene que ser la respuesta Python más corta que haya escrito en el menor tiempo posible. Es una función lambda anónima que se puede ejecutar nombrándolo como desee y luego llamándolo como una función normal envuelta print(). Por ejemplo, si su entrada es 12, y la función fue nombrada H, esto se llamaría como print(H(12)).

¡Pruébelo en línea! (Ideona)

Tenga en cuenta que esto solo funciona para valores ascendentes e iguales a 9223372036854775807desde cualquier valor más alto y repr()pone un Lal final del entero. Por lo tanto, para valores mayores que 9223372036854775807, esta versión de 24 bytes sería la que funciona:

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

¡Prueba esto en línea! (Ideona)

Gelatina, 4 Bytes

;DḌ×

Pruébalo en línea

Explicación

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

Versión anterior (48 bytes, sin funciones matemáticas), guardada 16 bytes gracias a @LeakyNun, 1 byte gracias a @FryAmTheEggman, 4 bytes gracias a @TobySpeight:

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

Llame f()con un argumento, el número, y devuelve el número no interesante correspondiente.

Programa de prueba

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

Resultados de la prueba:

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

Pruébalo en línea!

Dyalog APL, 7 bytes

⊢×#⍎⍕,⍕

⍕ string representation

⍕, prepend string representation

#⍎ make into number (in root namespace)

⊢× multiply by original number

J, 7 bytes

*,~&.":

Explanation

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

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

Gets a bit slow for large inputs, because before the last the stage the result is represented in unary.

Try it online! (The first line enables a linefeed-separated test suite.)

Explanation

I'll use 2 as an example input (because the unary representations get a bit unwieldy for larger inputs).

Etapa 1: sustitución

^
$_$*: $_

Al hacer coincidir el comienzo de la cadena con ^simplemente anteponemos algunas cosas. $_se refiere a la cadena de entrada en sí y $*:significa que insertamos esa cantidad de dos puntos. Entonces obtenemos:

:: 22

Etapa 2: sustitución

:
$_$*:

Ahora combinamos cada :vez que lo reemplazamos con $_$*:. Por supuesto, esta vez $_no evalúa un número entero (sino :: 22en nuestro ejemplo), sino que $*solo busca el primer decimal en la cadena, por lo que esto se evalúa como la entrada concatenada a sí misma ( Oen la especificación de desafío). Terminaremos con N*Odos puntos, seguidos de O:

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

Etapa 3: partido

:

Todo lo que queda es contar la :s para convertir de unario a decimal, que es exactamente lo que hace esta etapa.

CJam , 8 bytes

ri_`_+i*

Pruébalo en línea!

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

Jalea, 8 6 bytes

ŒṘẋ2v×

Pruébalo en línea!

Explicación

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

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

Establezca la línea en 2 de sí misma multiplicada por sí misma

Brachylog , 7 bytes

:?c:?*.

Explicación

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

Python, 42 bytes

Enfoque aritmético puro, sin cadenas!

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

Ideone it!

Matlab / Octave, 20 bytes

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

Esta es una función anónima que toma la entrada como una cadena.

Ejemplo de uso:

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

O pruébelo en línea con ideone .

Explicación

El código construye una cadena concatenando la cadena de entrada dos veces, luego el carácter *(que tiene el código ASCII 42) y luego la cadena nuevamente. Luego se evalúa la cadena concatenada.

MATL , 6 bytes

tVthU*

Pruébalo en línea!

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

zsh, 13 bytes

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

Toma la entrada como un argumento de línea de comando, sale a STDOUT.

Esto solo funciona en zsh, pero aquí hay 15 bytes en Bash usando en echolugar de <<<:

echo $[$1$1*$1]

Perl, 11 bytes

$_*=$_ x2

+ las py lbanderas.

(correr con perl -ple '$_*=$_ x2')

-2 bytes gracias a la tubería.

Excel VBA, 35 Bytes

Sub llamado con número, msgbox devuelve respuesta

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

Excel VBA alternativo, 42 bytes

Número dado en la fórmula, devuelve la respuesta.

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

Lua, 20 bytes

Toma un argumento de línea de comandos y emite a través de STDOUT

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

Y ungolf como @LeakyNun preguntó en el comentario :)

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*

Pruébalo aquí!

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

También 5 bytes con entradas de cadena

+bRb*
+]mbB

PHP, 25 24 bytes

Las etiquetas de apertura corta son útiles para sorprendentemente pocos desafíos de golf, afortunadamente este es uno de ellos. Desafortunadamente, la precedencia del operador es lo opuesto al orden en que debe hacerlos, por lo que se necesitan muchos corchetes.

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

editar: me di cuenta de que, viendo cómo uso los corchetes de todos modos, puedo omitir efectivamente el operador de concatenación cambiando el orden escrito de las operaciones.

dc, 11 10 bytes

ddZAr^1+**

¡ Sabía que eventualmente encontraría un uso para el Zcomando!

La operación es bastante simple: cuente los dígitos, tome 10 elevados a esa potencia y agregue uno. Esto le da un multiplicador que concatena el número consigo mismo. Entonces simplemente multiplícate.

I / O usa la pila, como de costumbre para dc.

Programa completo

Esto es lo que usé para las pruebas:

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

Los dos comandos adicionales nos dan E / S de canalización.

Pruebas

$ 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

Gracias a Sir Biden XVII (1 byte).

Paperas, 11 bytes

R I W I_I*I

Este es uno de esos raros desafíos de golf donde la idiosincrasia de las paperas puede ser muy útil. Primero, todas las variables son cadenas, y todas las ecuaciones matemáticas se evalúan estrictamente de izquierda a derecha (como en: no PEMDAS), por lo que 1 + 2 * 4 = 12 en Paperas en lugar de = 9 como lo haría PEMDAS. Entonces, (apenas) sin golfista:

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

Advertencia: debido a que el sabor de las paperas que estoy usando (InterSystems Ensemble) no se hace eco del retorno de carro para stdin, el número de entrada y salida aparecerá concatenado. Para rectificar eso / aumentar la legibilidad, necesitaría agregar dos bytes y agregar un CR / LF manual, por lo tanto:

R I W !,I_I*I

Sin embargo, como no vi ese requisito en las reglas del desafío, estoy bastante seguro de que soy bueno con el código más corto. Si me equivoco, no dude en LART me y modificaré mi respuesta. :-)

PowerShell, 25 , 18 bytes

Gracias TessellatingHeckler por recordarme cuánto PS ama la tubería.

Nuevos 18 bytes:

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

Antiguos 25 bytes:

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

Explicación:

# 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

Prueba (guardar como aburrido.ps1):

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

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

Definitivamente no es la respuesta ganadora, ¡pero es divertido de todos modos!

Lote, 27 20 18 bytes

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

Editar: Guardado 7 bytes gracias a @TessellatingHeckler. Ahorró otros 2 bytes gracias a @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.