pengantar

Dalam matematika, bilangan poligon adalah bilangan yang direpresentasikan sebagai titik atau kerikil yang disusun dalam bentuk poligon beraturan. Titik-titik dianggap sebagai alfa (unit). Ini adalah satu jenis angka figurate 2 dimensi.

Angka 10, misalnya, dapat disusun sebagai segitiga:

*
**
***
****

Tetapi 10 tidak dapat disusun sebagai kotak. Angka 9, di sisi lain, dapat berupa:

***
***
***

Beberapa angka, seperti 36, dapat disusun baik sebagai persegi maupun segitiga:

******  *
******  **
******  ***
******  ****
******  *****
******  ******

Dengan konvensi, 1 adalah angka poligon pertama untuk sejumlah sisi. Aturan untuk memperbesar poligon ke ukuran berikutnya adalah untuk memperpanjang dua lengan yang berdekatan dengan satu titik dan kemudian menambahkan sisi tambahan yang diperlukan antara titik-titik tersebut. Dalam diagram berikut, setiap lapisan tambahan ditampilkan dengan warna merah.

Angka segitiga:

Nomor Kuadrat:

Poligon dengan jumlah sisi yang lebih tinggi, seperti pentagon dan hexagon, juga dapat dibangun sesuai dengan aturan ini, meskipun titik-titik tidak akan lagi membentuk kisi yang teratur seperti di atas.

Bilangan Pentagonal:

Bilangan Heksagonal:

^{Sumber: Wikipedia}

Tugas Anda

Dengan bilangan bulat positif N (1 <= N <= 1000), cetak setiap jenis Nomor Poligon N mulai dari Bilangan Segitiga hingga dan termasuk Bilangan Icosagonal (20-gon).

Sebagai contoh, angka 10 adalah angka segitiga dan angka decagonal, jadi outputnya harus seperti (Anda dapat memilih format output Anda sendiri, tetapi akan terlihat seperti ini):

3 10

Uji kasus

1 -> 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
2 -> (None)
3 -> 3
6 -> 3 6
36 -> 3 4 13

Untuk referensi, n-th knomor -gonal adalah:

^{Kredit: xnor}

Ingat, ini adalah kode-golf , jadi kode dengan byte paling sedikit menang.

Python 3, 68 byte

lambda R:[s+2for s in range(1,19)if(s-2+(4+s*(s-4+8*R))**.5)/2%s==0]

Untuk setiap jumlah potensial sisi s+2, pecahkan rumus kuadratik R=s*n*(n-1)/2 + nuntuk nmelihat apakah hasilnya bilangan bulat.

Bandingkan (73 byte):

lambda R:[s+2for s in range(1,19)if R in[n+s*n*~-n/2for n in range(R+1)]]

Pendekatan alternatif penyelesaian untuk smemberikan 62 byte dalam Python 3, tetapi gagal R=1.

lambda R:{(R-n)*2/n/~-n+2for n in range(2,R+1)}&{*range(3,21)}

JavaScript (ES6), 90 byte

n=>[...Array(21).keys(n--)].slice(3).filter(i=>(Math.sqrt(i*i+8*i*n-16*n)+i-4)%(i+i-4)==0)

Memecahkan persamaan kuadrat. 73 byte pada versi Firefox yang cukup baru:

n=>[for(i of Array(18).keys())if(((~-i**2+8*n*-~i)**.5+~-i)/2%-~i==0)i+3]

> <>, 62 + 3 = 65 byte

&1v
v0<;?)+8a:+1~~<
1.292:{<>+n}ao^
>:&:&=?^:&:&)?^:@:@$-{:}++

Mengharapkan input di bagian atas tumpukan, jadi +3 byte untuk -vbendera.

Ini adalah pemrograman pertama saya di> <>, jadi saya mungkin kehilangan beberapa trik yang jelas untuk mempersingkat kodenya.

Penjelasan:

Inisialisasi

&1v
v0<
1

Memindahkan N ke register, mendorong penghitung ke tumpukan (mulai dari 1, yang sesuai dengan angka segitiga), dan memulai urutan dengan nilai 0dan 1.

Loop Utama

 :&:&=?^:&:&)?^:@:@$-{:}++

Bandingkan bagian atas tumpukan dengan register. Jika sama, buka rutin cetak. Jika lebih besar, buka rutin reset. Kalau tidak, ambil perbedaan antara dua item tumpukan teratas, tambahkan penghitung, dan tambahkan ke item tumpukan teratas sebelumnya. Ini menghitung angka poligon berikutnya.

Mencetak

 .292:{<>+n}ao^
       ^

Mencetak penghitung + 2, diikuti oleh baris baru, lalu pindah ke rutin reset.

Setel ulang

v0<;?)+8a:+1~~<
1             ^

Menghapus dua item tumpukan teratas dan menambah penghitung. Mengakhiri program jika penghitung lebih besar dari 18, jika tidak, tekan angka awal 0dan 1ke tumpukan dan kembali ke loop utama.

Jelly , 22 byte

18pȷµḢ×’×H+µ€_³¬FT:ȷ+3

Cobalah online!

Penjelasan

18pȷµḢ×’×H+µ€_³¬FT:ȷ+3
18pȷ                   - All possible (k-2,n) pairs
    µ      µ€          - to each pair compute the corresponding polygonal number:
     Ḣ                 -   retrieve k-2
      ×’               -   multiply by n-1
        ×H             -   multiply by half of n
          +            -   add n
             _³        - subtract the input. There will now be 0's at (k-2,n) pairs which produce the input
               ¬FT     - retrieve all indices of 0's. The indices are now (k-2)*1000+n
                  :ȷ   - floor division by 1000, returning k-3
                    +3 - add 3 to get all possible k.

