Este é o número Loeschian?

33

Um número inteiro positivo ké um número Loeschiano se

  • kpode ser expressa como i*i + j*j + i*jpara i, jinteiros.

Por exemplo, os primeiros números loeschianos positivos são: 1( i=1, j=0); 3( i=j=1); 4( i=2, j=0); 7( i=2, j=1); 9( i=-3, j=3); ... Observe que i, jpara um dado, knão são únicos. Por exemplo, 9pode também ser gerado com i=3, j=0.

Outras caracterizações equivalentes desses números são:

  • kpode ser expresso como i*i + j*j + i*jpara i, jinteiros não negativos. (Para cada par de números inteiros i, jhá um par de números inteiros não negativos que fornece o mesmo k)

  • Existe um conjunto de khexágonos contíguos que formam um mosaico em uma grade hexagonal (veja ilustrações para k = 4e para k = 7). (Devido a essa propriedade, esses números encontram aplicação nas redes de comunicação celular móvel .)

  • Veja mais caracterizações na página OEIS da sequência.

O desafio

Dado um número inteiro positivo , produza um resultado verdade, se for um número Loeschiano , ou um resultado falso, caso contrário.

O programa ou função deve manipular (digamos em menos de um minuto) entradas até 1000ou até limitações de tipo de dados.

Código de golfe. Vitórias mais curtas.

Casos de teste

Os seguintes números devem gerar um resultado verdadeiro:

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

Os seguintes números devem gerar um resultado falso:

2, 5, 10, 42, 101, 102, 128, 150, 501, 1000
Luis Mendo
fonte
Relacionados (como observado por @PeterTaylor)
Luis Mendo
observação para o algoritmo de força bruta: se você iterar para √k, reduz a complexidade do algoritmo de O (n²) para O (n), à custa de alguns bytes c;
Rod
i, j non-negative integersou 9 (i=-3, j=3)- qual é?
Titus
1
@ Titus Oh, agora eu vejo. Para cada par de inteiros i, j há um par não-negativa que dá a mesma k
Luis Mendo

Respostas:

17

Geléia , 11 9 bytes

ÆF‘%3,2ḄȦ

Experimente online! ou verifique todos os casos de teste .

fundo

Nos resultados elementares da forma quadrática binária a² + ab + b² , o autor prova o seguinte teorema sobre números de Löschian.

Teorema 16. A condição necessária e suficiente de qualquer número inteiro não negativo para estar na forma a² + ab + b² é que, em sua fatoração primária, todos os números primos diferentes de 3 que não estão na forma (6k + 1) tenham expoentes.

Como observado na página relevante do OEIS , como todos os números inteiros são congruentes a 0 , 1 ou 2 do módulo 3 , o número 3 é o único primo que é congruente a 0 , e todos os números da forma (6k + 1) são congruentes a 1 , o teorema pode ser afirmado alternativamente da seguinte forma.

Um número inteiro não negativo n é um número Löschiano se, e somente se, todos os fatores primos de n que são congruentes a 2 módulo 3 tiverem expoentes pares.

Como 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
fonte
17

Retina , 66 63 45 43 36 bytes

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

Apesar do título dizer Retina, este é apenas um regex .NET simples que aceita representações unárias de números Loeschianos.

As entradas 999 e 1000 demoram menos de um segundo.

Experimente online! (A primeira linha permite um conjunto de testes separado por avanço de linha, e as próximas duas cuidam da conversão para unárias por conveniência.)

Explicação

A solução é baseada na classificação de que a entrada pode ser escrita como i*i + j*(i + j)positiva ie não negativa j(já que não precisamos lidar com entrada 0), e essa n*né apenas a soma dos primeiros nnúmeros inteiros ímpares. Jogar golfe foi um exercício interessante nas referências futuras.

Uma "referência direta" é quando você coloca uma referência retroativa dentro do grupo a que se refere. É claro que isso não funciona quando o grupo é usado pela primeira vez, pois ainda não há nada a ser referenciado novamente, mas se você colocar isso em um loop, a referência anterior receberá a captura da iteração anterior a cada vez. Por sua vez, vamos criar uma captura maior a cada iteração. Isso pode ser usado para criar padrões muito compactos para coisas como números triangulares, quadrados e números de Fibonacci.

Como exemplo, usando o fato de que os quadrados são apenas somas dos primeiros nnúmeros inteiros ímpares, podemos combinar uma entrada quadrada como esta:

(^.|..\1)+$

