Einführung

In der Mathematik ist eine polygonale Zahl eine Zahl, die als Punkte oder Kiesel dargestellt wird, die in Form eines regelmäßigen Polygons angeordnet sind. Die Punkte werden als Buchstaben (Einheiten) angesehen. Dies sind eine Art zweidimensionaler figürlicher Zahlen.

Die Zahl 10 kann beispielsweise als Dreieck angeordnet sein:

*
**
***
****

Aber 10 kann nicht als Quadrat angeordnet werden. Die Zahl 9 kann andererseits sein:

***
***
***

Einige Zahlen, wie z. B. 36, können sowohl als Quadrat als auch als Dreieck angeordnet werden:

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

Gemäß der Konvention ist 1 die erste polygonale Zahl für eine beliebige Anzahl von Seiten. Die Regel zum Vergrößern des Polygons auf die nächste Größe besteht darin, zwei benachbarte Arme um einen Punkt zu verlängern und dann die erforderlichen zusätzlichen Seiten zwischen diesen Punkten hinzuzufügen. In den folgenden Diagrammen wird jede zusätzliche Ebene rot dargestellt.

Dreieckige Zahlen:

Quadratzahl:

Nach dieser Regel können auch Polygone mit einer höheren Anzahl von Seiten wie Fünfecke und Sechsecke konstruiert werden, obwohl die Punkte nicht mehr wie oben ein vollkommen regelmäßiges Gitter bilden.

Fünfeckige Zahlen:

Sechseckige Zahlen:

^{Quelle: Wikipedia}

Deine Aufgabe

Bei einer positiven ganzen Zahl N (1 <= N <= 1000) wird jede Art von polygonaler Zahl N von Dreieckszahlen bis einschließlich ikosagonaler Zahlen (20-gon) gedruckt.

Beispiel: Die Zahl 10 ist eine Dreiecks- und eine Dekagonalzahl. Die Ausgabe sollte also ungefähr so ​​aussehen (Sie können Ihr eigenes Ausgabeformat auswählen, aber es sollte ungefähr so ​​aussehen):

3 10

Testfälle

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

Als Referenz ist die n-te k-gonale Zahl:

^{Bildnachweis: xnor}

Denken Sie daran, das ist Code-Golf , also gewinnt der Code mit den wenigsten Bytes.

Python 3, 68 Bytes

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

Löst für jede mögliche Anzahl von Seiten s+2die quadratische Formel R=s*n*(n-1)/2 + nauf, num festzustellen, ob das Ergebnis eine ganze Zahl ist.

Vergleichen (73 Bytes):

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

Ein alternativer Lösungsansatz für sgibt 62 Bytes in Python 3, schlägt aber fehl 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)

Löst die quadratische Gleichung. 73 Bytes auf genügend neuen Firefox-Versionen:

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

> <>, 62 + 3 = 65 Bytes

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

Erwartet die Eingabe oben im Stapel, also +3 Bytes für die -v Flag.

Dies ist meine erste Programmierung in> <>, daher fehlen mir möglicherweise einige offensichtliche Tricks, um den Code zu verkürzen.

Erläuterung:

Initialisierung

&1v
v0<
1

Bewegt N zum Register, schiebt den Zähler auf den Stapel (beginnend mit 1, was Dreieckszahlen entspricht) und startet die Sequenz mit den Werten 0und 1.

Hauptschleife

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

Vergleicht die Oberseite des Stapels mit dem Register. Wenn es gleich ist, gehen Sie zur Druckroutine. Wenn es größer ist, gehen Sie zur Rücksetzroutine. Nehmen Sie andernfalls die Differenz zwischen den beiden obersten Stapelelementen, fügen Sie den Zähler hinzu und fügen Sie ihn zum vorherigen obersten Stapelelement hinzu. Dies berechnet die nächste polygonale Zahl.

Drucken

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

Gibt den Zähler + 2 gefolgt von einer neuen Zeile aus und wechselt dann zur Rücksetzroutine.

Zurücksetzen

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

Entfernt die beiden obersten Stapelelemente und erhöht den Zähler. Beendet das Programm, wenn der Zähler größer als 18 ist, ansonsten schiebt er die Startnummern 0und 1zum Stapel und kehrt zur Hauptschleife zurück.

Jelly , 22 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

 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)

Hier ist weniger Golf und Routine, die Zahlen zeigen

 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 Bytes

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

Probieren Sie es online!

Ich habe versucht, das Quadrat tatsächlich zu lösen, aber es ist kürzer (und für mich weniger fehleranfällig) , jeden Wert zu überprüfen, um festzustellen, ob er funktioniert.

R, 68 66 Bytes

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

Liest Nvon stdin. Berechnet die ersten Nk-gonalen Zahlen und ermittelt die kGleichheit Nmit der xnor-Formel. Spart jedoch Bytes in Klammern, indem 1:18anstelle von 3:20und 2am Ende hinzugefügt wird .

expand.gridvon Standardnamen der Spalten Var1, Var2..., wenn ein Name nicht gegeben ist. $Indizes durch partielle Übereinstimmung, m$Ventspricht also m$Var2,der zweiten Spalte.

alte Version:

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

Probieren Sie es online!

Pari / GP , 34 Bytes

Pari / GP verfügt über eine integrierte Funktion zum Testen, ob eine Zahl eine polygonale Zahl ist.

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

Probieren Sie es online!

Gelee , 20 Bytes

^{Ich habe gerade angefangen, eine effektive Kopie dieser Herausforderung zu schreiben (auch wenn sie alle k> 1 und nicht nur [1,20] abdeckt) ... also werde ich sie beantworten!}

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

Ein vollständiges Programm, das eine Geleelistendarstellung der Ergebnisse druckt *

Probieren Sie es online!

* Kein Ergebnis gibt nichts aus;
  Ein einzelnes Ergebnis gibt nur diese Zahl aus.
  mehrere ergebnisse druckt a[] geschlossene, , getrennte Liste der Zahlen

Wie?

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