Số nguyên dương klà số Loeschian nếu

• kcó thể được biểu thị như i*i + j*j + i*jcho i, jsố nguyên.

Ví dụ: các số Loeschian dương đầu tiên là: 1( i=1, j=0); 3( i=j=1); 4( i=2, j=0); 7( i=2, j=1); 9( i=-3, j=3); ... Lưu ý rằng i, jđối với một kkhông phải là duy nhất. Ví dụ, 9cũng có thể được tạo bằng i=3, j=0.

Các đặc điểm tương đương khác của những con số này là:

• kcó thể được biểu thị như i*i + j*j + i*jcho i, jsố nguyên không âm. (Đối với mỗi cặp số nguyên i, jcó một cặp số nguyên không âm cho cùng một số k)

• Có một tập hợp các khình lục giác liền kề tạo thành một tàu trên lưới lục giác (xem hình minh họa cho k = 4và cho k = 7). (Vì tính chất này, những con số này tìm thấy ứng dụng trong các mạng truyền thông di động .)

• Xem thêm các đặc tính trong trang OEIS của chuỗi.

Các thách thức

Cho một số nguyên dương , đưa ra một kết quả trung thực nếu đó là số Loeschian hoặc kết quả sai.

Chương trình hoặc chức năng sẽ xử lý (nói trong chưa đầy một phút) đầu vào tối đa 1000hoặc tối đa giới hạn loại dữ liệu.

Mã golf. Chiến thắng ngắn nhất.

Các trường hợp thử nghiệm

Các số sau sẽ cho kết quả trung thực:

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

Các số sau sẽ cho kết quả sai lệch:

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

Thạch , 11 9 byte

ÆF‘%3,2ḄȦ

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Lý lịch

Trong các kết quả sơ cấp trên dạng bậc hai nhị phân a² + ab + b² , tác giả đã chứng minh định lý sau về các số Löschian.

Định lý 16. Điều kiện cần và đủ của bất kỳ số nguyên không âm nào có dạng a² + ab + b² là, trong hệ số nguyên tố của nó, tất cả các số nguyên tố không phải là 3 không thuộc dạng (6k + 1) đều có số mũ.

Như đã lưu ý trên trang OEIS có liên quan , vì tất cả các số nguyên đều đồng dạng với 0 , 1 hoặc 2 modulo 3 , số 3 là số nguyên tố duy nhất đồng dạng với 0 và tất cả các số có dạng (6k + 1) đều đồng dạng với 1 , định lý có thể được nêu thay thế như sau.

Số nguyên n không âm là số Löschian khi và chỉ khi tất cả các thừa số nguyên tố của n đồng dạng với 2 modulo 3 có số mũ chẵn.

Làm thế nào nó hoạt động

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

Võng mạc , 66 63 45 43 36 byte

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

Mặc dù tiêu đề nói Retina, đây chỉ là một regex .NET đơn giản chấp nhận các đại diện đơn nhất của các số Loeschian.

Đầu vào 999 và 1000 hoạt động tốt trong một giây.

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ thử nghiệm được phân tách bằng nguồn cấp dữ liệu và hai dòng tiếp theo đảm nhiệm việc chuyển đổi thành đơn nguyên để thuận tiện.)

Giải trình

Giải pháp dựa trên phân loại rằng đầu vào có thể được viết là i*i + j*(i + j)dương ivà không âm j(vì chúng ta không phải xử lý đầu vào 0) và đó n*nchỉ là tổng của các nsố nguyên lẻ đầu tiên . Chơi golf này là một bài tập thú vị trong các tài liệu tham khảo về phía trước.

Một "tham chiếu chuyển tiếp" là khi bạn đặt một phản hồi trong nhóm mà nó đề cập đến. Tất nhiên điều đó không hoạt động khi nhóm được sử dụng lần đầu tiên, vì chưa có gì để phản hồi, nhưng nếu bạn đặt điều này trong một vòng lặp, thì phản hồi sẽ được ghi lại lần lặp trước đó mỗi lần. Đến lượt mình, chúng ta hãy xây dựng một bản chụp lớn hơn với mỗi lần lặp. Điều này có thể được sử dụng để tạo các mẫu rất nhỏ gọn cho những thứ như số tam giác, hình vuông và số Fibonacci.

