Incrémenter les cordes de base-36

20

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à 9et des lettres de aà z.

La base 36 fonctionne comme suit:

Le droit chiffre le plus est incrémenté, d' abord à l'aide 0de9

0000000000> 9 itérations> 0000000009

et après aà zest utilisé:

000000000a> 25 itérations> 000000000z

Si elle zdoit ê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 zzzzzzzzzzen entrée.

Cas de test:

"0000000000" -> "0000000001"
"0000000009" -> "000000000a"
"000000000z" -> "0000000010"
"123456zzzz" -> "1234570000"
"00codegolf" -> "00codegolg"
Jack Hales
la source
@JoKing Code-golf, idées sympas et efficacité je suppose.
Jack Hales
7
J'aime l'idée d'implémenter uniquement l'opération d'incrémentation car elle a le potentiel pour des stratégies autres que la conversion de base ici et retour.
2018
2
Bienvenue chez PPCG! C'est une bonne idée de défi, mais comme certains commentaires l'ont souligné, certaines parties de la spécification ne sont pas claires. Pour l'avenir, je recommande d'utiliser notre bac à sable où vous pouvez obtenir des commentaires sur un défi avant de le poster.
Laikoni
1
vous suggérons d'ajouter quelque chose comme "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.
OOBalance
1
a ajouté une entrée en supposant que ça va - une entrée C le fait déjà aussi.
Felix Palmen

Réponses:

6

05AB1E , 10 octets

L'entrée est en majuscule .

Code

1ì36ö>36B¦

Explication

1ì           # Prepend a 1 to the number
  36ö        # Convert from base 36 to decimal
     >       # Increment by 1
      36B    # Convert from decimal to base 36
         ¦   # Remove the first character

Utilise l' encodage 05AB1E . Essayez-le en ligne! ou Vérifiez tous les cas de test .

Adnan
la source
Peut être de 8 octets dans la nouvelle version de 05AB1E.
Kevin Cruijssen
8

Japt , 13 octets

n36 Ä s36 ù0A

Essayez-le en ligne! et vérifier les cas de test

Prend l'entrée sous forme de chaîne

Explication

n36            converts input to base 36
    Ä           +1
      s36       to base 36 string
          ù0A   left-pad with 0 to length 10
crashoz
la source
Bienvenue chez Japt! :)
Shaggy
8

JavaScript (ES6), 45 octets

4 octets enregistrés grâce à @OOBalance

s=>(parseInt(1+s,36)+1).toString(36).slice(1)

Essayez-le en ligne!

Arnauld
la source
Vous êtes fou, bon. +1
Jack Hales
2
45 octets: bit.ly/2K5tjw0
OOBalance
Je ne pense plus à l'ES8 après le dernier golf ...
Downgoat
@Downgoat Merci! Tu as raison. Mis à jour.
Arnauld
7

Haskell , 58 octets

d=['0'..'9']
f s=snd(span(<s)$mapM(\_->d++['a'..'z'])d)!!1

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

q '9'='a'
q c=succ c
f(h:t)|any(<'z')t=h:f t|r<-'0'<$t=q h:r

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.

xnor
la source
6

Stax , 7 octets

ûæ≥╡►N▀

Exécuter et déboguer

Explication:

|3^|3A|z Full program, implicit input
|3       Convert from base 36
  ^      Increment
   |3    Convert to base 36
     A|z Fill with "0" to length 10
         Implicit output
wastl
la source
6

C (gcc) , 50 48 octets

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

f(char*s){for(s+=9;(*s+=*s-57?1:8)>90;*s--=48);}

Essayez-le en ligne!


Version originale: 71 57 octets

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

f(s){for(char*t=s+9;s;)*t--+=(s=++*t>90)?-43:7*!(*t-58);}

Essayez-le en ligne!

ErikF
la source
6

C, 82 81 53 50 octets

