16

Esta es la publicación de policía. La publicación de Robber está aquí .

Su tarea es tomar una entrada entera N y generar el enésimo dígito en la secuencia OEIS A002942 .

La secuencia consiste en los números cuadrados escritos al revés:

1, 4, 9, 61, 52, 63, 94, 46, 18, 1, 121, 441, ...

Tenga en cuenta que los ceros iniciales se recortan ( 100 se convierte en 1 , no en 001 ). Concatenando esto en una cadena (o un número largo da):

1496152639446181121441

Deberá generar el enésimo dígito en esta cadena / número. Puede optar por tomar N como indexado 0 o indexado 1 (indique cuál elige).

Casos de prueba (1 indexado):

N = 1,      ==> 1
N = 5,      ==> 1
N = 17,     ==> 1   <- Important test case! It's not zero.
N = 20,     ==> 4
N = 78,     ==> 0
N = 100,    ==> 4

Su código debería funcionar para números hasta N = 2 ^ 15 (a menos que su idioma no pueda manejar enteros de 32 bits por defecto, en cuyo caso N puede ser menor).

Policías:

Debe escribir dos funciones / programas, en el mismo lenguaje, que hagan lo mismo. Debe publicar una de las funciones / programas, así como la distancia de Levenshtein entre las dos funciones / programas que ha escrito. La distancia de Levenshtein se mide en caracteres (por lo que la adición de un carácter de dos bytes dará un LD = 1).

El código no revelado no puede ser más largo que la solución original (pero puede ser del mismo tamaño). Los ladrones intentarán escribir un código con la distancia exacta de Levenshtein que diste (puede ser diferente de tu código no revelado, siempre que funcione).

El ganador será la presentación sin descifrar que tenga la menor distancia de Levenshtein.

¡Puede consultar la distancia de Levenshtein aquí!

Si su envío no se descifra durante 7 días, puede revelar el código alternativo que ha escrito y marcar su envío como seguro.

number sequence cops-and-robbers Stewie Griffin
fuente

Sí, lo agregaré a las reglas. :)

Stewie Griffin

¿Habla de scripts, pero supongo que este es el programa o la función predeterminados ?

Kevin Cruijssen

Sí, por defecto todo :)

Stewie Griffin

¿Cómo manejas los comentarios y los espacios en blanco? Veo algunas cosas raras.

Magic Octopus Urn

1

"Su código debería funcionar para números hasta N = 2 ^ 15" -> pero uno de los casos de prueba es más grande que eso. ¿Es necesario el caso 274164?

Tom Carpenter

6

Haskell , LD = 13, agrietado

((snd.span(<'1').reverse.show.(^2)=<<[1..])!!)

Pruébalo en línea!

Verifiqué que los ceros iniciales estén recortados;)

Explicación:

                    [1..]     -- for each element in [1,2,3,4,5,...]
                 =<<          -- apply the following functions 
             (^2)             -- square [1,4,9,16,25,...]
           show.              -- convert to string ["1","4","9","16","25",...]
       reverse.               -- reverse ["1","4","9","61","52",...,"001",...]
   span(<'1').                -- split into leading zeros and remainder [("","1"),("","4"),...,("00","1"),...]
  snd.                        -- only keep remainder ["1","4","9","61","52",...,"1",...]
                              -- and concatenate the result "1496152..."
((                       )!!) -- index into the sequence

Laikoni
fuente

2

Agrietado !

H.PWiz

3

cQuents 0 , LD = 1, agrietado

":\r$*$

Pruébalo en línea!

Pensé que esto no funcionaba para los ceros iniciales, pero en realidad sí funciona: la función inversa en cQuents se codifica como int(reversed(str(n))).

Explicación

"         Concatenate sequence together, get nth term in the string instead of the sequence
 :        Mode: Sequence: given input n, output the nth term, 1-indexed
          Each term in the sequences equals:
  \r      reverse(
    $*$           the index * the index
                  or
    $$            the index * the index
                   ) (implicit)

Stephen
fuente

¿agrietado?

Laikoni

@Laikoni sí, cQuents hace multiplicaciones implícitas, como Mathematica, pero no necesitas los espacios. Añadiendo una explicación.

Stephen

3

JavaScript (ES6), LD = 103 ( agrietado )

