45

Dato un numero non negativo n, fornire il numero di modi per esprimere ncome la somma di due quadrati di numeri interi n == a^2 + b^2( OEIS A004018 ). Si noti che ae bpuò essere positivo, negativo o pari a zero, e il loro ordine è importante. Vince il minor numero di byte.

Ad esempio, n=25dà 12perché 25può essere espresso come

(5)^2  + (0)^2
(4)^2  + (3)^2
(3)^2  + (4)^2
(0)^2  + (5)^2
(-3)^2 + (4)^2
(-4)^2 + (3)^2
(-5)^2 + (0)^2
(-4)^2 + (-3)^2
(-3)^2 + (-4)^2
(0)^2  + (-5)^2
(3)^2  + (-4)^2
(4)^2  + (-3)^2

Ecco i valori fino a n=25. Fai attenzione a che il tuo codice funzioni n=0.

Ecco i valori fino a n=100come un elenco.

[1, 4, 4, 0, 4, 8, 0, 0, 4, 4, 8, 0, 0, 8, 0, 0, 4, 8, 4, 0, 8, 0, 0, 0, 0, 12, 8, 0, 0, 8, 0, 0, 4, 0, 8, 0, 4, 8, 0, 0, 8, 8, 0, 0, 0, 8, 0, 0, 0, 4, 12, 0, 8, 8, 0, 0, 0, 0, 8, 0, 0, 8, 0, 0, 4, 16, 0, 0, 8, 0, 0, 0, 4, 8, 8, 0, 0, 0, 0, 0, 8, 4, 8, 0, 0, 16, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 8, 4, 0, 12]

Curiosità: la sequenza contiene termini arbitrariamente alti e il limite della sua media corrente è π.

Classifica:

Mostra snippet di codice

    var QUESTION_ID=64812,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/64812/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

    body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

    <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Espandi frammento

— XNOR
fonte

4

Aspetta cosa?? "La sequenza contiene termini arbitrariamente alti e il limite della sua media corrente è π."

— Stewie Griffin,

@StewieGriffin Le due affermazioni sono coerenti. Considera la sequenza 1,0,2,0,0,3,0,0,0,4,0,0,0,0,5,.... Tagliare la sequenza dopo ogni numero diverso da zero, la media finora è 1. E, le sequenze di 0 hanno sempre meno impatto in seguito nella sequenza.

— xnor

5

So che è coerente .. =) Avevo controllato i primi 10.000 numeri quando ho pubblicato il commento. Quello che non capisco è: perché mai è uguale a Pi?

— Stewie Griffin,

29

@StewieGriffin La somma dei termini fino a N corrisponde ai punti (a, b) con a ^ 2 + b ^ 2 <= N. Questi sono i punti reticolari nel cerchio di raggio sqrt (N), la cui area è πN.

— xnor

2

