Un número entero positivo kes un número de Loeschian si

• kse puede expresar como i*i + j*j + i*jpara i, jnúmeros enteros.

Por ejemplo, los primeros números positivos de Loeschian son: 1( i=1, j=0); 3( i=j=1); 4( i=2, j=0); 7( i=2, j=1); 9( i=-3, j=3); ... Tenga en cuenta que i, jpor cierto k, no son únicos. Por ejemplo, 9también pueden generarse con i=3, j=0.

Otras caracterizaciones equivalentes de estos números son:

• kse puede expresar como i*i + j*j + i*jpara i, jnúmeros enteros no negativos. (Para cada par de enteros i, jhay un par de enteros no negativos que dan lo mismo k)

• Hay un conjunto de khexágonos contiguos que forman una teselación en una cuadrícula hexagonal (ver ilustraciones para k = 4y para k = 7). (Debido a esta propiedad, estos números encuentran aplicación en redes móviles de comunicación celular ).

• Vea más caracterizaciones en la página OEIS de la secuencia.

El reto

Dado un número entero positivo , genera un resultado verdadero si es un número de Loeschian , o un resultado falso de lo contrario.

El programa o la función deben manejar (digamos en menos de un minuto) entradas hasta 1000, o hasta limitaciones de tipo de datos.

Código de golf. Las victorias más cortas.

Casos de prueba

Los siguientes números deberían generar un resultado verdadero:

1, 4, 7, 12, 13, 108, 109, 192, 516, 999

Los siguientes números deberían generar un resultado falso:

2, 5, 10, 42, 101, 102, 128, 150, 501, 1000

Jalea , 11 9 bytes

ÆF‘%3,2ḄȦ

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

Fondo

En los resultados elementales sobre la forma cuadrática binaria a² + ab + b² , el autor demuestra el siguiente teorema sobre los números de Löschian.

Teorema 16. La condición necesaria y suficiente de cualquier entero no negativo para estar en la forma a² + ab + b² es que, en su factorización prima, todos los primos distintos de 3 que no están en la forma (6k + 1) tienen incluso exponentes

Como se señaló en la página OEIS relevante , dado que todos los enteros son congruentes con 0 , 1 o 2 módulo 3 , el número 3 es el único primo congruente con 0 , y todos los números de la forma (6k + 1) son congruentes con 1 , el teorema puede expresarse alternativamente como sigue.

Un número entero no negativo n es un número de Löschian si y solo si todos los factores primos de n que son congruentes con 2 módulo 3 tienen exponentes pares.

Cómo funciona

ÆF‘%3,2ḄȦ  Main link. Argument: n (integer)

ÆF         Yield the prime factorization of n, as prime-exponent pairs.
  ‘        Increment all primes and exponents, turning primes of the form 3k - 2
           into multiples of 3 and odd exponents into multiples of 2.
   %3,2    Reduce all incremented primes/exponents modulo 3/2.
           n is Löschian if and only if this does not result in a [0, 0] pair.
           Due to Jelly's form of vectorization, this yields [3, 2] if n = 1.
       Ḅ   Unbinary; convert each pair from base 2 to integer.
           Note that [x, y] = [0, 0] if and only if 2x + y = 0.
        Ȧ  All; return 1 if the result contains no zeroes, 0 otherwise.

Retina , 66 63 45 43 36 bytes

^()(\1(?<1>.\1))+(\1(.(?(4).\4)))*$

A pesar del título que dice Retina, esta es solo una expresión regular .NET que acepta representaciones unarias de números de Loeschian.

Las entradas 999 y 1000 toman bastante menos de un segundo.

Pruébalo en línea! (La primera línea permite un conjunto de pruebas separadas por salto de línea, y las dos siguientes se encargan de la conversión a unario por conveniencia).

Explicación

La solución se basa en la clasificación de que la entrada se puede escribir como i*i + j*(i + j)positiva iy no negativa j(ya que no tenemos que manejar la entrada 0), y eso n*nes solo la suma de los primeros nenteros impares. Jugar al golf fue un ejercicio interesante en referencias avanzadas.

