Écrivez un programme ou une fonction pour sortir la somme des nombres carrés impairs (OEIS # A016754) moins qu'une entrée n .

Les 44 premiers numéros de la séquence sont:

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 formule de la séquence est a(n) = ( 2n + 1 ) ^ 2.

Remarques

• Le comportement de votre programme peut être indéfini n < 1(c'est-à-dire que toutes les entrées valides le sont >= 1.)

Cas de test

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

Gelée, 6 octets

½Ċ|1c3

Essayez-le en ligne! ou vérifiez tous les cas de test .

Contexte

Pour tous les entiers positifs k , nous avons 1² + 3² + ⋯ + (2k - 1) ² = k (2k - 1) (2k +1) ÷ 3 .

Puisqu'il y a m C r = m! ÷ ((mr)! R!) R -combinaisons d'un ensemble de m éléments, ce qui précède peut être calculé comme (2k + 1) C 3 = (2k + 1) 2k (2k - 1) ÷ 6 = k (2k - 1) (2k + 1) ÷ 3.

Pour appliquer la formule, il faut trouver les 2k + 1 les plus élevés tels que (2k - 1) ² <n . En ignorant la parité pendant un moment, nous pouvons calculer le plus haut m tel que (m - 1) ² <n comme m = ceil (srqt (n)) . Pour incrémenter conditionnellement m s'il est pair, il suffit de calculer m | 1 (OR au niveau du bit avec 1 ).

Comment ça fonctionne

½Ċ|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 octets

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

31 octets si f(1)doit retourner zéro au lieu de faux:

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

05AB1E , 10 8 octets

Code:

<tLDÉÏnO

Explication:

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

Peut - être pratique: t;L·<nO.

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Haskell, 30 octets

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

Étonnamment normal.

C #, 126 131 octets

Version éditée pour se conformer à la nouvelle question:

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

Utilisation d'une limite codée en dur:

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

Gelée, 7

’½R²m2S

Essayez-le en ligne ou essayez une version modifiée pour plusieurs valeurs

Chut ... Dennis dort ...

Merci à Sp3000 dans le chat pour leur aide!

Explication:

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

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

@Giuseppe a enregistré deux octets en se déplaçant xdans la liste des arguments pour enregistrer les accolades. Idée sympa!

Non golfé

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

Essayez-le en ligne!

C, 51, 50 48 octets

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

Parce que pourquoi ne pas jouer au golf dans l'une des langues les plus verbeuses? (Hé, au moins ce n'est pas Java!)

Essayez-le en ligne!

Programme complet non golfé, avec test E / S:

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

En fait, 7 octets

√K1|3@█

Essayez-le en ligne!

Aussi pour 7 octets:

3,√K1|█

Essayez-le en ligne!

Cela utilise la même formule que dans la réponse Jelly de Dennis.

Explication:

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

Octave, 23 octets

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

Essai:

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

CJam, 15 octets

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

Essayez-le en ligne!

Solutions 10000 codées en dur:

Solution de 12 octets de Martin:

99,2%:)2f#1b

Ma solution originale de 13 octets:

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

Essayez-le en ligne!

Pyth, 10 octets

s<#Qm^hyd2

Suite de tests

Explication:

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

Notez que Mathcad utilise des raccourcis clavier pour entrer plusieurs opérateurs, y compris la définition et tous les opérateurs de programmation. Par exemple, ctl-] entre dans une boucle while - elle ne peut pas être saisie et ne peut être saisie qu'à l'aide du raccourci clavier ou de la barre d'outils de programmation. Les "octets" sont considérés comme le nombre d'opérations au clavier nécessaires pour entrer un élément Mathcad (par exemple, le nom de la variable ou l'opérateur).

Comme je n'ai aucune chance de gagner ce concours, j'ai pensé ajouter un peu de variété avec une version formule directe.

Raquette, 57 octets

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

MATL , 10 octets

qX^:9L)2^s

EDIT (30 juillet 2016): le code lié remplace 9Lpar 1Lpour s'adapter aux évolutions récentes de la langue.

Essayez-le en ligne!

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 octets

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