Na primeira iteração, ..\1não pode funcionar, porque \1ainda não tem um valor. Então começamos com a ^.captura de um único personagem em grupo 1. Nas iterações subseqüentes, ^.não corresponde mais devido à âncora, mas agora ..\1é válido. Ele corresponde a mais dois caracteres que a iteração anterior e atualiza a captura. Dessa forma, combinamos números ímpares crescentes, obtendo um quadrado após cada iteração.

Agora, infelizmente, não podemos usar essa técnica como está. Após a correspondência i*i, precisamos obtê-lo itambém, para que possamos multiplicá-lo j. Uma maneira simples (mas longa) de fazer isso é usar o fato de que a correspondência i*iexige iiterações, para que capturemos as icoisas em grupo 1. Agora poderíamos usar grupos de balanceamento para extrair isso i, mas como eu disse, isso é caro.

Em vez disso, descobri uma maneira diferente de escrever essa "soma de números inteiros ímpares consecutivos" que também resulta iem um grupo de captura no final. Claro que o inúmero ímpar é justo 2i-1. Isso nos permite aumentar a referência direta apenas 1 em cada iteração. Essa é essa parte:

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

Isso ()apenas envia uma captura vazia para o grupo 1(inicializando ipara 0). Isso é praticamente equivalente ao da ^.|solução simples acima, mas usar |neste caso seria um pouco mais complicado.

Então nós temos o loop principal (\1(?<1>.\1)). \1corresponde ao anterior i, (?<1>.\1)em seguida, atualiza grupo 1com i+1. Em termos do novo i , acabamos de combinar 2i-1personagens. Exatamente o que precisamos.

Quando terminamos, combinamos algum quadrado i*ie o grupo 1ainda possui icaracteres.

A segunda parte está mais próxima da correspondência quadrada simples que mostrei acima. Vamos ignorar a referência anterior 1por enquanto:

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

É basicamente o mesmo que (^.|..\4)*, exceto que não podemos fazer uso ^porque não estamos no início da string. Em vez disso, usamos um condicional, para corresponder ao adicional .\1somente quando já usamos o grupo 4. Mas, na verdade, isso é exatamente o mesmo. Isso nos dá j*j.

A única coisa que falta é o j*itermo. Combinamos isso com o j*juso do fato de que a j*jcomputação ainda faz jiterações. Portanto, para cada iteração, também avançamos o cursor icom \1. Só precisamos ter certeza de não escrever isso em grupo 4, porque isso interferiria na correspondência de números ímpares consecutivos. É assim que chegamos ao:

(\1(.(?(4).\1)))*
Martin Ender
fonte
2
Quanto mais vezes leio isso, menos compreendo. Eu realmente quero saber que muitos regex
Javier Diaz
@JavierDiaz Há uma série de postagens explicando referências futuras no Stack Overflow, com base no regex Java. Os exemplos são provavelmente um pouco mais simples.
Martin Ender
13

CJam ( 16 15 bytes)

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

Demonstração online

Este é um bloco (uma "função anônima") que recebe entrada na pilha e sai 0ou 1na pilha. Ele usa a caracterização de que um número é Loeschiano se não tiver um fator primo igual a 2 mod 3 com multiplicidade ímpar.

Agradecemos a Dennis pela economia de um byte.

Peter Taylor
fonte
Uau, boa caracterização!
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
fonte
6

Haskell, 42 bytes

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

Exemplo de uso: f 501-> False.

Tenta todas as combinações de ipartir 0para ke jdesde 0a i. orretorna Truese a igualdade k==i*i+j*j+i*jé válida para pelo menos uma das combinações.

O @flawr encontrou uma versão ligeiramente diferente com a mesma contagem de bytes:

f k|v<-[0..k]=or[(i+j)^2==k+i*j|i<-v,j<-v]
nimi
fonte
Eu não sabia or, legal =) Talvez você tenha uma idéia de como jogar este fraseado alternativo f k|v<-[0..k]=or[(i+j)^2==k+i*j|i<-v,j<-v]:?
flawr
@ flawr: não, não faço ideia de como jogar sua versão mais abaixo. Se você não se importa, vou adicioná-lo à minha resposta como uma versão alternativa.
N
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;};

implementação simples e ingênua. coincidentemente o mesmo código que o C #, mas usa em ->vez de =>.

Justin
fonte
Três bytes a menos porque você pode omitir as chaves e o final ;. DROGA!
TheLethalCoder
@TheLethalCoder Na verdade, não posso, cometi um erro - a mesma contagem de bytes que o C #.
23416 Justin Justin
Me faz sentir melhor de qualquer maneira :)
TheLethalCoder
Isso não parece ser negativo iou j.
Titus
4

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

