Um número desinteressante (que eu totalmente não compensava apenas para esse desafio) é criado assim:

1. Tome um número inteiro positivo N
2. Crie um novo número O adicionando os dígitos de N no final de N
3. O número final desinteressante é O * N

Por exemplo, para N = 12:

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

Entrada

Um número inteiro positivo N (N> 0) ou o equivalente do seu idioma. Você não precisa capturar informações incorretas.

Saída

O número desinteressante correspondente.

Casos de teste

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

Pontuação

O menor código em bytes vence.

05AB1E , 3 bytes

Ы*

Explicado

Ð    # triplicate input
 «   # conactenate
  *  # multiply

Experimente online

JavaScript (ES6), 10 bytes

_=>(_+_)*_

Precisa ser chamado com o argumento como a String, não a Number.

Uso:

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

-3 bytes graças à sugestão de @Quill .

Java 8, 29 26 25 21 bytes

Deus abençoe lambda

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

c-> Código longo (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

Pitão, 5 4 bytes

*s+`

Explicação:

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

Teste aqui .

Emacs, 17 bytes

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

Explicação

• (*SPACEadiciona (*no ponto (antes do número);
• C-SPACEC-EM-Y Selecione e copie o número;
• SPACE adiciona um caractere de espaço no ponto (após o número);
• C-YC-Y cola duas vezes o número no ponto;
• )adiciona )no final;
• C-J interpreta a linha como uma expressão LISP e imprime seu resultado.

Exemplo

Cursor representado por um pipe ( |)

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

Sem strings, 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

Bem, essa deve ser a resposta mais curta em Python que eu já escrevi no menor tempo possível. É uma função lambda anônima que pode ser executada nomeando-a como quiser e, em seguida, chamando-a como uma função normal envolvida print(). Por exemplo, se sua entrada é 12e a função foi nomeada H, isso seria chamado como print(H(12)).

Experimente Online! (Ideona)

Observe que isso só funciona para valores acima e iguais a 9223372036854775807qualquer valor mais alto e repr()coloca a Lno final do número inteiro. Portanto, para valores maiores que 9223372036854775807, essa versão de 24 bytes seria a que funciona:

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

Experimente isto online! (Ideona)

Geléia, 4 bytes

;DḌ×

Experimente online

Explicação

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

Versão anterior (48 bytes, sem funções matemáticas), salva 16 bytes graças a @LeakyNun, 1 byte graças a @FryAmTheEggman, 4 bytes graças a @TobySpeight:

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

Ligue f()com um argumento, o número, e ele retornará o número desinteressante correspondente.

Programa de teste

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

Resultado dos testes:

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

Experimente online!

Dyalog APL , 7 bytes

⊢×#⍎⍕,⍕

⍕ representação de string

⍕, preceder representação de cadeia

#⍎ transformar em número (no espaço para nome raiz)

⊢× multiplicar pelo número original

J, 7 bytes

*,~&.":

Explicação

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

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

Fica um pouco lento para entradas grandes, porque antes da última etapa o resultado é representado em unário.

Experimente online! (A primeira linha ativa um conjunto de testes separado por avanço de linha.)

Explicação

Usarei 2como exemplo de entrada (porque as representações unárias ficam um pouco difíceis para entradas maiores).

Etapa 1: Substituição

^
$_$*: $_

Combinando o início da string com ^, simplesmente acrescentamos algumas coisas. $_refere-se à própria string de entrada e $*:significa que inserimos muitos dois pontos. Então temos:

:: 22

Etapa 2: Substituição

:
$_$*:

Agora, combinamos todas as :vezes substituí-lo por $_$*:. Obviamente, desta vez $_não é avaliado para um número inteiro (mas para o :: 22nosso exemplo), mas $*apenas procura o primeiro decimal na string, portanto isso avalia a entrada concatenada para si mesma ( Ona especificação de desafio). Terminaremos com N*Odois pontos, seguidos por O:

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

Etapa 3: partida

:

Tudo o que resta é contar os :s para converter de unário de volta para decimal, que é exatamente o que esse estágio faz.

CJam , 8 bytes

ri_`_+i*

Experimente 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

Geléia, 8 6 bytes

ŒṘẋ2v×

Experimente online!

Explicação

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

Defina a linha como 2 de si multiplicada por ela mesma

Braquilog , 7 bytes

:?c:?*.

Explicação

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

Python, 42 bytes

Abordagem aritmética pura, sem cordas!

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 é uma função anônima que recebe a entrada como uma string.

Exemplo de uso:

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

Ou experimente online com ideone .

Explicação

O código cria uma sequência concatenando a sequência de entrada duas vezes, depois o caractere *(que possui o código ASCII 42) e a sequência novamente. A sequência concatenada é então avaliada.

MATL , 6 bytes

tVthU*

Experimente 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 bytes

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

Recebe a entrada como argumento da linha de comando e gera para STDOUT.

Isso funciona apenas no zsh, mas aqui estão 15 bytes no Bash usando em echovez de <<<:

echo $[$1$1*$1]

Perl, 11 bytes

$_*=$_ x2

+ as sinalizadores pe l.

(corra com perl -ple '$_*=$_ x2')

-2 bytes graças ao pipe.

Excel VBA, 35 bytes

Sub chamado com número, msgbox retorna resposta

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

Excel VBA alternativo, 42 bytes

Número indicado na fórmula, retorna resposta.

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

Lua, 20 bytes

Recebe um argumento da linha de comando e sai via STDOUT

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

E ungolfed como @LeakyNun perguntou no comentário :)

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*