Una "referencia hacia adelante" es cuando coloca una referencia hacia atrás dentro del grupo al que hace referencia. Por supuesto, eso no funciona cuando el grupo se usa por primera vez, ya que no hay nada a lo que hacer referencia todavía, pero si lo coloca en un bucle, la referencia inversa obtiene la captura de la iteración anterior cada vez. Esto a su vez, le permite construir una captura más grande con cada iteración. Esto se puede usar para crear patrones muy compactos para cosas como números triangulares, cuadrados y números de Fibonacci.

Como ejemplo, usando el hecho de que los cuadrados son solo sumas de los primeros nenteros impares, podemos hacer coincidir una entrada cuadrada como esta:

(^.|..\1)+$

En la primera iteración, ..\1no puede funcionar, porque \1todavía no tiene un valor. Entonces comenzamos con la ^.captura de un solo personaje en grupo 1. En las iteraciones posteriores, ^.ya no coincide debido al ancla, pero ahora ..\1es válido. Coincide con dos caracteres más que la iteración anterior y actualiza la captura. De esta manera emparejamos números impares crecientes, obteniendo un cuadrado después de cada iteración.

Ahora, desafortunadamente, no podemos usar esta técnica tal como está. Después de hacer coincidir i*i, necesitamos obtener itambién, para poder multiplicarlo por j. Una manera simple (pero larga) de hacer esto es hacer uso del hecho de que la coincidencia i*irequiere iiteraciones, de modo que hemos capturado las icosas en grupo 1. Ahora podríamos usar grupos de equilibrio para extraer esto i, pero como dije, eso es costoso.

En cambio, descubrí una forma diferente de escribir esta "suma de enteros impares consecutivos" que también produce iun grupo de captura al final. Por supuesto, el itercer número es justo 2i-1. Esto nos da una manera de incrementar la referencia directa solo en 1 en cada iteración. Esa es esta parte:

^()(\1(?<1>.\1))+

Esto ()simplemente empuja una captura vacía al grupo 1(inicializando ia 0). Esto es bastante equivalente a la ^.|solución simple anterior, pero usar |en este caso sería un poco más complicado.

Luego tenemos el bucle principal (\1(?<1>.\1)). \1coincide con el anterior i, (?<1>.\1)luego actualiza el grupo 1con i+1. En términos de lo nuevo i , acabamos de hacer coincidir los 2i-1personajes. Exactamente lo que necesitamos.

Cuando terminamos, hemos combinado algunos cuadrados i*iy el grupo 1todavía tiene ipersonajes.

La segunda parte está más cerca de la simple coincidencia cuadrada que mostré arriba. Ignoremos la referencia a 1por ahora:

(.(?(4).\1))*

Esto es básicamente lo mismo que (^.|..\4)*, excepto que no podemos usarlo ^porque no estamos al comienzo de la cadena. En su lugar, utilizamos un condicional, para que coincida con el adicional .\1solo cuando ya hemos usado group 4. Pero en efecto esto es exactamente lo mismo. Esto nos da j*j.

Lo único que falta es el j*itérmino. Combinamos esto con el j*jhecho de que el j*jcómputo todavía toma jiteraciones. Entonces, para cada iteración también avanzamos el cursor icon \1. Solo tenemos que asegurarnos de no escribir eso en el grupo 4, porque eso podría interferir con números impares consecutivos. Así es como llegamos a:

(\1(.(?(4).\1)))*

CJam ( 16 15 bytes)

{mF{~\3%2=&},!}

Demostración en línea

Este es un bloque (una "función anónima") que toma datos en la pila y se va 0o 1en la pila. Utiliza la caracterización de que un número es Loeschian si no tiene un factor primo igual a 2 mod 3 con multiplicidad impar.

Gracias a Dennis por un ahorro de un byte.

Python 2, 56 bytes

lambda n:any(n==i*i%n+i/n*(i/n+i%n)for i in range(2*n*n))

Haskell, 42 bytes

f k=or[k==i*i+j*j+i*j|i<-[0..k],j<-[0..i]]

Ejemplo de uso: f 501-> False.

Trata todas las combinaciones de ipartir 0para ky jdesde 0a i. ordevuelve Truesi la igualdad se k==i*i+j*j+i*jcumple para al menos una de las combinaciones.

@flawr encontró una versión ligeramente diferente con el mismo número de bytes:

f k|v<-[0..k]=or[(i+j)^2==k+i*j|i<-v,j<-v]

Java 8, 81 bytes

