16

To jest policjant. Robber post jest tutaj .

Twoim zadaniem jest, aby wejście całkowitą N i wysyłać Pn cyfrowy w sekwencji OEIS A002942 .

Sekwencja składa się z kwadratowych liczb zapisanych wstecz:

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

Zauważ, że zera wiodące są usuwane ( 100 zmienia się na 1 , a nie 001 ). Łączenie tego w ciąg (lub jedną długą liczbę daje):

1496152639446181121441

Wyrzucisz N - tą cyfrę w tym ciągu / numerze. Możesz wybrać N jako 0 lub 1 indeks (proszę podać, który wybierzesz).

Przypadki testowe (indeksowane 1):

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

Twój kod powinien działać dla liczb do N = 2 ^ 15 (chyba że twój język domyślnie nie obsługuje 32-bitowych liczb całkowitych, w którym to przypadku N może być niższy).

Gliny:

Musisz napisać dwie funkcje / programy w tym samym języku, które robią to samo. Musisz opublikować jedną z funkcji / programów, a także odległość Levenshteina między dwiema napisanymi funkcjami / programami. Odległość Levenshteina mierzona jest w znakach (więc dodanie dwubajtowego znaku da LD = 1).

Ujawniony kod nie może być dłuższy niż oryginalne rozwiązanie (ale może mieć ten sam rozmiar). Rabusie spróbują napisać kod z dokładną podaną odległością Levenshteina (może się różnić od nieujawnionego kodu, o ile działa).

Zwycięzcą zostanie zgłoszenie bez krakowania, które ma najniższą odległość Levenshteina.

Tutaj możesz sprawdzić odległość Levenshtein!

Jeśli Twoje zgłoszenie pozostanie bez krakowania przez 7 dni, możesz ujawnić alternatywny kod, który napisałeś i oznaczyć go jako bezpieczny.

number sequence cops-and-robbers Stewie Griffin
źródło

Tak, dodam to do zasad. :)

Stewie Griffin

Mówisz o skryptach, ale zakładam, że jest to domyślny program lub funkcja ?

Kevin Cruijssen

Tak, domyślnie wszystko :)

Stewie Griffin

Jak sobie radzisz z komentarzami i białymi spacjami, widzę dziwne rzeczy.

Magic Octopus Urn

1

„Twój kod powinien działać dla liczb do N = 2 ^ 15” ->, ale jeden z przypadków testowych jest większy. Czy obudowa 274164 jest konieczna?

Tom Carpenter,

6

Haskell , LD = 13, pęknięty

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

Wypróbuj online!

Dokładnie sprawdziłem, czy wiodące zera są przycięte;)

Wyjaśnienie:

                    [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
źródło

2

Pęknięty !

H.PWiz

3

cQuents 0 , LD = 1, Cracked

":\r$*$

Wypróbuj online!

Myślałem, że to nie działa dla zer wiodących, ale tak naprawdę działa - funkcja odwrotna w cQuents jest zakodowana jako int(reversed(str(n))).

Wyjaśnienie

"         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
źródło

pęknięty?

Laikoni

@Laikoni tak, cQuents niesie za sobą ukryte mnożenie, trochę jak Mathematica, ale nie potrzebujesz spacji. Dodanie wyjaśnienia.

Stephen

3

JavaScript (ES6), LD = 103 ( pęknięty )

Korzystanie z tak dużego dystansu Levenshteina nie jest prawdopodobnie najlepszą strategią, ale i tak spróbujmy.

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

Przypadki testowe

Pokaż fragment kodu

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

Expand snippet

Zamierzone rozwiązanie

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

Zakodowana część:

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

Arnauld
źródło

Czy ten pasek prowadzi do 0 po cofnięciu?

Erik the Outgolfer

@EriktheOutgolfer Tak. Unary +zapewnia, że odwrócony ciąg jest wymuszany na liczbę.

Arnauld

1

Ohhhh ... wow, to trudniejsze niż myślałem.

Magic Octopus Urn

Pęknięty !

Lynn

3

Python 2, 104 bajty, LD = 21 Niepoprawny AND Cracked

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]

