Un nombre inintéressant (que je n'ai pas totalement inventé pour ce défi) est ainsi créé:
- Prendre un entier positif N
- Créez un nouveau nombre O en ajoutant les chiffres de N à la fin de N
- Le dernier numéro inintéressant est O * N
Par exemple pour N = 12:
- O = 1212
- O * N = 1212 * 12
- 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.
Réponses:
05AB1E , 3 octets
A expliqué
Essayez-le en ligne
la source
str
et*
interprète la chaîne en tant que nombre. Très utile :)JavaScript (ES6), 10 octets
Doit être appelé avec l'argument comme un
String
, pas unNumber
.Usage:
-3 octets grâce à la suggestion de @Quill .
la source
_=>(_+_)*+_
_
un caractère arbitraire pour une variable? (PS -(_+_)
ressemble totalement à un mégot)$
fonctionnerait égalementn=>(1+10**-~Math.log10(n))*n*n
(tristement-~
plus prioritaire que**
) ou 31 dans ES6n=>-~`1e${-~Math.log10(n)}`*n*n
. Même la récursion m'a pris 32 octets:f=(n,m=1)=>n<m?-~m*n*n:f(n,m*10)
Java 8,
29 26 2521 octetsQue Dieu bénisse lambda
c-> code long (c + "" + c) * c;la source
vim, 11
crcrcrcrcr ...
la source
<C-r>
est non imprimable.<C-r>
qu'un retour de voiture?<C-r>
c'est contrôle plus r. Retour de chariot est<cr>
.Pyth,
54 octetsExplication:
Testez-le ici .
la source
Emacs, 17 octets
(*SPACEC-SPACEC-EM-YSPACEC-YC-Y)C-J
Explication
(*
au point (avant le nombre);)
à la fin;Exemple
Curseur représenté par un tuyau (
|
)|174
(* |174
(* 174|
(* 174 |
(* 174 174174|
(* 174 174174)|
Résultat
la source
C #,
1923 octetsSans chaînes, 47 octets
la source
(n)=>{int.Parse(""+n+n)*n}
2;
?Python 2.7, 21 octets:
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 est12
et que la fonction a été nomméeH
, cela s'appellera commeprint(H(12))
.Essayez-le en ligne! (Idéone)
Notez que cela ne fonctionne que pour les valeurs supérieures et égales à
9223372036854775807
depuis toute valeur supérieure etrepr()
met unL
à la fin de l'entier. Par conséquent, pour les valeurs supérieures à9223372036854775807
, cette version à 24 octets serait celle qui fonctionne:Essayez ceci en ligne! (Idéone)
la source
Gelée, 4 octets
Essayez-le en ligne
Explication
la source
;DDx
Ḍ
prend seulement 1 octet? Habituellement, nous utilisons UTF-8, dans lequel il faut 3 (et le × en prend 2, mais il s'agit d'un octet, par exemple, ISO8859-1).C,
706854535244Version 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:
Appelez
f()
avec un argument, le nombre, et il renvoie le nombre sans intérêt correspondant.Programme de test
Résultats de test:
Essayez-le en ligne!
la source
f(n){int b=1;while(a)b*=10,a/=10;return(n+n*b)*n;}
math.h
, mais vous vous en tirez avec GCC, oùlog10()
etpow()
sont intégrés, et le compilateur met simplement en garde sur "la déclaration implicite incompatible de la fonction intégrée" plutôt que de supposer (comme il se doit) que ils reviennent tous les deuxint
.a
...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 originalla source
J, 7 octets
Explication
la source
Under
fonctionnait correctement avec la concaténation de chaînes. Quelle belle découverte pour moi! Merci.* ,~ &.": n
, et ne peut pas non plus être utilisé pour former d'autres verbes.Rétine ,
27 à20 octetsEst 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
2
comme 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:É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 à:: 22
notre 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 (O
dans la spécification de défi). Nous nous retrouverons avec desN*O
points, suivis deO
:Étape 3: match
Il ne reste plus qu'à compter le nombre
:
de décimales converties, ce qui est exactement ce que cette étape fait.la source
CJam , 8 octets
Essayez-le en ligne!
la source
r__+i\i*
, qui a la même longueur.r__+si*
, oùs
est "appliquer cette opération sur la pile"), mais je ne vois rien de telGelée,
8 à6 octetsEssayez-le en ligne!
Explication
la source
³
s.Awk, 13 octets
Définir la ligne à 2 d'elle-même multipliée par elle-même
la source
Brachylog , 7 octets
Explication
la source
Python, 42 octets
Approche arithmétique pure, sans ficelle!
Ideone ça!
la source
Matlab / Octave, 20 octets
C'est une fonction anonyme qui prend l'entrée sous forme de chaîne.
Exemple d'utilisation:
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.la source
42
veut dire?*
*
nouveau la chaîne. La chaîne concaténée est ensuite évaluée. Je vais modifier cela dans la réponseMATL , 6 octets
Essayez-le en ligne!
la source
zsh, 13 octets
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
echo
place de<<<
:la source
Perl, 11 octets
+ les drapeaux
p
etl
.(courir avec
perl -ple '$_*=$_ x2'
)-2 octets grâce au tuyau.
la source
$_*=$_ x2
-l
$_ x2
ce...\n...\n
qui, une fois converti en nombre par Perl, se termine au premier\n
6
.Excel VBA, 35 octets
Sous appelé avec numéro, msgbox renvoie la réponse
Alternative Excel VBA, 42 octets
Numéro donné dans la formule, retourne la réponse.
la source
Lua, 20 octets
Prend un argument de ligne de commande, et sort par STDOUT
Et ungolfed comme @LeakyNun a demandé dans le commentaire :)
la source
Pyke,
5 à4 octetsEssayez-le ici!
Aussi 5 octets avec des entrées de chaîne
la source
PHP,
2524 octetsLes é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.
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.
la source
dc,
1110 octetsJe savais que je finirais par trouver un usage pour la
Z
commande!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:
Les deux commandes supplémentaires nous donnent des entrées / sorties de pipeline.
Des tests
Merci à Sir Biden XVII (1 octet).
la source
A
pour10
sauvegarder un octet. Bien joué!Oreillons, 11 octets
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é:
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:
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. :-)
la source
PowerShell,
25, 18 octetsMerci TessellatingHeckler de m'avoir rappelé à quel point le PS aime le pipeline.
Nouveau 18 octets:
Vieux 25 octets:
Explication:
Test (enregistrer sous boring.ps1):
Ce n'est vraiment pas la réponse gagnante, mais amusant quand même!
la source
process{$_*"$_$_"}
est de 18 octets et prend une entrée de "stdin" (c'est-à-dire du pipeline), par exemple174|script.ps1
param($a);$a*"$a$a"
param($n)$n*"$n$n"
(ce que Darth avait, sans le;
) a la même longueur et n’est pas un REPL.test.ps1
fichier qui lit à partir du nombre de pipelines ne fonctionne-t-il pas ? Est-ce qu'un script shell bash qui lit stdin ne compte pas non plus?Lot,
272018 octetsEdit: 7 octets enregistrés grâce à @TessellatingHeckler. Sauvegardé 2 octets supplémentaires grâce à @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.
la source
set /a
à l'invite, le résultat de l'affectation est affiché. ->@cmd/c set/a n=%1%1*%1
pour 22 octets.@cmd/cset/a%1%1*%1
pour 18.cmd/c
pièce est nécessaire car l'outil d'exécution du fichier de commandes n'est pascmd
lui-même.