Un numero poligonale è il numero di punti in un k-gon di dimensioni n.

Ti verrà dato ne k, e il tuo compito è scrivere un programma / funzione che emetta / stampa il numero corrispondente.

punteggio

Questo è code-golf . Vince la soluzione più breve in byte.

Esempio

Il secondo 3numero esagonale ( k=6, n=3) è 28perché ci sono 28punti sopra.

Casi test

Può essere generato da questa suite di test Pyth .

Utilizzo: due righe per testcase, nsopra, ksotto.

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

Ulteriori informazioni

In Wikipedia: https://en.wikipedia.org/wiki/Polygonal_number
In Wolfram Mathworld: http://mathworld.wolfram.com/PolygonalNumber.html
In Wiki OEIS: http://oeis.org/wiki/Polygonal_numbers
Sequenze OEIS per numeri n -gonali per vari 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

— Perdente Suora
fonte

1

Non è il 4 ° numero esagonale nella foto?

— Neil,

@Neil Contiamo da zero.

— Leaky Nun,

2

Stai davvero facendo una domanda postando folle, vero?

— R. Kap

L'esempio potrebbe essere spento. Se metti n=3e k=6nella tua suite di test, ottieni 15. Se si inserisce n=4e k=6, si ottiene 28.

— NonlinearFruit

9

Gelatina , 7 byte

’;’;PH+

Questo utilizza la formula

formula

per calcolare la n ^° s numero -gonal.

Provalo online!

Come funziona

’;’;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
fonte

4

Esagonia , 25 byte

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

non piegato:

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

Legge il kprimo e il nsecondo (usando qualsiasi separatore).

Provalo online!

Spiegazione

Il programma è completamente lineare, ma come al solito in Hexagony, l'ordine di esecuzione è dappertutto:

I percorsi vengono eseguiti nell'ordine grigio , blu scuro , rosso , azzurro , verde scuro , rosa . Come puoi vedere, i tre /agiscono solo per reindirizzare il flusso. Inoltre, .non ci sono operazioni. Spogliando tutta la fantasia esagonale, il programma lineare risultante è:

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

Questo calcola la formula standard

formula

come la maggior parte delle altre risposte. Lo fa usando i seguenti cinque bordi di memoria, con il puntatore di memoria (MP) che inizia come mostrato in rosso:

Ecco come viene fatto:

?    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
fonte

Una formula così semplice ... richiede 25 byte ?!

— Leaky Nun,

4

@KennyLau Dopo tutto, questa è esagonia ...

— Martin Ender,

Meta domanda

— esagonia

3

05AB1E , 8 byte

Codice:

D<LOIÍ*+

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online! .

— Adnan
fonte

3

Labirinto , 13 byte

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

Provalo online!

Spiegazione

Grazie ai suoi comandi a carattere singolo (che sono semplicemente una necessità della 2D-lingua del linguaggio), Labyrinth può essere sorprendentemente matto per i programmi lineari.

Questo utilizza la stessa formula di molte altre risposte:

formula

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.                      []

A questo punto, il puntatore dell'istruzione raggiunge un vicolo cieco e si gira. Ora +viene eseguito di nuovo, che è un no-op (poiché il fondo dello stack è implicitamente riempito con una quantità infinita di zeri), quindi /tenta una divisione per zero che termina il programma con un errore.

— Martin Ender
fonte

2

JavaScript (ES6), 24 22 byte

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

Spiegazione: Ogni n-gon può essere considerato come n punti lungo un lato più k-2 triangoli di dimensione n-1, cioè n + n (n-1) (k-2) / 2.

— Neil
fonte

k--*n--+2-nnon ho ancora testato

— Leaky Nun

@KennyLau Siamo spiacenti, ma (k,n)=>n*(--k*--n-n+2)/2è ancora 24 byte.

— Neil,

@KennyLau In effetti ho trascurato l'ovvio uso di --nfor (n-1). D'oh!

— Neil,

@NeiI Bene, bello.

— Leaky Nun,

Puoi salvare un arrivederci con il curry:k=>n=>n+n*--n*(k-2)/2

— Dennis

2

CJam, 13 byte

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

Provalo online

2

APL (Dyalog Extended) , ^{SBCS da} 11 byte