~~PS Czy dozwolona jest nieograniczona ilość białych znaków i komentarzy? Jeśli tak, nie będzie to trudne do złamania.~~

dylnan
źródło

1

„Nie objawiony kod nie może być dłuższy niż oryginalne rozwiązanie”.

Khuldraeseth na'Barya

@ Scrooble Widziałem to, ale nie sądzę, że trudno będzie stworzyć program, który jest znacznie krótszy niż ten. Już zostało to zrobione w Pythonie 3 w innej odpowiedzi i działa w Pythonie 2, więc wszystko, co muszą dodać, to kilka \ns (około 50)

dylnan

Czy 50 linii nie przekroczy odległości Levenshteina wynoszącej 21?

Khuldraeseth na'Barya

@ Scrooble Masz rację, pomyliłem się i niepoprawnie myślałem o problemie. Dzięki

dylnan,

1

Wydaje się, że to błąd na wejściach niższych niż 5

Leo

3

6502 kod maszynowy (C64), LD = 1 ( pęknięty )

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

Demo online , użycie:sys49152,ngdzienjest wejście indeksowane 0.

W ostatnim przypadku testowym potrzebujesz trochę cierpliwości, ponieważ ta kiepska maszyna musi wykonać miliony przesunięć bitowych i dodatków, aby przedstawić ci wynik;)

Językiem jest tutaj kod maszynowy, więc LD jest mierzone w tym formacie - niemniej jednak, aby dać coś na początek, oto program w ca65źródle asemblera:

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

... a oto skrypt linkera dla 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
źródło

cracked (wierzę)

Jo.

@Jo. tak, zredagowane.

Felix Palmen,

2

Perl 5 , 59 + 1 ( `-a`) = 60 bajtów, LD = 55

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

Wypróbuj online!

Xcali
źródło

może pęknięty, nie jestem pewien mojego wpisu codegolf.stackexchange.com/questions/146927/…

Nahuel Fouilleul

2

Java 8, (177 bajtów) LD = 92 ( Pęknięty przez @Arnauld )

( Użyłem tego internetowego kalkulatora LD ).

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

Prawdopodobnie nie jest to zbyt trudne, jeśli po prostu grasz w golfa. :)

Wyjaśnienie:

Wypróbuj tutaj.

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
źródło

1

Pęknięty

Arnauld,

Zamierzone rozwiązanie: n->{String r="";for(int i=1;r.length()<=n+1;r+=new Long(new StringBuffer(i*i+++"").reverse()+""));return r.charAt(n);}( 118 bajtów, 92 LD )

Kevin Cruijssen

2

Oktawa , LD = 63, pęknięty

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

Wypróbuj online!

Przesłanie to 77 bajtów, więc musisz trochę podstawić =)

Stewie Griffin
źródło

pęknięty .

Tom Carpenter,

2

Kod maszynowy 6502 (C64), LD = 1, bezpieczny

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

Demo online , użycie:sys49152,ngdzienjest wejście indeksowane 0.

Zamierzone rozwiązanie: (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

30(Opcode bmi) jest zastąpiony przez 90(opcode bcc). Odpowiada to następującej części źródła asemblera:

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

Działa, ponieważ ten kod sprawdza, czy liczba jest mniejsza niż 8. cmpInstrukcja wykonuje odejmowanie, ustawiając odpowiednio flagi. Tak więc, jeśli akumulator ma liczbę mniejszą niż 8, to przepełnia się, usuwając flagę carry, dlatego rzeczywiście jest odpowiednia instrukcja rozgałęzienia bcc. bmi(rozgałęzienie, gdy jest ujemne), tak jak w oryginalnym kodzie, również tutaj działa, ponieważ porównywane liczby są wystarczająco małe, więc wynik odejmowania kończy się w ujemnym zakresie ( $80-$ff), gdy wystąpi niedopełnienie.

Demo online

To jest ulepszona / skompaktowana wersja mojego poprzedniego zgłoszenia . Oprócz kilku innych sztuczek mających na celu zmniejszenie rozmiaru, usuwa niepotrzebny kod, który był zawarty i pozwalał na rodzaj „prostego” *) pęknięcia. Podsumowując, rozmiar jest zmniejszony o 16 bajtów. Tym razem znalezienie odpowiedniego programu z LD 1 powinno być nieco trudniejsze :)