@xnor e ecco la magia :(

— Andras Deak

19

Python ( 59 57 56 byte)

lambda n:0**n+sum((-(n%(x-~x)<1))**x*4for x in range(n))

Demo online

Come per la mia risposta CJam, questa utilizza l'inversione di Möbius e scorre in tempo pseudoquasilineare.

Grazie a Sp3000 per un risparmio di 2 byte e feersum per 1.

— Peter Taylor
fonte

1

Quelle parentesi sono fastidiose.

— lirtosiast

@ThomasKwa, parlamene. La cosa che mi ha davvero sorpreso, in una delle versioni che ho passato sulla strada per la prima che ho pubblicato, è stata -1**xsempre -1. Mi aspettavo -1che fosse un singolo token letterale intero anziché un meno unario a bassa precedenza seguito da uno.

— Peter Taylor,

2

Congratulazioni per la generosità! Il tuo codice è più corto di qualsiasi cosa mi sia venuta in mente. La tua soluzione si basa su un'idea matematica completamente nuova e inaspettata, e mi fa piacere che ciò sia possibile anche in una sfida così semplice. Il risultato inverso di Mobius è piuttosto carino e ho avuto il piacere di ricavare una prova per me stessa.

— xnor

1 byte può essere salvato spostando la moltiplicazione da 4 a dopo **x.

— feersum

@PeterTaylor Puoi elaborare come funziona il tuo algoritmo / puoi indicarmi una risorsa? Non riesco proprio a capire come applicare l'inversione di möbius al numero di somme del problema di suqares.

— flawr

15

Mathematica, 13 byte

Se sono consentiti i built-in, ecco come farlo in Mathematica.

2~SquaresR~#&

Per 0 <= n <= 100

2~SquaresR~# & /@ Range[0, 100]

{1, 4, 4, 0, 4, 8, 0, 0, 4, 4, 8, 0, 0, 8, 0, 0, 4, 8, 4, 0, 8, 0, 0, 0, 0 , 12, 8, 0, 0, 8, 0, 0, 4, 0, 8, 0, 4, 8, 0, 0, 8, 8, 0, 0, 0, 8, 0, 0, 0, 4 , 12, 0, 8, 8, 0, 0, 0, 0, 8, 0, 0, 8, 0, 0, 4, 16, 0, 0, 8, 0, 0, 0, 4, 8, 8 , 0, 0, 0, 0, 0, 8, 4, 8, 0, 0, 16, 0, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 8, 4, 0 , 12}

— DavidC
fonte

1

Perché ovviamente Mathematica ha un built-in per questo.

— HyperNeutrino,

14

Python 2, 44 byte

f=lambda n,x=1:+(x>n)or(n%x<1)-f(n,x+2)/4<<2

Questo è quasi lo stesso della soluzione di xsot (che si basa sulla soluzione di Peter Taylor ), ma salva 8 byte semplificando il modo in cui i segni vengono gestiti.

Si noti che per un programma completo, è possibile salvare 2 byte nella funzione senza incorrere in un costo esterno alla funzione:

f=lambda n,x=1:x>n or(n%x<1)-f(n,x+2)/4<<2
print+f(input())

Due byte aggiuntivi per un programma completo in questo modo:

n=input()
f=lambda x:x>n or(n%x<1)-f(x+2)/4<<2
print+f(1)

Perché n > 0esiste una soluzione a 40 byte molto leggibile:

f=lambda n,x=1:n/x and(n%x<1)*4-f(n,x+2)

— Mitch Schwartz
fonte

1

Complimenti per aver vinto la taglia! La sottrazione ricorsiva è un modo chiaro e breve per esprimere la somma alternata per divisori dispari senza bisogno di estrarre un segno dal divisore stesso. Inoltre, merito a xsot per aver semplificato la soluzione di Peter Taylor a una ricorsiva con una gestione intelligente di n = 0.

— xnor

12

Pyth, 13 byte

/sM^^R2}_QQ2Q

Suite di test

/sM^^R2}_QQ2Q
                 Q = eval(input())
       }_QQ      Inclusive range from -Q to Q (all possible a and b)
    ^R2          Map to their squares
   ^       2     Form all pairs
 sM              Sum pairs
/           Q    Count occurances of Q

— isaacg
fonte

In ritardo, ma non credo che tu abbia bisogno dell'ultimo Q.

— Erik the Outgolfer,

12

J, 16 byte

+/@,@:=+&*:/~@i:

Questo è un verbo monadico (in altre parole, una funzione unaria). Provalo online o guardalo passare tutti i casi di test .

Spiegazione

+/@,@:=+&*:/~@i:  Denote input by n
              i:  The array of integers from -n to n
           /~@    Take outer product wrt the following function:
       +           the sum of
        &*:        squares of both inputs
                  This results in a 2D array of a^2+b^2 for all a, b between -n and n
      =           Replace by 1 those entries that are equal to n, and others by 0
   ,@:            Flatten the binary matrix
+/@               Take its sum

— Zgarb
fonte

11

Python 2, 69 55 53 52 byte

f=lambda n,x=1:+(x>n)or(2-x%4)*(n%x<1)+f(n,x+2)/4<<2

Questa è una funzione ricorsiva basata sull'eccellente soluzione di Peter Taylor .

— xsot
fonte

1

Questo è un grande miglioramento. Ma c'è ancora un modo per renderlo più breve e ti incoraggio a cercarlo.

— xnor

1

@xnor Un altro byte in basso. Spero che tu non abbia più trucchi nelle maniche.

— xsot

2

Non so se devo fare una risposta di esso, è solo la soluzione più uno trucco: f=lambda n,x=1:+(x>n)or(n%x<1)-f(n,x+2)/4<<2. Inoltre, immagino che non ci interessi a superare la profondità massima di ricorsione predefinita?

— Mitch Schwartz,

