Scrivere un programma o una funzione per generare la somma dei numeri quadrati dispari (OEIS # A016754) in meno di un input n .

I primi 44 numeri nella sequenza sono:

1, 9, 25, 49, 81, 121, 169, 225, 289, 361, 441, 529, 625, 729, 841, 961, 1089, 
1225, 1369, 1521, 1681, 1849, 2025, 2209, 2401, 2601, 2809, 3025, 3249, 3481, 
3721, 3969, 4225, 4489, 4761, 5041, 5329, 5625, 5929, 6241, 6561, 6889, 7225, 7569

La formula per la sequenza è a(n) = ( 2n + 1 ) ^ 2.

Appunti

• Il comportamento del programma potrebbe non essere definito per n < 1(ovvero, tutti gli input validi lo sono >= 1.)

Casi test

1 => 0
2 => 1
9 => 1
10 => 10
9801 => 156849
9802 => 166650
10000 => 166650

Gelatina, 6 byte

½Ċ|1c3

Provalo online! o verifica tutti i casi di test .

sfondo

Per tutti i numeri interi positivi k , abbiamo 1² + 3² + ⋯ + (2k - 1) ² = k (2k - 1) (2k +1) ÷ 3 .

Poiché ci sono m C r = m! ÷ ((mr)! R!) R -combinazioni di un insieme di m elementi, quanto sopra può essere calcolato come (2k + 1) C 3 = (2k + 1) 2k (2k - 1) ÷ 6 = k (2k - 1) (2k + 1) ÷ 3.

Per applicare la formula, dobbiamo trovare il più alto 2k + 1 tale che (2k - 1) ² <n . Ignorando la parità per un momento, possiamo calcolare la m più alta tale che (m - 1) ² <n come m = ceil (srqt (n)) . Per incrementare condizionalmente m se è pari, è sufficiente calcolare m | 1 (bit a bit O con 1 ).

Come funziona

½Ċ|1c3  Main link. Argument: n

½       Compute the square root of n.
 Ċ      Round it up to the nearest integer.
  |1    Bitwise OR with 1 to get an odd number.
    c3  Compute (2k + 1) C 3 (combinations).

JavaScript (ES6), 30 byte

f=(n,i=1)=>n>i*i&&i*i+f(n,i+2)

31 byte se è f(1)necessario restituire zero anziché false:

f=(n,i=1)=>n>i*i?i*i+f(n,i+2):0

05AB1E , 10 8 byte

Codice:

<tLDÉÏnO

Spiegazione:

<         # Decrease by 1, giving a non-inclusive range.
 t        # Take the square root of the implicit input.
  L       # Generate a list from [1 ... sqrt(input - 1)].
   DÉÏ    # Keep the uneven integers of the list.
      n   # Square them all.
       O  # Take the sum of the list and print implicitly.

Potrebbe tornare utile: t;L·<nO.

Utilizza la codifica CP-1252 . Provalo online! .

Haskell, 30 byte

f n=sum[x^2|x<-[1,3..n],x^2<n]

Sorprendentemente normale.

C #, 126 131 byte

Versione modificata per conformarsi alla nuova domanda:

class P{static void Main(){int x,s=0,n=int.Parse(System.Console.ReadLine());for(x=1;x*x<n;x+=2)s+=x*x;System.Console.Write(s);}}

Utilizzando il limite hardcoded:

using System;namespace F{class P{static void Main(){int x,s=0;for(x=1;x<100;x+=2)s+=x*x;Console.Write(s);Console.Read();}}}

Jelly, 7

’½R²m2S

Provalo online o prova una versione modificata per più valori

Shh ... Dennis sta dormendo ...

Grazie a Sp3000 in chat per il loro aiuto!

Spiegazione:

’½R²m2S
’           ##  Decrement to prevent off-by-one errors
 ½R²        ##  Square root, then floor and make a 1-indexed range, then square each value
    m2      ##  Take every other value, starting with the first
      S     ##  sum the result

R, 38 36 byte

function(n,x=(2*0:n+1)^2)sum(x[x<n])

@Giuseppe ha salvato due byte spostandosi xnell'elenco degli argomenti per salvare le parentesi graffe. Bella idea!

Ungolfed

function(n, x = (2*(0:n) + 1)^2)  # enough odd squares (actually too many)
  sum(x[x < n])                   # subset on those small enough
}

Provalo online!

C, 51, 50 48 byte

f(n,s,i)int*s;{for(*s=0,i=1;i*i<n;i+=2)*s+=i*i;}

Perché non giocare a golf in una delle lingue più dettagliate? (Ehi, almeno non è Java!)

Provalo online!

Programma completo non modificato, con I / O di prova:

int main()
{
    int s;
    f(10, &s);
    printf("%d\n", s);
    char *foobar[1];
    gets(foobar);
}

