Il s'agit d'une version de code golf d'une question similaire que j'ai posée sur la pile plus tôt, mais j'ai pensé que ce serait un puzzle intéressant.
Étant donné une chaîne de longueur 10 qui représente un nombre de base 36, incrémentez-la de un et retournez la chaîne résultante.
Cela signifie que les chaînes ne contiendront que des chiffres de 0
à 9
et des lettres de a
à z
.
La base 36 fonctionne comme suit:
Le droit chiffre le plus est incrémenté, d' abord à l'aide 0
de9
0000000000> 9 itérations> 0000000009
et après a
à z
est utilisé:
000000000a> 25 itérations> 000000000z
Si elle z
doit être incrémentée, elle revient à zéro et le chiffre à sa gauche est incrémenté:
000000010
Autres règles:
- Vous pouvez utiliser des majuscules ou des minuscules.
- Vous ne pouvez pas supprimer de zéros non significatifs. L'entrée et la sortie sont des chaînes de longueur 10.
- Vous n'avez pas besoin de gérer
zzzzzzzzzz
en entrée.
Cas de test:
"0000000000" -> "0000000001"
"0000000009" -> "000000000a"
"000000000z" -> "0000000010"
"123456zzzz" -> "1234570000"
"00codegolf" -> "00codegolg"
code-golf
string
base-conversion
Jack Hales
la source
la source
"0zzzzzzzzz"
(modifier le chiffre le plus significatif) comme cas de test. Il a déclenché ma solution C en raison d'une erreur de coupure par une.Réponses:
05AB1E , 10 octets
L'entrée est en majuscule .
Code
Explication
Utilise l' encodage 05AB1E . Essayez-le en ligne! ou Vérifiez tous les cas de test .
la source
Japt , 13 octets
Essayez-le en ligne! et vérifier les cas de test
Prend l'entrée sous forme de chaîne
Explication
la source
JavaScript (ES6), 45 octets
4 octets enregistrés grâce à @OOBalance
Essayez-le en ligne!
la source
Haskell , 58 octets
Essayez-le en ligne!
Une stratégie très brutale: générez toutes les chaînes de base 10 de longueur 36 dans l'ordre, et trouvez celle qui vient après l'entrée dans la liste. Prenez énormément de temps sur les chaînes loin du début de la liste.
Haskell , 60 octets
Essayez-le en ligne!
Lit la chaîne de gauche à droite jusqu'à ce qu'elle atteigne un caractère suivi d'un suffixe de tous les z, qui peut être vide. Incrémente ce caractère et remplace les z par des 0.
la source
Stax , 7 octets
Exécuter et déboguer
Explication:
la source
C (gcc) ,
5048 octetsUn indicateur de portage explicite n'était pas nécessaire après la restructuration de la boucle pour se terminer dès qu'aucun report ne se produirait. Le réglage 9-> A est effectué pendant la vérification de la boucle.
Merci à plafondcat pour la suggestion.
Essayez-le en ligne!
Version originale:
7157 octetsCette version utilise un indicateur de portage pour propager les mises à jour: je l'ai défini sur true pour commencer l'incrémentation. La chaîne est modifiée sur place et accepte uniquement 0-9, AZ. La partie délicate consistait à s'assurer que 9-> A était correctement géré lors des portées.
Edit: J'ai réorienté le pointeur d'entrée comme drapeau de report.
Essayez-le en ligne!
la source
C,
82815350 octetsModifie directement la chaîne d'entrée; l'entrée et la sortie sont en majuscules. Essayez-le en ligne ici . Merci à Arnauld d' avoir joué au golf 24 octets et à plafondcat d' avoir joué au golf 3 octets de plus.
Non golfé:
la source
ZZZZZZZZZZ
. La réponse d'ErikF fait la même chose, mais encore plus court: codegolf.stackexchange.com/a/169468/79343Simulateur de machine de Turing en ligne , 745 octets
Interprète en ligne
la source
Perl 6 ,
34 3230 octetsMerci à nwellnhof pour -2 octets grâce à l'utilisation de l'
o
opérateur pour combiner les fonctionsEssayez-le en ligne!
Fonction qui convertit l'argument en base 36, ajoute 1, reconvertit puis le formate. Utilise désormais la même tactique que la réponse d' Adnan pour conserver les zéros de tête.
la source
{S/.//}o{base :36(1~$_)+1: 36}
pour 30 octets.o
avant de jouer au golf, mais je peux voir où cela pourrait être utile!.succ
(incrémenter d'un) ne fonctionne pasMATL , 12 octets
Essayez-le en ligne!
la source
Haskell , 63 octets
Essayez-le en ligne! Inverse la chaîne et vérifie le premier caractère:
9
est remplacé par una
.z
est remplacé par a0
et récursivement le caractère suivant est vérifié.succ
la fonction successeur qui peut être utilisée sur les caractères car ils sont une instance de la classe Enum .Enfin, la chaîne résultante est à nouveau inversée.
la source
6502 (NMOS *) routine de code machine , 26 octets
*) utilise un opcode "illégal"
ISB
/0xF3
, fonctionne sur toutes les puces NMOS 6502 originales, pas sur les variantes CMOS ultérieures.Attend un pointeur sur une chaîne de 10 caractères dans
$fb
/$fc
qui devrait être un nombre en base 36. Incrémente ce nombre sur place.Ne fait rien de sensé sur une entrée invalide (comme par exemple une chaîne plus courte) - gère
ZZZZZZZZZZ
"correctement" par accident;)Démontage commenté
Exemple de programme assembleur C64 utilisant la routine:
Démo en ligne
Code dans la syntaxe ca65 :
la source
Retina 0.8.2 , 12 octets
Essayez-le en ligne! Explication: La
dl
partie de la destination de substitution se développe en0-9a-z
tandis que lao
copie vers la source, entraînantz0-9a-z
(bien que la secondez
soit ignorée car elle ne peut jamais correspondre). Cela incrémente les chiffres correspondants. La.z*$
partie du modèle correspond au dernier non-z
chiffre plus tous lesz
s de fin , gérant ainsi le report de leur incrément à0
.la source
Rubis , 40 octets
Essayez-le en ligne!
0
s"zzzzzzzzzz"
renvoie une chaîne longue de 11la source
brainfuck , 109 octets
Essayez-le en ligne!
la source
Apl (Dyalog Unicode) ,
302824 octetsMerci à ngn pour l'astuce pour économiser quelques octets.
Essayez-le en ligne!
Nécessite ⎕IO de 0
Utilise les majuscules
la source
'1',
partief
? puis1↓
fera partie de son inverse(⎕D,⎕A)⍳'1',
->1,(⎕D,⎕A)⍳
(f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢
PHP,
6964 octetsversion boiteuse :
Exécuter en tant que tuyau avec
-R
. Entrée insensible à la casse, sortie en minuscules.première approche, 69 octets:
Exécuter en tant que tuyau avec
-F
version en boucle, également 69 octets :
PHP plus récent générera des avertissements pour les constantes non définies.
Y
etA
par des lettres minuscules pour la saisie en minuscules.Exécuter en tant que tuyau avec
-nR
... ou essayez-les en ligne .
la source
-R
et appeler celui-ci 66 octets.printf('%010s',($b=base_convert)(1+$b($argn,36,10),10,36));
- 59 octets($b=base_convert)(a,b,c)
. J'apprends beaucoup de toi.Python 2 , 88 octets
Essayez-le en ligne!
Incrémente la chaîne "à la main".
la source
Fusain , 14 octets
Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:
Imprimer 9
0
s. Cela sert à garnir le résultat.Convertissez l'entrée de la base 36, incrémentez-la, puis reconvertissez-la en base 36. Ensuite, inversez le résultat et imprimez-le vers la gauche.
la source
Java 8,
907656 octetsAccepte les lettres majuscules et minuscules pour la saisie. La sortie est toujours en minuscules.
Merci à Okx d' avoir joué au golf 18 octets.
Essayez-le en ligne ici .
Non golfé:
la source
"".format("%10s",t).replace(' ','0')
1
au début puis à le supprimer:s->Long.toString(Long.valueOf("1"+s,36)+1,36).substring(1)
"1"+s
=>1+s
JavaScript (ES6), 89 octets
Celui-ci n'est pas aussi efficace en octets que l'autre entrée JavaScript , mais je l'ai fait sans remarquer cette règle:
Ce n'est donc pas une entrée sérieuse - juste pour le plaisir! Il fonctionne avec des chaînes de longueur générale, telles que
0abc
, et ajoute un1
lorsque le premier chiffre estz
, par exemplezzz
->1000
. L'entrée doit être en minuscules.Explication
L'expression
(A, B, C)
signifie en fait "faire A, puis faire B, puis retourner C", que j'utilise pour déclarer certaines variables que je réutilise dans le code.s
signifie "chaîne",l
signifie "dernier",r
signifie "repos".Il s'agit d'une fonction récursive. Pour une chaîne typique comme
aza
, il incrémentera simplement le dernier caractère (voir ligne 6) -azb
. Mais pour une chaîne qui se termine parz
, commeh0gz
, elle s'exécutera sur tout jusqu'au dernier caractère (lez
) et remplacera un0
à la place de celui-ci (voir ligne 5) -f(h0gz)
=f(h0g) + 0
=h0h0
.La
||'0'
ligne 5 est pour que la fonction fonctionne lorsqu'elle est appelée sur une chaîne de 1 longueur (c'est-à-dire la chaîne'z'
). Sans elle,f('')
est appelée (depuis'z'.slice(0, -1)
est''
), qui a un comportement indéfini (littéralement - essayez-le vous-même), et ce n'est pas bon. Le résultat attendu def('z')
est'10'
, qui est ce que nous obtenonsf('0') + 0
, nous utilisons donc||'0'
. (||'0'
est particulièrement utile car il ne gêne pas le cas habituel -r
étant d'au moins 1 longueur (s
au moins 2 longueurs) - parce que les chaînes ne sont falsey que lorsqu'elles sont de longueur 0.)La méthode pour incrémenter une chaîne est la même que celle utilisée dans l'autre entrée JS: convertir le "nombre" base-36 en un nombre réel, ajouter 1, puis le reconvertir en base-36. Nous n'avons pas à nous soucier de l'
1
incrémentation de 'z' ('z'
->'10'
), car nous n'incrémentons jamais réellement 'z' (voir lignes 4 et 6: le dernier caractère n'est incrémenté que s'il n'est pas 'z').De plus, nous ne risquons jamais de supprimer les zéros non significatifs, car nous ne manipulons jamais plus d'un seul caractère à la fois - uniquement le dernier caractère de la chaîne. Les autres caractères sont tranchés proprement au fur et à mesure que vous coupez n'importe quelle chaîne et après-mots ajoutés.
la source
Nettoyer ,
8984 octetsEssayez-le en ligne!
Une solution plus courte grâce à Laikoni .
Propre , 115 octets
J'adore quand j'utilise
limit(iterate...
Essayez-le en ligne!
Produit la réponse sans convertir les bases à l'aide de la correspondance de liste.
? :: [Char] -> [Char]
effectue le transport vers l'avant.@ :: Char -> Char
incréments d'une unité, ce qui explique l'écart entre'9'
et'z'
.$ :: [Char] -> [Char]
incrémente le dernier caractère et s'applique?
jusqu'à ce que la valeur se stabilise.la source
R ,
152123 octetsEssayez-le en ligne!
Une approche complètement différente. Obtenez les points de code ASCII et "incrémentez" récursivement le point de code le plus à droite (faisant
0
(57) sauter àa
(97) etz
(122) revenir à0
(48)) jusqu'à ce que vous soyez à court dez
s. Reconvertissez en chaîne.Ancienne version
Essayez-le en ligne!
Il s'agit uniquement de manipulation de texte, ce qui ne va pas de pair avec le golf en code R.
Remplacez tout
z
à la fin des chaînes par0
. Trouver l'emplacement du dernier élément avant les0
s finaux nouvellement créés . Trouvez le prochain chiffre de base 36. Faites le changement. Soyez heureux d'avoir à peine battu la solution Online Turing Machine Simulator.la source
strtoi
de vous aider à démarrer; il y a encore quelques astuces de golf pour le ramener à 72.strtoi
est limité à des nombres plutôt petits cependant? J'y ai renoncé il y a quelque temps.int
restriction était si problématique. Bummer! Pour la postérité, c'était ma solution ratée: essayez-la en ligne!Étoilé , 325 octets
Essayez-le en ligne!
Explication:
la source
Wolfram Language (Mathematica) , 39 octets
Essayez-le en ligne!
la source
Python 3.6+ et gmpy2 , 62 octets
Essayez-le en ligne!
(Notez que gmpy2 ne fait pas partie de la bibliothèque standard Python et nécessite une installation séparée)
la source
f=
. Les fonctions anonymes sont généralement considérées comme trouver dans le code golf.Pyke , 11 octets
Essayez-le ici!
Peut être 2 octets plus court avec le changement de langue suivant: Si le mode hexadécimal est utilisé, changez toutes les utilisations de base_36 et base_10 en base_92 (qui n'est pas vraiment de base 92 dans ce contexte de toute façon)
la source
sed , 94 octets
Essayez-le en ligne!
Sed souffre beaucoup d'avoir à changer les personnages par recherche.
la source
Zsh ,
4136 octetsEssayez-le en ligne!
la source
Gelée , 21 octets
Essayez-le en ligne!
Utilise des majuscules. Le lien TIO permet également les minuscules / mixtes.
la source