Usar una distancia de Levenshtein tan alta probablemente no sea la mejor estrategia, pero probémoslo de todos modos.

n => { for(i = 0, str = ''; i <= n; i++) { str += +[...i * i + ''].reverse().join(''); } return str[n]; }

Casos de prueba

Mostrar fragmento de código

let f =

n => { for(i = 0, str = ''; i <= n; i++) { str += +[...i * i + ''].reverse().join(''); } return str[n]; }

console.log(f(5))      // 1
console.log(f(17))     // 1
console.log(f(20))     // 4
console.log(f(78))     // 0
console.log(f(100))    // 4
console.log(f(274164)) // 1

Expandir fragmento

Solución prevista

$=>eval(atob`Wy4uLkFycmF5KCQrMSldLm1hcCgoXyxpKT0+K1suLi5pKmkrJyddLnJldmVyc2UoKS5qb2luYGApLmpvaW5gYFskXQ`)

Parte codificada:

[...Array($+1)].map((_,i)=>+[...i*i+''].reverse().join``).join``[$]

Arnauld
fuente

¿Esta tira lleva ceros después de revertir?

Erik the Outgolfer

@EriktheOutgolfer Sí. El unario +asegura que la cadena invertida se coaccione a un Número.

Arnauld

1

Ohhhh ... wow, eso es más difícil de lo que pensaba.

Urna de pulpo mágico el

Agrietado !

Lynn

3

Python 2, 104 bytes, LD = 21 no válido y agrietado

d=lambda y:y if'0'!=str(y)[-1]else d(y/10)
lambda n:''.join([str(d(x*x))[::-1]for x in range(1,n)])[n-1]

~~PD ¿Se permite una cantidad ilimitada de espacios en blanco y comentarios? Si es así, esto no será difícil de descifrar.~~

dylnan
fuente

1

"El código no revelado no puede ser más largo que la solución original".

Khuldraeseth na'Barya

@Scrooble Lo vi pero no creo que sea difícil hacer un programa que sea mucho más corto que este. Ya se hizo en python 3 en otra respuesta y funciona en python 2, por lo que todo lo que necesitan agregar es un montón de \ns (aproximadamente 50)

dylnan

¿No superarían 50 líneas nuevas una distancia de 21 de Levenshtein?

Khuldraeseth na'Barya

@Scrooble Tienes razón, me confundí y estaba pensando en el problema incorrectamente. Gracias

dylnan

1

Esto parece un error en entradas inferiores a 5

Leo

3

Código de máquina 6502 (C64), LD = 1 ( descifrado )

00 C0 20 FD AE A0 00 99 5B 00 C8 20 73 00 90 F7 99 5B 00 A2 0B CA 88 30 09 B9
5B 00 29 0F 95 5B 10 F3 A9 00 95 5B CA 10 F9 A9 00 A0 03 99 69 00 88 10 FA A0
20 A2 76 18 B5 E6 90 02 09 10 4A 95 E6 E8 10 F4 A2 03 76 69 CA 10 FB 88 F0 11
A2 09 B5 5C C9 08 30 04 E9 03 95 5C CA 10 F3 30 D6 A2 03 B5 69 95 57 CA 10 F9
A9 01 85 FB A2 03 A9 00 95 FB CA D0 FB A2 03 B5 FB 95 22 95 26 CA 10 F7 A9 00
A2 03 95 69 CA 10 FB A0 20 A2 02 46 25 76 22 CA 10 FB 90 0C A2 7C 18 B5 AA 75
ED 95 ED E8 10 F7 A2 7D 06 26 36 AA E8 10 FB 88 10 DD A0 0B A9 00 99 5A 00 88
D0 FA A0 20 A2 09 B5 5C C9 05 30 04 69 02 95 5C CA 10 F3 06 69 A2 FD 36 6D E8
D0 FB A2 09 B5 5C 2A C9 10 29 0F 95 5C CA 10 F4 88 D0 D7 E0 0A F0 05 E8 B5 5B
F0 F7 09 30 99 5B 00 C8 E8 E0 0B F0 04 B5 5B 90 F1 88 B9 5B 00 C9 30 F0 F8 A2
7C 18 B5 DB E9 00 95 DB E8 10 F7 90 14 88 30 05 B9 5B 00 D0 EA A2 7C F6 7F D0
03 E8 10 F9 4C 73 C0 B9 5B 00 4C D2 FF

