Pozitif bir tam sayı ka, Loeschian sayı ise

• kolarak ifade edilebilir i*i + j*j + i*jiçin i, jtam sayı.

Örneğin, ilk pozitif Loeschian sayıları: 1( i=1, j=0); 3( i=j=1); 4( i=2, j=0); 7( i=2, j=1); 9( i=-3, j=3); ... unutmayın i, jverilen için kbenzersiz değildir. Örneğin, 9aynı zamanda ile üretilebilir i=3, j=0.

Bu sayıların diğer eşdeğer karakteristikleri şunlardır:

• kolarak ifade edilebilir i*i + j*j + i*jiçin i, jnegatif olmayan tam. (Tamsayı her çifti için i, jaynı veren negatif olmayan tam bir çift var k)

• kAltıgen bir ızgara üzerinde bir kaplama oluşturan bir dizi bitişik altıgen vardır (bkz . k = 4Ve for k = 7). (Bu özellik nedeniyle, bu numaralar mobil hücresel iletişim ağlarında uygulama bulur .)

• Dizinin OEIS sayfasındaki karakterizasyonlara bakın .

Meydan okuma

Bir Verilen pozitif tam bir truthy sonuç çıktı, bu bir Loeschian sayı ise , ya da başka bir falsy sonucu.

Program veya işlev (bir dakikadan daha az bir sürede) 1000veri türü sınırlamalarına kadar veya en fazla girişleri işlemelidir.

Kod golfü. En kısa kazançlar.

Test durumları

Aşağıdaki numaralar gerçek bir sonuç vermelidir:

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

Aşağıdaki sayılar sahte sonuç vermelidir:

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

Jöle , 11 9 bayt

ÆF‘%3,2ḄȦ

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Arka fon

Gelen ikili kuadratik formda İlköğretim sonuçların + ab + b² a² , yazar Löschian sayılarla ilgili aşağıdaki teoremi ispatlar.

Teorem 16. a² + ab + b² formunda olmak üzere negatif olmayan bir tamsayı için gereken ve yeterli şart , asal çarpanlara ayırma biçiminde, 3 dışındaki tüm asallerin (6k + 1) eşit olmayan üsteller.

İlgili üzerinde belirtildiği gibi OEIS sayfa tüm tamsayılar uyumlu üzeresiniz olduğundan, 0 , 1 veya 2 modül 3 , sayı 3 ile uyumlu olduğunu sadece asal 0 ve formun tüm sayılar (+ 1 6k) için uyumlu olan 1 , teorem alternatif olarak aşağıdaki gibi ifade edilebilir.

Bir negatif olmayan bir tamsayı , n ve her ana faktörler sadece eğer Löschian sayıdır , n için uyumlu olan 2 modülo 3 hatta üs sahiptir.

Nasıl çalışır

Æ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 bayt

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

Retina isminin başlığına rağmen, bu sadece Loeschian sayılarının sıradışı temsilini kabul eden basit bir .NET regex .

999 ve 1000 girişleri bir saniyenin altında bir sürede başarılı.

Çevrimiçi deneyin! (İlk satır, satır besleme ile ayrılmış bir test takımını etkinleştirir ve sonraki iki kolaylık sağlamak için birliğe dönüşmeye özen gösterir.)

açıklama

Çözüm, girdinin hem i*i + j*(i + j)olumlu ihem de olumsuz olmayanlar için yazılabileceği sınıflamasına dayanmaktadır j(çünkü girdiyi tutmak zorunda değiliz 0) ve bu n*nsadece ilk ntek tamsayıların toplamıdır . Golf oynamak, ileriye dönük referanslarda ilginç bir egzersizdi.

Bir "ileri referans", başvurduğu grubun içine bir geri referans yerleştirdiğiniz zamandır. Elbette, grup ilk kez kullanıldığında işe yaramaz, çünkü henüz geri dönülecek bir şey yoktur, ancak bunu bir döngüye koyarsanız, geri dönüş her seferinde önceki yinelemenin yakalanmasını sağlar. Bu da, her yineleme ile daha büyük bir yakalamanızı sağlar. Bu, üçgen sayılar, kareler ve Fibonacci sayıları gibi şeyler için çok kompakt desenler oluşturmak için kullanılabilir.

Örnek olarak, karelerin sadece ilk ngarip tam sayıların toplamı olduğu gerçeğini kullanarak şöyle bir kare girişini eşleştirebiliriz:

(^.|..\1)+$

İlk tekrarda, ..\1çalışamaz, çünkü \1henüz bir değeri yok. Böylece ^.gruba tek bir karakter çekerek başlıyoruz 1. Sonraki yinelemelerde, ^.çapa nedeniyle artık eşleşme olmaz, ancak şimdi ..\1geçerlidir. Önceki yinelemeden iki karakter daha eşleşir ve yakalamayı günceller. Bu şekilde, her bir yinelemeden sonra bir kare alarak, artan tek sayıları eşleştiriyoruz.