Aksioma 203 byte

 l(x)==(local q,m,a;v:List INT:=[];for i in 3..20 repeat(q:=solve((i-2)*n*(n-1)+2*n-2*x=0,n);if #q>1 then(m:=rhs q.1;a:=rhs q.2;if(m>0 and denom(m)=1)or(a>0 and denom(a)=1)then v:=cons(i,v)));v:=sort v;v)

di sini kurang golf dan rutin yang menunjukkan angka

 l(x)==
  local q,m,a
  v:List INT:=[]
  for i in 3..20 repeat 
     q:=solve((i-2)*n*(n-1)+2*n-2*x=0,n)  -- this would find only rational solutions as r/s with r,s INT
     if #q>1 then -- if exist rational solution and denominator =1=> add to list of result
        m:=rhs q.1;a:=rhs q.2;
        if(m>0 and denom(m)=1)or(a>0 and denom(a)=1)then v:=cons(i,v) 
  v:=sort v
  v

 (2) ->  [[i,l(i)]  for i in 1..45]
    Compiling function l with type PositiveInteger -> List Integer

    (2)
    [[1,[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]], [2,[]], [3,[3]],
     [4,[4]], [5,[5]], [6,[3,6]], [7,[7]], [8,[8]], [9,[4,9]], [10,[3,10]],
     [11,[11]], [12,[5,12]], [13,[13]], [14,[14]], [15,[3,6,15]], [16,[4,16]],
     [17,[17]], [18,[7,18]], [19,[19]], [20,[20]], [21,[3,8]], [22,[5]],
     [23,[]], [24,[9]], [25,[4]], [26,[]], [27,[10]], [28,[3,6]], [29,[]],
     [30,[11]], [31,[]], [32,[]], [33,[12]], [34,[7]], [35,[5]], [36,[3,4,13]],
     [37,[]], [38,[]], [39,[14]], [40,[8]], [41,[]], [42,[15]], [43,[]],
     [44,[]], [45,[3,6,16]]]
                                                           Type: List List Any

AWK , 67 byte

{for(k=2;++k<21;)for(n=0;++n<=$1;)if((k/2-1)*(n*n-n)+n==$1)print k}

Cobalah online!

Saya mencoba memecahkan kuadrat sebenarnya, tetapi memeriksa setiap nilai untuk melihat apakah itu bekerja lebih pendek (dan lebih sedikit rawan kesalahan bagi saya)

R, 68 66 byte

N=scan();m=expand.grid(k=1:18,1:N);n=m$V;m$k[m$k*n*(n-1)/2+n==N]+2

Baca Ndari stdin. Menghitung angka Nk-gonal pertama dan mendapatkan di kmana mereka sama N, menggunakan rumus xnor; namun, menyimpan byte pada tanda kurung dengan menggunakan 1:18alih-alih 3:20dan menambahkan 2di akhir.

expand.griddengan nama default kolom Var1, Var2, ..., jika nama tidak diberikan. $indeks dengan pencocokan sebagian, sehingga m$Vsesuai dengan m$Var2,kolom kedua.

versi lama:

N=scan();m=expand.grid(k=3:20,1:N);n=m$V;m$k[(m$k-2)*n*(n-1)/2+n==N]

Cobalah online!

Pari / GP , 34 byte

Pari / GP memiliki built-in untuk menguji apakah suatu angka adalah angka poligonal.

x->[s|s<-[3..20],ispolygonal(x,s)]

Cobalah online!

Jelly , 20 byte

^{Saya baru saja mulai menulis pembohong yang efektif untuk tantangan ini (walaupun mencakup semua k> 1 bukan hanya [1,20]) ... jadi alih-alih saya akan menjawabnya!}

Ṫð’××H+⁸
18pÇċ¥Ðf⁸+2

Program lengkap mencetak representasi daftar Jelly dari hasil *

Cobalah online!

* Tidak ada hasil yang mencetak apa pun;
  hasil tunggal mencetak hanya angka itu;
  banyak hasil mencetak daftar angka yang []tertutup dan tertutup,

Bagaimana?

Ṫð’××H+⁸ - Link 1, ith (x+2)-gonal number: list [x,i]   e.g. [3,4] (for 4th Pentagonal)
Ṫ        - tail & modify (i.e. yield i & make input [x])     4
 ð       - new dyadic chain, i.e. left = i, right = [x]
  ’      - decrement i                                       3
   ×     - multiply by [x]                                   [9]
     H   - halve [x]                                         [2]
    ×    - multiply                                          [18]
       ⁸ - chain's left argument, i                          4
      +  - add                                               [22]

18pÇċ¥Ðf⁸+2 - Main link: number, n                      e.g. 36
18p         - Cartesian product of range [1,18] with n       [[1,1],[1,2],...,[1,36],[2,1],...,[18,1],[18,2],[18,36]]
            -   (all pairs of [(k-2),i] which could result in the ith k-gonal number being n)
      Ðf    - filter keep if this is truthy:
        ⁸   -   chain's left argument, n                     36
     ¥      -   last two links as a dyad:
   Ç        -     call the last link as a monad (note this removes the tail of each)
    ċ       -     count (this is 1 if the result is [n] and 0 otherwise)
            -                            filter keep result: [[1],[2],[11]]
         +2 - add two                                        [[3],[4],[13]]
            - implicit print ...due to Jelly representation: [3, 4, 13]