k->{for(int i=0,j;i<=k;i++)for(j=0;j<=k;)if(i*i+j*j+i*j++==k)return 1;return 0;};

Implementación simple e ingenua. casualmente el mismo código que C # pero usa en ->lugar de =>.

Python, 67 bytes

lambda k,r=range:any(i*i+j*j+i*j==k for i in r(k+1)for j in r(k+1))

https://repl.it/Cj6x

Jalea , 15 14 13 12 bytes

1 byte gracias a millas.

²S+P
‘ṗ2’Ç€i

Pruébalo en línea!

Verifique las cajas de prueba más pequeñas .

Un consejo a la hora de realizar pruebas para grandes números (mayores de 50): no lo hagas.

La verdad es un número positivo. Falsey es cero.

Explicación

‘ṗ2’Ç€i   main chain, argument: z
‘ṗ2’      generate all pairs of numbers between 0 and z inclusive
    ǀ    apply the helper link to each pair
      i   find the index of z in the result

²S+P   helper link, argument: [x,y] (a pair of numbers)
²      compute [x*x, y*y]
 S     x*x+y*y
  +P   x*x+y*y+x*y

Medusa , 56 43 41 29 28 bytes

2 bytes gracias a Zgarb

p
n    <
+`/
`1*
/
+
&*r&;>i

Pruébalo en línea!

Un tenedor de mi respuesta de gelatina .

MATL , 14 13 bytes

t:0hU&+HM&*+m

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

Salidas 1o 0.

Explicación

t:    % Implicitly input number k. Duplicate. Generate vector [1 2 ...k]
0h    % Concatenate a 0. Gives [1 2 ... k 0]
U     % Square, element-wise. Gives [1 4 ... k^2 0]
&+    % Sum of all pairs from this vector. Gives a (k+1)×(k+1) matrix
HM    % Push [1 2 ... k 0] again
&*    % Product of all pairs from this vector. Gives a (k+1)×(k+1) matrix
+     % Add the two matrices
m     % True if k is a member of the resulting matrix. Implicitly display

Python, 49 bytes

lambda n:0in[(n-3*i*i+0j)**.5%1for i in range(n)]

Utiliza la forma cuadrática equivalente dada en OEIS de n == 3*i*i+j*j. Verifique si n-3*i*ies un cuadrado perfecto para cualquiera itomando su raíz cuadrada y verificando si es un número entero, es decir, es igual a 0 módulo 1. Tenga en cuenta que Python calcula las raíces cuadradas de cuadrados perfectos exactamente, sin error de coma flotante. Esto lo +0jconvierte en un número complejo para evitar un error en la raíz cuadrada de un negativo.

C (gcc), 71 69 bytes

i,j,r;f(n){for(r=i=n+1;i--;)for(j=n;j--;)r*=n!=i*i+j*j+i*j;return!r;}

C #, 84 82 81 bytes

k=>{for(int i=0,j;i<=k;++i)for(j=0;j<=k;)if(i*i+j*j+i*j++==k)return 1;return 0;};

Una solución ingenua. 1 = verdadero, 0 = falso

VBA, 68 67 bytes

Function L(N):For a=0To N:For b=0To a:L=L+(N=a^2+a*b+b^2):Next b,a

Búsqueda ingenua, comenzando a disminuir un poco para n = 1000. Excel reconoce el retorno cero como falso, todos los demás retornos como verdaderos.

Tenga en cuenta que no es necesaria la investigación de i y j negativos , ya que dado i> j> = 0 :

(-i) ² + (-i) (- j) + (-j) ² = i ² + ij + j ²

(el mismo resultado que para i y j )

(-i) ² + (-i) j + j ² = i ² - ij + j ²

i ² + i (-j) + (-j) ² = i ² - ij + j ²

(si uno es negativo, no importa cuál), y luego

(ij) ² + (ij) j + j ² = (i ² - 2ij + j ² ) + (ij - j ² ) + j ² = i ² - ij + j ²

Y dado que tanto (ij) como j no son negativos, cualquier generación de números de Loeschian que involucre un número negativo se puede lograr usando números no negativos.

Guardado un byte, Next:Next-> Next b,agracias a Taylor Scott.

Javascript (usando una biblioteca externa - Enumerable) (63 bytes)

k=>_.Range(0,k+1).Any(i=>_.Range(0,k+1).Any(j=>i*i+j*j+i*j==k))