Ví dụ, sử dụng thực tế là các hình vuông chỉ là tổng của các nsố nguyên lẻ đầu tiên , chúng ta có thể khớp với một đầu vào hình vuông như thế này:

(^.|..\1)+$

Ở lần lặp đầu tiên, ..\1không thể làm việc, vì \1chưa có giá trị. Vì vậy, chúng tôi bắt đầu với ^., bắt một nhân vật duy nhất vào nhóm 1. Ở các lần lặp lại tiếp theo, ^.không còn phù hợp do neo, nhưng bây giờ ..\1là hợp lệ. Nó khớp với hai ký tự nhiều hơn lần lặp trước và cập nhật bản chụp. Bằng cách này, chúng ta khớp các số lẻ tăng dần, nhận được một hình vuông sau mỗi lần lặp.

Thật không may, chúng ta không thể sử dụng kỹ thuật này. Sau khi kết hợp i*i, chúng ta cũng cần phải có được i, để chúng ta có thể nhân nó với j. Một cách đơn giản (nhưng dài) để làm điều này là sử dụng thực tế là việc khớp i*isẽ ilặp đi lặp lại, để chúng tôi nắm bắt được imọi thứ trong nhóm 1. Bây giờ chúng ta có thể sử dụng các nhóm cân bằng để giải nén điều này i, nhưng như tôi đã nói là tốn kém.

Thay vào đó, tôi đã tìm ra một cách khác để viết "tổng các số nguyên lẻ liên tiếp" này cũng mang lại imột nhóm bắt giữ ở cuối. Tất nhiên isố lẻ thứ chỉ là 2i-1. Điều này cho chúng ta một cách để tăng tham chiếu chuyển tiếp chỉ bằng 1 trên mỗi lần lặp. Đó là phần này:

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

Đây ()chỉ đẩy một chụp rỗng vào nhóm 1(initialising iđến 0). Điều này khá giống với ^.|giải pháp đơn giản ở trên, nhưng sử dụng |trong trường hợp này sẽ khó khăn hơn một chút.

Sau đó, chúng ta có vòng lặp chính (\1(?<1>.\1)). \1phù hợp với trước đó i, (?<1>.\1)sau đó cập nhật nhóm 1với i+1. Về mặt mới i , chúng tôi chỉ phù hợp với các 2i-1nhân vật. Chính xác những gì chúng ta cần.

Khi chúng tôi hoàn thành, chúng tôi đã khớp một số hình vuông i*ivà nhóm 1vẫn giữ các iký tự.

Phần thứ hai gần hơn với kết hợp hình vuông đơn giản mà tôi đã trình bày ở trên. Bây giờ chúng ta hãy bỏ qua phản 1ứng ngược:

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

Điều này về cơ bản giống như (^.|..\4)*, ngoại trừ việc chúng ta không thể sử dụng ^vì chúng ta không ở đầu chuỗi. Thay vào đó, chúng tôi sử dụng một điều kiện, để chỉ khớp với bổ sung .\1khi chúng tôi đã sử dụng nhóm 4. Nhưng trong thực tế, điều này là hoàn toàn giống nhau. Điều này cho chúng ta j*j.

Điều duy nhất còn thiếu là j*ithuật ngữ. Chúng tôi kết hợp điều này với j*jbằng cách sử dụng thực tế là việc j*jtính toán vẫn có các jbước lặp. Vì vậy, cho mỗi lần lặp chúng tôi cũng tiến con trỏ bằng ivới \1. Chúng ta chỉ cần đảm bảo không viết nó thành nhóm 4, vì điều đó sẽ gây rối với việc khớp các số lẻ liên tiếp. Đó là cách chúng tôi đến:

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

CJam ( 16 15 byte)

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

Bản demo trực tuyến