f(char*s){for(s+=10;*--s>89;)*s=48;*s+=*s-57?1:8;}

Modifie 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é:

f(char *s) { // function taking a string argument
     for(s += 10; *--s > 89; ) // skip to the least significant digit, and step through the string until you hit something other than a 'Z' (90 is the ASCII code for 'Z') ...
         *s = 48; // ... replacing each digit with a zero (48 is the ASCII code for '0')
         *s += // the next digit has to be incremented:
         *s - 57 // if it's not a '9' (ASCII code 57) ...
         ? 1 // ... that is straightforward ...
         : 8; // ... otherwise it has to be replaced with an 'A' (ASCII code 65 = 57 + 8)
 }
OOBalance
la source
Je pense que cela devrait être sûr: 60 octets
Arnauld
1
@Arnauld Vous ne pouvez pas supposer un octet zéro avant la chaîne ...
Jakob
1
@Jakob Je n'en suis pas sûr à 100%. Nous définissons les langages par leurs implémentations. Il s'agit de C (gcc) exécuté sur une machine virtuelle TIO, où la mémoire peut - je pense - être supposée initialement effacée. (J'ai vu d'autres réponses en C qui font des suppositions similaires.)
Arnauld
2
En incluant l'environnement de test dans la «mise en œuvre», je vais peut-être trop loin. Mais vous pouvez toujours utiliser la version 60 octets qui ne repose sur aucune hypothèse de mémoire.
Arnauld
1
@Arnauld J'ai joué au golf encore 4 octets. Cela devrait vraiment être sûr, car nous n'avons pas à gérer ZZZZZZZZZZ. La réponse d'ErikF fait la même chose, mais encore plus court: codegolf.stackexchange.com/a/169468/79343
OOBalance
5

Simulateur de machine de Turing en ligne , 745 octets

init:0
accept:2
0,0
0,0,>
0,1
0,1,>
0,2
0,2,>
0,3
0,3,>
0,4
0,4,>
0,5
0,5,>
0,6
0,6,>
0,7
0,7,>
0,8
0,8,>
0,9
0,9,>
0,a
0,a,>
0,b
0,b,>
0,c
0,c,>
0,d
0,d,>
0,e
0,e,>
0,f
0,f,>
0,g
0,g,>
0,h
0,h,>
0,i
0,i,>
0,j
0,j,>
0,k
0,k,>
0,l
0,l,>
0,m
0,m,>
0,n
0,n,>
0,o
0,o,>
0,p
0,p,>
0,q
0,q,>
0,r
0,r,>
0,s
0,s,>
0,t
0,t,>
0,u
0,u,>
0,v
0,v,>
0,w
0,w,>
0,x
0,x,>
0,y
0,y,>
0,z
0,z,>
0,_
1,_,<
1,0
2,1,-
1,1
2,2,-
1,2
2,3,-
1,3
2,4,-
1,4
2,5,-
1,5
2,6,-
1,6
2,7,-
1,7
2,8,-
1,8
2,9,-
1,9
2,a,-
1,a
2,b,-
1,b
2,c,-
1,c
2,d,-
1,d
2,e,-
1,e
2,f,-
1,f
2,g,-
1,g
2,h,-
1,h
2,i,-
1,i
2,j,-
1,j
2,k,-
1,k
2,l,-
1,l
2,m,-
1,m
2,n,-
1,n
2,o,-
1,o
2,p,-
1,p
2,q,-
1,q
2,r,-
1,r
2,s,-
1,s
2,t,-
1,t
2,u,-
1,u
2,v,-
1,v
2,w,-
1,w
2,x,-
1,x
2,y,-
1,y
2,z,-
1,z
1,0,<

Interprète en ligne

Erik le Outgolfer
la source
5

Perl 6 , 34 32 30 octets

Merci à nwellnhof pour -2 octets grâce à l'utilisation de l' oopérateur pour combiner les fonctions

