Schreibe eine Programm oder eine Funktion zur Ausgabe der Summe der Quadratzahlen ungerade (OEIS # A016754) weniger als eine Eingabe n .

Die ersten 44 Zahlen in der Sequenz sind:

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

Die Formel für die Sequenz lautet a(n) = ( 2n + 1 ) ^ 2.

Anmerkungen

• Das Verhalten Ihres Programms ist möglicherweise undefiniert für n < 1(dh alle gültigen Eingaben sind >= 1.)

Testfälle

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

Gelee, 6 Bytes

½Ċ|1c3

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Hintergrund

Für alle positiven ganzen Zahlen k gilt 1² + 3² + ⋯ + (2k - 1) ² = k (2k - 1) (2k +1) ÷ 3 .

Da gibt es m C r = m! ÷ ((mr)! R!) R -Kombinationen einer Menge von m Elementen, die oben als (2k + 1) C 3 = (2k + 1) 2k (2k - 1) ÷ 6 = k (2k) berechnet werden können - 1) (2k + 1) ÷ 3.

Um die Formel anzuwenden, müssen wir die höchsten 2k + 1 so finden, dass (2k - 1) ² <n ist . Wenn wir die Parität für einen Moment ignorieren, können wir das höchste m so berechnen, dass (m - 1) ² <n als m = ceil (srqt (n)) gilt . Um m bedingt zu erhöhen, wenn es gerade ist, berechnen Sie einfach m | 1 (bitweises ODER mit 1 ).

Wie es funktioniert

½Ċ|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 Bytes, wenn f(1)Null statt False zurückgegeben werden soll:

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

05AB1E , 10 8 Bytes

Code:

<tLDÉÏnO

Erläuterung:

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

Könnte sich als nützlich erweisen: t;L·<nO .

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

Haskell, 30 Bytes

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

Überraschend normal aussehend.

C #, 126 131 Bytes

Überarbeitete Version, um der neuen Frage zu entsprechen:

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);}}

Hardcoded Limit verwenden:

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();}}}

Gelee, 7

’½R²m2S

Probieren Sie es online oder versuchen Sie es mit einer geänderten Version für mehrere Werte

Shh ... Dennis schläft ...

Danke an Sp3000 im Chat für die Hilfe!

Erläuterung:

’½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 Bytes

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

@ Giuseppe sparte zwei Bytes durch Verschieben x in die Argumentliste ging, um die geschweiften Klammern zu speichern. Tolle Idee!

Ungolfed

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

Probieren Sie es online!

C, 51, 50, 48 Bytes

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

Denn warum nicht in einer der wortreichsten Sprachen Golf spielen? (Hey, zumindest ist es nicht Java!)

Probieren Sie es online!

Volles ungolfed Programm mit Test I / O:

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

Eigentlich 7 Bytes

√K1|3@█

Probieren Sie es online!

Auch für 7 Bytes:

3,√K1|█

Probieren Sie es online!

Dies verwendet die gleiche Formel wie in Dennis 'Gelee-Antwort.

Erläuterung:

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

Oktave, 23 Bytes

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

Testen:

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

CJam, 15 Bytes

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

Probieren Sie es online!

Hardcodierte 10000-Lösungen:

Martins 12-Byte-Lösung:

99,2%:)2f#1b

Meine ursprüngliche 13-Byte-Lösung:

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

Probieren Sie es online!

Pyth, 10 Bytes

s<#Qm^hyd2

Testsuite

Erläuterung:

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

Beachten Sie, dass Mathcad Tastenkombinationen verwendet, um mehrere Operatoren einzugeben, einschließlich der Definition und aller Programmieroperatoren. Beispiel: ctl-] gibt eine while-Schleife ein. Sie kann nicht eingegeben werden und nur über die Tastenkombination oder über die Programmiersymbolleiste. "Bytes" ist die Anzahl der Tastaturoperationen, die zur Eingabe eines Mathcad-Elements erforderlich sind (z. B. Variablenname oder Operator).

Da ich keine Chance habe, diesen Wettbewerb zu gewinnen, dachte ich, ich würde mit einer direkten Formelversion ein bisschen Abwechslung schaffen.

Schläger, 57 Bytes

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

MATL , 10 Bytes

qX^:9L)2^s

EDIT (30. Juli 2016): der verknüpften Code ersetzt 9Ldurch 1Ldie jüngsten Änderungen in der Sprache anzupassen.

Probieren Sie es 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 Bytes

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

Wenn z. n=1B. Falseeher eine Ausgabe als eine Ausgabe zulässig ist, 0können wir die Basisfallkonvertierung vermeiden, um 37 Bytes zu erhalten

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

