I numeri quadrati sono quelli che assumono la forma di n^2dove n è un numero intero. Questi sono anche chiamati quadrati perfetti, perché quando prendi la loro radice quadrata ottieni un numero intero.

I primi 10 numeri quadrati sono: ( OEIS )

0, 1, 4, 9, 16, 25, 36, 49, 64, 81

I numeri triangolari sono numeri che possono formare un triangolo equilatero. Il n-esimo numero del triangolo è uguale alla somma di tutti i numeri naturali da 1 a n.

I primi 10 numeri triangolari sono: ( OEIS )

0, 1, 3, 6, 10, 15, 21, 28, 36, 45

I numeri triangolari quadrati sono numeri quadrati e triangolari.

I primi 10 numeri triangolari quadrati sono: ( OEIS )

0, 1, 36, 1225, 41616, 1413721, 48024900, 1631432881, 55420693056, 1882672131025, 63955431761796

C'è un numero infinito di numeri quadrati, numeri triangolari e numeri triangolari quadrati.

Scrivi un programma o una funzione con nome che ha dato un numero di input (parametro o stdin) n, calcola il nnumero triangolare quadrato e lo restituisce / restituisce, dove n è un numero diverso da zero. (Per n = 1 ritorno 0)

Affinché il programma / funzione sia un invio valido, dovrebbe essere in grado di restituire almeno tutti i numeri di triangoli quadrati inferiori a 2 ^ 31-1.

indennità

-4 byte per essere in grado di produrre tutti i numeri triangolari quadrati inferiori a 2 ^ 63-1

-4 byte per poter teoricamente produrre numeri triangolari quadrati di qualsiasi dimensione.

+8 byte di penalità per soluzioni che richiedono tempo non polinomiale.

Stack di bonus.

Questa è una sfida di code-golf, quindi vince la risposta con il minor numero di byte.

CJam, 12 8 byte

XUri{_34*@-Y+}*;

Utilizza la relazione di ricorrenza dall'articolo di Wikipedia.

Il codice è lungo 16 byte e si qualifica per entrambi i bonus.

Provalo online nell'interprete CJam .

Come funziona

Il mio codice si è rivelato identico a quello di xnor in ogni aspetto, tranne per il fatto che uso lo stack di CJam invece delle variabili.

XU               e# Push 1 and 0 on the stack.
                 e# Since 34 * 0 - 1 + 2 = 1, this compensates for 1-based indexing.
  ri{        }*  e# Do int(input()) times:
     _34*        e#   Copy the topmost integer and multiply it by 34.
         @-      e#   Subtract the bottommost integer from the result.
           Y+    e#   Add 2.
               ; e# Discard the last result.

Python 2, 45 - 4 - 4 = 37

a=1;b=0
exec"a,b=b,34*b-a+2;"*input()
print a

Iterati usando la reccurence

f(0) = 1
f(1) = 0
f(k) = 34*f(k-1)-f(k-2)+2

In teoria, questo supporta numeri di qualsiasi dimensione, ma funziona in tempo esponenziale, quindi non dovrebbe beneficiare dei bonus. Dovrebbe funzionare per numeri di qualsiasi dimensione. Ad esempio, per 100, dà

1185827220993342542557325920096705939276583904852110550753333094088280194260929920844987597980616456388639477930416411849864965254621398934978872054025

Una soluzione ricorsiva utilizza 41 caratteri, ma non dovrebbe qualificarsi perché richiede tempo esponenziale.

f=lambda k:k>2and 34*f(k-1)-f(k-2)+2or~-k

Pyth, 16 - 4 - 4 = 8 byte

Utilizza la formula ricorsiva dall'articolo OEIS.

K1uhh-*34G~KGtQZ

Utilizza il comando post-assegnazione che è piuttosto nuovo e sembra davvero interessante. Gli usi si riducono ai n-1tempi di iterazione a causa dell'indicizzazione basata su 1.

K1            Set K=1
u       tQ    Reduce input()-1 times
         Z    With zero as base case
 hh            +2
  -           Subtract
   *34G       34 times iterating variable
   ~K         Assign to K and use old value
    G         Assign the iterating variable.

Sembra essere polinomiale perché si ripete n volte e fa matematica e assegnazione ogni iterazione, ma non sono uno scienziato informatico. Finiture n = 10000 quasi istantaneamente.