{S/.//}o{base :36(1~$_)+1: 36}

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

Jo King
la source
{S/.//}o{base :36(1~$_)+1: 36}pour 30 octets.
nwellnhof
@nwellnhof Neat! Je n'ai jamais pensé à l'utiliser oavant de jouer au golf, mais je peux voir où cela pourrait être utile!
Jo King
Ah, c'est dommage que .succ(incrémenter d'un) ne fonctionne pas
Jo King
4

MATL , 12 octets

36ZAQ5M10&YA

Essayez-le en ligne!

           % Implicit input
36ZA       % convert from base 36 to decimal
Q          % increment by 1
5M         % bring the 36 back on stack (done this way to avoid needing space separator after this)
10         % = minimum length of output string
&YA        % convert back to base 36 with those arguments
           % Implicit output
Sundar - Rétablir Monica
la source
4

Haskell , 63 octets

r.f.r
f('9':r)='a':r
f('z':r)='0':f r
f(c:r)=succ c:r
r=reverse

Essayez-le en ligne! Inverse la chaîne et vérifie le premier caractère:

  • A 9est remplacé par un a.
  • A zest remplacé par a 0et récursivement le caractère suivant est vérifié.
  • Tous les autres caractères sont incrémentés à l'aide de succla 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.

Laikoni
la source
4

6502 (NMOS *) routine de code machine , 26 octets

A0 09 F3 FB B1 FB C9 5B 90 07 A9 30 91 FB 88 10 F1 C9 3A D0 04 A9 41 91 FB 60

*) 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/ $fcqui 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é

; function to increment base 36 number as 10 character string
;
; input:
;   $fb/$fc: address of string to increment
; clobbers:
;   A, Y
 .inc36:
A0 09       LDY #$09            ; start at last character
 .loop:
F3 FB       ISB ($FB),Y         ; increment character ("illegal" opcode)
B1 FB       LDA ($FB),Y         ; load incremented character
C9 5B       CMP #$5B            ; > 'z' ?
90 07       BCC .checkgap       ; no, check for gap between numbers and letters
A9 30       LDA #$30            ; load '0'
91 FB       STA ($FB),Y         ; and store in string
88          DEY                 ; previous position
10 F1       BPL .loop           ; and loop
 .checkgap:
C9 3A       CMP #$3A            ; == '9' + 1 ?
D0 04       BNE .done           ; done if not
A9 41       LDA #$41            ; load 'a'
91 FB       STA ($FB),Y         ; and store in string
 .done:
60          RTS

Exemple de programme assembleur C64 utilisant la routine:

Démo en ligne

capture d'écran

Code dans la syntaxe ca65 :

.import inc36   ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
b36str:         .res    11

.data
prompt:         .byte   "> ", $0

.code
                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<b36str        ; read string into buffer
                ldy     #>b36str
                ldx     #$b
                jsr     readline

                lda     #<b36str        ; address of array to $fb/fc
                sta     $fb
                lda     #>b36str
                sta     $fc
                jsr     inc36           ; call incrementing function

                lda     #<b36str        ; output result
                ldy     #>b36str
                jmp     $ab1e

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                dex
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key
.endproc
Felix Palmen
la source
1
La version 65C02 peut ignorer l'ISB, puis utiliser INC après le LDA (), Y (et .done monte d'une ligne) et être plus courte d'un octet.
peter ferrie
@peterferrie le 65C02 a-t-il un INC pour l'accu?
Felix Palmen
@peterferrie ok, ça le fait, c'est bien - c'est ce qui me manquait en premier sur le 6502 :)
Felix Palmen
3

Retina 0.8.2 , 12 octets

