Números poligonales

12

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

3er número de hexágono

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

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

Respuestas:

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:

ingrese la descripción de la imagen aquí

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:

ingrese la descripción de la imagen aquí

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

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

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