Incremento de cuerdas base-36

20

Esta es una versión de código de golf de una pregunta similar que hice en la pila anteriormente, pero pensé que sería un rompecabezas interesante.

Dada una cadena de longitud 10 que representa un número base 36, increméntelo en uno y devuelva la cadena resultante.

Esto significa que las cadenas solo contendrán dígitos de 0a 9y letras de aa z.

Base 36 funciona de la siguiente manera:

El dígito del extremo derecho se incrementa, en primer lugar mediante el uso 0de9

0000000000> 9 iteraciones> 0000000009

y después de que aa zse utiliza:

000000000a> 25 iteraciones> 000000000z

Si znecesita incrementarse, vuelve a cero y el dígito a su izquierda se incrementa:

000000010

Reglas adicionales:

  • Puede usar letras mayúsculas o minúsculas.
  • Es posible que no deje caer los ceros iniciales. Tanto la entrada como la salida son cadenas de longitud 10.
  • No necesita manejar zzzzzzzzzzcomo entrada.

Casos de prueba:

"0000000000" -> "0000000001"
"0000000009" -> "000000000a"
"000000000z" -> "0000000010"
"123456zzzz" -> "1234570000"
"00codegolf" -> "00codegolg"
Jack Hales
fuente
@JoKing Code-golf, ideas geniales y eficiencia, supongo.
Jack Hales
77
Me gusta la idea de implementar solo la operación de incremento porque tiene el potencial de estrategias distintas a la conversión de bases de ida y vuelta.
xnor
2
Bienvenido a PPCG! Esta es una buena idea de desafío, sin embargo, como algunos comentarios han señalado, algunas partes de la especificación no están claras. Para el futuro, recomiendo usar nuestro sandbox donde puede obtener comentarios sobre un desafío antes de publicarlo.
Laikoni
1
le sugiero que agregue algo como "0zzzzzzzzz"(modificar el dígito más significativo) como un caso de prueba. Se tropezó con mi solución C debido a un error de uno por uno.
OOBalance
1
agregó una entrada suponiendo que está bien, una entrada en C ya lo hace también.
Felix Palmen

Respuestas:

6

05AB1E , 10 bytes

La entrada está en mayúscula .

Código

1ì36ö>36B¦

Explicación

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

Utiliza la codificación 05AB1E . Pruébalo en línea! o Verificar todos los casos de prueba .

Adnan
fuente
Puede tener 8 bytes en la nueva versión de 05AB1E.
Kevin Cruijssen
8

JavaScript (ES6), 45 bytes

Guardado 4 bytes gracias a @OOBalance

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

Pruébalo en línea!

Arnauld
fuente
Estás loco, bueno. +1
Jack Hales
2
45 bytes: bit.ly/2K5tjw0
OOBalance
Ya no creo que ES8 después del último golf ...
Downgoat
@Downgoat Gracias! Tienes razón. Actualizado.
Arnauld
7

Haskell , 58 bytes

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

Pruébalo en línea!

Una estrategia de fuerza bruta: genera todas las cadenas de longitud 10 base-36 en orden, y encuentra la que viene después de la entrada en la lista. Tómese una enorme cantidad de tiempo en cadenas lejos del comienzo de la 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

Pruébalo en línea!

Lee la cadena de izquierda a derecha hasta que alcanza un carácter seguido de un sufijo de todas las z, que puede estar vacío. Incrementa ese carácter y reemplaza las z por 0.

xnor
fuente
6

Stax , 7 bytes

ûæ≥╡►N▀

Ejecutar y depurarlo

Explicación:

|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
fuente
6

C (gcc) , 50 48 bytes

No fue necesario un indicador de acarreo explícito después de reestructurar el ciclo para que finalice tan pronto como no ocurra ningún acarreo. El ajuste 9-> A se realiza durante la verificación del bucle.

Gracias a ceilingcat por la sugerencia.

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

Pruébalo en línea!


Versión original: 71 57 bytes

Esta versión utiliza un indicador de acarreo para propagar actualizaciones: lo configuré como verdadero para comenzar el incremento. La cadena se modifica en el lugar y solo acepta 0-9, AZ. La parte difícil fue asegurarse de que 9-> A se manejara correctamente en los acarreos.

Editar: reutilicé el puntero de entrada como el indicador de acarreo.

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

Pruébalo en línea!

ErikF
fuente
6

C, 82 81 53 50 bytes

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