Enlace a la biblioteca: https://github.com/mvegh1/ Explicación de código numerable: Cree un rango de enteros de 0 a k (llame a esto el rango "i") y pruebe si alguna "i" satisface un determinado predicado. Ese predicado crea un rango de 0 a k (llame a esto el rango "j") y prueba si alguna "j" satisface un determinado predicado. Ese predicado es la fórmula loeschiana

Perl 6 ,  52 51  50 bytes

->\k{?first ->(\i,\j){k==i*i+j*j+i*j},(0..k X 0..k)}
->\k{?grep ->(\i,\j){k==i*i+j*j+i*j},(0..k X 0..k)}

{?grep ->(\i,\j){$_==i*i+j*j+i*j},(0..$_ X 0..$_)}

Explicación:

{
  # Turn the following into a Bool
  # ( Technically not necessary as a list of 1 or more values is truthy )
  ?

  # find all where the code block returns a truthy value
  grep

  # pointy block that takes one value (list of 2 values)
  # and gives each of the values in it a name
  ->
    $ ( \i, \j )
  {
    # return true if the definition matches
    $_ == i*i + j*j + i*j
  },

  # a list of 2 element lists (possible i and j values)
  ( 0..$_ X 0..$_ )
}

Prueba:

use v6.c;
use Test;

my @true = 0, 1, 4, 7, 12, 13, 108, 109, 192, 516, 999;
my @false = 2, 5, 10, 42, 101, 102, 128, 150, 501, 1000;

plan (@true + @false) * 2;

my &is-loeschian = {?grep ->(\i,\j){$_==i*i+j*j+i*j},(0..$_ X 0..$_)}

for |(@true X True), |(@false X False) -> ( $input, $expected ) {
  my ($result,$seconds) = $input.&time-it;
  is $result, $expected, ~$input;
  cmp-ok $seconds, &[<], 60, "in $seconds seconds"
}

sub time-it ( $input ) {
  my $start = now;
  my $result = $input.&is-loeschian;
  my $finish = now;
  return ( $result, $finish - $start )
}

1..42
ok 1 - 0
ok 2 - in 0.00111763 seconds
ok 3 - 1
ok 4 - in 0.00076766 seconds
...
ok 19 - 516
ok 20 - in 0.19629727 seconds
ok 21 - 999
ok 22 - in 0.1126715 seconds
ok 23 - 2
ok 24 - in 0.0013301 seconds
ok 25 - 5
ok 26 - in 0.00186610 seconds
...
ok 37 - 150
ok 38 - in 0.83877554 seconds
ok 39 - 501
ok 40 - in 9.2968558 seconds
ok 41 - 1000
ok 42 - in 37.31434146 seconds

PowerShell v2 +, 63 56 55 bytes

param($k)(0..$k|%{0..($i=$_)|%{$i*($i+$_)+$_*$_}})-eq$k

Toma entrada $k, realiza bucles hacia arriba dos veces (bucle externo $i = 0 to $k, bucle interno $j = 0 to $i), cada iteración genera el resultado de i*i + j*j + i*j(acortado a i*(i+j) + j*j). Esos resultados se encapsulan en parens y se pasan como una matriz a -eq$k. Esto actúa como un filtro para seleccionar solo elementos que son iguales a la entrada. Emite un valor distinto de cero (el número de regreso) para la verdad, o nada (vacío) para falsey. Procesos 1000en aproximadamente 15 segundos en mi máquina.

Casos de prueba

PS C:\Tools\Scripts\golfing> (1,4,7,12,13,108,109,192,516,999|%{.\loeschian-numbers.ps1 $_})-join','
1,4,7,12,13,108,109,192,516,999

PS C:\Tools\Scripts\golfing> (2,5,10,42,101,102,128,150,501,1000|%{.\loeschian-numbers.ps1 $_})-join','

PS C:\Tools\Scripts\golfing>

Perl, 54 + 1 ( -nbandera) = 55 bytes

for$i(0..$_){for$j(0..$_){$i*$i+$j*$j+$i*$j-$_?1:say}}

Necesidades -ny -M5.010banderas para ejecutar:

perl -nE 'for$i(0..$_){for$j(0..$_){$i*$i+$j*$j+$i*$j-$_?1:say}}'