1

@MitchSchwartz Penso che sia un incredibile miglioramento degno della generosità e probabilmente dell'ottimizzazione finale che xnor aveva in mente.

— xsot,

1

@MitchSchwartz Sì, questa è l'ottimizzazione a cui stavo pensando! E il /4<<2trucco di xsot lo rende più corto di quello che avevo.

— xnor

8

Julia, 40 byte

n->n>0?4sum(i->(n-i^2)^.5%1==0,1:n^.5):1

Ungolfed:

function f(n)
  if n==0
    return 1           # Handle special case of n=0
  else
    m=0                # Start the counter at zero
    for i=1:sqrt(n)    # Loop over the values (i) whose squares are
                       # less than n (except zero)
      k=sqrt(n-i^2)    # Find k such that n=k^2+i^2
      if k==floor(k)   # if k is an integer, we've found a pair
        m+=4           # Add one for each of k^2+i^2, (-k)^2+(-i)^2, and the other two
      end
    end
    return m           # Return the resulting count
  end
end

Nota che il ciclo non include i==0, perché quando nè un quadrato, è già incluso da i=sqrt(n), e ci sono solo quattro, non otto, per quel form ( 0^2+k^2, 0^2+(-k)^2, k^2+0^2, (-k)^2+0^2).

— Glen O
fonte

7

CJam, 25 23 byte

Zri:R#Ym*{Rf-Yf#:+R=},,

Questa è una soluzione teorica che richiede O (9 ⁿ ) tempo e memoria per l'ingresso n .

Al costo di un byte extra - per un totale di 24 byte - possiamo ridurre la complessità a O (n ² ) :

ri:R)Y*Ym*{Rf-Yf#:+R=},,

Provalo online!

Come funziona

O

Z                  Push 3.
 ri:R              Read an integer from STDIN and save it in R.
     #             Compute 3**R.

o

ri:R               Read an integer from STDIN and save it in R.
    )Y*            Add 1 and multiply by 2.

Poi

Ym*                Take the second Cartesian power, i.e., compute all pairs.
   {          },   Filter the pairs:
    Rf-              Subtract R from each.
       Yf#           Square the differences.
          :+         Add the squares.
            R=       Compare with R.
                   If = pushed 1, keep the pair.
                ,  Count the kept pairs.

— Dennis
fonte

E con un risparmio di un byte è possibile ridurre la complessità a Õ (n)

— Peter Taylor,

Si, ho visto. È stupefacente.

— Dennis,

7

CJam ( 25 24 22 21 byte)

{:X!X{X\2*)%!4*\-}/z}

Demo online

Questo viene eseguito in tempo pseudoquasilineare * e utilizza la dichiarazione dell'OEIS che

La trasformata di Moebius è la sequenza del periodo 4 [4, 0, -4, 0, ...]. - Michael Somos, 17 settembre 2007

L'input 0 è ovviamente un caso speciale (le trasformazioni e gli annientatori di Möbius non vanno bene insieme), ma alla fine è costato solo un carattere.

* Pseudo- perché è quasilineare nel valore dell'input, non nella dimensione dell'input; quasi perché esegue Theta(n)operazioni su numeri interi di dimensioni nell'ordine di n; un'operazione bmod -bit dovrebbe richiedere b lg btempo, quindi nel complesso questo richiede Theta(n lg n lg lg n)tempo.

— Peter Taylor
fonte

6

Japt , 42 37 33 byte

Japt è una versione abbreviata di Ja vaScri pt . Interprete

V=Un oU+1;Vr@X+(Vf_p2 +Y*Y¥U)l ,0

Come funziona

           // Implicit: U = input number
V=Un oU+1  // Set variable V to range(-U, U+1). Ends up like [-U,-U+1,...,U-1,U]
Vr@    ,0  // Reduce each item Y in V with this function, starting at 0:
X+(     l  //  Return the previous value X + the length of:
Vf_p2      //   V filtered by items Z where Z*Z
+Y*Y==U)   //    + Y*Y equals U.
           // This ends up as the combined length of all fitting pairs of squares.
           // Implicit: return last expression

Forse c'è una tecnica migliore; suggerimenti sono ben accetti

— ETHproductions
fonte

6

Python 3, 68 61 60 byte

lambda n:0**n+4*sum(i**.5%1+(n-i)**.5%1==0for i in range(n))