Si, pour n=1, il est valide de sortir Falseplutôt que 0, alors nous pouvons éviter la conversion du cas de base pour obtenir 37 octets

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

Il est étrange que je ne l' ai pas trouvé un moyen plus court pour obtenir 0pour i*i>=net non nulle par ailleurs. En Python 2, on obtient toujours 39 octets avec

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

Python, 42 38 octets

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

Python 2, 38 octets

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

Basé sur la formule de Dennis , avec s==-2*k. Sort un flottant. En effet, l'entrée est enracinée au carré, décrémentée, puis arrondie au nombre pair suivant.

PARI / GP , 33 32 26 octets

Adapté du code de Dennis :

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

Ma première idée (30 octets), en utilisant une formule polynomiale simple:

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

Il s'agit d'une implémentation efficace, en fait pas très différente de la version non golfée que j'écrirais:

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

Une implémentation alternative (37 octets) qui fait une boucle sur chacun des carrés:

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

Une autre solution alternative (35 octets) démontrant la sommation sans variable temporaire:

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

Encore une autre solution, pas particulièrement compétitive (40 octets), utilisant la norme L ² . Ce serait mieux s'il y avait un support pour les vecteurs avec des indices de taille de pas. (On pourrait imaginer la syntaxe n->norml2([1..((n-1)^.5+1)\2..2])qui laisserait tomber 8 octets.)

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

Haskell, 32 31 octets

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

Exemple d'utilisation: (#1) 9802 ->166650 .

Edit: @xnor a enregistré un octet, avec une compréhension de liste intelligente. Merci!

Julia, 29 octets

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

Il s'agit d'une fonction récursive qui accepte un entier et renvoie un entier.

Nous commençons un index à 1 et si son carré est inférieur à l'entrée, nous prenons le carré et ajoutons le résultat de la récusation sur l'index + 2, ce qui garantit que les nombres pairs sont ignorés, sinon nous retournons 0.

Oracle SQL 11.2, 97 octets

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 octets

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

Ceci construit la plage de tous les entiers impairs positifs ci-dessous n et le tableau des carrés des entiers dans cette plage, puis calcule la somme des entiers dans les deux itérables.

Essayez-le en ligne!

Reng v.3.3, 36 octets

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

Essayez-le ici!

Explication

1: initialisation

 0#ci#m1ø

Définit csur 0(le compteur) et l'entrée Isur la mhache.1øpasse à la ligne suivante.

2: boucle

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

:duplique la valeur actuelle (le nombre impair au carré) et [je mmets mhache vers le bas. J'ai utilisé l'astuce moins que dans une autre réponse , que j'utilise ici. %:1,evérifie si le STOS <TOS. Si c'est le cas, q^monte et sort de la boucle. Autrement:

         c2*1+²c1+#c

cpose le compteur, le 2*double, en 1+ajoute un et le met au ²carré. c1+#Cincrémentsc , et la boucle recommence.

3: finale

        >$a+¡n~

$supprime la dernière valeur (supérieure à celle souhaitée), a+¡ajoute jusqu'à ce que la longueur de la pile soit 1,n~ sort et se termine.

Clojure, 53 octets

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

Vous pouvez le vérifier ici:  https://ideone.com/WKS4DA

Mathematica 30 octets

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

Cette fonction sans nom met au carré tous les nombres impairs de moins que l'entrée ( Range[1,Sqrt[#-1],2]) et les ajoute.

PHP, 64 octets

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

Étendu:

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

À chaque itération de la forboucle, il ajoutera 2 à k et vérifiera si k ² est inférieur à $i, s'il ajoute k ² à $a.

R, 60 octets

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

Fait exactement comme décrit dans le défi, y compris retourner 0 pour le cas n = 1. Dégolfé, ';' représente un saut de ligne dans R, ignoré ci-dessous:

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 117 111 49 octets

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

Basé sur la solution C # de @Thomas .

Explication:

Essayez-le en ligne.

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 octets

Cela a fini par être plus court qu'un lambda.

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

Essayez-le en ligne

Mon plus court lambda, 53 octets :

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