Un número poligonal es el número de puntos en un k-gon de tamaño n.

Se le dará ny k, y su tarea es escribir un programa / función que genere / imprima el número correspondiente.

Puntuación

Este es el código de golf . La solución más corta en bytes gana.

Ejemplo

El 3número del hexágono rd ( k=6, n=3) se 28debe a que hay 28puntos arriba.

Casos de prueba

Se puede generar a partir de este conjunto de pruebas de Pyth .

Uso: dos líneas por caso de prueba, narriba, kabajo.

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

Más información

En Wikipedia: https://en.wikipedia.org/wiki/Polygonal_number
En Wolfram Mathworld: http://mathworld.wolfram.com/PolygonalNumber.html
En OEIS Wiki: http://oeis.org/wiki/Polygonal_numbers
Secuencias OEIS para n números gonales para varios 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

— Monja permeable
fuente

1

¿No es ese el cuarto número hexagonal en la imagen?

— Neil

@Neil Contamos desde cero.

— Leaky Nun

2

Realmente vas a hacer una pregunta publicando juerga, ¿no?

— R. Kap

El ejemplo podría estar apagado. Si pones n=3y k=6en tu suite de prueba, obtienes 15. Si pones n=4y k=6, obtienes 28.

— NonlinearFruit

9

Jalea , 7 bytes

’;’;PH+

Esto usa la fórmula

fórmula

para calcular el n ^° s número -gonal.

Pruébalo en línea!

Cómo funciona

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

4

Hexagonía , 25 bytes.

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

Desplegado:

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

Lee kprimero y nsegundo (usando cualquier separador).

Pruébalo en línea!

Explicación

El programa es completamente lineal, pero como es habitual en Hexagony, el orden de ejecución está por todas partes:

Las rutas se ejecutan en el orden gris , azul oscuro , rojo , azul claro , verde oscuro , rosa . Como puede ver, los tres /solo actúan para redirigir el flujo. Además, .son no-ops. Despojando toda la fantasía hexagonal, el programa lineal resultante es:

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

Esto calcula la fórmula estándar

fórmula

como la mayoría de las otras respuestas. Lo hace usando los siguientes cinco bordes de memoria, con el puntero de memoria (MP) comenzando como se muestra en rojo:

Así es como se hace esto:

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

Una fórmula tan simple ... ¿requiere 25 bytes?

— Leaky Nun

44

@KennyLau Esto es Hexagonía después de todo ...

— Martin Ender

Meta pregunta de

— Hexagony

3

05AB1E , 8 bytes

Código:

D<LOIÍ*+

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea! .

— Adnan
fuente

3

Laberinto , 13 bytes

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

Pruébalo en línea!

Explicación

Debido a sus comandos de un solo carácter (que son meramente una necesidad del 2D-ness del lenguaje), Labyrinth puede ser sorprendentemente golfista para programas lineales.

Utiliza la misma fórmula que varias otras respuestas:

fórmula

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

En este punto, el puntero de instrucciones llega a un callejón sin salida y gira. Ahora +se ejecuta nuevamente, que es un no-op (ya que la parte inferior de la pila se llena implícitamente con una cantidad infinita de ceros), y luego /intenta una división por cero que termina el programa con un error.

— Martin Ender
fuente

2

JavaScript (ES6), 24 22 bytes

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

Explicación: cada n-gon puede considerarse como n puntos a lo largo de un lado más k-2 triángulos de tamaño n-1, es decir, n + n (n-1) (k-2) / 2.

— Neil
fuente

k--*n--+2-naunque no he probado

— Leaky Nun

@KennyLau Lo siento, pero (k,n)=>n*(--k*--n-n+2)/2todavía tiene 24 bytes.

— Neil

@KennyLau De hecho, pasé por alto el uso obvio de --nfor (n-1). D'oh!

— Neil

@NeiI Bueno, bien.

— Leaky Nun

Puede guardar un adiós con curry:k=>n=>n+n*--n*(k-2)/2

— Dennis

2

CJam, 13 bytes

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

Pruébalo en línea

2

APL (Dyalog Extended) , ^{SBCS de} 11 bytes

Gracias a Adám por su ayuda por sugerir esta versión alternativa.

⊢+-∘2⍤⊣×2!⊢