L'uso di due comprensioni nidificate è troppo costoso. Al contrario, controlla se entrambe le coordinate sul cerchio di raggio sqrt (n) sono numeri interi.

Peter Taylor lo ha battuto con un approccio basato sull'inversione di Moebius .

— lirtosiast
fonte

Molto bene. Stavo armeggiando con una funzione ricorsiva ma non sono riuscito a risolverlo n=0elegantemente.

— xsot,

5

Ottava, 28 byte

@(n)nnz((a=(-n:n).^2)'+a==n)

— alephalpha
fonte

5

Haskell, 42 byte

f n|q<-[-n..n]=sum[1|a<-q,b<-q,a*a+b*b==n]

Esempio di utilizzo:

*Main> map f [0..25]
[1,4,4,0,4,8,0,0,4,4,8,0,0,8,0,0,4,8,4,0,8,0,0,0,0,12]
*Main>

— Nome del modello
fonte

3

Legare quna guardia è intelligente, ricorderò questo trucco.

— xnor

5

Julia, 89 79 63 byte

g(x)=cos(π*x^.5)^2÷1
a(n)=(n==0)+4sum([g(i)g(n-i)for i=1:n])

Questa è una funzione denominata ache accetta un numero intero e restituisce un float. Chiama una funzione di aiuto g.

Ungolfed:

function g(x::Integer)
    floor(cos(π*sqrt(x))^2)
end

function a(n::Integer)
    (n == 0) + 4*sum([g(i)*g(n-i) for i=1:n])
end

L'approccio qui utilizza una semplificazione della formula di Wesley Ivan Hurt elencata su OEIS. La semplificazione è stata trovata da Glen O, la stessa persona che ha eliminato 26 byte di questa risposta!

— Alex A.
fonte

Utilizzare x^.5invece di sqrt(x)salvare 3 byte. E (n==0)salva oltre 2 byte 1÷(n+1). E puoi salvare altri 4 caratteri usando cos(π*sqrt(x))^2÷1invece di floor(cos(π*sqrt(x))^2). Inoltre, usa 1:n/2piuttosto che 1:n÷2, perché non c'è nulla di male nell'usare un float g(x)e sarà comunque bloccato sugli interi i. E sum(i->g(i)g(n-i),1:n/2)raderà anche altri personaggi.

— Glen O,

@GlenO Ottimi suggerimenti, grazie. Il sumtrucco però non riesce n=0, quindi ho mantenuto la comprensione dell'array.

— Alex A.

1

Quindi, può essere recuperato: se lasci che il i=0caso si verifichi nella somma, puoi attivare il segno 4g(n). Quindi (n==0)-4g(n)-4g(n/2)+8sum(i->g(i)g(n-i),0:n/2), che non si imbatterà nell'errore. Ma puoi fare ancora meglio, notando le simmetrie -(n==0)+4sum([g(i)g(n-i)for i=1:n])

— Glen O

@GlenO Questa semplificazione è seriamente geniale. Ti consiglio di inviarlo come formula alternativa per la sequenza su OEIS!

— Alex A.

4

Pyth, 16 15 byte

lfqQs^R2T^}_QQ2

Provalo online nel compilatore Pyth .

Come funziona

lfqQs^R2T^}_QQ2

          }_QQ   Compute the inclusive range from -Q to Q (input).
         ^    2  Take the second Cartesian power, i.e., compute all pairs.
 f               Filter; for each T in the list of pairs:
     ^R2T          Compute the squares of T's elements.
    s              Add the squares.
  qQ               Compare the sum with Q.
                 If q returned True, keep T.
l                Count the kept pairs.

— Dennis
fonte

4

TI-BASIC, 23 byte