Đây là một khối (một "hàm ẩn danh") nhận đầu vào trên ngăn xếp và rời khỏi 0hoặc 1trên ngăn xếp. Nó sử dụng đặc tính của một số là Loeschian iff nó không có thừa số nguyên tố bằng 2 mod 3 với bội số lẻ.

Cảm ơn Dennis vì đã tiết kiệm một byte.

Python 2, 56 byte

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

Haskell, 42 byte

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

Ví dụ sử dụng: f 501-> False.

Cố gắng tất cả các kết hợp của itừ 0để kvà jtừ 0đến i. ortrả về Truenếu đẳng thức k==i*i+j*j+i*jgiữ cho ít nhất một trong các kết hợp.

@flawr tìm thấy một phiên bản hơi khác với cùng số byte:

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

Java 8, 81 byte

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

đơn giản, thực hiện ngây thơ. trùng hợp mã giống như C # nhưng sử dụng ->chứ không phải =>.

Python, 67 byte

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

Thạch , 15 14 13 12 byte

1 byte nhờ dặm.

²S+P
‘ṗ2’Ç€i

Hãy thử trực tuyến!

Xác nhận các testcase nhỏ hơn .

Lời khuyên khi kiểm tra số lượng lớn (lớn hơn 50): không.

Chân lý là một con số tích cực. Falsey bằng không.

Giải trình

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

Sứa , 56 43 41 29 28 byte

2 byte nhờ Zgarb

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

Hãy thử trực tuyến!

Một ngã ba câu trả lời Jelly của tôi .

MATL , 14 13 byte

t:0hU&+HM&*+m

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Đầu ra 1hay 0.

Giải trình

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 byte

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

Sử dụng dạng bậc hai tương đương được đưa ra trên OEIS của n == 3*i*i+j*j. Kiểm tra xem có phải n-3*i*ilà một hình vuông hoàn hảo hay không ibằng cách lấy căn bậc hai của nó và kiểm tra xem nó có phải là số nguyên không, tức là bằng 0 modulo 1. Lưu ý rằng Python tính chính xác căn bậc hai của hình vuông hoàn hảo, không có lỗi dấu phẩy động. Điều này +0jlàm cho nó trở thành một số phức để tránh lỗi trên căn bậc hai của âm.

C (gcc), 71 69 byte

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 byte

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

Một giải pháp ngây thơ. 1 = đúng, 0 = sai

VBA, 68 67 byte

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

Tìm kiếm ngây thơ, bắt đầu chậm lại một chút với n = 1000. Excel nhận ra lợi nhuận bằng 0 là giả, tất cả các trả về khác là trung thực.

Lưu ý rằng không cần điều tra i và j âm , vì đã cho i> j> = 0 :

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

(kết quả tương tự như đối với i và j )

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

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

(nếu một âm tính, nó không quan trọng cái nào), và sau đó

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

Và vì cả (ij) và j đều không âm, nên bất kỳ thế hệ số Loeschian nào liên quan đến số âm đều có thể đạt được bằng cách sử dụng các số không âm.

Đã lưu một byte, Next:Next-> Next b,anhờ Taylor Scott.

Javascript (sử dụng thư viện bên ngoài - Có thể đếm được) (63 byte)

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

Liên kết đến thư viện: https://github.com/mvegh1/Enumerable Mã giải thích: Tạo một phạm vi số nguyên từ 0 đến k (gọi đây là phạm vi "i") và kiểm tra xem có "i" nào thỏa mãn một vị từ nhất định không. Vị từ đó tạo ra một phạm vi từ 0 đến k (gọi đây là phạm vi "j") và kiểm tra xem có "j" nào thỏa mãn một vị từ nhất định không. Vị ngữ đó là công thức loeschian

Perl 6 ,  52 51  50 byte

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

Giải trình:

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

Kiểm tra:

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 byte

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