Experimente aqui!

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

Também 5 bytes com entradas de string

+bRb*
+]mbB

PHP, 25 24 bytes

Tags de abertura curta são úteis para surpreendentemente poucos desafios no golfe; felizmente, esse é um deles. Infelizmente, a precedência do operador é o oposto da ordem em que você precisa executá-las, de modo que muitos colchetes são necessários.

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

edit: percebi que, como estou usando colchetes de qualquer maneira, posso efetivamente pular o operador de concatenação alterando a ordem por escrito das operações.

dc, 11 10 bytes

ddZAr^1+**

Eu sabia que, eventualmente, encontraria um uso para o Zcomando!

A operação é bastante simples - conte os dígitos, pegue 10 aumentados para esse poder e adicione um. Isso fornece um multiplicador que concatena o número consigo mesmo. Então apenas multiplique.

AE / S usa a pilha, como de costume para dc.

Programa completo

Isto é o que eu usei para os testes:

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

Os dois comandos extras nos fornecem E / S de pipeline.

Testes

$ 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

Agradecemos a Sir Biden XVII (1 byte).

Caxumba, 11 bytes

R I W I_I*I

Este é um daqueles raros desafios de golfe, onde as idiossincrasias de Mumps podem ser muito úteis. Primeiro, todas as variáveis ​​são cadeias de caracteres e todas as equações matemáticas são estritamente avaliadas da esquerda para a direita (como em: não no PEMDAS), então 1 + 2 * 4 = 12 no Mumps em vez de = 9 da maneira que o PEMDAS faria. Então, (mal) não destruído:

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

Atenção: como o sabor do Mumps que estou usando (InterSystems Ensemble) não reflete o retorno de carro para stdin, o número de entrada e saída aparecerá concatenado. Para corrigir isso / aumentar a legibilidade, você precisará adicionar dois bytes e adicionar um CR / LF manual, assim:

R I W !,I_I*I

No entanto, como não vi esse requisito nas regras do desafio, tenho certeza de que sou bom com o código mais curto. Se estiver enganado, sinta-se à vontade para me LART e modificarei minha resposta. :-)

PowerShell, 25 , 18 bytes

Obrigado TessellatingHeckler por me lembrar o quanto o PS adora o pipeline.

Novos 18 bytes:

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

25 bytes antigos:

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

Explicação:

# 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

Teste (salve como boring.ps1):

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

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

Definitivamente não é a resposta vencedora, mas divertida independentemente!

Lote, 27 20 18 bytes

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

Editar: salvou 7 bytes graças a @TessellatingHeckler. Economizou mais 2 bytes graças a @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.