Es ist seltsam , dass ich nicht einen kürzeren Weg zu bekommen gefunden 0für i*i>=nund ungleich Null sonst. In Python 2 bekommt man noch 39 Bytes mit

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

Python, 42 38 Bytes

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

Python 2, 38 Bytes

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

Basierend auf Dennis 'Formel mit s==-2*k. Gibt einen Float aus. Tatsächlich wird die Eingabe quadratisch, dekrementiert und dann auf die nächste gerade Zahl aufgerundet.

PARI / GP , 33 32 26 Bytes

Angepasst von Dennis 'Code :

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

Meine erste Idee (30 Bytes) mit einer einfachen Polynomformel:

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

Dies ist eine effiziente Implementierung, die sich eigentlich nicht sehr von der ungolfed Version unterscheidet, die ich schreiben würde:

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

Eine alternative Implementierung (37 Byte), die über jedes der Quadrate eine Schleife ausführt:

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

Eine andere alternative Lösung (35 Byte), die das Summieren ohne temporäre Variable demonstriert:

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

Noch eine andere, nicht besonders konkurrenzfähige Lösung (40 Byte), die die L ² -Norm verwendet . Dies wäre besser, wenn Vektoren mit Schrittgrößenindizes unterstützt würden. (Man könnte sich die Syntax vorstellen, bei der n->norml2([1..((n-1)^.5+1)\2..2])8 Bytes verloren gehen.)

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

Haskell, 32 31 Bytes

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

Anwendungsbeispiel: (#1) 9802-> 166650.

Edit: @xnor speicherte ein Byte mit einem klugen Listenverständnis. Vielen Dank!

Julia, 29 Bytes

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

Dies ist eine rekursive Funktion, die eine Ganzzahl akzeptiert und eine Ganzzahl zurückgibt.

Wir beginnen einen Index bei 1, und wenn sein Quadrat kleiner als die Eingabe ist, nehmen wir das Quadrat und addieren das Ergebnis der Wiederverwendung zum Index + 2, wodurch sichergestellt wird, dass gerade Zahlen übersprungen werden, andernfalls geben wir 0 zurück.

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 Bytes

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

Dies konstruiert den Bereich aller ungeraden positiven ganzen Zahlen unter n und die Anordnung der Quadrate der Ganzzahlen in diesem Bereich und berechnet dann die Summe der Ganzzahlen in beiden Iterablen.

Probieren Sie es online!

Reng v.3.3, 36 Bytes

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

Probieren Sie es hier aus!

Erläuterung

1: Initialisierung

 0#ci#m1ø

Setzt cauf 0(den Zähler) und die Eingabe Ifür die mAxt. 1øgeht zur nächsten Zeile.

2: Schleife

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

:dupliziert den aktuellen Wert (die quadrierte ungerade Zahl) und [Ich mlege die mAxt nieder. Ich habe den Lesser-als-Trick in einer anderen Antwort verwendet , die ich hier verwende. %:1,eprüft ob der STOS <TOS. Wenn es so ist, q^steigt es auf und bricht aus der Schleife aus. Andernfalls:

         c2*1+²c1+#c

clegt den Zähler ab, 2*verdoppelt ihn, 1+fügt einen hinzu und ²quadriert ihn. c1+#CInkremente cund die Schleife geht wieder.

3: endgültig

        >$a+¡n~

$löscht den letzten Wert (größer als gewünscht), a+¡addiert bis die Länge des Stapels 1 ist, n~gibt aus und endet.

Clojure, 53 Bytes

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

Sie können dies hier überprüfen:  https://ideone.com/WKS4DA

Mathematica 30 Bytes

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

Diese unbenannte Funktion quadriert alle ungeraden Zahlen, die kleiner als die Eingabe ( Range[1,Sqrt[#-1],2]) sind, und addiert sie.

PHP, 64 Bytes

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

Erweitert:

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

Bei jeder Iteration der forSchleife addiert sie 2 zu k und prüft, ob k ² kleiner ist als $i, wenn k ² zu addiert wird $a.

R, 60 Bytes

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

Entspricht genau der Beschreibung in challenge, einschließlich der Rückgabe von 0 für den Fall n = 1. Degolfed, ';' stellt einen Zeilenumbruch in R dar, der unten ignoriert wird:

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 Bytes

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

Basierend auf der C # -Lösung von @Thomas .

Erläuterung:

Probieren Sie es online aus.

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 Bytes

Dies endete kürzer als ein lambda.

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

Probieren Sie es online aus

Mein kürzestes lambda, 53 Bytes :

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