Provalo qui online .

Oasis , 7 - 4 - 4 = -1 (Non concorrente)

34*c-»T

Provalo online!

usi a(0) = 0, a(1) = 1; for n >= 2, a(n) = 34 * a(n-1) - a(n-2) + 2

Oasis supporta numeri interi di precisione arbitraria, quindi dovrebbe essere in grado di salire a qualsiasi numero purché non si verifichi lo overflow dello stack. Fammi sapere se questo non conta per il bonus a causa dello straripamento dello stack. È anche possibile che questo particolare algoritmo non sia polinomiale e fammi sapere se è così.

Non competitiva perché la lingua postdatata sfida.

Spiegazione:

34*c-»T -> 34*c-»10

a(0) = 0
a(1) = 1
a(n) = 34*c-»

34*c-»
34*    # 34*a(n-1)
   c-  # 34*a(n-1)-a(n-2)
     » # 34*a(n-1)-a(n-2)+2

Soluzione alternativa:

-35*d+T

Invece usa a(n) = 35*(a(n-1)-a(n-2)) + a(n-3)

JavaScript (ES6), 29-4 = 25 byte

n=>n>1?34*f(n-1)-f(n-2)+2:n|0

5 byte salvati grazie a @IsmaelMiguel !

Ho dovuto codificare 0, 1 e negativi per evitare la ricorsione infinita.

Console, ho chiamato la funzione f:

f(1);  // 0
f(13); // 73804512832419600
f(30); // 7.885505171090779e+42 or 7885505171090779000000000000000000000000000

EDIT : risulta che JavaScript arrotonderà i numeri a 16 (15) cifre (Spec) perché questi numeri sono troppo grandi causando un overflow. Inserisci 714341252076979033 nella tua console JavaScript e verifica tu stesso. È più una limitazione di JavaScript

Excel VBA - 90 byte

Utilizzando la relazione di ricorrenza dalla pagina di Wikipedia:

n = InputBox("n")
x = 0
y = 1
For i = 1 To n
Cells(i, 1) = x
r = 34 * y - x + 2
x = y
y = r
Next i

Quando eseguito, viene richiesto n, quindi la sequenza fino a e incluso n viene emessa nella colonna A:

Può essere eseguito fino a n = 202 incluso prima di dare un errore di overflow.

[Non Competente] Pyth (14 - 4 - 4 = 6 byte)

K1u/^tG2~KGQ36

