Compito

Il vostro compito è semplice, generare una sequenza che, dato indice i, il valore in tale posizione è la somma dei quadrati da 0fino a idove i >= 0.

Esempio:

Input: 0
Output: 0           (0^2)

Input: 4
Output: 30          (0^2 + 1^2 + 2^2 + 3^2 + 4^2)

Input: 5
Output: 55          (0^2 + 1^2 + 2^2 + 3^2 + 4^2 + 5^2)

Specifica:

Non è possibile accettare input e output in modo indefinito;
Puoi prendere input Ne output l' Nthelemento della sequenza;
Puoi prendere input Ne output i primi Nelementi della sequenza.

— Felipe Nardi Batista
fonte

2

Osservazione divertente da OEIS: questa sequenza contiene esattamente due quadrati perfetti:, f(1) == 1 * 1 (1)e f(24) == 70 * 70 (4900).

— DJMcMayhem

Possiamo iniziare la sequenza a f(1) = 1?

— Emigna,

@Emigna scusa ma no, devi iniziare da f(0) = 0. ho sottolineato che alle poche risposte che non hanno soddisfatto tale requisito

— Felipe Nardi Batista,

Il f(0) = 0requisito ha rovinato alcune delle mie soluzioni :(

— ATaco

4

Gelatina , 3 byte

R²S

Provalo online!

FGITW

Spiegazione

R²S  Main Link
R    Generate Range
 ²   Square (each term)
  S  Sum

— HyperNeutrino
fonte

Un'alternativa più lunga sarebbeRæ.R

— Mr. Xcoder,

22

Python 2 , 22 byte

lambda n:n*~n*~(n*2)/6

Provalo online!

Questo utilizza la formula a forma chiusa n * (n + 1) * (2 * n + 1) / 6 . Il codice esegue le seguenti operazioni:

Moltiplica n per ( n*):
- Il complemento bit per bit di n ( ~n), che essenzialmente significa -1-n .
- E dal complemento bit per bit di 2n ( *~(n*2)), che significa -1-2n .
Divide per 6 ( /6).

Python 2 , 27 byte

f=lambda n:n and f(n-1)+n*n

Provalo online!

_{Salvato 1 byte grazie a Rod e 1 grazie a GB .}

— Mr. Xcoder
fonte

1

Questo è molto intelligente!

— Skyler,

14

MATL , 3 byte

:Us

... o loro?

Provalo online!

Spiegazione

:    % Implicit input n. Push range [1 2 ... n]
U    % Square, element-wise
s    % Sum of array. Implicit display

— Luis Mendo
fonte

14

JavaScript (ES6), 16 byte

n=>n*(n+++n)*n/6

dimostrazione

Mostra snippet di codice

let f =

n=>n*(n+++n)*n/6

for(n = 0; n < 10; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

Espandi frammento

Come?

L'espressione n+++nviene analizzata come n++ + n⁽¹⁾ . Non che sia davvero importante perché n + ++nfunzionerebbe anche in questo caso.

Perciò:

n*(n+++n)*n/6 =
n * (n + (n + 1)) * (n + 1) / 6 =
n * (2 * n + 1) * (n + 1) / 6

che valuta la somma (k = 0 ... n) (k²) .

_{(1) Questo può essere verificato facendo ciò n='2';console.log(n+++n)che dà l'intero 5, mentre n + ++ndarebbe la stringa '23'.}

— Arnauld
fonte

6

05AB1E , 3 byte

ÝnO

Provalo online!

Spiegazione

  O    # sum of
 n     # squares of
Ý      # range [0 ... input]

— Emigna
fonte

6

Brain-Flak , 36 byte

({<(({}[()])())>{({})({}[()])}{}}{})

Provalo online!

# Main algorithm
(                                  )  # Push the sum of:
                {({})({}[()])}{}      #   The square of:
 {                              }     #     0 to i 

# Stuff for the loop
  <(({}[()])())>                      # Push i-1, i without counting it in the sum
                                 {}   # Pop the counter (0)

— Riley
fonte

Ben fatto! :) Mi sono ({<(({}))>{({})({}[()])}{}<({}[()])>})

— inventato

34 byte;)

— Wheat Wizard

6

Brain-Flak , 34 byte

({(({}[()])()){({}[()])({})}{}}{})

Provalo online!

Come funziona?

Inizialmente avevo la stessa idea di Riley ¹ ma mi sembrava sbagliato usare uno zero. L'ho capito poi

{({}[()])({})}{}

Calcola n ² - n.

Perché? Bene lo sappiamo

{({})({}[()])}{}

Calcola n ² e loop n volte. Ciò significa che se cambiamo l'ordine delle due spinte passiamo dall'aumentare la somma di n + (n-1) ogni volta all'aumento della somma di (n-1) + (n-1) ogni volta. Ciò ridurrà il risultato di uno per ciclo, rendendo così il nostro risultato n ² - n. Al livello più alto questo -n annulla con n generato dalla spinta che stavamo azzerando alleviando la necessità di uno zero e salvandoci due byte.

Brain-Flak , 36 byte

({({})(({}[()])){({})({}[()])}{}}{})

Provalo online!

Ecco un'altra soluzione, non è così da golf ma è piuttosto strana, quindi ho pensato di lasciarlo come una sfida per capire come funziona.

Se non ti piacciono i Brain-Flak ma vuoi ancora la sfida qui è come una sintesi.

Immagine

^{1: ho trovato la mia soluzione prima di dare un'occhiata alle risposte qui. Quindi nessun plagio qui.}

— Mago del grano
fonte

Sapevo che doveva esserci un modo per farlo, e avevo la sensazione che saresti stato tu a capire la matematica per questo.

— Riley,

4

Buccia , 3 byte

ṁ□ḣ

Provalo online!

— Mr. Xcoder
fonte

3

Ohm v2 , 3 byte

#²Σ

Provalo online!

Spiegazione

#    Range
 ²   Square
  Σ  Sum

— Cinaski
fonte

3

Japt , 3 byte

ô²x

Provalo qui.

-1 grazie a Shaggy .

Spiegazione:

ò²x 
ô²  Map square on [0..input]
  x Sum

— Erik the Outgolfer
fonte

3 byte usando il collegamento per p2.

— Shaggy,

@FelipeNardiBatista risolto

— Erik the Outgolfer,

2

Brain-Flak , 46 byte

{(({})[()])}{}{({({})({}[()])}{}<>)<>}<>({{}})

Provalo online!

— HyperNeutrino
fonte

Una piccola competizione amichevole :)

— Riley,

@Riley Ooh nice :)