T`zo`dl`.z*$

Essayez-le en ligne! Explication: La dlpartie de la destination de substitution se développe en 0-9a-ztandis que la ocopie vers la source, entraînant z0-9a-z(bien que la seconde zsoit ignorée car elle ne peut jamais correspondre). Cela incrémente les chiffres correspondants. La .z*$partie du modèle correspond au dernier non- zchiffre plus tous les zs de fin , gérant ainsi le report de leur incrément à 0.

Neil
la source
3

Rubis , 40 octets

->s{(s.to_i(36)+1).to_s(36).rjust 10,?0}

Essayez-le en ligne!

  1. Convertir la chaîne en un entier l'interprétant comme base 36
  2. Ajouter 1
  3. Convertir en chaîne de base 36
  4. Pad gauche avec 0s

"zzzzzzzzzz" renvoie une chaîne longue de 11

Asone Tuhid
la source
3

brainfuck , 109 octets

,[>>,]<+[++++<[<--->>-<-]-[<->>+<---]<[[-]>-------<]+>>[[+<+>]<<+[>+<------]>>]-[<+>-----]<++++<]<[<<]>>[.>>]

Essayez-le en ligne!

Nitrodon
la source
C'est ce que j'avais envie de voir!
Jack Hales
3

Apl (Dyalog Unicode) , 30 28 24 octets

Merci à ngn pour l'astuce pour économiser quelques octets.

(f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢

Essayez-le en ligne!

  • Nécessite ⎕IO de 0

  • Utilise les majuscules

jslip
la source
pourquoi ne pas aller plus loin et en faire '1',partie f? puis 1↓fera partie de son inverse
ngn
@ngn Nice, merci!
jslip
encore plus court: (⎕D,⎕A)⍳'1',->1,(⎕D,⎕A)⍳
ngn
une dernière amélioration - il peut être réécrit comme un train:(f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢
ngn
3

PHP, 69 64 octets

version boiteuse :

printf("%010s",base_convert(1+base_convert($argn,36,10),10,36));

Exécuter en tant que tuyau avec -R. Entrée insensible à la casse, sortie en minuscules.

première approche, 69 octets:

<?=str_pad(base_convert(1+base_convert($argn,36,10),10,36),10,'0',0);

Exécuter en tant que tuyau avec -F

version en boucle, également 69 octets :

for($n=$argn;~$c=$n[$i-=1];)$f||$f=$n[$i]=$c!=9?$c>Y?0:++$c:A;echo$n;
  • PHP 7.1 uniquement: le PHP plus ancien ne comprend pas les index de chaîne négatifs, le
    PHP plus récent générera des avertissements pour les constantes non définies.
  • nécessite une entrée en majuscules. Remplacez Yet Apar des lettres minuscules pour la saisie en minuscules.

Exécuter en tant que tuyau avec -nR

... ou essayez-les en ligne .

Titus
la source
68 octets: essayez-le en ligne!
Night2
Une autre version de 68 octets: Essayez-le en ligne! Vous pouvez également utiliser votre -Ret appeler celui-ci 66 octets.
Night2
1
@ Night2 Bonne approche; mais cela peut être fait encore plus court: printf('%010s',($b=base_convert)(1+$b($argn,36,10),10,36));- 59 octets
Titus
1
Joli. Je ne savais pas que nous pourrions appeler une fonction comme ceci: ($b=base_convert)(a,b,c). J'apprends beaucoup de toi.
Night2
2

Python 2 , 88 octets

def f(s):L,R=s[:-1],s[-1:];return s and[[L+chr(ord(R)+1),f(L)+'0'][R>'y'],L+'a'][R=='9']

Essayez-le en ligne!

Incrémente la chaîne "à la main".

Chas Brown
la source
2

Fusain , 14 octets

×0⁹←⮌⍘⊕⍘S³⁶¦³⁶

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

×0⁹

Imprimer 9 0s. Cela sert à garnir le résultat.

←⮌⍘⊕⍘S³⁶¦³⁶

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.

Neil
la source
2

Java 8, 90 76 56 octets

s->Long.toString(Long.valueOf(1+s,36)+1,36).substring(1)

Accepte 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é:

s -> // lambda taking a String argument and returning a String
    Long.toString(Long.valueOf(1+s,36)+1,36) // prefix input with '1' to ensure leading zeros, convert to Long using base 36, increment, then convert back to String in base 36
    .substring(1) // remove the leading '1'
OOBalance
la source
Agréable! Pour référence future dans Java plus ancien, vous pouvez remplir avec quelque chose comme"".format("%10s",t).replace(' ','0')
Jakob
@Jakob Merci, c'est ce que je cherchais.
OOBalance
Il est plus court d'utiliser l'approche consistant à ajouter un 1au début puis à le supprimer:s->Long.toString(Long.valueOf("1"+s,36)+1,36).substring(1)
Okx
@Okx Belle approche. 2 octets supplémentaires: "1"+s=>1+s
OOBalance
2

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:

Étant donné une chaîne de longueur 10

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 un 1lorsque le premier chiffre est z, par exemple zzz-> 1000. L'entrée doit être en minuscules.

s=>(l=s[s.length-1],r=s.slice(0,-1),l=='z'?f(r||'0')+0:r+(parseInt(l,36)+1).toString(36))

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. ssignifie "chaîne", lsignifie "dernier", rsignifie "repos".

/*1*/ s=>(
/*2*/   l=s[s.length-1],
/*3*/   r=s.slice(0,-1),
/*4*/   l=='z'
/*5*/     ? f(r||'0')+0
/*6*/     : r+(parseInt(l,36)+1).toString(36))

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 par z, comme h0gz, elle s'exécutera sur tout jusqu'au dernier caractère (le z) et remplacera un 0à 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 de f('z')est '10', qui est ce que nous obtenons f('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 ( sau 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' 1incré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.

Florrie
la source
2

Nettoyer , 89 84 octets

import StdEnv
@['9':t]=['a':t]
@['z':t]=['0': @t]
@[c:t]=[inc c:t]
r=reverse

r o@o r

Essayez-le en ligne!

Une solution plus courte grâce à Laikoni .

Propre , 115 octets

J'adore quand j'utilise limit(iterate...

import StdEnv
@'9'='a'
@c=inc c
?[h,'{':t]=[@h,'0': ?t]
?[h:t]=[h: ?t]
?e=e
$l=limit(iterate?(init l++[@(last l)]))

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 -> Charincré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.
Οurous
la source
1
Moins sophistiqué, mais un peu plus court: essayez-le en ligne!
Laikoni
@Laikoni Modifié en, merci!
2018 20urous
2

R , 152 123 octets

function(x)f(utf8ToInt(x),10)
f=function(x,n,y=x[n]){x[n]=y+(y==57)*39+(y==122)*(-75)+1
"if"(y==122,f(x,n-1),intToUtf8(x))}

Essayez-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) et z(122) revenir à 0(48)) jusqu'à ce que vous soyez à court de zs. Reconvertissez en chaîne.

Ancienne version

function(s,w=gsub("(z)(?=\\1*$)","0",s,,T),x=regexpr(".0*$",w)[1],y=substr(w,x,x),z=chartr("0-9a-z","1-9a-z0",y))sub(p(y,"(0*$)"),p(z,"\\1"),w)
p=paste0

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 par 0. Trouver l'emplacement du dernier élément avant les 0s 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.

ngm
la source
Vous pouvez faire bien mieux que ça !! Je pense que j'ai 72 octets, si vous pouvez trouver le bon intégré ...
Giuseppe
Oups ... pensiez que ce défi était un jeu de code!
ngm
Eh bien, la fonction intégrée est strtoide vous aider à démarrer; il y a encore quelques astuces de golf pour le ramener à 72.
Giuseppe
1
strtoiest limité à des nombres plutôt petits cependant? J'y ai renoncé il y a quelque temps.
ngm
Oh je vois. Je ne savais pas que la intrestriction était si problématique. Bummer! Pour la postérité, c'était ma solution ratée: essayez-la en ligne!
Giuseppe
2

Étoilé , 325 octets

     + , , , , , , , , , ,     +      +   +   +`* +          + +* + +**      + * +* * '    +           + +* +* +* +*      +* `     +  + +                + +  *       +* *  '    +      +*           + +* +* +*  `   +   +           + +* +  *  **   +  + +'    +    +   ` +           + +* +  *    * .           + +* +  *   * +   '

