Escriba un programa o función para generar la suma de los números cuadrados impares (OEIS # A016754) menos que una entrada n .

Los primeros 44 números en la secuencia son:

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 fórmula para la secuencia es a(n) = ( 2n + 1 ) ^ 2.

Notas

• El comportamiento de su programa puede estar indefinido n < 1(es decir, todas las entradas válidas son >= 1).

Casos de prueba

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

Jalea, 6 bytes

½Ċ|1c3

Pruébalo en línea! o verificar todos los casos de prueba .

Antecedentes

Para todos los enteros positivos k , tenemos 1² + 3² + ⋯ + (2k - 1) ² = k (2k - 1) (2k +1) ÷ 3 .

Como hay m C r = m! ÷ ((mr)! R!) R -combinaciones de un conjunto de elementos m , lo anterior se puede calcular como (2k + 1) C 3 = (2k + 1) 2k (2k - 1) ÷ 6 = k (2k - 1) (2k + 1) ÷ 3.

Para aplicar la fórmula, debemos encontrar el 2k + 1 más alto tal que (2k - 1) ² <n . Ignorando la paridad por un momento, podemos calcular la m más alta tal que (m - 1) ² <n como m = ceil (srqt (n)) . Para incrementar condicionalmente m si es par, simplemente calcule m | 1 (bit a bit O con 1 ).

Cómo funciona

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

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

31 bytes si f(1)necesita devolver cero en lugar de falso:

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

05AB1E , 10 8 bytes

Código:

<tLDÉÏnO

Explicación:

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

Puede ser útil: t;L·<nO.

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Haskell, 30 bytes

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

Sorprendentemente de aspecto normal.

C #, 126 131 bytes

Versión editada para cumplir con la nueva pregunta:

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

Usando límite codificado:

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

Gelatina, 7

’½R²m2S

Pruébelo en línea o pruebe una versión modificada para múltiples valores

Shh ... Dennis está durmiendo ...

¡Gracias a Sp3000 en el chat por su ayuda!

Explicación:

’½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 guardó dos bytes moviéndose xa la lista de argumentos para guardar las llaves. ¡Buena idea!

Sin golf

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

Pruébalo en línea!

C, 51, 50 48 bytes

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

¿Por qué no jugar al golf en uno de los idiomas más detallados? (¡Oye, al menos no es Java!)

Pruébalo en línea!

Programa completo sin golf, con prueba de 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 realidad, 7 bytes

√K1|3@█

Pruébalo en línea!

También para 7 bytes:

3,√K1|█

Pruébalo en línea!

Utiliza la misma fórmula que en la respuesta de Dennis's Jelly.

Explicación:

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

Octava, 23 bytes

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

Pruebas:

[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

Pruébalo en línea!

Soluciones 10000 codificadas:

Solución de 12 bytes de Martin:

99,2%:)2f#1b

Mi solución original de 13 bytes:

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

Pruébalo en línea!

Pyth, 10 bytes

s<#Qm^hyd2

Banco de pruebas

Explicación:

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"

Tenga en cuenta que Mathcad usa métodos abreviados de teclado para ingresar varios operadores, incluida la definición y todos los operadores de programación. Por ejemplo, ctl-] ingresa un ciclo while; no se puede escribir y solo se puede ingresar usando el atajo de teclado o desde la barra de herramientas de Programación. Se considera que los "bytes" son la cantidad de operaciones de teclado necesarias para ingresar un elemento de Mathcad (por ejemplo, nombre de variable u operador).

Como no tengo ninguna posibilidad de ganar esta competencia, pensé en agregar un poco de variedad con una versión de fórmula directa.

Raqueta, 57 bytes

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

MATL , 10 bytes

qX^:9L)2^s

EDITAR (30 de julio de 2016): el código vinculado se reemplaza 9Lpor 1Lpara adaptarse a los cambios recientes en el idioma.

Pruébalo en línea!

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)

Si, por n=1, es válido para la salida en Falselugar de 0, entonces podemos evitar la conversión del caso base para obtener 37 bytes

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

Es extraño que no he encontrado un camino más corto para llegar 0a i*i>=ny distinto de cero de otra manera. En Python 2, uno todavía obtiene 39 bytes con

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

Basado en la fórmula de Dennis , con s==-2*k. Emite un flotador. En efecto, la entrada tiene raíz cuadrada, disminuye, luego se redondea al siguiente número par.

PARI / GP , 33 32 26 bytes

Adaptado del código de Dennis :

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

Mi primera idea (30 bytes), usando una fórmula polinómica simple:

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

Esta es una implementación eficiente, en realidad no muy diferente de la versión sin golf que escribiría:

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

Una implementación alternativa (37 bytes) que recorre cada uno de los cuadrados:

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

Otra solución alternativa (35 bytes) que demuestra la suma sin una variable temporal:

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

Otra solución, no particularmente competitiva (40 bytes), utilizando la norma L ² . Esto sería mejor si hubiera soporte para vectores con índices de tamaño de paso. (Uno podría imaginar la sintaxis n->norml2([1..((n-1)^.5+1)\2..2])que dejaría caer 8 bytes).

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)

Ejemplo de uso: (#1) 9802-> 166650.

Editar: @xnor guardó un byte, con una lista inteligente de comprensión. ¡Gracias!

Julia, 29 bytes

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

Esta es una función recursiva que acepta un entero y devuelve un entero.

Comenzamos un índice en 1 y si su cuadrado es menor que la entrada, tomamos el cuadrado y agregamos el resultado de recusar en el índice + 2, lo que garantiza que se omitan los números pares, de lo contrario devolvemos 0.

Oracle SQL 11.2, 97 bytes

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)

Esto construye el rango de todos los enteros positivos impares por debajo de n y la matriz de los cuadrados de los enteros en ese rango, luego calcula la suma de los enteros en ambos iterables.

Pruébalo en línea!

Reng v.3.3, 36 bytes

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

Pruébalo aquí!

Explicación

1: inicialización

 0#ci#m1ø

Se establece cen 0(el contador) y la entrada Ial mhacha. 1øva a la siguiente línea

2: bucle

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

:duplica el valor actual (el número impar cuadrado) y [me mpone mhacha. Usé el truco menos que en otra respuesta , que uso aquí. %:1,ecomprueba si el STOS <TOS. Si es así, q^sube y sale del bucle. De otra manera:

         c2*1+²c1+#c

cbaja el contador, lo 2*dobla, 1+agrega uno y lo ²cuadra. c1+#Cincrementosc , y el bucle va de nuevo.

3: final

        >$a+¡n~

$deja caer el último valor (mayor que el deseado), a+¡agrega hasta que la longitud de la pila es 1, n~sale y termina.

Clojure, 53 bytes

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

Puede verificarlo aquí:  https://ideone.com/WKS4DA

Mathematica 30 bytes

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

Esta función sin nombre ajusta todos los números impares menos que la entrada ( Range[1,Sqrt[#-1],2]) y los agrega.

PHP, 64 bytes

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

Expandido:

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

En cada iteración del forciclo, agregará 2 a k y verificará si k ² es menor que $i, si es agregar k ² a $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}

Hace exactamente como se describe en el desafío, incluido el retorno de 0 para el caso n = 1. Degolfed, ';' representa salto de línea en R, ignorado a continuación:

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

Residencia en solución C # de @Thomas .

Explicación:

Pruébalo en línea.

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

Esto terminó siendo más corto que a lambda.

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

Pruébalo en línea

El más corto lambda, 53 bytes :

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