16

Ini adalah pos Cop. The Robber posting di sini .

Tugas Anda adalah mengambil input bilangan bulat N dan menghasilkan digit ke- N dalam urutan OEIS A002942 .

Urutan terdiri dari angka kuadrat yang ditulis mundur:

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

Perhatikan bahwa nol di awal dipangkas jauh ( 100 menjadi 1 , bukan 001 ). Menggabungkan ini menjadi string (atau satu nomor panjang memberi):

1496152639446181121441

Anda harus menampilkan digit ke- N dalam string / angka ini. Anda dapat memilih untuk mengambil N sebagai diindeks 0 atau 1 diindeks (sebutkan yang mana yang Anda pilih).

Kasus uji (1-diindeks):

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

Kode Anda harus bekerja untuk angka hingga N = 2 ^ 15 (kecuali bahasa Anda tidak dapat menangani bilangan bulat 32 bit secara default, dalam hal ini N dapat lebih rendah).

Polisi:

Anda harus menulis dua fungsi / program, dalam bahasa yang sama, yang melakukan hal yang sama. Anda harus memposting salah satu fungsi / program, serta jarak Levenshtein antara dua fungsi / program yang Anda tulis. Jarak Levenshtein diukur dalam karakter (jadi penambahan karakter dua byte akan menghasilkan LD = 1).

Kode yang tidak terungkap tidak boleh lebih panjang dari solusi asli (tetapi bisa dengan ukuran yang sama). Perampok akan berusaha untuk menulis kode dengan jarak Levenshtein yang Anda berikan (bisa berbeda dari kode Anda yang belum diungkap, asalkan berhasil).

Pemenangnya adalah pengajuan tanpa retak yang memiliki jarak Levenshtein terendah.

Anda dapat memeriksa jarak Levenshtein di sini!

Jika kiriman Anda tidak retak selama 7 hari maka Anda dapat mengungkapkan kode alternatif yang telah Anda tulis dan menandai kiriman Anda sebagai aman.

number sequence cops-and-robbers Stewie Griffin
sumber

Ya, saya akan menambahkannya ke aturan. :)

Stewie Griffin

Anda berbicara tentang skrip, tetapi saya menganggap ini adalah program atau fungsi default ?

Kevin Cruijssen

Ya, default semuanya :)

Stewie Griffin

Bagaimana Anda menangani komentar dan spasi, saya melihat beberapa hal aneh.

Magic Gurita Guci

1

"Kode Anda harus bekerja untuk angka hingga N = 2 ^ 15" -> tetapi salah satu kasus uji lebih besar dari itu. Apakah kasus 274164 diperlukan?

Tom Carpenter

6

Haskell , LD = 13, sudah retak

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

Cobalah online!

Saya memeriksa ulang bahwa nol di awal terpangkas;)

Penjelasan:

                    [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
sumber

2

Retak !

H.PWiz

3

cQuents 0 , LD = 1, Cracked

":\r$*$

Cobalah online!

Saya pikir ini tidak berfungsi untuk memimpin nol, tetapi sebenarnya - fungsi terbalik di cQuents dikodekan sebagai int(reversed(str(n))).

Penjelasan

"         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
sumber

retak?

Laikoni

@Laikoni ya, cQuents melakukan perkalian implisit seperti, agak seperti Mathematica, tetapi Anda tidak membutuhkan spasi. Menambahkan penjelasan.

Stephen

3

JavaScript (ES6), LD = 103 ( retak )

Menggunakan jarak Levenshtein setinggi itu mungkin bukan strategi terbaik, tapi mari kita coba saja.

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

Uji kasus

Tampilkan cuplikan kode

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

Luaskan cuplikan

Solusi yang dimaksudkan

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

Bagian yang dikodekan:

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

Arnauld
sumber

Apakah strip ini memimpin 0s setelah membalikkan?

Erik the Outgolfer

@EriktheOutgolfer Ya. Unary +memastikan bahwa string yang dibalik dipaksa ke suatu Nomor.

Arnauld

1

Ohhhh ... wow, itu lebih sulit dari yang saya kira.

Magic Octopus Urn

Retak !

Lynn

3

Python 2, 104 byte, LD = 21 Tidak Valid DAN Retak

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 Apakah jumlah ruang kosong dan komentar yang tidak terbatas diizinkan? Jika demikian, ini tidak akan sulit retak.~~

dylnan
sumber

1

"Kode yang tidak diungkapkan tidak boleh lebih lama dari solusi aslinya."

Khuldraeseth na'Barya

@ Scrooble Saya melihat itu tetapi saya tidak berpikir akan sulit untuk membuat program yang jauh lebih pendek dari yang ini. Sudah dilakukan di python 3 di jawaban lain dan itu bekerja di python 2 sehingga semua yang mereka perlu tambahkan adalah sekelompok \ns (sekitar 50)

dylnan

Bukankah 50 baris baru akan melebihi jarak Levenshtein 21?

Khuldraeseth na'Barya

@ Scrooble Anda benar sekali, saya bingung dan salah memikirkan masalahnya. Terima kasih

dylnan

1

Ini sepertinya kesalahan input yang lebih rendah dari 5

Leo

3

6502 kode mesin (C64), LD = 1 ( retak )

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 , penggunaan: disys49152,nmananinput 0-diindeks.

Untuk kasus uji terakhir, Anda perlu sedikit kesabaran, karena mesin yang buruk ini harus melakukan jutaan bit-shift dan tambahan untuk menyajikan hasilnya kepada Anda;)

Bahasa di sini adalah kode mesin, jadi LD diukur dalam format ini - namun, untuk memberikan sesuatu untuk memulai, inilah program dalam ca65sumber assembler:

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