f(n,s,i)int*s;{for(*s=0,i=1;i*i<n;i+=2)*s+=i*i;}

In realtà, 7 byte

√K1|3@█

Provalo online!

Anche per 7 byte:

3,√K1|█

Provalo online!

Questo utilizza la stessa formula della risposta Jelly di Dennis.

Spiegazione:

√K1|3@█
√K       push ceil(sqrt(n))
  1|     bitwise-OR with 1
    3@█  x C 3

Ottava, 23 byte

@(x)(x=1:2:(x-1)^.5)*x'

test:

[f(1); f(2); f(3); f(10); f(9801); f(9802); f(10000)]
ans =    
        0
        1
        1
       10
   156849
   166650
   166650

CJam, 15 byte

qi(mq,2%:)2f#1b

Provalo online!

10000 soluzioni hardcoded:

La soluzione a 12 byte di Martin:

99,2%:)2f#1b

La mia soluzione originale a 13 byte:

50,{2*)2#}%:+

Provalo online!

Pyth, 10 byte

s<#Qm^hyd2

Suite di test

Spiegazione:

s<#Qm^hyd2
    m          Map over the range of input (0 ... input - 1)
       yd      Double the number
      h        Add 1
     ^   2     Square it
 <#            Filter the resulting list on being less than
   Q           The input
s              Add up what's left

Mathcad, 31 "byte"

Nota che Mathcad utilizza le scorciatoie da tastiera per inserire diversi operatori, inclusa la definizione e tutti gli operatori di programmazione. Ad esempio, ctl-] inserisce un ciclo while - non può essere digitato e può essere inserito solo usando la scorciatoia da tastiera o dalla barra degli strumenti Programmazione. I "byte" sono considerati il ​​numero di operazioni da tastiera necessarie per inserire un elemento Mathcad (ad es. Nome variabile o operatore).

Dato che non ho alcuna possibilità di vincere questa competizione, ho pensato di aggiungere un po 'di varietà con una versione di formula diretta.

Racchetta, 57 byte

