Imprime un montón de números sin interés!

40

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.

Seims
fuente
9
Debe haber una entrada relevante de OEIS ...
MKII
1
@Seims Fue una broma, basada en el nombre "sin interés"
MKII
77
@MKII mi mal, no hablo broma
Seims
1
¿Tomar el número como un argumento de cadena dobla demasiado las reglas?
Dom Hastings
1
¡Adelante, doble las reglas! : P
Seims

Respuestas:

38

05AB1E , 3 bytes

Ы*

Explicado

Ð    # triplicate input
 «   # conactenate
  *  # multiply

Pruébalo en línea

Emigna
fuente
2
Ahh, bien! Ninja'd por segundos: p.
Adnan
2
@Adnan Hehe. Venganza por ese tiempo que me lo hiciste: P
Emigna
1
3 operaciones, 3 bytes, no creo que puedas hacerlo más corto que eso.
Lasse Meyer
2
@busukxuan Sí. Concatenate convierte automáticamente el número stre *interpreta la cadena como un número. Muy útil :)
Emigna
2
@busukxuan Sí, una combinación de Pyth y 05AB1E podría haberlo hecho en 2 bytes :)
Emigna
29

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 .

Dom Hastings
fuente
1
Si puede pasar el parámetro como una cadena, puede cortar dos bytes de esta solución:_=>(_+_)*+_
Quill
3
¿Cómo funciona esto exactamente? Si entiendo correctamente, ¿estás usando _un carácter arbitrario para una variable? (PD: (_+_)parece un trasero)
charredgrass
@charredgrass $también funcionaría
gato
11
type casting abuse once
Downgoat
3
Por interés, lo mejor que pude hacer puramente matemáticamente fue 30 bytes en ES7 n=>(1+10**-~Math.log10(n))*n*n(lamentablemente -~tienen mayor prioridad que **) o 31 en ES6 n=>-~`1e${-~Math.log10(n)}`*n*n. Incluso la recursión me llevó 32 bytes:f=(n,m=1)=>n<m?-~m*n*n:f(n,m*10)
Neil
24

Java 8, 29 26 25 21 Bytes

Dios bendiga a lambda

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

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

usuario902383
fuente
28
Tienes que amar Java; incluso con las lambdas de Java 8 y una de las respuestas Java más cortas que haya existido aquí en codegolf, todavía está superada por todas las demás respuestas actuales. xD
Kevin Cruijssen
3
java es bae, lambda es bae
Seims
3
@KevinCruijssen Todavía tengo una esperanza, un día Java ganará el concurso de
codegolf
1
¡Después de su edición, superó a @MartinEnder con su respuesta de Retina por 1 byte! o.Ô
Kevin Cruijssen
1
@KevinCruijssen pero aún no es suficiente para ganar o al menos vencer a python :(
user902383
20

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
Pomo de la puerta
fuente
11 que? bytes?
Loco
3
@ Bytes internos si lo llama desde la línea de comando, pulsaciones de teclas si lo hace directamente desde vim. Por lo general, omito la unidad de mis respuestas vim porque puede ser cualquiera de las dos.
Pomo de la puerta
v.tryitonline.net/#code=QxI9EiISIioSIgo&input=MTI Lo malo <C-r>no se puede imprimir.
DJMcMayhem
¿Es <C-r>un retorno de carro?
Capitán Man
@CaptainMan No, <C-r>es control más r. El retorno del carro es <cr>.
Pomo de la puerta
15

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í .

busukxuan
fuente
15

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|
YSC
fuente
3
Hola y bienvenidos a PPCG! Bonito primer post!
Rɪᴋᴇʀ
13

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;};
Weston
fuente
44
Este es un fragmento, no un programa o función completo. Sería válido con, por ejemplo, (n)=>{int.Parse(""+n+n)*n}2
gato
@cat mejor? ¿Necesito el seguimiento ;?
weston
12

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)