... dan inilah skrip tautan untuk 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
sumber

retak (saya percaya)

Jo.

@ Jo. ya, diedit.

Felix Palmen

2

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

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

Cobalah online!

Xcali
sumber

mungkin retak, saya tidak yakin dengan entri saya codegolf.stackexchange.com/questions/146927/…

Nahuel Fouilleul

2

Java 8, (177 bytes) LD = 92 ( Cracked oleh @Arnauld )

(Saya sudah menggunakan kalkulator LD online ini. )

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

Ini mungkin tidak terlalu sulit jika Anda hanya bermain golf ini. :)

Penjelasan:

Coba di sini.

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
sumber

1

Cracked

Arnauld

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

Kevin Cruijssen

2

Oktaf , LD = 63, Retak

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

Cobalah online!

Pengajuan adalah 77 byte, jadi Anda perlu mengganti sedikit =)

Stewie Griffin
sumber

retak .

Tom Carpenter

2

6502 kode mesin (C64), LD = 1, aman

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 , penggunaan: disys49152,nmananinput 0-diindeks.

Solusi yang dimaksudkan: (beda)

 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

The 30(opcode bmi) diganti dengan 90(opcode bcc). Ini sesuai dengan bagian berikut dalam sumber assembler:

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

Ini bekerja karena kode ini memeriksa apakah angka lebih kecil dari 8. cmpInstruksi melakukan pengurangan untuk itu, mengatur bendera yang sesuai. Jadi, jika akumulator memegang angka lebih kecil dari 8, ini mengalir di bawah, membersihkan bendera carry, oleh karena itu instruksi cabang yang benar memang bcc. bmi(bercabang ketika negatif), seperti dalam kode asli, kebetulan bekerja di sini juga, karena angka yang dibandingkan cukup kecil, sehingga hasil pengurangan tersebut berakhir pada rentang negatif ($80-$ff ) ketika terjadi underflow.

Demo online

Ini adalah versi yang disempurnakan / dipadatkan dari kiriman saya sebelumnya . Di antara beberapa trik lain untuk mengurangi ukuran, itu menghilangkan kode tidak berguna yang terkandung dan memungkinkan semacam "sederhana" *) retak. Secara keseluruhan, ukurannya dikurangi sebesar 16 byte. Kali ini, akan sedikit lebih sulit untuk menemukan program yang setara dengan LD 1 :)

^{*) mungkin masih cukup sulit untuk ditemukan, tentu saja :)}

Sekali lagi, inilah ca65sumber assembler, untuk membantu memulai dengan kode:

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

... dan inilah skrip tautan untuk 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
sumber

Anggap saja tidak retak :)

Jo.

@ Jo. baik jika Anda bersikeras - terima kasih banyak, saya mengeditnya.

Felix Palmen

1

Lua: LD = 1, retak

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

Tidak ada trik mewah di sini :)

Katenkyo
sumber

retak

Erik the Outgolfer

1

Mathematica, LD = 43 retak

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

Cobalah online!

J42161217
sumber

Retak .

Misha Lavrov

1

PHP, LD = 35 ( Retak )

1-diindeks

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

Cobalah online!

Jo.
sumber

0

Python 3: LD = 9 | Retak

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

Ini harus cukup (sangat) mudah didapat: P

HyperNeutrino
sumber

Retak .

Tn. Xcoder

1

Saya menghapus Crack saya karena jawaban aslinya tidak valid.

Tn. Xcoder

@ Mr.Xcoder Anda dapat membatalkan penghapusan sekarang; LD adalah sama karena .lstrip("0")bagian itu hanya dapat disalin.

HyperNeutrino

Selesai

Tn. Xcoder

0

C ++, LD = 159

Diindeks 0, input masuk argv[1], disusun pada 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
sumber

0

Groovy , 61 byte (LD = 23)

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

Cobalah online!

Guci Gurita Ajaib
sumber

Bagaimana ini aman> _> ...

Magic Octopus Mm

Jarak Levenshtein & OEIS (Polisi)

Kasus uji (1-diindeks):

Polisi:

Jawaban:

Haskell , LD = 13, sudah retak

cQuents 0 , LD = 1, Cracked

Penjelasan

JavaScript (ES6), LD = 103 ( retak )

Uji kasus

Solusi yang dimaksudkan

Python 2, 104 byte, LD = 21 Tidak Valid DAN Retak

6502 kode mesin (C64), LD = 1 ( retak )

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

Java 8, (177 bytes) LD = 92 ( Cracked oleh @Arnauld )

Oktaf , LD = 63, Retak

6502 kode mesin (C64), LD = 1, aman

Lua: LD = 1, retak

Mathematica, LD = 43 retak

PHP, LD = 35 ( Retak )

Python 3: LD = 9 | Retak

C ++, LD = 159

Groovy , 61 byte (LD = 23)

Jarak Levenshtein & OEIS (Polisi)

Kasus uji (1-diindeks):

Polisi:

Jawaban:

Haskell , LD = 13, sudah retak

cQuents 0 , LD = 1, Cracked

Penjelasan

JavaScript (ES6), LD = 103 ( retak )

Uji kasus

Solusi yang dimaksudkan

Python 2, 104 byte, LD = 21 Tidak Valid DAN Retak

6502 kode mesin (C64), LD = 1 ( retak )

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

Java 8, (177 bytes) LD = 92 ( Cracked oleh @Arnauld )

Oktaf , LD = 63, Retak

6502 kode mesin (C64), LD = 1, aman

Lua: LD = 1, retak

Mathematica, LD = 43 retak

PHP, LD = 35 ( Retak )

Python 3: LD = 9 | Retak

C ++, LD = 159

Groovy , 61 byte (LD = 23)

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