Essayez-le en ligne!

Explication:

Put-a-zero-at-the-base-of-the-stack
|     +
Read-10-digits
| , , , , , , , , , ,
Initialise-next-stack
|     +
Initialise-carry-bit
|      +
|   +   +
Do
|`
    Top-of-stack:-[output-stack]-[carry-bit]-[next-value]
    Add-Carry-bit-to-digit
    |*

    Compare-with-58-("9"=57)
    | +
    5-double-triple-sub1-double
    |          + +* + +**      + * +*
    Take-difference
    | *
    If-one-above-"9"
    | '
        set-to-"a"=97=6-double-double-double-double-add1
        |    +
        |           + +* +* +* +*      +*
    | `

    Initialise-next-carry-bit
    |     +
    |  +

    Compare-with-123-("z"=122)
    | +
    11-squared-add2
    |                + +  *       +*
    Take-difference
    | *
    If-one-above-"z"
    |  '
        Delete-current-value
        |    +
        set-carry-bit
        |      +*
        Set-to-"0"=48
        |           + +* +* +*
    |  `

    Push-value-to-stack
    |   +   +
    |           + +* +  *
    |  **

    |   +  +
While-next-value-is-not-null
| +'

Pop-carry-bit-and-null-string-terminator
|    +    +
Do
|   `
    Get-top-value
    | +
    |           + +* +  *
    |    *

    Print-it
    | .

    Pop-the-value-off-the-stack
    |           + +* +  *
    |   *