R. Kap
fuente
Todavía encuentro mágicas las operaciones de Phytons String ...
Seims
@ ¿De qué manera?
busukxuan
Multiplicación y suma de cadenas. No he visto eso a menudo.
Seims
@Seims ¿Supongo que entonces trabajas principalmente con lenguajes estáticos?
busukxuan
@busukxuan Llámame novato si quieres: ^)
Seims
11

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
Essari
fuente
1
¡Es una cara de guiño muy feliz con una perilla! ;DDx
gato
¿En qué codificación solo toma 1 byte? Usualmente usamos UTF-8, en el cual toma 3 (y el × toma 2, pero es 1 byte en, por ejemplo, ISO8859-1).
o11c
@o11c Jelly uses its own custom code page where these characters are one byte each.
a spaghetto
10

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!

owacoder
fuente
f(n){int b=1;while(a)b*=10,a/=10;return(n+n*b)*n;}
Leaky Nun
Esto no debería funcionar correctamente sin incluirlo math.h, pero se saldrá con la suya en GCC, donde log10()y pow()están integrados, y el compilador simplemente advierte sobre la "declaración implícita incompatible de la función incorporada" en lugar de suponer (como debería) Ambos regresan int.
Toby Speight
@Leaky - no pusiste nada en a...
Toby Speight
1
Es agradable ver otra respuesta que se mantiene completamente dentro del mundo aritmético (sin hacer una concatenación de cadenas). :-)
Toby Speight
1
@Toby - String concatenation in C is incompatible with golfing. ;-)
owacoder
9

Dyalog APL, 7 bytes

⊢×#⍎⍕,⍕

string representation

⍕, prepend string representation

#⍎ make into number (in root namespace)

⊢× multiply by original number

Adám
fuente
1
Those wrecked TIE fighters are funny!
Luis Mendo
1
The fork awakens :-D
Luis Mendo
I'm pretty sure those aren't bytes in any encoding, since they're not letterlike or very common.
o11c
@o11c Did you check out the preemptive link for the word "bytes", viz. meta.codegolf.stackexchange.com/a/9429/43319.
Adám
9

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
miles
fuente
+1. I couldn't even think that Under is working properly with string concatenation. What a great discovery for me! Thank you.
Dan Oak
Sadly, I think this should be in parenthesis, since it's a hook that is not working if typed directly * ,~ &.": n, and can't be used in formation of other verbs either.
Dan Oak
1
@dahnoak Here at PPCG, we only have to specify what is needed for a function, and so the above is all that is necessary to create a function in J. Then to invoke it using some input as an argument, it will either be in parentheses or stored in a variable.
miles
Ah, I got this, ty.
Dan Oak
9

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.

Martin Ender
fuente
Ooh, tan cerca de ser tan largo como Java. Lo superó en solo 2 bytes. +1
R. Kap
@ R.Kap En realidad, Java 8 lo superó después de eliminar 3 bytes. o.Ô
Kevin Cruijssen
44
Lo siento, Java ...
Martin Ender
9

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
Luis Mendo
fuente
2
Estaba a punto de sugerir que no se convirtiera en inmediatamente luego de vuelta a la cadena, pero el enfoque ingenuo (es decir, nunca antes había usado CJam) es r__+i\i*, que tiene la misma longitud.
Financia la demanda de Mónica el
@QPaysTaxes Ah nice. I noticed the same thing as you: why first convert it to int and then back to string again. I also never used CJam and didn't really look close enough at all the possible operators, so I was unable to find a solution on first glance. Thanks for sharing your approach without converting it back to string, even though it's the same byte-length.
Kevin Cruijssen
If there was a way to apply an operation to the whole stack in two bytes, it would be a byte shorter (something like r__+si*, where s is "apply this operation over the stack"), but I don't see anything like that
Fund Monica's Lawsuit
8

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
usuario48538
fuente
1
No creo que necesites ninguno de esos ³s.
Martin Ender
8

Awk, 13 bytes

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

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

Usuario112638726
fuente
7