Modifica directamente la cadena de entrada; La entrada y la salida están en mayúsculas. Pruébelo en línea aquí . Gracias a Arnauld por jugar al golf 24 bytes y a ceilingcat por jugar al golf 3 bytes más.

Sin 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
fuente
Creo que esto debería ser seguro: 60 bytes
Arnauld
1
@Arnauld No puedes asumir un byte cero antes de la cadena ...
Jakob
1
@Jakob No estoy 100% seguro de eso. Definimos idiomas por sus implementaciones. Esto es C (gcc) ejecutándose en una máquina virtual TIO, donde la memoria puede, creo, asumir que se borró inicialmente. (He visto otras respuestas C que hacen suposiciones similares.)
Arnauld
2
Al incluir el entorno de prueba en la 'implementación', puedo estar llevando una etapa demasiado lejos. Pero aún puede usar la versión de 60 bytes que no depende de ningún supuesto de memoria.
Arnauld
1
@Arnauld He jugado otros 4 bytes. Realmente debería ser seguro, ya que no tenemos que manejarlo ZZZZZZZZZZ. La respuesta de ErikF hace lo mismo, pero aún más corta: codegolf.stackexchange.com/a/169468/79343
OOBalance
5

Simulador de máquina de Turing en línea , 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 en línea

Erik el Outgolfer
fuente
5

Perl 6 , 34 32 30 bytes

Gracias a nwellnhof por -2 bytes a través del uso del ooperador para combinar funciones

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

Pruébalo en línea!

Función que convierte el argumento en base 36, agrega 1, convierte de nuevo y luego lo formatea. Ahora usa la misma táctica que la respuesta de Adnan para preservar los ceros iniciales.

Jo King
fuente
{S/.//}o{base :36(1~$_)+1: 36}por 30 bytes.
nwellnhof
@nwellnhof Neat! Nunca antes había pensado usarlo opara jugar al golf, ¡pero puedo ver dónde podría ser útil!
Jo King
Ah, es una pena que .succ(incremente en uno) no funcione
Jo King
4

MATL , 12 bytes

36ZAQ5M10&YA

Pruébalo en línea!

           % 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 - Restablecer a Monica
fuente
4

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

Pruébalo en línea! Invierte la cadena y comprueba el primer carácter:

  • A 9es reemplazado por un a.
  • A zse reemplaza por a 0y recursivamente se verifica el siguiente carácter.
  • Todos los demás caracteres se incrementan usando succla función sucesora que se puede usar en Chars porque son una instancia de la clase Enum .

Finalmente, la cadena resultante se invierte nuevamente.

Laikoni
fuente
4

Rutina 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

*) Utiliza un código de operación "ilegal" ISB/ 0xF3, funciona en todos los NMOS 6502 fichas originales, no en las variantes más adelante CMOS.

Espera un puntero a una cadena de 10 caracteres en $fb/ $fcque se espera que sea un número base 36. Incrementa este número en el lugar.

No hace nada sensato en una entrada no válida (como, por ejemplo, una cadena más corta): maneja ZZZZZZZZZZ"correctamente" por accidente;)

Desmontaje comentado

; 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

Ejemplo de programa ensamblador C64 usando la rutina:

Demostración en línea

captura de pantalla

Código en sintaxis 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
fuente
1
La versión 65C02 puede descartar el ISB, luego usar INC después del LDA (), Y (y .done se mueve hacia arriba en una línea) y ser más corto en un byte.
Peter Ferrie
@peterferrie ¿el 65C02 tiene un INC para el accu?
Felix Palmen
@peterferrie ok, sí, bien - eso es lo que me faltaba en primer lugar en el 6502 :)
Felix Palmen
3

Retina 0.8.2 , 12 bytes