While-stack-is-not-null
| +   '
Sasha
la source
1

Python 3.6+ et gmpy2 , 62 octets

from gmpy2 import*;f=lambda s:f'{digits(mpz(s,36)+1,36):0>10}'

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)

chariot813
la source
Je ne pense pas que vous en ayez besoin f=. Les fonctions anonymes sont généralement considérées comme trouver dans le code golf.
mypetlion
1

Pyke , 11 octets

? b!!R+bhbt

Essayez-le ici!

? b         - Change default base of `base` command to 36 
            -  This is kind of clever because it modifies the list of characters 
            -  the command uses to exactly the same as it was originally, whilst
            -  forcing an overwrite from the default settings of 10. 
            -  The default setup works for base 36, you just have to specify it
            -  time when using the command.
            -  Literally `b.contents = modify(b.contents, func=lambda: noop)`
   !!       - The previous command returns `0123456789abcdefghijklmnopqrstuvwxyz`
            -  So we convert it into a 1 with (not not ^) for the following command:
     R+     -     "1"+input
       b    -    base(^, 36)
        h   -   ^ + 1
         b  -  base(^, 36)
          t - ^[1:]

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)

Bleu
la source
1

sed , 94 octets

s/$/#:0123456789abcdefghijklmnopqrstuvwxyz#0/
:l
s/\(.\)#\(.*:.*\1\)\(#*.\)/\3\2\3/
tl
s/:.*//

Essayez-le en ligne!

Sed souffre beaucoup d'avoir à changer les personnages par recherche.

Geoff Reedy
la source
@ETHproductions whoops, merci pour la capture
Geoff Reedy
0

Gelée , 21 octets

ØBḊiⱮḅ‘bɗ36Ż9¡ṫ-9‘ịØB

Essayez-le en ligne!

Utilise des majuscules. Le lien TIO permet également les minuscules / mixtes.

Erik le Outgolfer
la source