Demostración en línea , uso:sys49152,ndóndenestá la entrada indexada 0.

Para el último caso de prueba, necesita un poco de paciencia, ya que esta máquina pobre tiene que hacer millones de cambios de bits y adiciones para presentarle el resultado;)

El lenguaje aquí es el código de la máquina, por lo que LD se mide en este formato; sin embargo, para empezar, aquí está el programa en la ca65fuente del ensamblador:

NUMSIZE         = 4     ; 32 bit integers ...
NUMSTRSIZE      = 11    ; need up to 11 characters for 0-terminated string

.segment "ZPUSR": zeropage
v_x:            .res    NUMSIZE         ; next number to be squared

.segment "ZPFAC": zeropage
v_n:            .res    NUMSIZE         ; input index (0-based), counts down
nc_string:      .res    NUMSTRSIZE      ; string buffer for numbers

.segment "ZPTMP": zeropage
mpm_arg1:       .res    NUMSIZE         ; arg1 for multiplication
mpm_arg2:       .res    NUMSIZE         ; arg2 for multiplication

.segment "ZPFAC2": zeropage
mpm_res:        .res    NUMSIZE         ; numeric result (mult and str convert)

; load address for creating a C64 .PRG file:

.segment "LDADDR"
                .word   $c000

.code

; first read number from command argument and convert to unsigned
; integer in little-endian:

                jsr     $aefd
                ldy     #$00
rn_loop:        sta     nc_string,y
                iny
                jsr     $73
                bcc     rn_loop
                sta     nc_string,y
                ldx     #NUMSTRSIZE
stn_copybcd:    dex
                dey
                bmi     stn_fillzero
                lda     nc_string,y
                and     #$f
                sta     nc_string,x
                bpl     stn_copybcd
stn_fillzero:   lda     #$0
                sta     nc_string,x
                dex
                bpl     stn_fillzero
                lda     #$0
                ldy     #(NUMSIZE-1)
stn_znumloop:   sta     mpm_res,y
                dey
                bpl     stn_znumloop
                ldy     #(NUMSIZE*8)
stn_loop:       ldx     #($81-NUMSTRSIZE)
                clc
stn_rorloop:    lda     nc_string+NUMSTRSIZE+$80,x
                bcc     stn_skipbit
                ora     #$10
stn_skipbit:    lsr     a
                sta     nc_string+NUMSTRSIZE+$80,x
                inx
                bpl     stn_rorloop
                ldx     #(NUMSIZE-1)
stn_ror:        ror     mpm_res,x
                dex
                bpl     stn_ror
                dey
                beq     main
stn_sub:        ldx     #(NUMSTRSIZE-2)
stn_subloop:    lda     nc_string+1,x
                cmp     #$8
                bmi     stn_nosub
                sbc     #$3
                sta     nc_string+1,x
stn_nosub:      dex
                bpl     stn_subloop
                bmi     stn_loop

main:
                ldx     #(NUMSIZE-1)
argloop:        lda     mpm_res,x
                sta     v_n,x
                dex
                bpl     argloop
                lda     #$01
                sta     v_x
                ldx     #(NUMSIZE-1)
                lda     #$00
initxloop:      sta     v_x,x
                dex
                bne     initxloop

mainloop:

; prepare arguments for multiplication:

                ldx     #(NUMSIZE-1)
sqrargloop:     lda     v_x,x
                sta     mpm_arg1,x
                sta     mpm_arg2,x
                dex
                bpl     sqrargloop

; do multiplication:

                lda     #$00
                ldx     #(NUMSIZE-1)
mul_clearloop:  sta     mpm_res,x
                dex
                bpl     mul_clearloop
                ldy     #(NUMSIZE*8)
mul_loop:       ldx     #(NUMSIZE-2)
                lsr     mpm_arg1+NUMSIZE-1
mul_rorloop:    ror     mpm_arg1,x
                dex
                bpl     mul_rorloop
                bcc     mul_noadd
                ldx     #($80-NUMSIZE)
                clc