Şimdi ne yazık ki, bu tekniği olduğu gibi kullanamıyoruz. Eşleştirdikten sonra i*i, onu da çarpmamız için iiyi yapmamız gerekir j. Bunu yapmanın basit (ama uzun) bir yolu, eşleştirmenin yinelemeler i*ialması gerçeğini kullanmak i, böylece igruptaki şeyleri yakaladık 1. Şimdi bunu çıkarmak için dengeleme gruplarını kullanabiliriz i, ancak dediğim gibi pahalı.

Bunun yerine, isonunda bir yakalama grubunda da ortaya çıkan “ardışık tuhaf tam sayıların toplamını” yazmanın farklı bir yolunu buldum . Tabii ki itek sayı sadece 2i-1. Bu bize ileri referansı her bir yinelemede sadece 1 arttırmak için bir yol sunar. Bu kısım:

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

Bu ()sadece boş bir yakalamayı gruba iter 1(başlangıç iolarak 0). Bu, ^.|yukarıdaki basit çözümde hemen hemen eşdeğerdir , ancak |bu durumda kullanmak biraz zor olabilir.

O zaman ana döngümüz var (\1(?<1>.\1)). \1Bir önceki maçları i, (?<1>.\1)sonra grup günceller 1ile i+1. Açısından yeni i , sadece eşleştirdiğimizde 2i-1karakterleri. Tam olarak ihtiyacımız olan şey.

İşimiz bittiğinde, bir kareyi eşleştirdik i*ive grup 1hala ikarakter tutuyor .

İkinci kısım yukarıda gösterdiğim basit kare eşleşmesine daha yakın. Şimdilik geri tepkisini görmezden gelelim 1:

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

Bu temelde aynıdır (^.|..\4)*, ancak faydalanamayız ^çünkü ipin başında değiliz. Bunun yerine, .\1yalnızca grubu kullandığımız zaman ek eşleştirmek için bir koşullu kullanırız 4. Ama aslında bu tamamen aynı. Bu bize veriyor j*j.

Eksik olan tek şey j*iterimdir. Bunu j*j, j*jhesaplamanın hala jyinelemeler alması gerçeğinden yararlanarak birleştiriyoruz . Yani her yineleme için biz de imleci ilerletmek iile \1. Bunu sadece gruba yazmamaya dikkat etmemiz gerekiyor 4, çünkü bu ardışık tuhaf rakamlarla eşleşir. İşte bu şekilde:

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

CJam ( 16 15 bayt)

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

Çevrimiçi demo

Bu, yığın ve yaprakları 0ya da yığın üzerinde girdi alan bir bloktur ("anonim bir işlev") 1. Bir rakamın Loeschian olduğu karakteristiğini, tek modlu 2 mod3 e eşit bir asal çarpan yoksa tek bir çokluk ile kullanır.

Bir baytlık tasarruf için Dennis'e teşekkürler .

Python 2, 56 bayt

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

Haskell, 42 bayt

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

Kullanım örneği: f 501-> False.

Tüm kombinasyonlarını çalışır igelen 0etmek kve jgelen 0etmek i. Eşitlik , kombinasyonlardan en az birini tutarsa orgeri döner .Truek==i*i+j*j+i*j

@flawr, aynı bayt sayısıyla biraz farklı bir sürüm buldu:

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

Java 8, 81 bayt

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

Basit, saf uygulama. tesadüfen C # ile aynı kod ama ->yerine kullanır =>.

Python, 67 bayt

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

Jöle , 15 14 13 12 bayt

Kilometrelerce 1 bayt.

²S+P
‘ṗ2’Ç€i

Çevrimiçi deneyin!

Küçük testcas'ları doğrulayın .

