Nombres polygonaux

12

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

3e numéro hexagonal

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

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
la 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

Réponses:

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
la 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:

entrez la description de l'image ici

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:

entrez la description de l'image ici

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
la 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
la 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
la 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
la 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

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
la 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
la 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
ბიმო
la 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
la source
1

MathGolf , 8 octets

_┐*½?⌡*+

Essayez-le en ligne!

n=dix,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
la 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
la 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
la 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
la source
0

Langue GameMaker, 44 octets

n=argument1;return (argument0-2)*n*(n-1)/2+n
Timtech
la 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
la 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
la source
0

Excel, 22 octets

Calcule le nombre A1th B1-gonal.

=(B1-2)*A1*(A1-1)/2+A1
Wernisch
la 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
la 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)
ბიმო
la 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
la source