^{*) prawdopodobnie nadal sporo pracy do znalezienia, oczywiście :)}

Ponownie, oto jest ca65 źródło asemblera, które pomaga w rozpoczęciu pracy z kodem:

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

... a oto skrypt linkera dla 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
źródło

Uważaj to za niespękane :)

Jo.

@Jo. cóż, jeśli nalegasz - wielkie dzięki, edytowałem to.

Felix Palmen,

1

Lua: LD = 1, pęknięty

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

Żadnych fantazyjnych sztuczek tutaj :)

Katenkyo
źródło

cracked

Erik the Outgolfer

1

Mathematica, LD = 43 pęknięty

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

Wypróbuj online!

J42161217
źródło

Pęknięty .

Misza Ławrow

1

PHP, LD = 35 ( pęknięty )

1-indeksowany

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

Wypróbuj online!

Jo.
źródło

0

Python 3: LD = 9 | Pęknięty

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

Ten powinien być dość (bardzo) łatwy do zdobycia: P

HyperNeutrino
źródło

Pęknięty .

Pan Xcoder,

1

Usunąłem swój crack, ponieważ oryginalna odpowiedź jest nieprawidłowa.

Pan Xcoder,

@ Mr.Xcoder Możesz teraz cofnąć usunięcie; LD jest taki sam, ponieważ .lstrip("0")część można po prostu skopiować.

HyperNeutrino,

Zrobione

Mr. Xcoder,

0

C ++, LD = 159

Indeksowane 0, wejście argv[1], skompilowane na 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
źródło

0

Groovy , 61 bajtów (LD = 23)

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

Wypróbuj online!

Urna Magicznej Ośmiornicy
źródło

Jak to jest bezpieczne> _> ...

Magic Octopus Urn

Dystans Levenshtein i OEIS (policjanci)

Przypadki testowe (indeksowane 1):

Gliny:

Odpowiedzi:

Haskell , LD = 13, pęknięty

cQuents 0 , LD = 1, Cracked

Wyjaśnienie

JavaScript (ES6), LD = 103 ( pęknięty )

Przypadki testowe

Zamierzone rozwiązanie

Python 2, 104 bajty, LD = 21 Niepoprawny AND Cracked

6502 kod maszynowy (C64), LD = 1 ( pęknięty )

Perl 5 , 59 + 1 ( `-a`) = 60 bajtów, LD = 55

Java 8, (177 bajtów) LD = 92 ( Pęknięty przez @Arnauld )

Oktawa , LD = 63, pęknięty

Kod maszynowy 6502 (C64), LD = 1, bezpieczny

Lua: LD = 1, pęknięty

Mathematica, LD = 43 pęknięty

PHP, LD = 35 ( pęknięty )

Python 3: LD = 9 | Pęknięty

C ++, LD = 159

Groovy , 61 bajtów (LD = 23)

Dystans Levenshtein i OEIS (policjanci)

Przypadki testowe (indeksowane 1):

Gliny:

Odpowiedzi:

Haskell , LD = 13, pęknięty

cQuents 0 , LD = 1, Cracked

Wyjaśnienie

JavaScript (ES6), LD = 103 ( pęknięty )

Przypadki testowe

Zamierzone rozwiązanie

Python 2, 104 bajty, LD = 21 Niepoprawny AND Cracked

6502 kod maszynowy (C64), LD = 1 ( pęknięty )

Perl 5 , 59 + 1 ( -a) = 60 bajtów, LD = 55

Java 8, (177 bajtów) LD = 92 ( Pęknięty przez @Arnauld )

Oktawa , LD = 63, pęknięty

Kod maszynowy 6502 (C64), LD = 1, bezpieczny

Lua: LD = 1, pęknięty

Mathematica, LD = 43 pęknięty

PHP, LD = 35 ( pęknięty )

Python 3: LD = 9 | Pęknięty

C ++, LD = 159

Groovy , 61 bajtów (LD = 23)

Perl 5 , 59 + 1 ( `-a`) = 60 bajtów, LD = 55