T`zo`dl`.z*$

Pruébalo en línea! Explicación: La dlparte del destino de sustitución se expande hasta 0-9a-zque se ocopia en la fuente, lo que da como resultado z0-9a-z(aunque el segundo zse ignora, ya que nunca puede coincidir). Esto incrementa los dígitos coincidentes. La .z*$parte del patrón coincide con el último no zdígito más todos los zs finales , manejando así el acarreo desde su incremento hasta 0.

Neil
fuente
3

Rubí , 40 bytes.

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

Pruébalo en línea!

  1. Convierta la cadena a un entero interpretándola como base 36
  2. Añadir 1
  3. Convertir de nuevo a la cadena base 36
  4. Almohadilla izquierda con 0s

"zzzzzzzzzz" devuelve una cadena de 11 largos

Asone Tuhid
fuente
3

brainfuck , 109 bytes

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

Pruébalo en línea!

Nitrodon
fuente
¡Esto es lo que quería ver!
Jack Hales
3

Apl (Dyalog Unicode) , 30 28 24 bytes

Gracias a ngn por la sugerencia de guardar algunos bytes.

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

Pruébalo en línea!

  • Requiere ⎕IO de 0

  • Utiliza mayúsculas

jslip
fuente
¿Por qué no ir un paso más allá y formar '1',parte f? luego 1↓pasará a ser parte de su inverso
ngn
@ngn Bien, gracias!
jslip
aún más corto: (⎕D,⎕A)⍳'1',->1,(⎕D,⎕A)⍳
ngn
una última mejora - que puede ser reescrito como un tren:(f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢
NGN
3

PHP, 69 64 bytes

versión pobre :

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

Ejecutar como tubería con -R. Entrada insensible a mayúsculas y minúsculas.

primer enfoque, 69 bytes:

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

Corre como tubería con -F

versión de bucle, también 69 bytes :

for($n=$argn;~$c=$n[$i-=1];)$f||$f=$n[$i]=$c!=9?$c>Y?0:++$c:A;echo$n;
  • Solo PHP 7.1: el PHP anterior no entiende los índices de cadena negativos, el
    PHP más joven generará advertencias para constantes indefinidas.
  • requiere entrada en mayúscula. Reemplace Yy Acon letras minúsculas para la entrada en minúsculas.

Corre como tubería con -nR

... o pruébalos en línea .

Titus
fuente
68 bytes: ¡ Pruébelo en línea!
Noche2
Otra versión de 68 bytes: ¡ Pruébelo en línea! Puede usar su -Ry llamar a este 66 bytes también.
Noche2
1
@ Noche2 Buen enfoque; pero se puede hacer aún más corto: printf('%010s',($b=base_convert)(1+$b($argn,36,10),10,36));- 59 bytes
Tito
1
Buena esa. No sabíamos que podríamos llamar una función como esta: ($b=base_convert)(a,b,c). Estoy aprendiendo mucho de ti.
Noche2
2

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

Pruébalo en línea!

Incrementa la cadena "a mano".

Chas Brown
fuente
2

Carbón , 14 bytes

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

Pruébalo en línea!El enlace es a la versión detallada del código. Explicación:

×0⁹

Imprimir 9 0 s. Esto sirve para rellenar el resultado.

←⮌⍘⊕⍘S³⁶¦³⁶

Convierta la entrada de la base 36, incremente, luego vuelva a convertir a la base 36. Luego, invierta el resultado e imprímalo hacia la izquierda.

Neil
fuente
2

Java 8, 90 76 56 bytes

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

Acepta letras mayúsculas y minúsculas para la entrada. La salida siempre está en minúscula.

Gracias a Okx por jugar al golf 18 bytes.

Pruébelo en línea aquí .

Sin 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
fuente
¡Agradable! Para futuras referencias en Java anterior, puede rellenar con algo como"".format("%10s",t).replace(' ','0')
Jakob
@Jakob Gracias, eso es lo que estaba buscando.
OOBalance
Es más corto usar el enfoque de agregar un 1al principio y luego eliminarlo:s->Long.toString(Long.valueOf("1"+s,36)+1,36).substring(1)
Okx
@Okx Buen enfoque. 2 bytes más: "1"+s=>1+s
OOBalance
2

JavaScript (ES6), 89 bytes

Este no es tan eficiente en bytes como la otra entrada de JavaScript , pero lo hice sin notar esta regla:

Dada una cuerda de longitud 10

Así que esta no es una entrada seria, ¡solo por diversión! Funciona con cadenas de longitud general, como 0abc, y antepone a 1cuando el primer dígito es z, por ejemplo, zzz-> 1000. La entrada debe estar en 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))

Explicación

La expresión en (A, B, C)realidad significa "hacer A, luego hacer B, luego devolver C", que utilizo para declarar algunas variables que reutilizo en el código. ssignifica "cadena", lsignifica "último", 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 es una función recursiva. Para una cadena típica como aza, solo incrementará el último carácter (ver línea 6) - azb. Pero para una cadena que termina con z, como h0gz, se ejecutará en todo hasta el último carácter (el z) y sustituirá a 0en su lugar (vea la línea 5) - f(h0gz)= f(h0g) + 0=h0h0 .

La ||'0'línea 5 es para que la función funcione cuando se llama en una cadena de 1 longitud (es decir, la cadena 'z'). Sin él, f('')se llama (como 'z'.slice(0, -1)es ''), que tiene un comportamiento indefinido (literalmente, pruébelo usted mismo), y eso no es bueno. El resultado esperado de f('z')es '10', que es de lo que obtenemos f('0') + 0, por lo que utilizamos ||'0'. ( ||'0'es particularmente útil porque no se interpone en el caso habitual , ya rque tiene al menos 1 longitud ( sal menos 2 de longitud), porque las cuerdas son falsey solo cuando son de longitud 0).

El método para incrementar una cadena es el mismo que el utilizado en la otra entrada JS: convierta el "número" base 36 en un número real, agregue 1 y luego vuelva a convertirlo en base 36. No debemos preocuparnos por el 1incremento de 'z' ( 'z'-> '10'), ya que nunca incrementamos 'z' (ver líneas 4 y 6: el último carácter solo se incrementa si no es 'z').

Además, nunca corremos el riesgo de descartar los ceros a la izquierda, porque en realidad nunca manipulamos más de un solo carácter a la vez, solo el último carácter de la cadena. El resto de los caracteres se cortan limpiamente a medida que corta cualquier cadena y palabras posteriores.

Florrie
fuente
2

Limpio , 89 84 bytes

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

r o@o r

Pruébalo en línea!

Una solución más corta gracias a Laikoni .

Limpio , 115 bytes

Me encanta cuando puedo usar 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)]))

Pruébalo en línea!

Produce la respuesta sin convertir bases usando la comparación de listas.

  • ? :: [Char] -> [Char] realiza transporte hacia adelante.
  • @ :: Char -> Charincrementos en uno, lo que representa la brecha entre '9'y 'z'.
  • $ :: [Char] -> [Char]incrementa el último carácter y se aplica ?hasta que el valor se estabilice.
Οurous
fuente
1
Menos elegante, pero bastante más corto: ¡ Pruébelo en línea!
Laikoni
@Laikoni Editado en, gracias!
Agradable
2

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

Pruébalo en línea!

Un enfoque completamente diferente. Obtenga los puntos de código ASCII y "incremente" recursivamente el punto de código más a la derecha (haciendo que 0(57) salte a a(97) y z(122) regrese a 0(48)) hasta que se quede sin zs. Convertir de nuevo a cadena.

Versión antigua

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

Pruébalo en línea!

Todo esto es manipulación de texto, que no va de la mano con el golf de código R.

Reemplace todo zal final de las cadenas con 0. Encuentre la ubicación del último elemento antes del 0s. Encuentra la siguiente base de 36 dígitos. Haz el cambio. Alégrate de haber superado apenas la solución Online Turing Machine Simulator.

ngm
fuente
¡Puedes hacerlo mucho mejor que esto! Creo que tengo 72 bytes, si puedes encontrar el correcto incorporado ...
Giuseppe
¡Vaya ... pensé que este desafío era el juego de bolos en código!
ngm
Bueno, lo incorporado es strtoipara comenzar; Hay un par de trucos de golf más para llegar a 72.
Giuseppe
1
strtoi¿se limita a números bastante pequeños? Lo dejé hace un tiempo.
ngm
Oh ya veo. No me di cuenta de que la intrestricción era tan problemática. ¡Gorrón! Para la posteridad, esta fue mi solución fallida: ¡ Pruébelo en línea!
Giuseppe
2

Estrellado , 325 bytes

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

Pruébalo en línea!

Explicación:

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
fuente
1

Python 3.6+ y gmpy2 , 62 bytes

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

Pruébalo en línea!

(Tenga en cuenta que gmpy2 no es parte de la biblioteca estándar de Python y requiere una instalación separada)

trolley813
fuente
No creo que necesites el f=. Las funciones anónimas generalmente se consideran encontrar en el código de golf.
mypetlion
1

Pyke , 11 bytes

? b!!R+bhbt

Pruébalo aquí!

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

Podría ser 2 bytes más corto con el siguiente cambio de idioma: si se utiliza el modo hexadecimal, cambie todos los usos de base_36 y base_10 a base_92 (que de todos modos no es realmente base 92 en ese contexto)

Azul
fuente
1

sed , 94 bytes

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

Pruébalo en línea!

Sed sufre mucho por tener que cambiar los personajes por búsqueda.

Geoff Reedy
fuente
@ETHproductions whoops, gracias por la captura
Geoff Reedy
0

Jalea , 21 bytes

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

Pruébalo en línea!

Utiliza mayúsculas. El enlace TIO también permite mayúsculas / minúsculas.

Erik el Outgolfer
fuente