mul_addloop:    lda     mpm_arg2+NUMSIZE+$80,x
                adc     mpm_res+NUMSIZE+$80,x
                sta     mpm_res+NUMSIZE+$80,x
                inx
                bpl     mul_addloop
mul_noadd:      ldx     #($81-NUMSIZE)
                asl     mpm_arg2
mul_rolloop:    rol     mpm_arg2+NUMSIZE+$80,x
                inx
                bpl     mul_rolloop
                dey
                bpl     mul_loop

; convert result to string:

                ldy     #NUMSTRSIZE
                lda     #$0
nts_fillzero:   sta     nc_string-1,y
                dey
                bne     nts_fillzero
                ldy     #(NUMSIZE*8)
nts_bcdloop:    ldx     #(NUMSTRSIZE-2)
nts_addloop:    lda     nc_string+1,x
                cmp     #$5
                bmi     nts_noadd
                adc     #$2
                sta     nc_string+1,x
nts_noadd:      dex
                bpl     nts_addloop
                asl     mpm_res
                ldx     #($ff-NUMSIZE+2)
nts_rol:        rol     mpm_res+NUMSIZE,x       ; + $100 w/o zp wraparound
                inx
                bne     nts_rol
                ldx     #(NUMSTRSIZE-2)
nts_rolloop:    lda     nc_string+1,x
                rol     a
                cmp     #$10
                and     #$f
                sta     nc_string+1,x
nts_rolnext:    dex
                bpl     nts_rolloop
                dey
                bne     nts_bcdloop
nts_scan:       cpx     #(NUMSTRSIZE-1)
                beq     nts_copydigits
                inx
                lda     nc_string,x
                beq     nts_scan
nts_copydigits: ora     #$30
                sta     nc_string,y
                iny
                inx
                cpx     #(NUMSTRSIZE)
                beq     strip0loop
                lda     nc_string,x
                bcc     nts_copydigits

; search for first non-0 character from the end of the string:

strip0loop:     dey
                lda     nc_string,y
                cmp     #$30
                beq     strip0loop

; decrement n for each digit:

founddigit:
                ldx     #($80-NUMSIZE)
                clc
decnloop:       lda     v_n+NUMSIZE+$80,x
                sbc     #$00
                sta     v_n+NUMSIZE+$80,x
                inx
                bpl     decnloop
                bcc     foundresult

                dey
                bmi     next_x
                lda     nc_string,y
                bne     founddigit

; increment x to calculate next square number:

next_x:
                ldx     #($80-NUMSIZE)
incxloop:       inc     v_x+NUMSIZE-$80,x
                bne     incxdone
                inx
                bpl     incxloop
incxdone:       jmp     mainloop

foundresult:    lda     nc_string,y
                jmp     $ffd2

... y aquí está el script de enlace para ld65:

MEMORY {
  LDADDR: start = $bffe, size = 2;
  CODE: start = $c000, size = $1000;
  ZPTMP: start = $0022, size = $0008;
  ZPFAC: start = $0057, size = $000f;
  ZPFAC2: start = $0069, size = $0004;
  ZPUSR: start = $00fb, size = $0004;
}

SEGMENTS {
  LDADDR: load = LDADDR;
  CODE: load = CODE;
  ZPTMP: load = ZPTMP, type = zp;
  ZPFAC: load = ZPFAC, type = zp;
  ZPFAC2: load = ZPFAC2, type = zp;
  ZPUSR: load = ZPUSR, type = zp;
}

Felix Palmen
fuente

agrietado (creo)

Jo.

@Jo. Sí, editado.

Felix Palmen

2

Perl 5 , 59 + 1 ( `-a`) = 60 bytes, LD = 55

$j.=int reverse$_**2for 1..$_;$_--;say$j=~s/.{$_}(.).*/$1/r

Pruébalo en línea!

Xcali
fuente

quizás agrietado, no estoy seguro de mi entrada codegolf.stackexchange.com/questions/146927/…

Nahuel Fouilleul

2

Java 8, (177 bytes) LD = 92 ( descifrado por @Arnauld )

( He usado esta calculadora de LD en línea ) .

n->{String r="",t=r;for(int i=1,j;r.length()<=n+1;i++)if(Math.sqrt(i)%1==0){for(t="",j=(i+"").length();j>0;t+=(i+"").charAt(--j));r+=t.replaceAll("^0+","");}return r.charAt(n);}