Utilizzata la prima ricorrenza da OEIS , che dopo 0,1,36 è possibile trovare A _n = (A _n-1 -1) ² / A _n-2 . A Non competere perché questa soluzione inizia da 36, ​​se si scende si divide per zero (quindi l'input di 0 dà 36). Inoltre ha dovuto hardcode 36.

Provalo qui

Java, 53 - 4 = 49 byte

È un'altra semplice ricorsione, ma spesso non riesco a pubblicare Java con un punteggio <50, quindi ...

long g(int n){return n<2?n<1?1:0:34*g(n-1)-g(n-2)+2;}

Ora, per qualcosa di non ricorsivo, diventa un po 'più lungo. Questo è più lungo (112-4 = 108) e più lento, quindi non sono sicuro del perché lo sto postando se non per avere qualcosa di iterativo:

long f(int n){long a=0,b,c,d=0;for(;a<1l<<32&n>0;)if((c=(int)Math.sqrt(b=(a*a+a++)/2))*c==b){d=b;n--;}return d;}

Julia, 51 byte - 4 - 4 = 43

f(n)=(a=b=big(1);b-=1;for i=1:n a,b=b,34b-a+2end;a)

Questo utilizza la prima relazione di ricorrenza elencata nella pagina Wikipedia per i numeri triangolari quadrati. Calcola n = 1000 in 0,006 secondi e n = 100000 in 6,93 secondi. È qualche byte più lungo di una soluzione ricorsiva ma è molto più veloce.

Ungolfed + spiegazione:

function f(n)
    # Set a and b to be big integers
    a = big(1)
    b = big(0)

    # Iterate n times
    for i = 1:n
        # Use the recurrence relation, Luke
        a, b = b, 34*b - a + 2
    end

    # Return a
    a
end

Esempi:

julia> for i = 1:4 println(f(i)) end
0
1
36
1225

julia> @time for i = 1:1000 println(f(i)) end
0
... (further printing omitted here)
elapsed time: 1.137734341 seconds (403573226 bytes allocated, 38.75% gc time)

PHP, 65 59 56-4 = 52 byte

while($argv[1]--)while((0|$r=sqrt($s+=$f++))-$r);echo$s;

ripetere fino a quando la radice quadrata di $sè ∈ℤ: aggiungi $falla somma $s, incrementa $f;
ripetere i $argv[1]tempi.
somma di output.

Prolog, 70 74-4-4 = 66

n(X,R):-n(X,0,1,R).
n(X,A,B,R):-X=0,R=A;Z is X-1,E is 34*B-A+2,n(Z,B,E,R).

n(100,R)Uscite in esecuzione :

X = 40283218019606612026870715051828504163181534465162581625898684828251284020309760525686544840519804069618265491900426463694050293008018241080068813316496

Richiede circa 1 secondo per essere eseguito n(10000,X)sul mio computer.

Modifica : la versione 66 è ricorsiva alla coda. La precedente versione non ricorsiva della coda è la seguente:

n(X,[Z|R]):-X>1,Y is X-1,n(Y,R),R=[A,B|_],Z is 34*A-B+2;X=1,Z=1,R=[0];Z=0.

Hanno la stessa lunghezza in byte ma il non ricorsivo di coda genera overflow dello stack oltre un certo punto (sul mio computer, intorno al 20500).

Javascript ES6, 77 75 71 caratteri

// 71 chars
f=n=>{for(q=t=w=0;n;++q)for(s=q*q;t<=s;t+=++w)s==t&&--n&console.log(s)}

// No multiplication, 75 chars
f=n=>{for(s=t=w=0,q=-1;n;s+=q+=2)for(;t<=s;t+=++w)s==t&&--n&console.log(s)}

// Old, 77 chars
f=n=>{for(s=t=w=0,q=-1;n;s+=q+=2){for(;t<s;t+=++w);s==t&&--n&console.log(s)}}

• La soluzione è lineare
• La soluzione può generare tutti i numeri meno di 2 ^ 53 a causa del tipo di numeri.
• L'algoritmo stesso può essere utilizzato per numeri illimitati.

Test:

f(11)

0
1
36
1225
41616
1413721
48024900
1631432881
55420693056
1882672131025
63955431761796

C, 68 byte

Questa è stata una sfida divertente con C

main(o,k){o==1?k=0:0;k<9e9&&k>=0&&main(34*o-k+2,o,printf("%d,",k));}

Guarda correre qui: https://ideone.com/0ulGmM

Gelatina , 13 - 8 = 5 byte

Questo si qualifica per entrambi i bonus.

×8‘,µÆ²Ạ
0Ç#Ṫ

Provalo online!

Fatto insieme a caird coinheringaahing in chat .

Spiegazione

× 8 ', µÆ²Ạ ~ Collegamento helper.

× 8 ~ 8 volte il numero.
  '~ Incremento.
   , ~ Associato al numero corrente.
    µ ~ Avvia un nuovo collegamento monadico (1-arg).
     ~² ~ Vectorized "Is Square?".
       All ~ Tutto. Restituisci 1 solo se entrambi sono veritieri.



0Ç # Ṫ ~ Link principale.

0 # ~ A partire da 0, raccogli i primi N numeri interi con risultati veritieri, quando applicati:
 ~ L'ultimo link come una monade.
   Ṫ ~ Ultimo elemento. Uscita implicita.

Perl 6 , 25 - 8 = 17 byte

{(0,1,2-*+34* *…*)[$_]}

Provalo online!

05AB1E , 10 - 8 = 2 byte

1ÎGDŠ34*Ìα

Provalo online!

APL (NARS), 67 caratteri, 134 byte

r←f w;c;i;m
c←0⋄i←¯1⋄r←⍬
→2×⍳0≠1∣√1+8×m←i×i+←1⋄r←r,m⋄→2×⍳w>c+←1

test:

  f 10
0 1 36 1225 41616 1413721 48024900 1631432881 55420693056 1882672131025 

f cercherebbe in sequenza quadratica anche gli elementi che sono numeri triangolari, quindi devono seguire la formula di controllo triangolare negli APL: 0 = 1∣√1 + 8 × m con numero m per controllare.