— HyperNeutrino,

Invece di spingere il quadrato sulla pila alternativa, puoi sommarlo direttamente valutandolo e non spingendolo, quindi spingendo invece l'intero ciclo. Questo cambia la tua seconda metà in ({{({})({}[()])}{}}{})e ti fa risparmiare 10 byte. (Se non ha senso,

— eseguimi il

2

CJam , 10 byte

ri),{_*+}*

Provalo online!

ri            e# Input integer n
  )           e# Add 1
   ,          e# Range [0 1 ... n]
    {   }*    e# Fold (reduce)
     _        e# Duplicate
      *       e# Multiply
       +      e# Add

— Luis Mendo
fonte

Che ne dici di ri),_.*:+o ri),2f#:+?

— Martin Ender,

@Martin Buona idea! Penso che dovresti pubblicarlo come una risposta diversa

— Luis Mendo,

2

Wolfram Language (Mathematica) , 14 byte

Tr[Range@#^2]&

Provalo online!

— totallyhuman
fonte

4

#.#&@Range@#&salva un byte

— miglia il

4

#.#&@*Range.

— alephalpha,

2

In realtà , 3 byte

R;*

Provalo online!

Accetta Ncome input e genera ilN elemento th nella sequenza.

Spiegazione:

R;*
R    range(1, N+1) ([1, 2, ..., N])
 ;*  dot product with self

— Mego
fonte

2

APL (Dyalog) , 7 5 byte

2 byte salvati grazie a @Mego

+.×⍨⍳

Provalo online!

Come?

⍳ - gamma

+.× - prodotto punto

⍨ - con se stesso

— Uriel
fonte

@Uriel mio male, ho pensato che ¨⍳fosse necessario

— Felipe Nardi Batista,

2

R, 17 byte

sum((0:scan())^2)

Piuttosto semplice, si sfrutta il fatto che ^(esponenziale) viene vettorializzare in R .

— Frédéric
fonte

1

(x=0:scan())%*%xè più corto di un byte, ma credo che sia necessario un catoutput per ottenere l'output.

— Giuseppe,

@Giuseppe L'ho appena provato e il tuo codice funziona senza cat, genera una matrice 1x1.

— Rui Barradas,

@RuiBarradas L'attuale meta consenso è catnecessario affinché questo si qualifichi come un programma completo. Se desideri modificarlo, rispondi a questa domanda e ottieni una certa trazione tra le altre persone R sul sito.

— Giuseppe,

2

CJam , 9 byte

ri),_.*:+

