introduction

En mathématiques, un nombre polygonal est un nombre représenté par des points ou des cailloux disposés sous la forme d'un polygone régulier. Les points sont considérés comme des alphas (unités). Ce sont un type de nombres figuratifs bidimensionnels.

Le nombre 10, par exemple, peut être organisé en triangle:

*
**
***
****

Mais 10 ne peut pas être organisé en carré. Le chiffre 9, en revanche, peut être:

***
***
***

Certains nombres, comme 36, peuvent être organisés à la fois en carré et en triangle:

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

Par convention, 1 est le premier nombre polygonal pour un nombre quelconque de côtés. La règle pour agrandir le polygone à la taille suivante consiste à étendre deux bras adjacents d'un point, puis à ajouter les côtés supplémentaires requis entre ces points. Dans les schémas suivants, chaque couche supplémentaire est représentée en rouge.

Numéros triangulaires:

Numéros carrés:

Des polygones avec un plus grand nombre de côtés, tels que des pentagones et des hexagones, peuvent également être construits selon cette règle, bien que les points ne formeront plus un réseau parfaitement régulier comme ci-dessus.

Nombres pentagonaux:

Numéros hexagonaux:

^{Source: Wikipedia}

Ta tâche

Étant donné un entier positif N (1 <= N <= 1000), imprimez chaque type de nombre polygonal N à partir des nombres triangulaires jusqu'aux nombres icosagonaux (20 gon) inclus.

Par exemple, le nombre 10 est un nombre triangulaire et un nombre décagonal, donc la sortie devrait ressembler à quelque chose (vous pouvez choisir votre propre format de sortie, mais il devrait ressembler à ceci):

3 10

Cas de test

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

Pour référence, le n-ième- knuméro de zone est:

^{Crédits: xnor}

N'oubliez pas qu'il s'agit de code-golf , donc le code avec le moins d'octets gagne.

Python 3, 68 octets

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

Pour chaque nombre potentiel de côtés s+2, résout la formule quadratique R=s*n*(n-1)/2 + npour nvoir si le résultat est un nombre entier.

Comparer (73 octets):

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

Une approche alternative de résolution de sdonne 62 octets en Python 3, mais échoue R=1.

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

JavaScript (ES6), 90 octets

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

Résout l'équation quadratique. 73 octets sur les nouvelles versions de Firefox:

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

> <>, 62 + 3 = 65 octets

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

Attend l'entrée en haut de la pile, donc +3 octets pour l' -vindicateur.

Il s'agit de ma première programmation dans> <>, il me manque donc peut-être des astuces évidentes pour raccourcir le code.

Explication:

Initialisation

&1v
v0<
1

Déplace N dans le registre, pousse le compteur dans la pile (à partir de 1, ce qui correspond aux nombres triangulaires), et démarre la séquence avec les valeurs 0et 1.

Boucle principale

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

Compare le haut de la pile avec le registre. S'il est égal, passez à la routine d'impression. S'il est supérieur, passez à la routine de réinitialisation. Sinon, prenez la différence entre les deux éléments de pile supérieurs, ajoutez le compteur et ajoutez à l'élément de pile supérieur précédent. Ceci calcule le prochain nombre polygonal.

Impression

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

Imprime le compteur + 2, suivi d'une nouvelle ligne, puis passe à la routine de réinitialisation.

Réinitialiser

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

Supprime les deux premiers éléments de la pile et incrémente le compteur. Termine le programme si le compteur est supérieur à 18, sinon pousse les nombres de départ 0et 1vers la pile et revient à la boucle principale.

Gelée , 22 octets

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

Essayez-le en ligne!

Explication

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.

Axiome 203 octets

 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)

voici moins de golf et de routine qui montrent des chiffres

 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 octets

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

Essayez-le en ligne!

J'ai essayé de résoudre le quadratique, mais vérifier chaque valeur pour voir si cela fonctionne est plus court (et moins sujet aux erreurs pour moi)

R, 68 66 octets

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

Lit à Npartir de stdin. Calcule les premiers Nnombres k-gonaux et obtient les koù ils sont égaux N, en utilisant la formule de xnor; cependant, enregistre les octets entre parenthèses en utilisant 1:18au lieu de 3:20et en ajoutant 2à la fin.

expand.gridpar défaut les noms des colonnes Var1, Var2..., si un nom n'est pas donné. $index par correspondance partielle, m$Vcorrespond donc à m$Var2,la deuxième colonne.

ancienne 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]

Essayez-le en ligne!

Pari / GP , 34 octets

Pari / GP a un intégré pour tester si un nombre est un nombre polygonal.

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

Essayez-le en ligne!

Gelée , 20 octets

^{Je viens de commencer à écrire une dupe efficace de ce défi (bien que couvrant tous les k> 1 et pas seulement [1,20]) ... alors à la place je vais y répondre!}

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

Un programme complet imprimant une représentation de la liste Jelly des résultats *

Essayez-le en ligne!

* Aucun résultat n'imprime rien;
  un seul résultat imprime juste ce nombre;
  plusieurs résultats imprime une liste de nombres []fermée et , séparée

Comment?

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