Đưa đầu vào $k, vòng lặp lên hai lần (vòng ngoài $i = 0 to $k, vòng trong $j = 0 to $i), mỗi lần lặp tạo ra kết quả của i*i + j*j + i*j(rút ngắn thành i*(i+j) + j*j). Những kết quả đó được gói gọn trong parens và được truyền dưới dạng một mảng tới -eq$k. Điều này hoạt động như một bộ lọc để chỉ chọn các yếu tố bằng với đầu vào. Xuất ra một số khác (số trở lại) cho trung thực hoặc không có gì (trống) cho falsey. Quá trình 1000trong khoảng 15 giây trên máy của tôi.

Các trường hợp thử nghiệm

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 ( -ncờ) = 55 byte

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

Nhu cầu -nvà -M5.010cờ để chạy:

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

Xuất ra một số nội dung nếu số đó là số Loeschian và không có gì khác.

Việc triển khai này khá nhàm chán, vì vậy đây là một cách khác, với 87 byte, dựa trên regex, chỉ dành cho mắt:

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

Hãy cẩn thận với điều này, vì việc quay lại sẽ sử dụng rất nhiều bộ nhớ, vì vậy đừng thử kiểm tra những con số quá lớn! (đặc biệt là những con số không phải là người Loeschian)

APL Dyalog , 19 byte

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

Kiểm tra xem k ∊ ( i + j ) ² - ij , với bất kỳ 0 ≤ i , j ≤ k .

    ⊢là k
∊ là thành viên của
    ∘.tất cả các kết hợp của
        × i lần j được
        -⍨ trừ từ bình
        2*⍨phương của
        + i cộng với j
    ⍨ cho tất cả i và j từ
    0,0 đến trước
    ⍳các số nguyên từ 1 đến k

1000 mất 3,3 giây trên M540 của tôi và thậm chí ít hơn trên TryAPL .

Matlab, 53 52 byte

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

Tìm kiếm đơn giản trên tất cả các khả năng.
Xuất ra mảng trống dưới dạng giả và một vectơ không trống là giá trị trung thực.

Coi ma trận tất cả các số không là ma trận giả và không phải tất cả các số không là sự thật, chúng ta có thể loại bỏ findhàm dẫn đến giải pháp 47 46 byte :

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

Một byte được lưu nhờ @flawr

C, 66 byte

Gọi f()với số để kiểm tra. Hàm trả về số lượng giải pháp tìm thấy.

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

Hãy thử nó trên ideone .

Toán học, 44 byte

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

Hàm không tên lấy một số nguyên làm đầu vào và trả về Truehoặc False. Lệnh 0~Range~#~Tuples~2tạo tất cả các cặp số nguyên theo thứ tự giữa 0và đầu vào #. Hàm (+##)^2-##&tính bình phương tổng của các đối số của nó trừ đi tích của các đối số của nó; khi được gọi trên hai đối số ivà j, điều này là chính xác i^2+j^2+ijnhư mong muốn. Vì vậy, hàm đó được gọi trên tất cả các bộ dữ liệu, và sau đó MemberQ[...,#]kiểm tra xem đầu vào có phải là một trong các giá trị kết quả hay không.

ASP, 39 + 4 = 43 byte

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

Đầu ra: vấn đề thỏa đáng iff k là Loeschian.

Trả lời Set Lập trình là một ngôn ngữ logic, tương tự như prolog. Tôi sử dụng ở đây để thực hiện Potassco , clingo .

Đầu vào được lấy từ các tham số ( -ck=dài 4 byte). Gọi ví dụ:

clingo -ck=999

Mẫu đầu ra:

SATISFIABLE

Đã thử với 1000:

clingo -ck=1000

Mẫu đầu ra:

UNSATISFIABLE

Bạn có thể thử nó trong trình duyệt của bạn ; Thật không may, phương pháp này không xử lý các cờ gọi, vì vậy bạn cần thêm đường dây #const k=999để làm cho nó hoạt động.

Mã giải thích & giải thích:

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 byte

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

lấy đầu vào từ đối số dòng lệnh; thoát với 1số Loeschian, với 0người khác.
Chạy với -nr.

phá vỡ

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