Çok sayıda (50'den büyük) test yaparken bir tavsiye kelimesi: yapmayın.

Gerçek, pozitif bir sayıdır. Falsey sıfır.

açıklama

‘ṗ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

Denizanası , 56 43 41 29 28 bayt

Zgarb sayesinde 2 bayt

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

Çevrimiçi deneyin!

Jelly cevabımın bir çatalı .

Matl , 14 13 bayt

t:0hU&+HM&*+m

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Çıkışlar 1veya 0.

açıklama

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 bayt

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

OEIS’inde verilen eşdeğer ikinci dereceden formu kullanır n == 3*i*i+j*j. Kare kökü alarak ve tamsayı olup olmadığını kontrol ederek n-3*i*iherhangi biri için mükemmel bir kare olup olmadığını ikontrol edin, yani 0 modulo 1'e eşittir. Bu +0j, negatifin karekökünde bir hatayı önlemek için karmaşık bir sayı yapar.

C (gcc), 71 69 bayt

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 bayt

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

Saf bir çözüm. 1 = doğru, 0 = yanlış

VBA, 68 67 bayt

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

Naif arama, n = 1000 için hafifçe yavaşlamaya başlıyor. Excel sıfır getiriyi sahte, diğer tüm getirileri gerçeğe uygun olarak tanır.

İ> j> = 0 verildiğinden negatif i ve j'nin araştırılmasına gerek olmadığını unutmayın :

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

( i ve j ile aynı sonuç )

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

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

(eğer biri negatifse, hangisi olduğu önemli değildir), ve sonra

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

Ve her iki yana (ij) ve j negatif olmayan, sigara-negatif sayılar kullanılarak elde edilebilir negatif bir sayı içeren Loeschian sayıların herhangi bir kuşak.

Bir bayt kaydedildi, Next:Next-> Next b,aTaylor Scott sayesinde.

Javascript (harici kütüphaneyi kullanarak - Numaralandırılabilir) (63 bayt)

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

Kütüphaneye bağlantı: https://github.com/mvegh1/Enumerable Kod açıklaması: 0 ile k arasında bir tamsayı aralığı oluşturun (buna "i" aralığı olarak adlandırın) ve "i" ifadesinin belirli bir yüklemeye uygun olup olmadığını sınayın. Bu yüklem 0 ile k arasında bir aralık oluşturur (buna "j" aralığı denir) ve "j" nin belirli bir yüklemeyi karşılayıp karşılamadığını test eder. Bu kehanet loeschian formülüdür.

Perl 6 ,  52 51  50 bayt

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

Açıklama:

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

Ölçek:

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 bayt

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

Girdiyi alır $k, iki kez yukarı doğru döngüler (dış döngü $i = 0 to $k, iç döngü $j = 0 to $i), her yineleme sonucu i*i + j*j + i*j(kısaltılmış i*(i+j) + j*j) oluşturur. Bu sonuçlar parens içinde kapsüllenir ve bir dizi olarak iletilir -eq$k. Bu sadece girişe eşit elemanlar seçmek için bir filtre görevi görür. Hakikat için sıfır olmayan (geri sayı) veya falsey için boş (boş) çıktılar. Makinemde 1000yaklaşık 15 saniye içinde işlem yapıyor.

Test Kılıfları

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 ( -nbayrak) = 55 bayt

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

Çalıştırılması gerekenler -nve -M5.010bayraklar:

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

Sayı bir Loeschian sayısıysa ve başka bir şey yoksa, bazı maddeleri çıkarır.

Bu uygulama oldukça sıkıcı, bu yüzden sadece gözler için 87 baytlık regex tabanlı bir tane daha var:

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

Bu konuda çok dikkat edin, çünkü geri izleme çok fazla bellek kullanır, bu yüzden sayıları çok büyük test etmeye çalışmayın! (özellikle Loeschian olmayan sayılar)

Dyalog APL , 19 bayt

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

Kontroller ise k ε ( i + j ) ² - ij , bir 0 ≤ için i , j ≤ k .

    ⊢olan k
∊ bir üyesi
    ∘.tüm kombinasyonları
        × i kere j
        -⍨ çıkarılır
        2*⍨karesi
        + i artı j
    ⍨ herkes için i ve j içinde
    0,başına ilave sıfır
    ⍳aracılığıyla tamsayılar 1 k

1000, M540'ımda 3.3 saniye ve hatta TryAPL'de daha az zaman alıyor .

Matlab, 53 52 bayt

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

Tüm olasılıklar üzerinde basit arama.
Boş diziyi sahte, boş olmayan bir vektörü gerçeğe uygun değer olarak verir.

All-sıfır matrisini sahte, all-sıfır-olmayan matrisini truthy olarak kabul edersek, 47 46 baytlık çözümle findsonuçlanan fonksiyondan kurtulabiliriz :

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

@Flawr sayesinde bir bayt kurtarıldı

C, 66 bayt

f()Test edilecek numara ile arayın . İşlev, bulduğu çözüm sayısını döndürür.

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

İdeone üzerinde deneyin .

Mathematica, 44 bayt

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

Adsız işlev, bir tamsayı alarak girdi olarak döndürüyor Trueveya döndürüyor False. Komut , giriş 0~Range~#~Tuples~2arasında hem sıralı tüm tam sayı çiftlerini oluşturur . İşlev , argümanlarının toplamının karesini eksi argümanlarının ürününü hesaplar; iki argüman çağrıldığında ve bu tam olarak istenildiği gibi. Böylece bu fonksiyon tüm başlıklarda çağrılır ve ardından girişin sonuçtaki değerlerden biri olup olmadığını kontrol eder.0#(+##)^2-##&iji^2+j^2+ijMemberQ[...,#]

ASP, 39 + 4 = 43 bayt

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

Çıktı: Sorun tatmin edicidir, eğer k Loeschian ise.

Cevap Kümesi Programlama , prolog'a benzer, mantıklı bir dildir. Burada kullanmak Potassco uygulanmasını , clingo .

Giriş, parametrelerden alınır ( -ck=4 bayt uzunluğunda). Çağrı örneği:

clingo -ck=999

Çıkış örneği:

SATISFIABLE

1000 ile denendi:

clingo -ck=1000

Çıkış örneği:

UNSATISFIABLE

Tarayıcınızda deneyebilirsiniz ; maalesef, bu yöntem çağrı bayraklarını işlemez, bu nedenle #const k=999çalışması için satırı eklemeniz gerekir .

Ungolfed ve açıklanmış kod:

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 bayt

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

komut satırı argümanından girdi alır; 1Loeschian sayısı için olanlarla birlikte çıkar 0.
İle koş -nr.

Yıkmak

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