Esto probablemente no sea demasiado difícil si simplemente juegas al golf. :)

Explicación:

Pruébalo aquí

n->{                             // Method with integer parameter and character return-type
  String r="",                   //  Result-String, starting empty
         t=r;                    //  Temp-String, starting empty
  for(int i=1,j;                 //  Index-integers
      r.length()<=n+1;i++)       //  Loop (1) as long as the length is at least n+1
    if(Math.sqrt(i)%1==0){       //   If the current number `i` is a perfect square:
      for(t="",                  //    Reset the temp-String to empty
          j=(i+"").length();     //    Set `j` to the length of the current number
          j>0;                   //    Inner loop (2) as long as `j` is larger than 0
        t+=                      //     Append the temp-String with:
           (i+"").charAt(--j)    //     The digit of integer `i` at index `j-1`
                                 //     (by first decrease `j` with 1 with `--j`)
      );                         //    End of inner loop (2)
      r+=t                       //    And then append the temp-String to the result-String
          .replaceAll("^0+","");}//    after we've removed any leading zeroes
                                 //  End of loop (1) (implicit / single-line body)
  return r.charAt(n);            //  Return the `n`'th character of the result-String
}                                // End of method

Kevin Cruijssen
fuente

1

Agrietado

Arnauld

Solución prevista: n->{String r="";for(int i=1;r.length()<=n+1;r+=new Long(new StringBuffer(i*i+++"").reverse()+""));return r.charAt(n);}( 118 bytes, 92 LD )

Kevin Cruijssen

2

Octava , LD = 63, Agrietada

@(t)[arrayfun(@(t)num2str(str2num(flip(num2str(t)))),(1:t).^2,'uni',0){:}](t)

Pruébalo en línea!

El envío es de 77 bytes, por lo que debe sustituir un poco =)

Stewie Griffin
fuente

agrietada .

Tom Carpenter

2

6502 código máquina (C64), LD = 1, seguro

00 C0 20 FD AE A0 00 99 5B 00 C8 20 73 00 90 F7 99 5B 00 A2 0B CA 98 88 30 09
B9 5B 00 29 0F 95 5B 10 F2 95 5B CA 10 FB A0 20 A2 76 18 B5 E6 90 02 09 10 4A
95 E6 E8 10 F4 A2 03 76 69 CA 10 FB 88 F0 11 A2 09 B5 5C C9 08 30 04 E9 03 95
5C CA 10 F3 30 D6 A2 03 B5 69 95 57 CA 10 F9 A9 01 85 FB A2 03 A9 00 95 FB CA
D0 FB A2 03 B5 FB 95 22 95 26 CA 10 F7 A9 00 A2 03 95 69 CA 10 FB A0 20 A2 02
46 25 76 22 CA 10 FB 90 0C A2 7C 18 B5 AA 75 ED 95 ED E8 10 F7 A2 7D 06 26 36
AA E8 10 FB 88 10 DD A2 0B A9 00 95 5A CA D0 FB A0 20 A2 09 B5 5C C9 05 30 04
69 02 95 5C CA 10 F3 06 69 A2 FD 36 6D E8 D0 FB A2 09 B5 5C 2A C9 10 29 0F 95
5C CA 10 F4 88 D0 D7 E8 B5 5B F0 FB 09 30 99 5B 00 C8 E8 E0 0B F0 04 B5 5B 90
F1 88 B9 5B 00 C9 30 F0 F8 A2 7C 18 B5 DB E9 00 95 DB E8 10 F7 90 14 88 30 05
B9 5B 00 D0 EA A2 7C F6 7F D0 03 E8 10 F9 4C 68 C0 B9 5B 00 4C D2 FF

Demostración en línea , uso:sys49152,ndóndenestá la entrada indexada 0.

Solución prevista: (diff)

 B9 5B 00 29 0F 95 5B 10 F2 95 5B CA 10 FB A0 20 A2 76 18 B5 E6 90 02 09 10 4A
-95 E6 E8 10 F4 A2 03 76 69 CA 10 FB 88 F0 11 A2 09 B5 5C C9 08 30 04 E9 03 95
+95 E6 E8 10 F4 A2 03 76 69 CA 10 FB 88 F0 11 A2 09 B5 5C C9 08 90 04 E9 03 95
 5C CA 10 F3 30 D6 A2 03 B5 69 95 57 CA 10 F9 A9 01 85 FB A2 03 A9 00 95 FB CA