atlasologist
fonte
4

Geléia , 15 14 13 12 bytes

1 byte graças a milhas.

²S+P
‘ṗ2’Ç€i

Experimente online!

Verifique as caixas de teste menores .

Um conselho ao testar números grandes (maiores que 50): não.

Verdade é um número positivo. Falsey é zero.

Explicação

‘ṗ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
Freira Furada
fonte
Amarrado (para) agora ... :-)
Luis Mendo
Devemos explorar a caracterização de Pedro ...?
Luis Mendo
@LuisMendo Isso parece interessante, mas parece que seria mais
Leaky Nun
Eu não acho que você precisa achatá-lo. Seu link auxiliar já mapeia de tuplas para números inteiros.
milhas
@miles Isso é inteligente, obrigado.
Leaky Nun
3

MATL , 14 13 bytes

t:0hU&+HM&*+m

Experimente online! Ou verifique todos os casos de teste .

Saídas 1ou 0.

Explicação

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
fonte
Você acabou de jogar Jelly?
Leaky Nun
@LeakyNun Vamos ver quanto tempo dura. Talvez eu deva atrasar um pouco a explicação do código :-P
Luis Mendo
Não. - - - - -
Leaky Nun
Sua vez - - -
Leaky Nun
@LeakyNun Aw :-( Agora eu posso acrescentar a explicação :-)
Luis Mendo
3

Python, 49 bytes

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

Usa a forma quadrática equivalente dada no OEIS de n == 3*i*i+j*j. Verifique se n-3*i*ié um quadrado perfeito para qualquer um i, pegando sua raiz quadrada e verificando se é um número inteiro, ou seja, igual a 0 módulo 1. Observe que o Python calcula exatamente as raízes quadradas dos quadrados perfeitos, sem erro de ponto flutuante. O +0jfaz com que seja um número complexo para evitar um erro na raiz quadrada de um negativo.

xnor
fonte
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
fonte
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 5/08
Isso não parece ser negativo iou j.
Titus
@Titus A questão dita não-negativo ie j.
orlp 6/01/19
positivo k, mas não ie j. Dê uma olhada nos exemplos.
Titus
@Titus Citando o desafio: " kpode ser expresso como i*i + j*j + i*jpara números inteiros i, j não negativos ". Você olha mais de perto.
orlp 6/01/19
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;};

Uma solução ingênua. 1 = verdadeiro, 0 = falso

TheLethalCoder
fonte
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

Pesquisa ingênua, começando a desacelerar levemente para n = 1000. O Excel reconhece retorno zero como falso, todos os outros retornos como verdade.

Note-se que a investigação de negativo i e j não é necessário, uma vez determinado i> j> = 0 :

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

(o mesmo resultado que para i e j )

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

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

(se um for negativo, não importa qual) e, em seguida,

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

E uma vez que ambos (i, j) e j são não-negativo, qualquer geração de números Loeschian envolvendo um número negativo pode ser conseguido usando números não-negativos.


Salvo um byte, Next:Next-> Next b,agraças a Taylor Scott.

Joffan
fonte
Isso não parece ser negativo iou j.
Titus
Veja o primeiro ponto em "Outras caracterizações equivalentes". Observe que todos os casos de teste aparecem corretamente. Vou adicionar a justificativa matemática à minha resposta (se eu puder).
Joffan
Desculpe minha culpa. Leia em excesso que isso não é necessário.
Titus
@Joffan você pode condensar Next:NextparaNext b,a
Taylor Scott
@Joffan olhando para a sua solução, talvez, que é por causa de uma falta :End Functionno final da sua solução
Taylor Scott
1

Javascript (usando biblioteca externa - Enumerável) (63 bytes)

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

Link para a biblioteca: https://github.com/mvegh1/Explicação do código numeroso: Crie um intervalo de números inteiros de 0 a k (chame isso de intervalo "i") e teste se algum "i" satisfaz um determinado predicado. Esse predicado cria um intervalo de 0 a k (chame isso de "j") e testa se algum "j" satisfaz um determinado predicado. Esse predicado é a fórmula loeschiana

insira a descrição da imagem aqui

applejacks01
fonte
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..$_)}

Explicação:

{
  # 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..$_ )
}

