Un nombre inintéressant (que je n'ai pas totalement inventé pour ce défi) est ainsi créé:

1. Prendre un entier positif N
2. Créez un nouveau nombre O en ajoutant les chiffres de N à la fin de N
3. Le dernier numéro inintéressant est O * N

Par exemple pour N = 12:

1. O = 1212
2. O * N = 1212 * 12
3. Le numéro final est 14544

Contribution

Un entier positif N (N> 0) ou l'équivalent de votre langue. Vous n'avez pas à attraper une entrée incorrecte.

Sortie

Le nombre sans intérêt correspondant.

Cas de test

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

Notation

Le code le plus court en octets l'emporte.

05AB1E , 3 octets

Ы*

A expliqué

Ð    # triplicate input
 «   # conactenate
  *  # multiply

Essayez-le en ligne

JavaScript (ES6), 10 octets

_=>(_+_)*_

Doit être appelé avec l'argument comme un String, pas un Number.

Usage:

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

-3 octets grâce à la suggestion de @Quill .

Java 8, 29 26 25 21 octets

Que Dieu bénisse lambda

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

c-> code long (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 octets

*s+`

Explication:

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

Testez-le ici .

Emacs, 17 octets

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

Explication

• (*SPACEajoute (*au point (avant le nombre);
• C-SPACEC-EM-Y Sélectionnez et copiez le numéro.
• SPACE ajoute un espace au point (après le nombre);
• C-YC-Y colle deux fois le nombre au point;
• )ajoute )à la fin;
• C-J interprète la ligne comme une expression LISP et affiche son résultat.

Exemple

Curseur représenté par un tuyau ( |)

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

Résultat

(* 174 174174)
30306276|

C #, 19 23 octets

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

Sans chaînes, 47 octets

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

Python 2.7, 21 octets:

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

Eh bien, ce doit être la réponse la plus courte que j'ai jamais écrite en Python dans les plus brefs délais. C'est une fonction lambda anonyme qui peut être exécutée en la nommant comme vous le souhaitez, puis en l'appelant comme une fonction normale encapsulée print(). Par exemple, si votre entrée est 12et que la fonction a été nommée H, cela s'appellera comme print(H(12)).

Essayez-le en ligne! (Idéone)

Notez que cela ne fonctionne que pour les valeurs supérieures et égales à 9223372036854775807depuis toute valeur supérieure et repr()met un Là la fin de l'entier. Par conséquent, pour les valeurs supérieures à 9223372036854775807, cette version à 24 octets serait celle qui fonctionne:

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

Essayez ceci en ligne! (Idéone)

Gelée, 4 octets

;DḌ×

Essayez-le en ligne

Explication

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

Version précédente (48 octets, pas de fonctions mathématiques), 16 octets enregistrés grâce à @LeakyNun, 1 octet grâce à @FryAmTheEggman, 4 octets grâce à @TobySpeight:

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

Appelez f()avec un argument, le nombre, et il renvoie le nombre sans intérêt correspondant.

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

Résultats de test:

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

Essayez-le en ligne!

Dyalog APL , 7 octets

⊢×#⍎⍕,⍕

⍕ représentation de chaîne

⍕, préfixe une représentation de chaîne

#⍎ faire en nombre (dans l'espace de noms racine)

⊢× multiplier par le nombre original

J, 7 octets

*,~&.":

Explication

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

Rétine , 27 à 20 octets

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

Est un peu lent pour les entrées volumineuses, car avant la dernière étape, le résultat est représenté de manière unaire.

Essayez-le en ligne! (La première ligne active une suite de tests séparée par saut de ligne.)

Explication

Je vais utiliser 2comme exemple d'entrée (car les représentations unaires deviennent un peu difficiles à manier pour des entrées plus importantes).

Étape 1: substitution

^
$_$*: $_

En faisant correspondre le début de la chaîne avec, ^nous ajoutons simplement des éléments. $_fait référence à la chaîne d'entrée elle-même et $*:signifie que nous insérons autant de deux points. Nous obtenons donc:

:: 22

Étape 2: substitution

:
$_$*:

Maintenant, nous associons chaque :et remplaçons à nouveau par $_$*:. Bien sûr, cette fois, la valeur $_ne correspond pas à un entier (mais à :: 22notre exemple), elle $*recherche simplement la première décimale de la chaîne. Elle correspond donc à l’entrée concaténée sur elle-même ( Odans la spécification de défi). Nous nous retrouverons avec des N*Opoints, suivis de O:

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

Étape 3: match

:

Il ne reste plus qu'à compter le nombre :de décimales converties, ce qui est exactement ce que cette étape fait.

CJam , 8 octets

ri_`_+i*

Essayez-le en ligne!

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ée, 8 à 6 octets

ŒṘẋ2v×

Essayez-le en ligne!

Explication

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

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

Définir la ligne à 2 d'elle-même multipliée par elle-même

Brachylog , 7 octets

:?c:?*.

Explication

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

Python, 42 octets

Approche arithmétique pure, sans ficelle!

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

Ideone ça!

Matlab / Octave, 20 octets

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

C'est une fonction anonyme qui prend l'entrée sous forme de chaîne.

Exemple d'utilisation:

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

Ou essayez-le en ligne avec ideone .

Explication

Le code construit une chaîne en concaténant la chaîne d'entrée deux fois, puis le caractère *(qui a le code ASCII 42), puis la chaîne à nouveau. La chaîne concaténée est ensuite évaluée.

MATL , 6 octets

tVthU*

Essayez-le en ligne!

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

zsh, 13 octets

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

Prend l'entrée en tant qu'argument de ligne de commande et renvoie STDOUT.

Cela ne fonctionne que dans zsh, mais voici 15 octets dans Bash qui utilisent à la echoplace de <<<:

echo $[$1$1*$1]

Perl, 11 octets

$_*=$_ x2

+ les drapeaux pet l.

(courir avec perl -ple '$_*=$_ x2')

-2 octets grâce au tuyau.

Excel VBA, 35 octets

Sous appelé avec numéro, msgbox renvoie la réponse

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

Alternative Excel VBA, 42 octets

Numéro donné dans la formule, retourne la réponse.

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

Lua, 20 octets

Prend un argument de ligne de commande, et sort par STDOUT

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

Et ungolfed comme @LeakyNun a demandé dans le commentaire :)

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 octets

`+b*

Essayez-le ici!

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

Aussi 5 octets avec des entrées de chaîne

+bRb*
+]mbB

PHP, 25 24 octets

Les étiquettes à ouverture courte sont utiles pour étonnamment peu de défis de golf, heureusement, c’est l’un d’eux. Malheureusement, la priorité des opérateurs est à l'opposé de l'ordre dans lequel vous devez les effectuer. Il faut donc beaucoup de crochets.

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

edit: Je me suis rendu compte que, de toute façon, en utilisant des crochets, je pouvais effectivement sauter l’opérateur de concaténation en modifiant l’ordre écrit des opérations.

dc, 11 10 octets

ddZAr^1+**

Je savais que je finirais par trouver un usage pour la Zcommande!

Le fonctionnement est assez simple: comptez les chiffres, prenez 10 points élevés et ajoutez-en un. Cela donne un multiplicateur qui concatène le nombre avec lui-même. Alors il suffit de multiplier.

I / O utilise la pile, comme d'habitude pour dc.

Programme complet

Voici ce que j'ai utilisé pour les tests:

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

Les deux commandes supplémentaires nous donnent des entrées / sorties de pipeline.

Des 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

Merci à Sir Biden XVII (1 octet).

Oreillons, 11 octets

R I W I_I*I

C’est l’un des rares défis de golf où les particularités des oreillons peuvent être très utiles. Premièrement, toutes les variables sont des chaînes et toutes les équations mathématiques sont strictement évaluées de gauche à droite (comme dans: pas PEMDAS), donc 1 + 2 * 4 = 12 dans Mumps au lieu de = 9 comme le ferait PEMDAS. Donc, à peine ungolfé:

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

Attention: parce que la saveur de Mumps que j'utilise (InterSystems Ensemble) ne fait pas écho au retour chariot de stdin, les numéros d'entrée et de sortie apparaissent concaténés. Pour rectifier cela / améliorer la lisibilité, vous devez ajouter deux octets et ajouter un CR / LF manuel, ainsi:

R I W !,I_I*I

Cependant, comme je ne voyais pas cette exigence dans les règles du challenge, je suis à peu près sûr que je suis doué pour le code plus court. Si je me trompe, n'hésitez pas à LART moi et je modifierai ma réponse. :-)

PowerShell, 25 , 18 octets

Merci TessellatingHeckler de m'avoir rappelé à quel point le PS aime le pipeline.

Nouveau 18 octets:

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

Vieux 25 octets:

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

Explication:

# 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

Test (enregistrer sous boring.ps1):

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

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

Ce n'est vraiment pas la réponse gagnante, mais amusant quand même!

Lot, 27 20 18 octets

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

Edit: 7 octets enregistrés grâce à @TessellatingHeckler. Sauvegardé 2 octets supplémentaires grâce à @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.