Esta é uma versão de código-golfe de uma pergunta semelhante que fiz anteriormente na pilha, mas pensei que seria um quebra-cabeça interessante.

Dada uma sequência de comprimento 10 que representa um número base 36, aumente-a em um e retorne a sequência resultante.

Isso significa que as cordas irá conter apenas dígitos de 0a 9e cartas de aa z.

A base 36 funciona da seguinte maneira:

O dígito mais à direita é incrementado, primeiro usando 0para9

0000000000> 9 iterações> 0000000009

e depois que aa zé usado:

000000000a> 25 iterações> 000000000z

Se zprecisar ser incrementado, ele volta ao zero e o dígito à esquerda é incrementado:

000000010

Regras adicionais:

• Você pode usar letras maiúsculas ou minúsculas.
• Você não pode soltar zeros à esquerda. Tanto a entrada quanto a saída são cadeias de comprimento 10.
• Você não precisa manipular zzzzzzzzzzcomo entrada.

Casos de teste:

"0000000000" -> "0000000001"
"0000000009" -> "000000000a"
"000000000z" -> "0000000010"
"123456zzzz" -> "1234570000"
"00codegolf" -> "00codegolg"

05AB1E , 10 bytes

A entrada está em maiúscula .

Código

1ì36ö>36B¦

Explicação

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

Usa a codificação 05AB1E . Experimente online! ou Verifique todos os casos de teste .

Japonês , 13 bytes

n36 Ä s36 ù0A

Experimente online! e verificar casos de teste

Recebe entrada como uma string

Explicação

n36            converts input to base 36
    Ä           +1
      s36       to base 36 string
          ù0A   left-pad with 0 to length 10

JavaScript (ES6), 45 bytes

Guardado 4 bytes graças a @OOBalance

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

Experimente online!

Haskell , 58 bytes

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

Experimente online!

Uma estratégia de força bruta: gere todas as seqüências de comprimento-10-base-36 em ordem e encontre a que vem depois da entrada da lista. Reserve uma quantidade enorme de tempo em seqüências de caracteres distantes do início da lista.

Haskell , 60 bytes

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

Experimente online!

Lê a string da esquerda para a direita até atingir um caractere seguido por um sufixo de todos os zs, que podem estar vazios. Incrementa esse caractere e substitui o z pelo 0.

Stax , 7 bytes

ûæ≥╡►N▀

Execute e depure

Explicação:

|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

C (gcc) , 50 48 bytes

Um sinalizador de transporte explícito não era necessário após a reestruturação do loop para terminar assim que nenhum transporte acontecesse. O ajuste 9-> A é realizado durante a verificação do loop.

Agradecimentos a ceilingcat pela sugestão.

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

Experimente online!

Versão original: 71 57 bytes

Esta versão usa um sinalizador carry para propagar atualizações: eu o defino como verdadeiro para iniciar o incremento. A sequência é modificada no local e aceita apenas 0-9, AZ. A parte complicada era garantir que 9-> A fosse manuseado corretamente nos carregamentos.

Edit: Eu redirecionei o ponteiro de entrada como o sinalizador de transporte.

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

Experimente online!

C, 82 81 53 50 bytes

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

Modifica diretamente a sequência de entrada; entrada e saída estão em maiúsculas. Experimente online aqui . Agradecimentos a Arnauld pelo golfe de 24 bytes e ao tetocat por jogar mais 3 bytes.

Ungolfed:

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

Simulador de máquina de Turing on-line , 745 bytes

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

Intérprete online

Perl 6 , 34 32 30 bytes

Graças ao nwellnhof por -2 bytes através do uso do ooperador para combinar funções

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

Experimente online!

Função que converte o argumento na base 36, adiciona 1, converte novamente e depois o formata. Agora usa a mesma tática da resposta de Adnan para preservar os zeros à esquerda.

MATL , 12 bytes

36ZAQ5M10&YA

Experimente online!

           % 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

Haskell , 63 bytes

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

Experimente online! Inverte a string e verifica o primeiro caractere:

• A 9é substituído por um a.
• A zé substituído por um0 e recursivamente o próximo caractere é verificado.
• Todos os outros caracteres são incrementados usando succ, a função sucessora que pode ser usada em Chars porque são uma instância da classe Enum .

Finalmente, a sequência resultante é revertida novamente.

Rotina de código de máquina 6502 (NMOS *) , 26 bytes

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

*) usa um código de operação "ilegal" ISB/0xF3 , funciona em todos os chips NMOS 6502 originais, não nas variantes posteriores do CMOS.

Espera um ponteiro para uma sequência de 10 caracteres em $fb/$fc que deve ser um número de base 36. Incrementa esse número no local.

Não faz nada sensato na entrada inválida (como, por exemplo, uma string mais curta) - manipula ZZZZZZZZZZ"corretamente" por acidente;)

Desmontagem comentada

; 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

Exemplo de programa assembler C64 usando a rotina:

Demonstração online

Código na sintaxe 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

Retina 0.8.2 , 12 bytes

T`zo`dl`.z*$

Experimente online! Explicação: A dlparte do destino de substituição se expande para 0-9a-zenquanto as ocópias são enviadas para a origem, resultando em z0-9a-z(embora o segundo zseja ignorado, pois nunca poderá corresponder). Isso incrementa os dígitos correspondentes. A .z*$parte do padrão corresponde ao último não zdígito mais todos os zs finais , manipulando assim o transporte do incremento para 0.

Ruby , 40 bytes

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

Experimente online!

1. Converta a string em um número inteiro interpretando-a como base 36
2. Adicionar 1
3. Converter de volta para a base 36 string
4. Almofada esquerda com 0s

"zzzzzzzzzz" retorna uma cadeia de 11 caracteres

brainfuck , 109 bytes

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

Experimente online!

Apl (Dyalog Unicode) , 30 28 24 bytes

Agradecemos a ngn pela dica de salvar alguns bytes.

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

Experimente online!

• Requer ⎕IO de 0

• Usa maiúsculas

PHP, 69 64 bytes

versão coxo :

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

Corra como cano com -R. Insensível a maiúsculas e minúsculas, saída em minúsculas.

primeira abordagem, 69 bytes:

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

Executar como tubo com -F

versão em loop, também 69 bytes :

for($n=$argn;~$c=$n[$i-=1];)$f||$f=$n[$i]=$c!=9?$c>Y?0:++$c:A;echo$n;

• Somente PHP 7.1: o PHP antigo não entende índices negativos de string,
  o PHP mais novo emitirá avisos para constantes indefinidas.
• requer entrada em maiúsculas. Substitua Ye Apor letras minúsculas para inserir letras minúsculas.

Executar como tubo com -nR

... ou experimentá-los online .

Python 2 , 88 bytes

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']

Experimente online!

Incrementa a string "manualmente".

Carvão , 14 bytes

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

Experimente online!Link é a versão detalhada do código. Explicação:

×0⁹

Imprima 9 0s. Isso serve para amortecer o resultado.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Converta a entrada da base 36, aumente e depois converta novamente na base 36. Em seguida, inverta o resultado e imprima para a esquerda.

Java 8, 90 76 56 bytes

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

Aceita letras maiúsculas e minúsculas para entrada. A saída está sempre em minúsculas.

Graças a Okx por jogar 18 bytes.

Experimente online aqui .

Ungolfed:

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'

JavaScript (ES6), 89 bytes

Este não é tão eficiente em bytes quanto a outra entrada JavaScript , mas eu fiz isso sem observar esta regra:

Dada uma sequência de comprimento 10

Portanto, essa não é uma entrada séria - apenas por diversão! Ele funciona com cadeias de comprimento geral, como 0abc, e precede a 1quando o primeiro dígito é z, por exemplo zzz- -> 1000. A entrada deve estar em minúscula.

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

Explicação

A expressão (A, B, C)realmente significa "faça A, depois faça B e depois retorne C", que utilizo para declarar algumas variáveis ​​que reutilizo no código. ssignifica "string", lsignifica "last", rsignifica "descanso".

/*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))

Esta é uma função recursiva. Para uma string típica como aza, isso apenas aumentará o último caractere (veja a linha 6) - azb. Mas uma string que termina com z, como h0gz, será executada em tudo até o último caractere (the z) e substituirá a 0no lugar dela (consulte a linha 5) - f(h0gz)= f(h0g) + 0=h0h0 .

A ||'0'linha 5 é para que a função funcione quando é chamada em uma string de 1 comprimento (ou seja, a string 'z'). Sem ele, f('')é chamado (como 'z'.slice(0, -1)está ''), que tem um comportamento indefinido (literalmente - tente você mesmo), e isso não é bom. O resultado esperado def('z') é '10', que é o que obtemos f('0') + 0, então usamos ||'0'. ( ||'0'é particularmente útil porque não atrapalha o caso usual - rsendo pelo menos um comprimento (s pelo menos 2) - porque as strings são falsey apenas quando são 0).

O método para incrementar uma sequência é o mesmo usado na outra entrada JS: converta o "número" da base-36 em um número real, adicione 1 e depois converta-o novamente em base-36. Não precisamos nos preocupar com o 1incremento de 'z' ( 'z'-> '10'), pois nunca incrementamos 'z' (consulte as linhas 4 e 6: o último caractere só é incrementado se não for 'z').

Além disso, nunca corremos o risco de descartar zeros à esquerda, porque na verdade nunca manipulamos mais de um caractere por vez - apenas o último caractere da string. O restante dos caracteres é cortado em fatias à medida que você corta qualquer sequência de caracteres e o prefixo anexado.

Limpo , 89 84 bytes

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

r o@o r

Experimente online!

Uma solução mais curta graças ao Laikoni .

Limpar \ limpo , 115 bytes

Adoro quando uso 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)]))

Experimente online!

Produz a resposta sem converter bases usando a correspondência de lista.

• ? :: [Char] -> [Char] executa transporte para frente.
• @ :: Char -> Charincrementos de um, representando a diferença entre '9'e 'z'.
• $ :: [Char] -> [Char]incrementa o último caractere e aplica-se ?até o valor estabilizar.

R , 152 123 bytes

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

Experimente online!

Uma abordagem completamente diferente. Obtenha os pontos de código ASCII e "incremente" recursivamente o ponto de código mais à direita (fazendo 0(57) pular para a(97) e z(122) voltar para 0(48)) até ficar sem zs. Converta de volta para string.

Versão antiga

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

Experimente online!

Isso é tudo manipulação de texto, que não caminha de mãos dadas com o golfe com código R.

Substitua tudo zno final das cordas por 0. Encontre a localização do último elemento antes dos 0s à direita recém-formados . Encontre a próxima base de 36 dígitos. Fazer a mudança. Fique feliz por ter vencido a solução Online Turing Machine Simulator.

Estrelado , 325 bytes

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

Experimente online!

Explicação:

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
| +   '

Wolfram Language (Mathematica) , 39 bytes

IntegerString[#~FromDigits~36+1,36,10]&

Experimente online!

Python 3.6+ e gmpy2 , 62 bytes

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

Experimente online!

(Observe que o gmpy2 não faz parte da biblioteca padrão do Python e requer instalação separada)

Pyke , 11 bytes

? b!!R+bhbt

Experimente aqui!

? 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:]

Pode ser 2 bytes mais curto com a seguinte alteração de idioma: Se o modo hexadecimal for usado, altere todos os usos base_36 e base_10 para base_92 (que não é realmente a base 92 nesse contexto).

sed , 94 bytes

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

Experimente online!

Sed sofre muito por ter que mudar os caracteres pela pesquisa.

Zsh , 41 36 bytes

echo ${(l:10::0:)$(([##36]36#$1+1))}

Experimente online!

Geléia , 21 bytes

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

Experimente online!

Usa maiúsculas. O link TIO também permite letras minúsculas / mistas.