Giriş

Matematikte, çokgen bir sayı, normal bir çokgen şeklinde düzenlenmiş noktalar veya çakıllar olarak temsil edilen bir sayıdır. Noktalar alfa (birim) olarak düşünülür. Bunlar bir tür 2 boyutlu figüratif sayılardır.

Örneğin 10 sayısı bir üçgen olarak düzenlenebilir:

*
**
***
****

Ancak 10 kare olarak düzenlenemez. Öte yandan, 9 sayısı şunlar olabilir:

***
***
***

36 gibi bazı sayılar hem kare hem de üçgen olarak düzenlenebilir:

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

Kural olarak, 1 herhangi bir sayıda taraf için ilk çokgen sayıdır. Çokgeni bir sonraki boyuta büyütme kuralı, iki bitişik kolu bir nokta uzatmak ve daha sonra bu noktalar arasına gerekli ekstra kenarları eklemektir. Aşağıdaki şemalarda, her ilave katman kırmızı olarak gösterilmiştir.

Üçgen Sayılar:

Kare Sayılar:

Beşgenler ve altıgenler gibi daha fazla sayıda kenarı olan çokgenler de bu kurala göre inşa edilebilir, ancak noktalar artık yukarıdaki gibi mükemmel şekilde düzenli bir kafes oluşturmayacaktır.

Beşgen Sayılar:

Altıgen Sayılar:

^{Kaynak: Wikipedia}

Senin görevin

Pozitif bir tamsayı N (1 <= N <= 1000) verildiğinde , her Poligonal Sayı N türünü yazdırın Üçgen Sayılardan Icosagonal (20-gon) Sayılara kadar dahil.

Örneğin, 10 sayısı üçgen bir sayı ve altıgen bir sayıdır, bu nedenle çıktı aşağıdaki gibi olmalıdır (kendi çıktı biçiminizi seçebilirsiniz, ancak bu şekilde görünmelidir):

3 10

Test senaryoları

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

Referans olarak, ninci k-gonal sayıdır:

^{Kredi bilgileri: xnor}

Unutmayın, bu kod golfüdür , bu yüzden en az baytlık kod kazanır.

Python 3, 68 bayt

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

Her bir potansiyel taraf sayısı için , sonucun bir tam sayı olup olmadığını görmek için s+2ikinci dereceden formülü çözer .R=s*n*(n-1)/2 + nn

Karşılaştır (73 bayt):

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

Alternatif bir çözüm yaklaşımı sPython 3'te 62 bayt verir, ancak başarısız olur R=1.

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

JavaScript (ES6), 90 bayt

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

İkinci dereceden denklemi çözer. Firefox'un yeterince yeni sürümlerinde 73 bayt:

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

> <>, 62 + 3 = 65 bayt

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

Yığının en üstündeki girdiyi bekler, böylece -vbayrak için +3 bayt .

Bu benim ilk <>> programlama, bu yüzden kodu kısaltmak için bazı açık hileler eksik olabilir.

Açıklama:

Başlatma

&1v
v0<
1

Taşır , N yazmacına, yığın sayacı iter (başlangıç 1üçgen sayı olduğu tekabül), ve değerleri dizisini başlatır 0ve 1.

Ana döngü

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

Yığının üstünü yazmaçla karşılaştırır. Eşitse, yazdırma rutinine gidin. Daha büyükse, sıfırlama rutinine gidin. Aksi takdirde, en üstteki iki yığın öğesi arasındaki farkı alın, sayacı ekleyin ve önceki üst yığın öğesine ekleyin. Bu, bir sonraki çokgen sayısını hesaplar.

Yazdır

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

Sayacı + 2 ve ardından bir yeni satır yazdırır, ardından sıfırlama rutinine gider.

Sıfırla

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

Üstteki iki yığın öğesini kaldırır ve sayacı artırır. Sayaç 18'den büyükse programı sonlandırır, aksi takdirde başlangıç ​​sayılarını 0ve 1yığına iter ve ana döngüye geri döner.

Jöle , 22 bayt

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

Çevrimiçi deneyin!

açıklama

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.

Axiom 203 bayt

 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)

burada sayıları gösteren daha az golf ve rutin

 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 bayt

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

Çevrimiçi deneyin!

Aslında ikinci dereceden çözmeyi denedim, ancak çalışıp çalışmadığını görmek için her değeri kontrol etmek daha kısa (ve benim için daha az hataya açık)

R, 6866 bayt

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

Stdin'den okur N. İlk Nk-gonal sayılarını hesaplar ve xnor formülünü kullanarak keşit oldukları yeri alır N; ancak, baytları parantez içine kaydeder ve sonunda ekler 1:18yerine kullanır .3:202

expand.gridVarsayılan adlarıyla kolonlar Var1, Var2, ..., bir isim verilmediği takdirde. $kısmi eşleme ile dizinler, bu nedenle ikinci sütuna m$Vkarşılık gelir m$Var2,.

eski versiyon:

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

Çevrimiçi deneyin!

Pari / GP , 34 bayt

Pari / GP, bir sayının çokgen sayı olup olmadığını sınamak için yerleşiktir.

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

Çevrimiçi deneyin!

Jöle , 20 bayt

^{Ben sadece bu meydan okuma etkili bir dupe yazmaya başladım (sadece [1,20] değil tüm k> 1'i de kapsayacak şekilde de olsa) ... bu yüzden cevaplayacağım!}

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

Sonuçların bir Jelly listesi temsilini basan tam bir program *

Çevrimiçi deneyin!

* Hiçbir sonuç hiçbir şey yazdırmaz;
  tek bir sonuç sadece bu sayıyı basar;
  birden çok sonuç []ekli, , ayrılmış bir sayı listesi yazdırır

Nasıl?

Ṫð’××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]