Provalo online!

Spiegazione

ri        e# Read input and convert to integer N.
  ),      e# Get range [0 1 2 ... N].
    _     e# Duplicate.
     .*   e# Pairwise products, giving [0 1 4 ... N^2].
       :+ e# Sum.

In alternativa:

ri),2f#:+

In questo modo ogni elemento viene quadrato mappando 2#anziché utilizzare prodotti a coppie. E solo per divertimento un'altra alternativa che diventa inaccurata per input di grandi dimensioni perché utilizza l'aritmetica in virgola mobile:

ri),:mh2#

— Martin Ender
fonte

2

Julia , 16 14 byte

2 byte salvati grazie a @MartinEnder

!n=(x=1:n)⋅x

Provalo online!

Come?

(x=1:n)crea una serie di 1per ne assegnare a x, ⋅dot prodotto x.

— Uriel
fonte

2

Labirinto , 11 byte

:!\
+ :
*:#

Provalo online!

Stampa la sequenza indefinitamente.

Spiegazione

Il puntatore alle istruzioni continua a girare continuamente attorno al quadrato del codice:

:!\    Duplicate the last result (initially zero), print it and a linefeed.
:      Duplicate the result again, which increases the stack depth.
#      Push the stack depth (used as a counter variable).
:*     Square it.
+      Add it to the running total.

— Martin Ender
fonte

2

Cubix , 15 byte

Iu):^\+*p*6u@O,

Provalo online!

Il mio codice è un po 'triste ):

Calcola n*(n+1)*(2n+1)/6

    I u
    ) :
^ \ + * p * 6 u
@ O , . . . . .
    . .
    . .

^Iu : read in input, u-turn
    : stack  n
:)\ : dup, increment, go right..oh, hey, it cheered up!
    : stack: n, n+1
+   : sum
    : stack: n, n+1, 2*n+1
*   : multiply
    : stack: n, n+1, 2*n+1, (n+1)*(2*n+1)
p   : move bottom of stack to top
    : stack: n+1, 2*n+1, (n+1)*(2*n+1), n
*   : multiply
6   : push 6
u   : right u-turn
,   : divide
O   : output
@   : terminate

— Giuseppe
fonte

2

Befunge , 16 byte

&::2*1+*\1+*6/.@

Usando la formula a forma chiusa n * (n + 1) * (2n + 1) / 6 .

Provalo online!

Befunge , 38 byte

v>::*\1-:v0+_$.@
&^ <     _\:^
>:#^_.@

Utilizzando un loop.

Provalo online!

— Cinaski
fonte

2

Haskell, 20 byte

f 0=0
f n=n*n+f(n-1)

Provalo online!

— Nome del modello
fonte

2

Excel, 19 byte

=A1^3/3+A1^2/2+A1/6

— Wernisch
fonte

2

Esagonia , 23 byte