Emite algunas cosas si el número es un número de Loeschian, y nada de lo contrario.

Esta implementación es bastante aburrida, así que aquí hay otra, para 87 bytes, basada en expresiones regulares, solo para los ojos:

perl -pE '$_=(1 x$_)=~/^(.*)(??{$1x(-1+length$1)})(.*)(??{$2x(-1+length$2)})(??{$1x length$2})$/'

Tenga cuidado con este, ya que el retroceso usará mucha memoria, ¡así que no intente probar números demasiado grandes! (especialmente números que no son loeschianos)

Dyalog APL , 19 bytes

⊢∊(∘.(×-⍨2*⍨+)⍨0,⍳)

Comprueba si k ∊ ( i + j ) ² - ij , para cualquier 0 ≤ i , j ≤ k .

    ⊢es k
∊ un miembro de
    ∘.todas las combinaciones de
        × i veces j
        -⍨ restado del
        2*⍨cuadrado de
        + i más j
    ⍨ para todo i y j en
    0,cero antepuesto a
    ⍳los enteros 1 a k

1000 toma 3.3 segundos en mi M540 y aún menos en TryAPL .

Matlab, 53 52 bytes

n=input('');[a b]=ndgrid(0:n);find((a+b).^2-a.*b==n)

Búsqueda simple sobre todas las posibilidades.
Emite una matriz vacía como falso y un vector no vacío como valor verdadero.

Considerando la matriz de todos ceros como falsa y la matriz de no todos ceros como verdadera, podemos deshacernos de la findfunción que resulta en una solución de 47 46 bytes :

n=input('');[a b]=ndgrid(0:n);(a+b).^2-a.*b==n

Un byte guardado gracias a @flawr

C, 66 bytes

Llame f()con el número para probar. La función devuelve el número de soluciones que encontró.

q,r;f(n){for(r=q=0;q++<n*n;r+=n==q%n*(q%n+q/n)+q/n*q/n);return r;}

Pruébalo con ideone .

Mathematica, 44 bytes

MemberQ[(+##)^2-##&@@@0~Range~#~Tuples~2,#]&

Función sin nombre que toma un entero como entrada y devuelve Trueo False. El comando 0~Range~#~Tuples~2crea todos los pares de enteros ordenados entre 0y la entrada #. La función (+##)^2-##&calcula el cuadrado de la suma de sus argumentos menos el producto de sus argumentos; cuando se le solicitan dos argumentos iy j, esto es exactamente i^2+j^2+ijcomo se desea. Entonces esa función se llama en todas las tuplas, y luego MemberQ[...,#]verifica si la entrada es uno de los valores resultantes.

ASP, 39 + 4 = 43 bytes

o:-k=I*I+J*J+I*J;I=1..k;J=1..k.:-not o.

Salida: el problema es satisfactoria si k es Loeschian.

La programación del conjunto de respuestas es un lenguaje lógico, similar al prólogo. Utilizo aquí la implementación de Potassco , clingo .

La entrada se toma de los parámetros ( -ck=tiene 4 bytes de longitud). Ejemplo de llamada:

clingo -ck=999

Muestra de salida:

SATISFIABLE

Probado con 1000:

clingo -ck=1000

Muestra de salida:

UNSATISFIABLE

Puedes probarlo en tu navegador ; desafortunadamente, este método no maneja los indicadores de llamada, por lo que debe agregar la línea #const k=999para que funcione.

Código sin golf y explicado:

v(1..k).  % predicate v(X) holds for any X in [1..k]
o:- k=I*I+J*J+I*J ; v(I) ; v(J).  % o holds if k is Loeschian.
:- not o.  % discard models where o doesn't holds (make problem unsatisfiable)

PHP, 70 bytes

for(;$i++<$k=$argv[1];)for($j=$i+1;$j--;)$i*$i+$j*$j+$i*$j-$k?:die(1);

toma datos del argumento de la línea de comando; sale con 1para número Loeschian, con 0más.
Corre con -nr.

Descompostura

for(;$i++<$k=$argv[1];)     # loop $i from 1 to $k
    for($j=$i+1;$j--;)      # loop $j from $i to 0
        $i*$i+$j*$j+$i*$j-$k?   # if $i,$j,$k do not satisfy the equation, do nothing
        :die(1);                # else exit with return code 1
                            # implicit: exit with code 0