Pruébalo en línea!

Explicación

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

Gracias a Adám por su ayuda en jugar golf.

Editar: -1 byte de ngn.

⊢+{⍺-2}×2!⊢

Pruébalo en línea!

No golfista

⊢+{⍺-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
fuente

1

En realidad, 12 bytes

3@n(¬@D3╟π½+

Pruébalo en línea!

Explicación:

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
fuente

1

dc , 14 bytes

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

Pruébalo en línea!

Explicación

Esto hace uso de la siguiente fórmula (tenga en cuenta que T _n = n*(n-1)/2):

Números poligonales

                # 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

— ბიმო
fuente

1

Aceto , 18 15 bytes

La respuesta de DC del puerto de Bruce Forte :

riddD*2/ri2-*+p

Se guardaron 3 bytes al darse cuenta de que cualquier programa Aceto "puro" (sin comandos combinados) se puede escribir linealmente.

— L3viatán
fuente

1

MathGolf , 8 bytes

_┐*½?⌡*+

Pruébalo en línea!

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

Una alternativa de 8 bytes es ┼┐*½\⌡*+, que toma la entrada en orden inverso.

— maxb
fuente

1

> <> , 13 bytes

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

Pruébalo en línea!

— Emigna
fuente

0

Mathematica, 17 bytes

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

Aplicación directa de la fórmula.

Uso

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

— millas
fuente

0

J, 14 bytes

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

De acuerdo con la fórmula.

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

Explicación

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

— millas
fuente

¿Cuánto tiempo sería, usando mi enfoque?

— Leaky Nun

0

TI-Basic, 20 bytes

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

— Timtech
fuente

0

Lenguaje GameMaker, 44 bytes

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

— Timtech
fuente

¿Se requiere espacio?

— Leaky Nun

0

Python 3, 31 30 28 bytes

La ecuación directa de este artículo wiki

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

¡Gracias a @Mego por guardar un byte!

— Fruta no lineal
fuente

Puede eliminar el espacio entre los dos puntos y el paréntesis.

— Mego

0

Fourier, 18 bytes

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

Pruébalo en FourIDE!

Toma k como primera entrada yn como segunda entrada. Utiliza la fórmula:

Explicación Pseudocódigo:

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

— Decaimiento Beta
fuente

0

Excel, 22 bytes

Calcula el número A1th- B1gonal.

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

— Wernisch
fuente

0

Java 8, 21 bytes

Todas las respuestas individuales de igual longitud de 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

Explicación:

Pruébalo aquí.

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
fuente

0

Japt , 14 12 bytes

U+[U½UÉVa2]×

Intentalo

— Lanudo
fuente

0

Casco , 9 bytes

S+~*-2(Σ←

Pruébalo en línea!

Explicación

Usando la misma fórmula que en mi dcrespuesta:

Números poligonales

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

— ბიმო
fuente

0

APL (NARS), 16 caracteres, 32 bytes

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

Se basa en el hecho de que parece prueba n × (n-1) / 2 = suma (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
fuente

Números poligonales

Puntuación

Ejemplo

Casos de prueba

Más información

Jalea , 7 bytes

Cómo funciona

Hexagonía , 25 bytes.

Explicación

05AB1E , 8 bytes

Laberinto , 13 bytes

Explicación

JavaScript (ES6), 24 22 bytes

CJam, 13 bytes

APL (Dyalog Extended) , SBCS de 11 bytes

APL (Dyalog Unicode) , 12 11 bytes SBCS

En realidad, 12 bytes

dc , 14 bytes

Explicación

Aceto , 18 15 bytes

MathGolf , 8 bytes

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

> <> , 13 bytes

Mathematica, 17 bytes

Uso

J, 14 bytes

Uso

Explicación

TI-Basic, 20 bytes

Lenguaje GameMaker, 44 bytes

Python 3, 31 30 28 bytes

Fourier, 18 bytes

Excel, 22 bytes

Java 8, 21 bytes

Japt , 14 12 bytes

Casco , 9 bytes

Explicación

APL (NARS), 16 caracteres, 32 bytes

APL (Dyalog Extended) , ^{SBCS de} 11 bytes

APL (Dyalog Unicode) , 12 11 bytes ^SBCS

$n = 10, k = 5$