El 30(opcode bmi) se reemplaza por 90(opcode bcc). Esto corresponde a la siguiente parte en la fuente del ensamblador:

stn_subloop:    lda     nc_string+1,x
                cmp     #$8
                bmi     stn_nosub       ; use bcc here for same result
                sbc     #$3
                sta     nc_string+1,x

Funciona porque este código verifica si un número es menor que 8. La cmpinstrucción realiza una resta para eso, estableciendo las banderas en consecuencia. Entonces, si el acumulador contiene un número menor que 8, esto se desborda, borrando el indicador de acarreo, por lo tanto, la instrucción de ramificación correcta es bcc. bmi(ramificando cuando es negativo), como en el código original, simplemente funciona aquí también, porque los números comparados son lo suficientemente pequeños, por lo que el resultado de la resta termina en el rango negativo ( $80-$ff) cuando ocurre un flujo inferior.

Demostración en línea

Esta es una versión mejorada / compacta de mi envío anterior . Entre otros trucos para reducir el tamaño, elimina el código inútil que estaba contenido y permitía una especie de "simple" *) crack. Con todo, el tamaño se reduce en 16 bytes. Esta vez, debería ser un poco más difícil encontrar el programa equivalente con LD 1 :)

^{*) probablemente todavía hay bastante trabajo por encontrar, por supuesto :)}

De nuevo, aquí está el ca65 fuente ensamblador, para ayudar a comenzar con el código:

NUMSIZE         = 4     ; 32 bit integers ...
NUMSTRSIZE      = 11    ; need up to 11 characters for 0-terminated string

.segment "ZPUSR": zeropage
v_x:            .res    NUMSIZE         ; next number to be squared

.segment "ZPFAC": zeropage
v_n:            .res    NUMSIZE         ; input index (0-based), counts down
nc_string:      .res    NUMSTRSIZE      ; string buffer for numbers

.segment "ZPTMP": zeropage
mpm_arg1:       .res    NUMSIZE         ; arg1 for multiplication
mpm_arg2:       .res    NUMSIZE         ; arg2 for multiplication

.segment "ZPFAC2": zeropage
mpm_res:        .res    NUMSIZE         ; numeric result (mult and str convert)

; load address for creating a C64 .PRG file:

.segment "LDADDR"
                .word   $c000

.code

; first read number from command argument and convert to unsigned
; integer in little-endian:

                jsr     $aefd
                ldy     #$00
rn_loop:        sta     nc_string,y
                iny
                jsr     $73
                bcc     rn_loop
                sta     nc_string,y
                ldx     #NUMSTRSIZE
stn_copybcd:    dex
                tya
                dey
                bmi     stn_fillzero
                lda     nc_string,y
                and     #$f
                sta     nc_string,x
                bpl     stn_copybcd
stn_fillzero:   sta     nc_string,x
                dex
                bpl     stn_fillzero
                ldy     #(NUMSIZE*8)
stn_loop:       ldx     #($81-NUMSTRSIZE)
                clc
stn_rorloop:    lda     nc_string+NUMSTRSIZE+$80,x
                bcc     stn_skipbit
                ora     #$10
stn_skipbit:    lsr     a
                sta     nc_string+NUMSTRSIZE+$80,x
                inx
                bpl     stn_rorloop
                ldx     #(NUMSIZE-1)
stn_ror:        ror     mpm_res,x
                dex
                bpl     stn_ror
                dey
                beq     main
stn_sub:        ldx     #(NUMSTRSIZE-2)
stn_subloop:    lda     nc_string+1,x
                cmp     #$8
                bmi     stn_nosub
                sbc     #$3
                sta     nc_string+1,x
stn_nosub:      dex
                bpl     stn_subloop
                bmi     stn_loop

main:
                ldx     #(NUMSIZE-1)
argloop:        lda     mpm_res,x
                sta     v_n,x
                dex
                bpl     argloop
                lda     #$01
                sta     v_x
                ldx     #(NUMSIZE-1)
                lda     #$00
initxloop:      sta     v_x,x
                dex
                bne     initxloop

