Un nombre polygonal est le nombre de points dans un k-gon de taille n.

On vous donnera net k, et votre tâche consiste à écrire un programme / fonction qui génère / imprime le numéro correspondant.

Notation

C'est du code-golf . La solution la plus courte en octets gagne.

Exemple

Le 3numéro hexagonal ( k=6, n=3) est 28dû au fait qu'il y a des 28points au-dessus.

Cas de test

Peut être généré à partir de cette suite de tests Pyth .

Utilisation: deux lignes par testcase, en nhaut, en kbas.

n    k  output
10   3  55
10   5  145
100  3  5050
1000 24 10990000

Plus d'informations

Dans Wikipedia: https://en.wikipedia.org/wiki/Polygonal_number
Dans Wolfram Mathworld: http://mathworld.wolfram.com/PolygonalNumber.html
Dans le wiki OEIS: http://oeis.org/wiki/Polygonal_numbers
Séquences OEIS pour n nombres géographiques pour différents n : 3 (A000217) , 4 (A000290) , 5 (A000326) , 6 (A000384) , 7 (A000566) , 8 (A000567) , 9 (A001106) , 10 (A001107) , 11 (A051682) , 12 (A051624) , 13 (A051865) , 14 (A051866) , 15 (A051867) , 16 (A051868) , 17 (A051869) , 18 (A051870) , 19 (A051871) , 20 (A051872) , 21 (A051873) , 22 (A051874) , 23 (A051875) , 24 (A051876)

code-golf sequence number-theory code-golf math geometry code-golf combinatorics code-golf integer code-golf arithmetic number-theory code-golf arithmetic restricted-source number-theory restricted-complexity

— Leaky Nun
source

1

N'est-ce pas le 4e nombre hexagonal sur la photo?

— Neil

@Neil Nous comptons à partir de zéro.

— Leaky Nun

2

Vous allez vraiment vous poser une question en postant une virée, non?

— R. Kap

L'exemple est peut-être éteint. Si vous mettez n=3et k=6dans votre suite de tests, vous obtenez 15. Si vous mettez n=4et k=6vous obtenez 28.

— NonlinearFruit

9

Gelée , 7 octets

’;’;PH+

Cela utilise la formule

formule

pour calculer la n ^ième du nombre -gonal.

Essayez-le en ligne!

Comment ça fonctionne

’;’;PH+  Main link. Arguments: s, n

’        Decrement; yield s - 1.
 ;       Concatenate; yield [s - 1, n].
  ’      Decrement; yield [s - 2, n - 1].
   ;     Concatenate; yield [s - 2, n - 1, n].
    P    Product; yield (s - 2)(n - 1)n.
     H   Halve; yield (s - 2)(n - 1)n ÷ 2.
      +  Add; yield (s - 2)(n - 1)n ÷ 2 + n.

— Dennis
source

4

Hexagonie , 25 octets