sum(seq(Σ(X²+Y²=Ans,X,-Ans,Ans),Y,-Ans,Ans

Abbastanza diretto. Σ(è la somma.

Stranamente, sum(seq(sum(seq(lancia un ERR:ILLEGAL NEST, e così fa Σ(Σ(, ma sum(seq(Σ(va bene. Ho scelto di mettere l' Σ(interno per salvare un paren vicino.

— lirtosiast
fonte

Qual è la differenza tra sume Σ?

— alephalpha,

1

@alephalpha Σ (prende una somma, sommando tutti i X²+Y²=Ansvalori di X tra -Anse Ans. sum (è la somma di una lista , quindi dobbiamo prima creare la lista usando seq (..., Y, -Ans, Ans

— lirtosiast

4

JavaScript (ES6), 66 60 byte

n=>eval("for(r=0,a=~n;a++<n;)for(b=~n;b++<n;)r+=a*a+b*b==n")

6 byte salvati grazie a @ edc65 !

Spiegazione

n=>eval(`              // use eval to allow for loops in an unparenthesised arrow function
  for(r=0,             // r = number of pairs
    a=~n;a++<n;        // a = first number to square
  )
      for(b=~n;b++<n;) // b = second number to square
        r+=a*a+b*b==n  // add one to the result if a^2 + b^2 == n
                       // implicit: return r
`)

Test

n = <input type="number" oninput='result.innerHTML=(

n=>eval("for(r=0,a=~n;a++<n;)for(b=~n;b++<n;)r+=a*a+b*b==n")

)(+this.value)' /><pre id="result"></pre>

Espandi frammento

— user81655
fonte

1

60:n=>eval('for(r=0,a=~n;a++<n;)for(b=~n;b++<n;)r+=a*a+b*b==n')

— edc65,

@ edc65 Nice! Non pensavo di usare evalper mettere i forloop in una funzione freccia senza parentesi. Mi sono anche dimenticato ~dell'operatore haha.

— user81655,

4

Python 3, 93 62 69 byte

Itertools non funzionava, quindi ho usato di nuovo due intervalli, ma ho spostato l'intervallo per salvare byte.

Modifica: il codice precedente in realtà non funzionava, poiché ho definito l'intervallo su n prima di aver definito n.

lambda n:sum(i*i+j*j==n for i in range(-n,n+1)for j in range(-n,n+1))

— Sherlock9
fonte

2

APL, 23 20 19 byte

{+/⍵=∊∘.+⍨×⍨0,,⍨⍳⍵}

Spiegazione:

{+/⍵=∊∘.+⍨×⍨0,,⍨⍳⍵}        Monadic function:
                 ⍳⍵          1 2 3 ... ⍵
               ,⍨            Duplicate
             0,              Concatenate to 0
          ×⍨                 Square everything
      ∘.+⍨                   Make an addition table
     ∊                       Flatten
   ⍵=                        1s where equal to the input
 +/                          Sum up the 1s

A parte il fatto che APL non ha la funzione di J i:(numeri da -n a n), questo funziona praticamente come la risposta di J.

Non possiamo usare un treno perché ottenere il -\⍳2×⍵non analizzare in quanto (-\) ⍳ (2×⍵)costerebbe tre byte; allo stesso modo con un'altra coppia di top. Tutte quelle parentesi riducono la funzione regolare.

Provalo qui . L'output di 1significa che tutti i valori corrispondono.

— lirtosiast
fonte

2

Matlab 41 byte

Ancora più piccolo delle risposte precedenti

@(n)nnz(~mod(sqrt(n-(1:n^.5).^2),1))*4+~n

Sostanzialmente sostituita la risposta di Agawa001 con potenza e sqrt

— Jonas
fonte

2

Candy , 17 14 byte

Input inserito inizialmente nello stack

~~~TbAT1C(sWs+Aeh)Z~~

~T0C(sWs+Aeh)Z

peekA    # copy arg from stack to register A
range2   # create double sided range on stack, -A, 1-A, ... A-1, A
digit0   # prefix argument to 'cart', 
cart     # cartesian product of current stack(0), and other stack(0)
while    # while stack not empty
  sqr    # pop and square and push
  swap   # swap two stack elements
  sqr    # pop and square and push
  add    # pop and pop and add and push
  pushA  # push original argument
  equal  # equality test 0/1
  popAddZ  # Z := Z + pop
endwhile
pushZ    # push Z onto stack, will be output to stdout on termination

— Dale Johnson
fonte

2

CJam, 28

qi_mF{3a>},{~)\4%2-&}%4+:*1?

Non molto breve, ma efficiente. Ad esempio, il risultato per 15625 è immediatamente 28. Utilizza la formula basata sulla fattorizzazione di OEIS.
Provalo online

Spiegazione:

qi       read input and convert to integer
_        make a copy (will be used to handle the 0 case at the end)
mF       factorize into [prime exponent] pairs
{…},     filter the array of pairs
  3a>    with the condition that the pair is greater than [3]
          which means the prime factor must be ⩾3
{…}%     transform each pair as follows:
  ~      dump the prime factor and exponent onto the stack
  )      increment the exponent
  \      swap with the prime
  4%     get the remainder mod 4 (it will be 1 or 3)
  2-     subtract 2 (resulting in -1 or 1)
  &      bitwise AND with the incremented exponent (see below)
4+       append a 4 to the array
:*       multiply all
1?       if the input was 0, use 1, else use the above result

Alcuni dettagli sul calcolo:

se il primo è 1 mod 4, il codice calcola (exponent + 1) & -1 , che èexponent + 1
se il primo è 3 mod 4, il codice calcola (exponent + 1) & 1, che è 0 se l'esponente è dispari e 1 se pari

Tutti questi valori moltiplicati insieme e moltiplicati per 4 sono esattamente la formula OEIS.

— aditsu
fonte

2

Python 2, 68 byte

def x(n):r=range(-n,n+1);print sum(a*a+b*b==n for a in r for b in r)

Definisce una funzione chiamata x() che accetta un numero n.

Provalo online. http://ideone.com/aRoxGF

— Rɪᴋᴇʀ
fonte

Manca un'istruzione printo return.

— Zgarb,

Grazie, mi ero completamente dimenticato. Il collegamento ha però la dichiarazione di stampa. Ho modificato il mio codice mentre lo stavo realizzando.

— Rɪᴋᴇʀ

Ok non ti preoccupare. Ma questo sembra anche dare risultati errati per n=0e n=1(0 e 2 invece di 1 e 4). Forse i limiti di portata devono essere regolati?

— Zgarb,

@Zgarb Sì, dovrebbero finire a n+1.

— lirtosiast,

1

Lo cercherò.

— Rɪᴋᴇʀ

2

Pyth, 41 35 33 30 27 byte

Provalo online.

Modifica: grazie a isaacg , ho ottenuto me *Fal lavoro! SÌ!

?Q*F+4m.&tt%ed4hhdr-PQ2 8 1
                                (implicit) Q = input()
?Q                              If Q != 0
      m                           Map to d (exponent, prime) from ...
                  r-PQ2 8         run-length-encoded(PQ with 2's removed)
       .&                           Bitwise and
           %ed4                       d[-1] % 4
         tt                           -2
                hd                  with d[0]
               h                      +1
    +4                            Append 4 to the resulting array
  *F                              Then multiply it all together
                          1     Else 1

Modificare: inserisci bit a bit e reinseriscilo per ulteriori risparmi di byte! Inoltre ho rimosso tutte le cose "precedentemente". Stava iniziando a essere ingombra.

Grazie ad aditsu e alla sua soluzione CJam, a Maltysen e ai suoi consigli (un giorno mi metterò m*Fdal lavoro. Un giorno ...)

J4Vr-PQ2 8=J*J.&tt%eN4hhN;?QJ1
                                (implicit) Q=input()
J4                              J=4
    -PQ2                        Remove all 2's from the prime factorization of Q
   r     8                      run-length encode (exponent, prime factor)
  V                      ;      For N in range( the above ):
          =J*J                      J = J * ...
                tt%eN4                N[-1] mod 4 -2 
                      hhN             (exponent + 1)
              .&                    bitwise and
                          ?QJ1  if Q != 0 print(J) else print(1)

Nota che,

se il primo è 1 mod 4, otteniamo -1 & (exponent + 1), che èexponent + 1
ma se il primo è 3 mod 4, otteniamo 1 & (exponent + 1), ovvero 0se l'esponente è dispari e 1se pari

Moltiplica tutto insieme (volte 4 all'inizio) e otteniamo il numero di somme di due quadrati che si sommano al nostro input.

— Sherlock9
fonte

2

Python, 57 byte

Bella sfida. Purtroppo al momento non lo sto diventando più corto di così.

lambda n:0**n+sum(2-d%4for d in range(1,n+1)if d%2>n%d)*4

— Willem
fonte

2

PARI / GP, 34 28 byte

Utilizzo delle funzioni di generazione:

Risparmiato 6 byte grazie a Mitch Schwartz .

n->sum(i=-n,n,x^i^2)^2\x^n%x

Utilizzando built-in, 33 byte (salvato 1 byte grazie a Mitch Schwartz .):

n->if(n,2*qfrep(matid(2),n)[n],1)

qfrep (q, B, {flag = 0}): vettore di (metà) il numero di vettori di norme da 1 a B per la forma quadratica integrale e definita q. Se flag è 1, conta i vettori di norma pari da 1 a 2B.

— alephalpha
fonte

matid(2)salva un byte.

— Mitch Schwartz,

1

E fino a 28 per l'approccio della funzione generatrice:n->sum(i=-n,n,x^i^2)^2\x^n%x

— Mitch Schwartz

1

Matlab, 72 byte

n=input('');m=fix(sqrt(n));m=(-m:m).^2;disp(nnz(bsxfun(@plus,m,m')==n))

— Luis Mendo
fonte

Non è necessario dispin questa sfida Luis! =)

— Stewie Griffin,

@StewieGriffin Grazie! Ma in questo caso è un programma, non una funzione. Quindi, secondo la risposta accettata nel tuo link è necessario, no?

— Luis Mendo,

1

Matlab, 63 50 byte

@(y)nnz(~mod(sqrt(y-power((1:sqrt(y)),2)),1))*4+~y

Questo batte l'altro codice con lo stesso titolo, quindi lo metto: D.
Il programma trova le soluzioni di numero intero positivo, quindi moltiplica per 4 per comprendere quelle negative.

Può eseguire tutti e 25 i primi casi di test

for i=1:25 ans(i)
end

   1

   4

   4

   0

   4

   8

   0

   0

   4

   4

   8

   0

   0

   8

   0

   0

   4

   8

   4

   0

   8

   0

   0

   0

   0

   12

— Abr001am
fonte

Non è necessario dispin questa sfida ! =)

— Stewie Griffin il

grazie @StewieGriffin l'ho incluso proprio come un gioco leale relativo a quello di luis

— Abr001am

Suggerimenti: quando prevedi di pubblicare i risultati da MATLAB, usa format compact=)

— Stewie Griffin,

1

JavaScript, 89 byte

n=prompt()
p=Math.pow
for (x=c=(+n?0:1);x<=n;x++)if(x&&p(n-p(x,2),.5)%1===0)c+=4
alert(c)

So che questa non è la risposta JavaScript più breve anche se dovessi rimuovere le linee di I / O, ma penso che sia la risposta JS più performante che mi dà il risultato per un milione in pochi secondi (dieci milioni hanno impiegato circa un minuto).

— Adam Dally
fonte

Puoi usare == invece di ===?

— lirtosiast

Potrei, usando solo le migliori pratiche, ah ah.

— Adam Dally,

1

PHP, 70 byte, non in competizione

for($x=-1;$x++<=$n=$argv[1];)$s+=(-($n%($x-~$x)<1))**$x*4;echo$n?$s:1;

algoritmo rubato da una delle risposte di Python ... Ho dimenticato quale; volevo capire almeno in parte quello che sta succedendo prima che pubblicassi.

— Titus
fonte

for(;$x<=$n=$argv[1];)$s+=(-($n%(2*$x+1)<1))**$x++*4;echo$n?$s:1;salva 5 byte. $x-~$xè uguale a 2*$x+1e ora puoi iniziare senza assegnare la variabile.

— Jörg Hülsermann,

Conta le somme di due quadrati

Python ( 59 57 56 byte)

Mathematica, 13 byte

Python 2, 44 byte

Pyth, 13 byte

J, 16 byte

Spiegazione

Python 2, 69 55 53 52 byte

Julia, 40 byte

CJam, 25 23 byte

Come funziona

CJam ( 25 24 22 21 byte)

Japt , 42 37 33 byte

Come funziona

Python 3, 68 61 60 byte

Ottava, 28 byte

Haskell, 42 byte

Julia, 89 79 63 byte

Pyth, 16 15 byte

Come funziona

TI-BASIC, 23 byte

JavaScript (ES6), 66 60 byte

Spiegazione

Test

Python 3, 93 62 69 byte

APL, 23 20 19 byte

Matlab 41 byte

Candy , 17 14 byte

CJam, 28

Python 2, 68 byte

Pyth, 41 35 33 30 27 byte

Python, 57 byte

PARI / GP, 34 28 byte

Matlab, 72 byte

Matlab, 63 50 byte

JavaScript, 89 byte

PHP, 70 byte, non in competizione