mainloop:

; prepare arguments for multiplication:

                ldx     #(NUMSIZE-1)
sqrargloop:     lda     v_x,x
                sta     mpm_arg1,x
                sta     mpm_arg2,x
                dex
                bpl     sqrargloop

; do multiplication:

                lda     #$00
                ldx     #(NUMSIZE-1)
mul_clearloop:  sta     mpm_res,x
                dex
                bpl     mul_clearloop
                ldy     #(NUMSIZE*8)
mul_loop:       ldx     #(NUMSIZE-2)
                lsr     mpm_arg1+NUMSIZE-1
mul_rorloop:    ror     mpm_arg1,x
                dex
                bpl     mul_rorloop
                bcc     mul_noadd
                ldx     #($80-NUMSIZE)
                clc
mul_addloop:    lda     mpm_arg2+NUMSIZE+$80,x
                adc     mpm_res+NUMSIZE+$80,x
                sta     mpm_res+NUMSIZE+$80,x
                inx
                bpl     mul_addloop
mul_noadd:      ldx     #($81-NUMSIZE)
                asl     mpm_arg2
mul_rolloop:    rol     mpm_arg2+NUMSIZE+$80,x
                inx
                bpl     mul_rolloop
                dey
                bpl     mul_loop

; convert result to string:

                ldx     #NUMSTRSIZE
                lda     #$0
nts_fillzero:   sta     nc_string-1,x
                dex
                bne     nts_fillzero
                ldy     #(NUMSIZE*8)
nts_bcdloop:    ldx     #(NUMSTRSIZE-2)
nts_addloop:    lda     nc_string+1,x
                cmp     #$5
                bmi     nts_noadd
                adc     #$2
                sta     nc_string+1,x
nts_noadd:      dex
                bpl     nts_addloop
                asl     mpm_res
                ldx     #($ff-NUMSIZE+2)
nts_rol:        rol     mpm_res+NUMSIZE,x       ; + $100 w/o zp wraparound
                inx
                bne     nts_rol
                ldx     #(NUMSTRSIZE-2)
nts_rolloop:    lda     nc_string+1,x
                rol     a
                cmp     #$10
                and     #$f
                sta     nc_string+1,x
nts_rolnext:    dex
                bpl     nts_rolloop
                dey
                bne     nts_bcdloop
nts_scan:       inx
                lda     nc_string,x
                beq     nts_scan
nts_copydigits: ora     #$30
                sta     nc_string,y
                iny
                inx
                cpx     #(NUMSTRSIZE)
                beq     strip0loop
                lda     nc_string,x
                bcc     nts_copydigits

; search for first non-0 character from the end of the string:

strip0loop:     dey
                lda     nc_string,y
                cmp     #$30
                beq     strip0loop

; decrement n for each digit:

founddigit:
                ldx     #($80-NUMSIZE)
                clc
decnloop:       lda     v_n+NUMSIZE+$80,x
                sbc     #$00
                sta     v_n+NUMSIZE+$80,x
                inx
                bpl     decnloop
                bcc     foundresult

                dey
                bmi     next_x
                lda     nc_string,y
                bne     founddigit

; increment x to calculate next square number:

next_x:
                ldx     #($80-NUMSIZE)
incxloop:       inc     v_x+NUMSIZE-$80,x
                bne     incxdone
                inx
                bpl     incxloop
incxdone:       jmp     mainloop

foundresult:    lda     nc_string,y
                jmp     $ffd2

... y aquí está el script de enlace para ld65:

MEMORY {
  LDADDR: start = $bffe, size = 2;
  CODE: start = $c000, size = $1000;
  ZPTMP: start = $0022, size = $0008;
  ZPFAC: start = $0057, size = $000f;
  ZPFAC2: start = $0069, size = $0004;
  ZPUSR: start = $00fb, size = $0004;
}

SEGMENTS {
  LDADDR: load = LDADDR;
  CODE: load = CODE;
  ZPTMP: load = ZPTMP, type = zp;
  ZPFAC: load = ZPFAC, type = zp;
  ZPFAC2: load = ZPFAC2, type = zp;
  ZPUSR: load = ZPUSR, type = zp;
}

Felix Palmen
fuente

Considéralo descifrado :)

Jo.