?(({"+!@/"*'+{/?('*})/2':

Déplié:

   ? ( ( {
  " + ! @ /
 " * ' + { /
? ( ' * } ) /
 2 ' : . . .
  . . . . .
   . . . .

Lit la kpremière et la nseconde (en utilisant n'importe quel séparateur).

Essayez-le en ligne!

Explication

Le programme est complètement linéaire, mais comme d'habitude dans Hexagony, l'ordre d'exécution est partout:

Les chemins sont exécutés dans l'ordre gris , bleu foncé , rouge , bleu clair , vert foncé , rose . Comme vous pouvez le voir, les trois /n'agissent que pour rediriger le flux. De plus, ce .ne sont pas des opérations. Dépouillant toute fantaisie hexagonale, le programme linéaire résultant est:

?(({?('*})"*'+{2':"+!@

Ceci calcule la formule standard

formule

comme la plupart des autres réponses. Il le fait en utilisant les cinq bords de mémoire suivants, avec le pointeur de mémoire (MP) commençant comme indiqué en rouge:

Voici comment procéder:

?    Read integer input s into edge A.
((   Decrement twice to get (s-2).
{    Move the MP forwards onto edge B.
?    Read integer input n into edge B.
(    Decrement to get (n-1).
'    Move the MP backwards onto edge C.
*    Multiply edges A and B to store the result (s-2)(n-1) in edge C.
}    Move the MP forwards onto edge B.
)    Increment to restore the value n.
"    Move the MP backwards onto edge A.
*    Multiply edge B and C to store the result (s-2)(n-1)n in edge A.
'    Move the MP backwards onto edge D.
+    Add edges E (initially 0) and A to copy (s-2)(n-1)n into edge D.
{    Move the MP forwards onto edge E.
2    Set the memory edge to value 2.
'    Move the MP backwards onto edge A.
:    Divide edge D by edge E to store (s-2)(n-1)n/2 in edge A.
"    Move the MP backwards onto edge C.
+    Add edges A and B to store (s-2)(n-1)n/2+n in edge C.
!    Print as integer.
@    Terminate the program.

— Martin Ender
source

Une formule aussi simple ... nécessite 25 octets?!

— Leaky Nun

4

Ce @KennyLau est Hexagony après tout ...

— Martin Ender

Hexagony meta question

— downrep_nation

3

05AB1E , 8 octets

Code:

D<LOIÍ*+

Explication:

D         # Duplicate the input
 <LO      # Compute n × (n - 1) / 2
    IÍ    # Compute k - 2
      *   # Multiply, resulting into (k - 2)(n - 1)(n) / 2
       +  # Add, resulting into n + (k - 2)(n - 1)(n) / 2

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

— Adnan
source

3

Labyrinthe , 13 octets

?::(*?((*#/+!

Essayez-le en ligne!

Explication

En raison de ses commandes à un seul caractère (qui sont simplement une nécessité de la 2D-ness du langage), Labyrinth peut être étonnamment golfique pour les programmes linéaires.

Cela utilise la même formule que plusieurs autres réponses:

formule

Op  Explanation                 Stack
?   Read n.                     [n]
::  Make two copies.            [n n n]
(   Decrement.                  [n n (n-1)]
*   Multiply.                   [n (n*(n-1))]
?   Read s.                     [n (n*(n-1)) s]
((  Decrement twice.            [n (n*(n-1)) (s-2)]
*   Multiply.                   [n (n*(n-1)*(s-2))]
#   Push stack depth, 2.        [n (n*(n-1)*(s-2)) 2]
/   Divide.                     [n (n*(n-1)*(s-2))/2]
+   Add.                        [(n+(n*(n-1)*(s-2))/2)]
!   Print.                      []

À ce stade, le pointeur d'instruction atteint une impasse et se retourne. Now +est à nouveau exécuté, ce qui est un no-op (car le bas de la pile est implicitement rempli d'une quantité infinie de zéros), puis /tente une division par zéro qui termine le programme avec une erreur.

— Martin Ender
source

2

JavaScript (ES6), 24 22 octets

(k,n)=>n+n*--n*(k-2)/2

Explication: Chaque n-gon peut être considéré comme n points le long d'un côté plus k-2 triangles de taille n-1, c'est-à-dire n + n (n-1) (k-2) / 2.

— Neil
source

k--*n--+2-npas encore testé

— Leaky Nun

@KennyLau Désolé, mais (k,n)=>n*(--k*--n-n+2)/2est toujours de 24 octets.

— Neil

@KennyLau En fait, j'ai négligé l'utilisation évidente de --nfor (n-1). Oh!

— Neil

@NeiI Eh bien, bien.

— Leaky Nun

Vous pouvez enregistrer un bye avec curry:k=>n=>n+n*--n*(k-2)/2

— Dennis

2

CJam, 13 octets

q~__(*2/@2-*+

Essayez-le en ligne

2

APL (Dyalog Extended) , 11 octets ^SBCS

Merci à Adám pour son aide pour avoir suggéré cette version alternative.

⊢+-∘2⍤⊣×2!⊢

Essayez-le en ligne!

Explication

⊢+-∘2⍤⊣×2!⊢  Right argument (⊢) is n. Left argument (⊣) is s.

        2!⊢  Binomial(n, 2) == n*(n-1)/2.
  -∘2⍤⊣×     Multiply (×) with by getLeftArgument (⊢) with (⍤) minus 2 (-∘2) called on it.
             In short, multiply binomial(n,2) with (s-2).
⊢+           Add n.

APL (Dyalog Unicode) , 12 11 octets ^SBCS

Merci à Adám pour son aide à jouer au golf.

Édition: -1 octet de ngn.

⊢+{⍺-2}×2!⊢

Essayez-le en ligne!

Ungolfing

⊢+{⍺-2}×2!⊢  Right argument (⊢) is n. Left argument (⊣) is s.

        2!⊢  Binomial(n, 2) == n*(n-1)/2.
  {⍺-2}×     Multiply it by s-2.
⊢+           Add n.

— Sherlock9
source

1

En fait, 12 octets

3@n(¬@D3╟π½+

Essayez-le en ligne!

Explication:

3@n(¬@D3╟π½+
3@n           push 3 copies of n (stack: [n, n, n, k])
   (¬         bring k to front and subtract 2 ([k-2, n, n, n])
     @D       bring an n to front and subtract 1 ([n-1, k-2, n, n])
       3╟π    product of top 3 elements ([n*(n-1)*(k-2), n])
          ½   divide by 2 ([n*(n-1)*(k-2)/2, n])
           +  add ([n*(n-1)*(k-2)/2 + n])

— Mego
source

1

DC , 14 octets

?dd1-*2/?2-*+p

Essayez-le en ligne!

Explication

Cela utilise la formule suivante (notez que T _n = n*(n-1)/2):

Nombres polygonaux

                # inputs              | N S                  | 10 5
?dd             # push N three times  | N, N, N              | 10, 10, 10
   1-           # subtract 1          | (N-1), N, N          | 9, 10, 10
     *          # multiply            | (N-1)*N, N           | 90, 10
      2/        # divide by two       | (N-1)*N/2, N         | 45, 10
        ?       # push S              | S, (N-1)*N/2, N      | 5, 45, 10
         2-     # subtract 2          | (S-2), (N-1)*N/2, N  | 3, 45, 10
           *    # multiply            | (S-2)*(N-1)*N/2, N   | 135, 10
            +   # add                 | (S-2)*(N-1)*N/2 + N  | 145
             p  # print to stdout

— ბიმო
source

1

Aceto , 18 15 octets

Port de la réponse DC de Bruce Forte :

riddD*2/ri2-*+p

Enregistrement de 3 octets en réalisant que tout programme Aceto "pur" (pas de commandes combinées) peut être écrit de façon linéaire.

— L3viathan
source

1

MathGolf , 8 octets

_┐*½?⌡*+

Essayez-le en ligne!

$n = 10, k = 5$

_          duplicate first implicit input, stack is [10, 10]
 ┐         push TOS-1 without popping, stack is [10, 10, 9]
  *        multiply, stack is [10, 90]
   ½       halve TOS, stack is [10, 45]
    ?      rotate top 3 stack elements, popping k to the top: [10, 45, 5]
     ⌡     decrement TOS twice: [10, 45, 3]
      *    multiply: [10, 135]
       +   add: [145]

Une alternative à 8 octets est ┼┐*½\⌡*+, qui prend l'entrée dans l'ordre inverse.

— maxb
source

1

> <> , 13 octets

::1-*2,{2-*+n

Essayez-le en ligne!

— Emigna
source

0

Mathematica, 17 octets

(#2-2)#(#-1)/2+#&

Application simple de la formule.

Usage

  f = (#2-2)#(#-1)/2+#&
  f[10, 3]
55
  f[10, 5]
145
  f[100, 3]
5050
  f[1000, 24]
10990000

— miles
source

0

J, 14 octets

]++/@i.@]*[-2:

Basé sur la formule.

P(k, n) = (k - 2) * T(n - 1) + n where T(n) = n * (n + 1) / 2
        = (k - 2) * n * (n - 1) / 2 + n

Usage

   f =: ]++/@i.@]*[-2:
   3 f 10
55
   5 f 10
145
   3 f 100
5050
   24 f 1000
10990000

Explication

]++/@i.@]*[-2:
            2:  The constant function 2
          [     Get k
           -    Subtract to get k-2
        ]       Get n
     i.@        Make a range from 0 to n-1
  +/@           Sum the range to get the (n-1) Triangle number = n*(n-1)/2
                The nth Triangle number is also the sum of the first n numbers
         *      Multiply n*(n-1)/2 with (k-2)
]               Get n
 +              Add n to (k-2)*n*(n-1)/2

— miles
source

Combien de temps cela prendrait-il avec mon approche?

— Leaky Nun

0

TI-Basic, 20 octets

Prompt K,N:(K-2)N(N-1)/2+N

— Timtech
source

0

Langue GameMaker, 44 octets

n=argument1;return (argument0-2)*n*(n-1)/2+n

— Timtech
source

L'espace est-il nécessaire?

— Leaky Nun

0

Python 3, 31 30 28 octets

L'équation directe de cet article wiki

lambda s,n:(s-2)*(n-1)*n/2+n

Merci à @Mego d'avoir enregistré un octet!

— Non linéaire
source

Vous pouvez supprimer l'espace entre les deux points et les parenthèses.

— Mego

0

Fourier, 18 octets

I-2~SI~Nv*N/2*S+No

Essayez-le sur FourIDE!

Prend k comme première entrée et n comme deuxième entrée. Utilise la formule:

Explication du pseudocode:

S = Input - 2
N = Input
Print (N - 1) * N / 2 *S + N

— Beta Decay
source

0

Excel, 22 octets

Calcule le nombre A1th B1-gonal.

=(B1-2)*A1*(A1-1)/2+A1

— Wernisch
source

0

Java 8, 21 octets

Toutes les réponses individuelles de longueur d'octet égale:

k->n->n+n*~-n*(k-2)/2
k->n->n+n*--n*(k-2)/2
k->n->n+n*~-n*~-~-k/2
k->n->n+n*--n*~-~-k/2

Explication:

Essayez-le ici.

k->n->            // Method with two integer parameters and integer return-type
  n+              //  Return `n` plus
    n*            //   `n` multiplied by
      ~-n         //   `n-1`
         *(k-2)   //   Multiplied by `k-2`
               /2 //   Divided by 2
                  // End of method (implicit / single-line return-statement)

— Kevin Cruijssen
source

0

Japt , 14 12 octets

U+[U½UÉVa2]×

Essayez-le

— Hirsute
source

0

Coque , 9 octets

S+~*-2(Σ←

Essayez-le en ligne!

Explication

En utilisant la même formule que dans ma dcréponse:

Nombres polygonaux

            -- implicit inputs S, N                     | 5, 10
S+          -- compute N + the result of the following  | 10 + 
  ~*        --   multiply these two together            |      (   ) * 
    -2      --     S-2                                  |       S-2
      (Σ←)  --     triangle number of (N-1)             |              tri(N-1)

— ბიმო
source

0

APL (NARS), 16 caractères, 32 octets

{⍵+(⍺-2)×+/⍳⍵-1}

Il est basé sur le fait que semble n × (n-1) / 2 = test de somme (1..n-1):

  f←{⍵+(⍺-2)×+/⍳⍵-1}
  10 f 3
27
  3 f 10
55
  5 f 19
532
  3 f 10
55
  5 f 10
145
  3 f 100
5050
  24 f 1000
10990000

— RosLuP
source

Nombres polygonaux

Notation

Exemple

Cas de test

Plus d'informations

Gelée , 7 octets

Comment ça fonctionne

Hexagonie , 25 octets

Explication

05AB1E , 8 octets

Labyrinthe , 13 octets

Explication

JavaScript (ES6), 24 22 octets

CJam, 13 octets

APL (Dyalog Extended) , 11 octets SBCS

APL (Dyalog Unicode) , 12 11 octets SBCS

En fait, 12 octets

DC , 14 octets

Explication

Aceto , 18 15 octets

MathGolf , 8 octets

n = 10 , k = 5n=dix,k=5n = 10, k = 5

> <> , 13 octets

Mathematica, 17 octets

Usage

J, 14 octets

Usage

Explication

TI-Basic, 20 octets

Langue GameMaker, 44 octets

Python 3, 31 30 28 octets

Fourier, 18 octets

Excel, 22 octets

Java 8, 21 octets

Japt , 14 12 octets

Coque , 9 octets

Explication

APL (NARS), 16 caractères, 32 octets

APL (Dyalog Extended) , 11 octets ^SBCS

APL (Dyalog Unicode) , 12 11 octets ^SBCS

$n = 10, k = 5$