Brachylog , 7 bytes

:?c:?*.

Explicación

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

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!

Monja permeable
fuente
7

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.

Luis Mendo
fuente
Que 42significa
Leaky Nun
44
@LeakyNun Es la respuesta a la última pregunta de la vida, el universo y todo " . Además, resulta ser el código ASCII para*
Luis Mendo
Ah Estaba buscando algo como la 42a función.
Leaky Nun
El código simplemente construye una cadena concatenando la cadena de entrada dos veces, luego *, luego la cadena nuevamente. Luego se evalúa la cadena concatenada. Lo editaré en la respuesta
Luis Mendo
6

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
Luis Mendo
fuente
6

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]
Pomo de la puerta
fuente
6

Perl, 11 bytes

$_*=$_ x2

+ las py lbanderas.

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

-2 bytes gracias a la tubería.

Dada
fuente
Ahorre dos bytes:$_*=$_ x2
pipe
No creo que lo necesites-l
Brad Gilbert b2gills
@ BradGilbertb2gills Sí, lo necesito porque sin él, $_ x2producirá ...\n...\nque cuando se convierta en un número por perl, termina el primero\n
Dada
Lo estaba probando con Perl 5 y 6, y no me di cuenta de que olvidé eliminarlo 6.
Brad Gilbert b2gills
6

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
tjb1
fuente
Piensa en un MsgBox y un Sub. Le ahorrará 13 bytes, si cuento correctamente
GER_Moki
Necesitaría alguna forma de cuadro de entrada para obtener el valor, ¿no?
tjb1
Prueba Sub B (a) MsgBox (a & a) * a End Sub
GER_Moki
Eso requiere otro submarino para pasar el valor, no estoy seguro de que esté permitido en el golf.
tjb1
También se debe llamar a la función;)
GER_Moki
6

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
Katenkyo
fuente
Esa puede ser una buena demostración de coerción de tipo ... si agrega la explicación.
Leaky Nun
5

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
Azul
fuente
5

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.

usuario55641
fuente
5

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

Toby Speight
fuente
Puede sustituir Apara 10guardar un byte. ¡Bien hecho!
Joe
4

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

zmerch
fuente
4

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!

ThePoShWolf
fuente
Si coloca las variables al revés, int * string implícitamente convertirá la cadena en un int, y puede guardar 5 bytes de conversión. process{$_*"$_$_"}es de 18 bytes, y toma la entrada de "stdin" (es decir, la tubería), por ejemplo174|script.ps1
TessellatingHeckler
Hmmm ... punto interesante. También puedo cambiarlos usando mi misma estructura y lograr el mismo resultado:param($a);$a*"$a$a"
ThePoShWolf
Err, lo retiro, ¡el mío es un byte más!
ThePoShWolf
@TessellatingHeckler Cuidado con esa respuesta, ya que el entorno REPL de PowerShell no califica para el programa o la función predeterminada . Algo así param($n)$n*"$n$n"(lo que Darth tenía, sin el ;) es de la misma longitud y no es un REPL.
AdmBorkBork
@TimmyD ¿por qué no cuenta un test.ps1archivo que se lee en la tubería? ¿Una lectura de script bash shell de stdin tampoco cuenta?
TessellatingHeckler
4

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ᴏʟғᴇʀ.

Neil
fuente
set /aen el indicador se muestra el resultado de la asignación. -> @cmd/c set/a n=%1%1*%1para 22 bytes.
TessellatingHeckler
@TessellatingHeckler ¿Por qué molestarse en asignar si está produciendo?
Neil
@TessellatingHeckler Huh, ya hice este truco hace seis semanas, y ya lo he olvidado ...
Neil
@cmd/cset/a%1%1*%1para 18.
Erik the Outgolfer
1
@Neil Nope, pero lo probé (¡en Windows 10!) La cmd/cparte es necesaria porque la herramienta de ejecución de archivos por lotes no es en cmdsí misma.
Erik the Outgolfer