@Jo. bueno, si insistes, muchas gracias, lo edité.

Felix Palmen

1

Lua: LD = 1, agrietado

i=1s=""while(#s<...+0)do s=s..((i*i)..""):reverse():gsub("(0+)(%d+)$","%2")i=i+1 end print(s:sub(...,...))

No hay trucos elegantes aquí :)

Katenkyo
fuente

agrietado

Erik the Outgolfer

1

Mathematica, LD = 43 agrietado

Flatten[Table[(k=IntegerDigits)@FromDigits@Reverse@k[i^2],{i,10^4}]][[#]]&

Pruébalo en línea!

J42161217
fuente

Agrietada .

Misha Lavrov

1

PHP, LD = 35 ( Agrietado )

1 indexado

<?while(strlen($s)<$argv[1])$s.=(int)strrev(++$i*$i);echo substr($s,$argv[1]-1,1);

Pruébalo en línea!

Jo
fuente

0

Python 3: LD = 9 | Agrietado

lambda i:"".join(str(k*k+2*k+1)[::-1].lstrip("0")for k in range(i+1))[i]

Este debería ser bastante (muy) fácil de obtener: P

Hiperneutrino
fuente

Agrietada .

Sr. Xcoder

1

Eliminé mi Crack porque la respuesta original no es válida.

Sr. Xcoder

@ Mr.Xcoder Puede recuperar ahora; LD es igual porque la .lstrip("0")parte solo se puede copiar.

HyperNeutrino

Hecho

Sr. Xcoder

0

C ++, LD = 159

0 indexado, entrada argv[1], compilado en GCC 7.2.0

#import<bits/stdc++.h>
char*h,b[1<<17],*q=b;int x,y;main(int,char**j){sscanf(j[1],"%d",&y);do{x++;q+=sprintf(h=q,"%d",x*x);while(*--q==48);std::reverse(h,++q);}while(q-b<=y);b[y+1]=0,printf(b+y);}

Colera Su
fuente

0

Groovy , 61 bytes (LD = 23)

{(1..it).collect{0.valueOf("${it**2}".reverse())}.join()[it]}

Pruébalo en línea!

Urna de pulpo mágico
fuente

Cómo es esto seguro> _> ...

Urna de pulpo mágico

Distancia de Levenshtein y OEIS (policías)

Casos de prueba (1 indexado):

Policías:

Respuestas:

Haskell , LD = 13, agrietado

cQuents 0 , LD = 1, agrietado

Explicación

JavaScript (ES6), LD = 103 ( agrietado )

Casos de prueba

Solución prevista

Python 2, 104 bytes, LD = 21 no válido y agrietado

Código de máquina 6502 (C64), LD = 1 ( descifrado )

Perl 5 , 59 + 1 ( `-a`) = 60 bytes, LD = 55

Java 8, (177 bytes) LD = 92 ( descifrado por @Arnauld )

Octava , LD = 63, Agrietada

6502 código máquina (C64), LD = 1, seguro

Lua: LD = 1, agrietado

Mathematica, LD = 43 agrietado

PHP, LD = 35 ( Agrietado )

Python 3: LD = 9 | Agrietado

C ++, LD = 159

Groovy , 61 bytes (LD = 23)

Distancia de Levenshtein y OEIS (policías)

Casos de prueba (1 indexado):

Policías:

Respuestas:

Haskell , LD = 13, agrietado

cQuents 0 , LD = 1, agrietado

Explicación

JavaScript (ES6), LD = 103 ( agrietado )

Casos de prueba

Solución prevista

Python 2, 104 bytes, LD = 21 no válido y agrietado

Código de máquina 6502 (C64), LD = 1 ( descifrado )

Perl 5 , 59 + 1 ( -a) = 60 bytes, LD = 55

Java 8, (177 bytes) LD = 92 ( descifrado por @Arnauld )

Octava , LD = 63, Agrietada

6502 código máquina (C64), LD = 1, seguro

Lua: LD = 1, agrietado

Mathematica, LD = 43 agrietado

PHP, LD = 35 ( Agrietado )

Python 3: LD = 9 | Agrietado

C ++, LD = 159

Groovy , 61 bytes (LD = 23)

Perl 5 , 59 + 1 ( `-a`) = 60 bytes, LD = 55