?'+)=:!@/*"*'6/{=+'+}/{

Provalo online!

Spiegazione

non piegato:

   ? ' + )
  = : ! @ /
 * " * ' 6 /
{ = + ' + } /
 { . . . . .
  . . . . .
   . . . .

Questo è davvero solo un programma lineare con /usato per un po 'di reindirizzamento. Il codice lineare è:

?'+){=+'+}*"*'6{=:!@

Che calcola n (n + 1) (2n + 1) / 6 . Utilizza i seguenti bordi di memoria:

Dove inizia il punto di memoria (MP) sul bordo etichettato n , che punta a nord.

?   Read input into edge labelled 'n'.
'   Move MP backwards onto edge labelled 'n+1'.
+   Copy 'n' into 'n+1'.
)   Increment the value (so that it actually stores the value n+1).
{=  Move MP forwards onto edge labelled 'temp' and turn around to face
    edges 'n' and 'n+1'.
+   Add 'n' and 'n+1' into edge 'temp', so that it stores the value 2n+1.
'   Move MP backwards onto edge labelled '2n+1'.
+   Copy the value 2n+1 into this edge.
}   Move MP forwards onto 'temp' again.
*   Multiply 'n' and 'n+1' into edge 'temp', so that it stores the value
    n(n+1).
"   Move MP backwards onto edge labelled 'product'.
*   Multiply 'temp' and '2n+1' into edge 'product', so that it stores the
    value n(n+1)(2n+1).
'   Move MP backwards onto edge labelled '6'.
6   Store an actual 6 there.
{=  Move MP forwards onto edge labelled 'result' and turn around, so that
    the MP faces edges 'product' and '6'.
:   Divide 'product' by '6' into 'result', so that it stores the value
    n(n+1)(2n+1)/6, i.e. the actual result.
!   Print the result.
@   Terminate the program.

In teoria, potrebbe essere possibile adattare questo programma alla lunghezza 3, poiché /non sono necessari per il calcolo, :possono essere riutilizzati per terminare il programma e alcuni '"=+*{potrebbero essere riutilizzabili, portando il numero di comandi inferiori a 19 (il massimo per la lunghezza laterale 3). Dubito che sia possibile trovare una soluzione del genere a mano, se ne esiste una.

— Martin Ender
fonte

2

> <> , 15 13 11 byte

Salvato 2 byte grazie a Non un albero

0:n:l1-:*+!

Provalo online!

Emette la sequenza indefinitamente.

— Emigna
fonte

1

14 byte (12 + 2 per la -vbandiera): ::1+:}+**6,n( Provalo online! )

— Non un albero il

1

O 11 byte (stampa per sempre, a partire da N=1): provalo online!

— Non un albero il

@Notatree: idea molto bella da usare l. Verificare con OP se è corretto iniziare alle 1.

— Emigna,

@Notatree: purtroppo non è consentito iniziare da 1, ma salva comunque 2 byte. Grazie!

— Emigna,

1

(Devo dire che ho avuto l' lidea dalla risposta Labyrinth di Martin Ender .)

— Non un albero

2

Pyth , 7 5 byte grazie a Steven H

s^R2h

Spiegazione:

s^R2h       Full program - inputs from stdin and outputs to stdout
s           output the sum of
    h       range(input), with
 ^R2         each element squared

La mia prima soluzione

sm*ddUh

Provalo online!

Spiegazione:

sm*ddUh    Full program - inputs from stdin and outputs to stdout
s          sum of
 m   Uh    each d in range(input)
  *dd      squared

— Dave
fonte

Non esiste un quadrato incorporato in Pyth?

— caird coinheringaahing il

Non per quanto ne so ...

— Dave,

No, non esiste un Pyth incorporato quadrato. Anche 6 byte

— Mr. Xcoder il

1

5 byte .

— Steven H.

Risolvibile con +1 byte per ogni risposta, lo modificherò una volta uscito dal cellulare.

— Dave,

1

Neim , 3 byte

𝐈ᛦ𝐬

Questa potrebbe essere stata una sfida per mostrare il numero poligonale incorporato di Neim, ma apparentemente no.

Provalo online!

— Okx
fonte

1

Oasi , 4 byte

nk+0

Provalo online!

Spiegazione

   0      # a(0) = 0
nk+       # a(n) = a(n-1)+n^2

— Emigna
fonte

1

Brachylog , 5 byte

⟦^₂ᵐ+

Provalo online!

Spiegazione

⟦        Range
 ^₂ᵐ     Map square
    +    Sum

— Fatalize
fonte

1

Gaia , 3 byte

s¦Σ

Provalo online!

— Mr. Xcoder
fonte

Numeri piramidali quadrati

Compito

Esempio:

Specifica:

Gelatina , 3 byte

Spiegazione

Python 2 , 22 byte

Python 2 , 27 byte

MATL , 3 byte

Spiegazione

JavaScript (ES6), 16 byte

dimostrazione

Come?

05AB1E , 3 byte

Brain-Flak , 36 byte

Brain-Flak , 34 byte

Come funziona?

Brain-Flak , 36 byte

Buccia , 3 byte

Ohm v2 , 3 byte

Japt , 3 byte

Brain-Flak , 46 byte

CJam , 10 byte

Wolfram Language (Mathematica) , 14 byte

In realtà , 3 byte

APL (Dyalog) , 7 5 byte

R, 17 byte

CJam , 9 byte

Spiegazione

Julia , 16 14 byte

Labirinto , 11 byte

Spiegazione

Cubix , 15 byte

Befunge , 16 byte

Befunge , 38 byte

Haskell, 20 byte

Excel, 19 byte

Esagonia , 23 byte

Spiegazione

> <> , 15 13 11 byte

Pyth , 7 5 byte grazie a Steven H

Neim , 3 byte

Oasi , 4 byte

Brachylog , 5 byte

Spiegazione

Gaia , 3 byte