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

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.

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)))*

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.

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]]

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]

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

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

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

Água-viva , 56 43 41 29 28 bytes

2 bytes graças ao Zgarb

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

Experimente online!

Um garfo da minha resposta Jelly .

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

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.

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

Uma solução ingênua. 1 = verdadeiro, 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

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

(o mesmo resultado que para i e j )

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

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

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

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

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.

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

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

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>

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)

Dyalog APL , 19 bytes

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

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

    ⊢é 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 .

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

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 .

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.

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)

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