¿Es este número Loeschian?

33

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
Luis Mendo
fuente
Relacionado (como señaló @PeterTaylor)
Luis Mendo
nota para el algoritmo de fuerza bruta: si itera a √k reduce la complejidad del algoritmo de O (n²) a O (n), a expensas de algunos bytes c;
Rod
i, j non-negative integerso 9 (i=-3, j=3), ¿cuál es?
Titus
1
@Titus Oh, ahora veo. Para cada par de enteros i, j hay un par no negativo que da el mismo k
Luis Mendo

Respuestas:

17

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.
Dennis
fuente
17

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)))*
Martin Ender
fuente
2
Cuanto más leo esto, menos entiendo. Tengo muchas ganas de saber que muchas expresiones regulares
Javier Díaz
@JavierDiaz Hay una serie de publicaciones que explican las referencias futuras en Stack Overflow, basadas en expresiones regulares Java. Los ejemplos allí son probablemente un poco más simples.
Martin Ender
13

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.

Peter Taylor
fuente
¡Guau, buena caracterización!
Luis Mendo
6

Python 2, 56 bytes

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

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]
nimi
fuente
No sabía or, cool =) Quizás tengas una idea de cómo jugar a este fraseo alternativo f k|v<-[0..k]=or[(i+j)^2==k+i*j|i<-v,j<-v]:?
error
@flawr: no, no tengo idea de cómo jugar golf tu versión más abajo. Si no le importa, lo agregaré a mi respuesta como una versión alternativa.
nimi
5

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

Justin
fuente
Tres bytes menos porque puedes omitir las llaves y el final ;. ¡MALDITA SEA!
TheLethalCoder
@TheLethalCoder En realidad no puedo, cometí un error: el mismo número de bytes que C #.
Justin
Me hace sentir mejor de todos modos :)
TheLethalCoder
Esto no parece resultar negativo io j.
Titus
4

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
Monja permeable
fuente
Atado (por) ahora ... :-)
Luis Mendo el
¿Deberíamos explotar la caracterización de Peter ...?
Luis Mendo el
@LuisMendo Eso parece interesante, pero parece que sería más largo
Leaky Nun
No creo que necesites aplanarlo. Su enlace de ayuda ya se asigna de tuplas a enteros.
millas
@miles Eso es inteligente, gracias.
Leaky Nun
3

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
Luis Mendo
fuente
¿Acabas de jugar golf Jelly?
Leaky Nun
@LeakyNun Veamos cuánto dura. Tal vez retrasaré un poco la explicación del código :-P
Luis Mendo
No - - - - -
Leaky Nun
Tu turno - - -
Leaky Nun
@LeakyNun Aw :-( Ahora puedo agregar la explicación :-)
Luis Mendo
3

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.

xnor
fuente
3

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;}
orlp
fuente
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;}.
owacoder
Esto no parece resultar negativo io j.
Titus
@Titus La pregunta dicta no negativa iy j.
orlp
positivo k, pero no iy j. Mire más de cerca los ejemplos.
Titus
@Titus Cita del desafío: " kse puede expresar como i*i + j*j + i*jpara enteros i, j no negativos ". Usted toma una mirada más cercana.
orlp
2

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

TheLethalCoder
fuente
2

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) 2 + (-i) (- j) + (-j) 2 = i 2 + ij + j 2

(el mismo resultado que para i y j )

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

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

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

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

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.

Joffan
fuente
Esto no parece resultar negativo io j.
Titus
Consulte el primer punto en "Otras caracterizaciones equivalentes". Tenga en cuenta que todos los casos de prueba aparecen correctamente. Agregaré la justificación matemática a mi respuesta (si puedo).
Joffan
Disculpa, mi error. Overread que eso no es necesario.
Titus
@Joffan puede condensar Next:NextaNext b,a
Taylor de Scott
@Joffan está buscando su solución nuevamente, tal vez se deba a una falta :End Functional final de su solución
Taylor Scott
1

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

ingrese la descripción de la imagen aquí

applejacks01
fuente
1

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
Brad Gilbert b2gills
fuente
Esto no parece resultar negativo io j.
Titus
@Titus the (0..$_ X 0..$_)produce una lista vacía si $_es menor que 0, por lo que no hay necesidad de verificar si es negativo iy jporque nunca serán negativos. Como solo se supone que produce Trueun número Loeschian positivo, no tengo que hacer nada especial para el caso negativo.
Brad Gilbert b2gills
9 = (3*3)+(-3*-3)+(3*-3)es un Loeschian positivo con i=3, j=-3; PERO sobrepasé que cada número de Loeschian tiene no negativo iy j. Por lo tanto, no es necesario buscar números negativos. Entonces, de hecho, podríamos eliminar esos comentarios. Perdón por molestar; mi culpa.
Titus
@Titus modificando el código a {grep ->(\i,\j){$_==i*i+j*j+i*j},(-$_..$_ X -$_..$_)}(9)resultados ((-3,0),(-3,3),(0,-3),(0,3),(3,-3),(3,0)). Honestamente, probablemente lo acabo de adaptar de otras respuestas.
Brad Gilbert b2gills
1

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>
AdmBorkBork
fuente
1

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)

Dada
fuente
1

Dyalog APL , 19 bytes

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

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

    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 .

Adán
fuente
1

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

pajonk
fuente
1
(a+b).^2-a.*b==nEs más corto.
error
1

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 .

owacoder
fuente
1

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.

Greg Martin
fuente
1

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)
aluriak
fuente
1

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
Titus
fuente