Teste:

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
fonte
Isso não parece ser negativo iou j.
Titus
@Titus the (0..$_ X 0..$_)produz uma lista vazia se $_for menor que 0, portanto, não há necessidade de verificar se há negativos ie jporque eles nunca serão negativos. Como é suposto produzir apenas Trueum número loeschiano positivo, não preciso fazer nada de especial pelo caso negativo.
Brad Gilbert b2gills
9 = (3*3)+(-3*-3)+(3*-3)é um loeschiano positivo i=3, j=-3; MAS eu li demais que todo número Loeschiano não é negativo ie j. Portanto, não é necessário procurar números negativos. Então, na verdade, poderíamos excluir esses comentários. Desculpe por incomodar; minha culpa.
Titus
@Titus modificando o código para {grep ->(\i,\j){$_==i*i+j*j+i*j},(-$_..$_ X -$_..$_)}(9)resultar em ((-3,0),(-3,3),(0,-3),(0,3),(3,-3),(3,0)). Honestamente, eu provavelmente apenas o adaptei de outras respostas.
Brad Gilbert b2gills
1

PowerShell v2 +, 63 56 55 bytes

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

Recebe entrada $k, volta duas vezes para cima (loop externo $i = 0 to $k, loop interno $j = 0 to $i), cada iteração gera o resultado de i*i + j*j + i*j(abreviado para i*(i+j) + j*j). Esses resultados são encapsulados em parênteses e passados ​​como uma matriz para -eq$k. Isso atua como um filtro para selecionar apenas elementos que sejam iguais à entrada. Emite um valor diferente de zero (o número anterior) para verdade ou nada (vazio) para falsey. Processa 1000em cerca de 15 segundos na minha máquina.

Casos de teste

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
fonte
1

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

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

Necessidades -ne -M5.010sinalizadores para executar:

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

Produz alguns materiais se o número for um número Loeschiano e nada de outra maneira.

Essa implementação é bastante chata, então aqui está outra, de 87 bytes, baseada em regex, apenas para os olhos:

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

Cuidado com este, pois o retorno usa muita memória; portanto, não tente testar números muito grandes! (especialmente números que não são loeschianos)

dada
fonte
1

Dyalog APL , 19 bytes

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

Verifica se k ∊ ( i + j ) ² - ij , para qualquer 0 ≤ i , jk .

    é k
um membro de
    ∘.todas as combinações de
        × i vezes j
        -⍨ subtraídas do
        2*⍨quadrado de
        + i mais j
     para todos os i e j em
    0,zero prefixados aos
    números inteiros 1 a k

1000 demora 3,3 segundos no meu M540 e menos ainda no TryAPL .

Adão
fonte
1

Matlab, 53 52 bytes

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

Pesquisa simples sobre todas as possibilidades.
Gera um array vazio como falso e um vetor não vazio como valor de verdade.

Considerando a matriz all-zeros como falsy e a matriz not-all-zeros como verdade, podemos nos livrar da findfunção que resulta na solução de 47 46 bytes :

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

Um byte salvo graças a @flawr

pajonk
fonte
1
(a+b).^2-a.*b==né mais curto.
flawr
1

C, 66 bytes

Ligue f()com o número para testar. A função retorna o número de soluções encontradas.

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

Experimente em ideone .

owacoder
fonte
1

Mathematica, 44 bytes

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

Função sem nome, tendo um número inteiro como entrada e retornando Trueou False. O comando 0~Range~#~Tuples~2cria todos os pares ordenados de números inteiros entre 0e a entrada #. A função (+##)^2-##&calcula o quadrado da soma de seus argumentos menos o produto de seus argumentos; quando chamado em dois argumentos ie j, é exatamente i^2+j^2+ijcomo desejado. Portanto, essa função é chamada em todas as tuplas e MemberQ[...,#]verifica se a entrada é um dos valores resultantes.

Greg Martin
fonte
1

ASP, 39 + 4 = 43 bytes

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

Saída: o problema é satisfatório se k for Loeschiano.

Conjunto de respostas A programação é uma linguagem lógica, semelhante ao prólogo. Eu uso aqui a implementação do Potassco , clingo .

A entrada é obtida dos parâmetros ( -ck=tem 4 bytes). Exemplo de chamada:

clingo -ck=999

Amostra de saída:

SATISFIABLE

Tentei com 1000:

clingo -ck=1000

Amostra de saída:

UNSATISFIABLE

Você pode experimentá-lo no seu navegador ; infelizmente, esse método não trata de sinalizadores de chamada, então você precisa adicionar a linha #const k=999para fazê-la funcionar.


Código não explicado e 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
fonte
1

PHP, 70 bytes

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

recebe entrada do argumento da linha de comando; sai com 1para o número Loeschiano, com 0mais.
Corra com -nr.

demolir

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
fonte