Grazie ad Adám per il suo aiuto nel suggerire questa versione alternativa.

⊢+-∘2⍤⊣×2!⊢

Provalo online!

Spiegazione

⊢+-∘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 byte ^SBCS

Grazie ad Adám per il suo aiuto nel golf.

Modifica: -1 byte da ngn.

⊢+{⍺-2}×2!⊢

Provalo online!

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
fonte

1

In realtà, 12 byte

3@n(¬@D3╟π½+

Provalo online!

Spiegazione:

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
fonte

1

dc , 14 byte

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

Provalo online!

Spiegazione

Questo utilizza la seguente formula (nota che T _n = n*(n-1)/2):

Numeri poligonali

                # 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

— ბიმო
fonte

1

Aceto , 18 15 byte

Risposta DC del Porto del Bruce Forte :

riddD*2/ri2-*+p

Salvati 3 byte realizzando che qualsiasi programma Aceto "puro" (senza comandi combinati) può essere scritto in modo lineare.

— L3viathan
fonte

1

MathGolf , 8 byte

_┐*½?⌡*+

Provalo online!

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

È un 8-byte alternativo ┼┐*½\⌡*+, che accetta l'input in ordine inverso.

— maxb
fonte

1

> <> , 13 byte

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

Provalo online!

— Emigna
fonte

0

Mathematica, 17 byte

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

Applicazione diretta della formula.

uso

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

— miglia
fonte

0

J, 14 byte

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

Basato sulla formula

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

uso

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

Spiegazione

]++/@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

— miglia
fonte

Quanto tempo sarebbe, usando il mio approccio?

— Leaky Nun,

0

TI-Basic, 20 byte

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

— Timtech
fonte

0

Lingua GameMaker, 44 byte

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

— Timtech
fonte

Lo spazio è richiesto?

— Leaky Nun,

0

Python 3, 31 30 28 byte

L'equazione semplice di questo articolo wiki

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

Grazie a @Mego per aver salvato un byte!

— NonlinearFruit
fonte

È possibile rimuovere lo spazio tra i due punti e la parentesi.

— Mego,

0

Fourier, 18 byte

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

Provalo su FourIDE!

Prende k come primo input e n come secondo input. Usa la formula:

Spiegazione Pseudocodice:

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

— Decadimento beta
fonte

0

Excel, 22 byte

Calcola il numero A1th B1-gonal.

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

— Wernisch
fonte

0

Java 8, 21 byte

Tutte le risposte individuali di uguale lunghezza in byte:

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

Spiegazione:

Provalo qui.

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
fonte

0

Japt , 14 12 byte

U+[U½UÉVa2]×

Provalo

— ispido
fonte

0

Buccia , 9 byte

S+~*-2(Σ←

Provalo online!

Spiegazione

Usando la stessa formula della mia dcrisposta:

Numeri poligonali

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

— ბიმო
fonte

0

APL (NARS), 16 caratteri, 32 byte

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

Si basa sul fatto che sembra n × (n-1) / 2 = somma (1..n-1) test:

  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
fonte

Numeri poligonali

punteggio

Esempio

Casi test

Ulteriori informazioni

Gelatina , 7 byte

Come funziona

Esagonia , 25 byte

Spiegazione

05AB1E , 8 byte

Labirinto , 13 byte

Spiegazione

JavaScript (ES6), 24 22 byte

CJam, 13 byte

APL (Dyalog Extended) , SBCS da 11 byte

APL (Dyalog Unicode) , 12 11 byte SBCS

In realtà, 12 byte

dc , 14 byte

Spiegazione

Aceto , 18 15 byte

MathGolf , 8 byte

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

> <> , 13 byte

Mathematica, 17 byte

uso

J, 14 byte

uso

Spiegazione

TI-Basic, 20 byte

Lingua GameMaker, 44 byte

Python 3, 31 30 28 byte

Fourier, 18 byte

Excel, 22 byte

Java 8, 21 byte

Japt , 14 12 byte

Buccia , 9 byte

Spiegazione

APL (NARS), 16 caratteri, 32 byte

APL (Dyalog Extended) , ^{SBCS da} 11 byte

APL (Dyalog Unicode) , 12 11 byte ^SBCS

$n = 10, k = 5$