(λ(n)(for/sum([m(map sqr(range 1 n 2))]#:when(< m n))m))

MATL , 10 byte

qX^:9L)2^s

EDIT (30 lug 2016): le sostituisce codice legato 9Lda 1Ladattare ai recenti cambiamenti nel linguaggio.

Provalo online!

q    % Implicit input. Subtract 1
X^   % Square root
:    % Inclusive range from 1 to that
9L)  % Keep odd-indexed values only
2^   % Square
s    % Sum of array

Python, 39 byte

f=lambda n,i=1:+(i*i<n)and i*i+f(n,i+2)

Se, per n=1, è valido per l'output Falsepiuttosto che 0, allora possiamo evitare la conversione del case base per ottenere 37 byte

f=lambda n,i=1:i*i<n and i*i+f(n,i+2)

E 'strano che non ho trovato un modo più breve per ottenere 0per i*i>=ne diverso da zero altrimenti. In Python 2, si ottengono ancora 39 byte con

f=lambda n,i=1:~-n/i/i and i*i+f(n,i+2)

Python, 42 38 byte

f=lambda n,i=1:i*i<n and i*i+f(n,i+2)

Python 2, 38 byte

s=(1-input()**.5)//2*2;print(s-s**3)/6

Basato sulla formula di Dennis , con s==-2*k. Emette un float. In effetti, l'input è a radice quadrata, decrementato, quindi arrotondato al numero pari successivo.

PARI / GP , 33 32 26 byte

Adattato dal codice di Dennis :

n->t=(1-n^.5)\2*2;(t-t^3)/6

La mia prima idea (30 byte), usando una semplice formula polinomiale:

n->t=((n-1)^.5+1)\2;(4*t^3-t)/3

Questa è un'implementazione efficiente, in realtà non molto diversa dalla versione non golfata che scriverei:

a(n)=
{
  my(t=ceil(sqrtint(n-1)/2));
  t*(4*t^2-1)/3;
}

Un'implementazione alternativa (37 byte) che scorre su ciascuno dei quadrati:

n->s=0;t=1;while(t^2<n,s+=t^2;t+=2);s

Un'altra soluzione alternativa (35 byte) che dimostra la somma senza una variabile temporanea:

n->sum(k=1,((n-1)^.5+1)\2,(2*k-1)^2)

Ancora un'altra soluzione, non particolarmente competitiva (40 byte), che utilizza la norma L ² . Questo sarebbe meglio se ci fosse supporto per i vettori con indici a gradino. (Si potrebbe immaginare la sintassi n->norml2([1..((n-1)^.5+1)\2..2])che lascerebbe cadere 8 byte.)

n->norml2(vector(((n-1)^.5+1)\2,k,2*k-1))

Haskell, 32 31 byte

 n#x=sum[x^2+n#(x+2)|x^2<n]
 (#1)

Esempio di utilizzo: (#1) 9802-> 166650.

Modifica: @xnor ha salvato un byte, con una comprensione intelligente dell'elenco. Grazie!

Julia, 29 byte

f(n,i=1)=i^2<n?i^2+f(n,i+2):0

Questa è una funzione ricorsiva che accetta un numero intero e restituisce un numero intero.

Iniziamo un indice a 1 e se il suo quadrato è inferiore all'input, prendiamo il quadrato e aggiungiamo il risultato della riutilizzazione sull'indice + 2, il che assicura che i numeri pari vengano saltati, altrimenti restituiamo 0.

Oracle SQL 11.2, 97 byte

SELECT NVL(SUM(v),0)FROM(SELECT POWER((LEVEL-1)*2+1,2)v FROM DUAL CONNECT BY LEVEL<:1)WHERE v<:1;

Julia, 26 byte

x->sum((r=1:2:x-1)∩r.^2)

Questo costruisce l'intervallo di tutti gli interi dispari e positivi al di sotto di n e l'array dei quadrati degli interi in quell'intervallo, quindi calcola la somma degli interi in entrambi gli iterabili.

Provalo online!

Reng v.3.3, 36 byte

0#ci#m1ø>$a+¡n~
:m%:1,eq^c2*1+²c1+#c

Provalo qui!

Spiegazione

1: inizializzazione

 0#ci#m1ø

Insiemi ca 0(contatore) e l'ingresso Ial max. 1øpassa alla riga successiva.

2: loop

:m%:1,eq^c2*1+²c1+#c

:duplica il valore corrente (il numero dispari quadrato) e [I mmette mascia. Ho usato il trucco meno che in un'altra risposta , che uso qui. %:1,econtrolla se STOS <TOS. Se lo è, q^si alza ed esce dal circuito. Altrimenti:

         c2*1+²c1+#c

cmette il contatore in basso, lo 2*raddoppia, ne 1+aggiunge uno e lo ²piazza. c1+#Cincrementa ce il ciclo va di nuovo.

3: finale

        >$a+¡n~

$elimina l'ultimo valore (maggiore di quello desiderato), a+¡aggiunge fino a quando la lunghezza dello stack è 1, n~emette e termina.

Clojure, 53 byte

#(reduce +(map(fn[x](* x x))(range 1(Math/sqrt %)2)))

Puoi verificarlo qui:  https://ideone.com/WKS4DA

Mathematica 30 byte

Total[Range[1,Sqrt[#-1],2]^2]&

Questa funzione senza nome quadra tutti i numeri dispari in meno rispetto all'input ( Range[1,Sqrt[#-1],2]) e li aggiunge.

PHP, 64 byte

function f($i){$a=0;for($k=-1;($k+=2)*$k<$i;$a+=$k*$k);echo $a;}

Allargato:

function f($i){
    $a=0;
    for($k=-1; ($k+=2)*$k<$i; $a+=$k*$k);
    echo $a;
}

Ad ogni iterazione del forciclo, aggiungerà 2 a k e controllerà se k ² è minore di $i, se si aggiunge k ² a $a.

R, 60 byte

function(n){i=s=0;while((2*i+1)^2<n){s=s+(2*i+1)^2;i=i+1};s}

Fa esattamente come descritto nella sfida, incluso restituire 0 per il caso n = 1. Degolfato, ';' rappresenta l'interruzione di riga in R, ignorata di seguito:

function(n){         # Take input n
i = s = 0            # Declare integer and sum variables
while((2*i+1)^2 < n) # While the odd square is less than n
s = s + (2*i+1)^2    # Increase sum by odd square
i = i + 1            # Increase i by 1
s}                   # Return sum, end function expression

Java 8, 128 119 117 111 49 byte

n->{int s=0,i=1;for(;i*i<n;i+=2)s+=i*i;return s;}

Basato sulla soluzione C # di @Thomas .

Spiegazione:

Provalo online.

n->{           // Method with integer as both parameter and return-type
  int s=0,     //  Sum, starting at 0
      i=1;     //  Index-integer, starting at 1
  for(;i*i<n;  //  Loop as long as the square of `i` is smaller than the input
      i+=2)    //    After every iteration, increase `i` by 2
    s+=i*i;    //   Increase the sum by the square of `i`
  return s;}   //  Return the result-sum

Python 2, 49 byte

Questo ha finito per essere più breve di un lambda.

x=input()
i=1;k=0
while i*i<x:k+=i*i;i+=2
print k

Provalo online

Il mio più breve lambda, 53 byte :

lambda x:sum((n-~n)**2for n in range(x)if(n-~n)**2<x)