क्या यह संख्या Loeschian है?

Question

एक सकारात्मक पूर्णांक kएक Loeschian संख्या है यदि

• kके रूप में व्यक्त किया जा सकता है i*i + j*j + i*jके लिए i, jपूर्णांकों।

उदाहरण के लिए, पहले सकारात्मक लोइशियन नंबर हैं: 1( i=1, j=0); 3( i=j=1); 4( i=2, j=0); 7( i=2, j=1); 9( i=-3, j=3); ... ध्यान दें i, jकिसी के लिए kअद्वितीय नहीं हैं। उदाहरण के लिए, 9यह भी साथ उत्पन्न किया जा सकता i=3, j=0।

इन नंबरों के अन्य समकक्ष लक्षण हैं:

• kके रूप में व्यक्त किया जा सकता है i*i + j*j + i*jके लिए i, jगैर नकारात्मक पूर्णांक। (पूर्णांक के प्रत्येक जोड़े के लिए i, jगैर-नकारात्मक पूर्णांक की एक जोड़ी है जो समान देता है k)

• kसन्निहित हेक्सागोन का एक सेट है जो एक हेक्सागोनल ग्रिड पर टेसलेशन बनाता है (देखें k = 4और उसके लिए चित्र k = 7)। (इस संपत्ति के कारण, ये संख्याएँ मोबाइल सेलुलर संचार नेटवर्क में अनुप्रयोग ढूंढती हैं ।)

• अनुक्रम के OEIS पृष्ठ में और अधिक लक्षण देखें ।

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए , एक सत्य परिणाम का उत्पादन अगर यह एक Loeschian संख्या है , या एक मिथ्या परिणाम अन्यथा।

प्रोग्राम या फ़ंक्शन 1000को डेटा प्रकार की सीमाओं तक या एक मिनट से कम समय में इनपुट करना चाहिए ।

कोड गोल्फ। सबसे छोटी जीत।

परीक्षण के मामलों

निम्नलिखित नंबरों को एक सत्य परिणाम का उत्पादन करना चाहिए:

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

निम्नलिखित संख्याओं को एक मिथ्या परिणाम का उत्पादन करना चाहिए:

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

Comments

संबंधित (@PeterTaylor द्वारा नोट किया गया)

— लुइस मेंडो

जानवर बल एल्गोरिथ्म के लिए ध्यान दें: यदि आप thek करने के लिए पुनरावृत्ति करते हैं, तो आप कुछ बाइट्स c की कीमत पर O (n) से O (n) तक एल्गोरिथ्म जटिलता को कम करते हैं;

— रॉड

i, j non-negative integersया 9 (i=-3, j=3)- कौन सा है?

— टाइटस

@ टिट्स ओह अब मैं देख रहा हूं। पूर्णांक के प्रत्येक जोड़े के लिए, j एक गैर-नकारात्मक जोड़ी है जो एक ही k

— लुइस मेंडो

Answer 1

जेली , 11 9 बाइट्स

ÆF‘%3,2ḄȦ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

में द्विआधारी द्विघात फार्म पर प्राथमिक परिणाम + ab + b² a² , लेखक Löschian संख्या के बारे में निम्नलिखित प्रमेय साबित होता है।

प्रमेय 16. किसी भी गैर नकारात्मक पूर्णांक के आवश्यक और पर्याप्त शर्त रूप में होने की a² + ab + b² है कि, अपने प्रधानमंत्री गुणन में, के अलावा अन्य सभी अभाज्य संख्या 3 उस रूप में नहीं कर रहे हैं (6k +1) भी है घातांक।

जैसा कि प्रासंगिक OEIS पृष्ठ पर उल्लेख किया गया है , क्योंकि सभी पूर्णांक 0 , 1 या 2 मोडुलो 3 के अनुरूप हैं , संख्या 3 एकमात्र अभाज्य है जो 0 के अनुरूप है , और प्रपत्र (6k + 1) के सभी संख्याओं के अनुरूप हैं 1 , प्रमेय को वैकल्पिक रूप से निम्नानुसार कहा जा सकता है।

एक गैर-नकारात्मक पूर्णांक n एक Löschian संख्या है यदि और केवल अगर n के सभी प्रमुख कारक जो 2 modulo 3 के अनुरूप हैं, तो भी प्रतिपादक हैं।

यह काम किस प्रकार करता है

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

Answer 2

रेटिना , 66 63 45 43 36 बाइट्स

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

रेटिना के शीर्षक के बावजूद, यह केवल एक सादा .NET .NET रेगेक्स है जो लोसेचियन नंबरों के एकात्मक प्रतिनिधित्व को स्वीकार करता है ।

इनपुट्स 999 और 1000 एक सेकंड के तहत अच्छी तरह से लेते हैं।

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-अलग किए गए परीक्षण सूट को सक्षम करती है, और अगले दो रूपांतरण सुविधाओं के लिए एकात्मकता का ख्याल रखते हैं।)

व्याख्या

समाधान वर्गीकरण पर आधारित है कि इनपुट को i*i + j*(i + j)सकारात्मक iऔर गैर-नकारात्मक j(चूंकि हमें इनपुट को संभालने की आवश्यकता नहीं है 0) के लिए लिखा जा सकता है , और n*nयह केवल पहले nविषम पूर्णांक का योग है । इसे आगे के संदर्भों में देखना एक दिलचस्प अभ्यास था।

एक "फॉरवर्ड रेफरेंस" तब होता है जब आप उस समूह के अंदर एक बैकरेसेंस रखते हैं जिसे वह संदर्भित करता है। बेशक, जब समूह पहली बार उपयोग किया जाता है, तो काम नहीं करता है, क्योंकि अभी तक बैकरेफ़र्ड होने के लिए कुछ भी नहीं है, लेकिन यदि आप इसे एक लूप में रखते हैं, तो बैकरेफेरेंस को पिछली बार पुनरावृत्ति प्राप्त होती है। यह बदले में, चलो आप प्रत्येक पुनरावृत्ति के साथ एक बड़ा कब्जा बनाते हैं। इसका उपयोग त्रिकोणीय संख्याओं, वर्गों और फाइबोनैचि संख्याओं जैसी चीजों के लिए बहुत कॉम्पैक्ट पैटर्न तैयार करने के लिए किया जा सकता है।

एक उदाहरण के रूप में, इस तथ्य का उपयोग करते हुए कि वर्ग पहले nविषम पूर्णांक के योग हैं, हम इस तरह एक वर्ग इनपुट से मेल कर सकते हैं:

(^.|..\1)+$

पहली यात्रा पर, ..\1काम नहीं कर सकते, क्योंकि \1अभी तक कोई मूल्य नहीं है। इसलिए हम ^.समूह में किसी एक वर्ण को कैप्चर करना शुरू करते हैं 1। बाद के पुनरावृत्तियों पर, ^.लंगर के कारण अब मेल नहीं खाता, लेकिन अब ..\1मान्य है। यह पिछले पुनरावृति की तुलना में दो अधिक वर्णों से मेल खाता है और कैप्चर को अद्यतन करता है। इस तरह हम बढ़ती संख्याओं से मेल खाते हैं, प्रत्येक पुनरावृत्ति के बाद एक वर्ग हो रहा है।

अब दुर्भाग्य से, हम इस तकनीक का उपयोग नहीं कर सकते हैं। मिलान करने के बाद i*i, हमें भी प्राप्त करने की आवश्यकता है i, ताकि हम इसे गुणा कर सकें j। ऐसा करने का एक सरल (लेकिन लंबा) तरीका इस तथ्य का उपयोग करना है कि मिलान पुनरावृत्तियों i*iलेता है i, ताकि हमने iसमूह में चीजों को पकड़ लिया है 1। अब हम इसे निकालने के लिए संतुलन समूहों का उपयोग कर सकते हैं i, लेकिन जैसे मैंने कहा कि यह महंगा है।

इसके बजाय, मैंने इस "लगातार विषम पूर्णांक का योग" लिखने के लिए एक अलग तरीका निकाला i, जो अंत में एक कैप्चरिंग समूह में भी पैदावार देता है। निश्चित ही iविषम संख्या बस है 2i-1। यह हमें प्रत्येक पुनरावृत्ति पर केवल 1 द्वारा आगे के संदर्भ को बढ़ाने का एक तरीका देता है। यह हिस्सा है:

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

यह ()सिर्फ समूह पर एक खाली कब्जा धक्का 1(initialising iलिए 0)। यह ^.|ऊपर दिए गए सरल समाधान में काफी समान है , लेकिन |इस मामले में उपयोग करना थोड़ा पेचीदा होगा।

फिर हमारे पास मुख्य लूप है (\1(?<1>.\1))। \1पहले से मेल खाता है i, (?<1>.\1)फिर समूह 1को अपडेट करता है i+1। नए के संदर्भ में i, हमने अभी-अभी 2i-1वर्णों का मिलान किया है। वास्तव में हमें जो चाहिए।

जब हम कर लेते हैं, तो हम कुछ वर्ग से मेल खाते हैं i*iऔर समूह में 1अभी भी iअक्षर हैं।

दूसरा भाग सरल वर्ग मिलान के करीब है जो मैंने ऊपर दिखाया था। चलो 1अब के लिए पीछे हटने की उपेक्षा करें :

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

यह मूल रूप से समान है (^.|..\4)*, सिवाय इसके कि हम उपयोग नहीं कर सकते ^क्योंकि हम स्ट्रिंग की शुरुआत में नहीं हैं। इसके बजाय हम एक सशर्त का उपयोग करते हैं, अतिरिक्त से मेल खाने के लिए .\1जब हम पहले ही समूह का उपयोग कर चुके होते हैं 4। लेकिन वास्तव में यह बिल्कुल वैसा ही है। यह हमें देता है j*j।

केवल एक चीज जो गायब है वह है j*iपद। हम इसे इस j*jतथ्य के उपयोग से जोड़ते हैं कि j*jगणना अभी भी jपुनरावृत्तियों को लेती है । इसलिए प्रत्येक यात्रा के लिए हम भी द्वारा कर्सर अग्रिम iके साथ \1। हमें केवल यह सुनिश्चित करने की आवश्यकता है कि इसे समूह में न लिखें 4, क्योंकि यह लगातार विषम संख्याओं के मिलान के साथ गड़बड़ करेगा। इस प्रकार हम यहां पहुंचे:

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

Comments

जितना अधिक बार मैं इसे पढ़ता हूं, उतना ही कम मैं समझता हूं। मैं वास्तव में जानना चाहता हूं कि कई regex

— जेवियर डियाज

@JavierDiaz जावा रेगेक्स पर आधारित स्टैक ओवरफ्लो पर आगे के संदर्भों की व्याख्या करने वाले पदों की एक श्रृंखला है । वहाँ के उदाहरण शायद थोड़े सरल हैं।

— मार्टिन एंडर

Answer 3

CJam ( 16 15 बाइट्स)

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

ऑनलाइन डेमो

This is a block (an "anonymous function") which takes input on the stack and leaves 0 or 1 on the stack. It uses the characterisation that a number is Loeschian iff it has no prime factor equal to 2 mod 3 with odd multiplicity.

Thanks to Dennis for a one-byte saving.

Comments

Wow, nice characterization!

— Luis Mendo

Answer 4

Python 2, 56 bytes

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

Answer 5

Haskell, 42 bytes

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

Usage example: f 501 -> False.

Tries all combinations of i from 0 to k and j from 0 to i . or returns True if the equality k==i*i+j*j+i*j holds for at least one of the combinations.

@flawr found a slightly different version with the same byte count:

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

Comments

I didn't know about or, cool=) Perhaps you have an idea how to golf this alternative phrasing: f k|v<-[0..k]=or[(i+j)^2==k+i*j|i<-v,j<-v]?

— flawr

@flawr: no, no idea how to golf your version further down. If you don't mind, I'l add it to my answer as an alternative version.

— nimi

Answer 6

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

simple, naïve implementation. coincidentally same code as C# but uses -> rather than =>.

Comments

Three less bytes because you can omit the curly braces and ending ;. DAMN!

— TheLethalCoder

@TheLethalCoder I actually can't, I made a mistake - same byte count as C#.

— Justin

Makes me feel better anyway :)

— TheLethalCoder

This doesn´t seem to test negative i or j.

— Titus

Answer 7

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

Answer 8

Jelly, 15 14 13 12 bytes

1 byte thanks to miles.

²S+P
‘ṗ2’Ç€i

Try it online!

Verify the smaller testcases.

A word of advice when testing for large numbers (bigger than 50): don't.

Truthy is a positive number. Falsey is zero.

Explanation

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

Comments

Tied (for) now... :-)

— Luis Mendo

Should we exploit Peter's characterization...?

— Luis Mendo

@LuisMendo That seems interesting, but it seems that it would be longer

— Leaky Nun

I don't think you need to flatten it. Your helper link already maps from tuples to integers.

— miles

@miles That's clever, thanks.

— Leaky Nun

Answer 9

Jellyfish, 56 43 41 29 28 bytes

2 bytes thanks to Zgarb

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

Try it online!

A fork of my Jelly answer.

Answer 10

MATL, 14 13 bytes

t:0hU&+HM&*+m

Try it online! Or verify all test cases.

Outputs 1 or 0.

Explanation

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

Comments

Did you just out-golf Jelly?

— Leaky Nun

@LeakyNun Let's see how long it lasts. Maybe I'll delay the code explanation a bit :-P

— Luis Mendo

Nope. – – – – –

— Leaky Nun

Your turn – – –

— Leaky Nun

@LeakyNun Aw :-( Now I can add the explanation :-)

— Luis Mendo

Answer 11

Python, 49 bytes

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

Uses the equivalent quadratic form given on OEIS of n == 3*i*i+j*j. Check whether n-3*i*i is a perfect square for any i by taking its square root and checking if it's an integer, i.e. equals 0 modulo 1. Note that Python computes square roots of perfect squares exactly, without floating point error. The +0j makes it a complex number to avoid an error on the square root of a negative.

Answer 12

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

Comments

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

This doesn´t seem to test negative i or j.

— Titus

@Titus The question dictates non-negative i and j.

— orlp

positive k, but not i and j. Take a closer look at the examples.

— Titus

@Titus Quoting from the challenge: "k can be expressed as i*i + j*j + i*j for i, j non-negative integers." You take a closer look.

— orlp

Answer 13

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

A naïve solution. 1 = true, 0 = false

Answer 14

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

Naive search, starting to slow down slightly for n=1000. Excel recognizes zero return as falsy, all other returns as truthy.

Note that investigation of negative i and j is not needed, since given i>j>=0 :

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

(the same result as for i and j)

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

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

(if one is negative, it doesn't matter which one), and then

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

And since both (i-j) and j are non-negative, any generation of Loeschian numbers involving a negative number can be achieved using non-negative numbers.

---

Saved a byte, Next:Next -> Next b,a thanks to Taylor Scott.

Comments

This doesn´t seem to test negative i or j.

— Titus

See the first point under "Other equivalent characterizations". Note that all test cases come up correctly. I'll add the mathematical justification to my answer (if I can).

— Joffan

Sorry, my fault. Overread that that´s not necessary.

— Titus

@Joffan you can condense Next:Next to Next b,a

— Taylor Scott

@Joffan looking at your solution again maybe that is because of a missing :End Functionat the end of your solution

— Taylor Scott

Answer 15

Javascript (using external library - Enumerable) (63 bytes)

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

Link to library: https://github.com/mvegh1/Enumerable Code explanation: Create a range of integers from 0 to k (call this the "i" range), and test if any "i" satisfies a certain predicate. That predicate creates a range from 0 to k (call this the "j" range), and tests if any "j" satisfies a certain predicate. That predicate is the loeschian formula

Answer 16

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

Explanation:

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

Test:

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

Comments

This doesn´t seem to test negative i or j.

— Titus

@Titus the (0..$_ X 0..$_) produces an empty list if $_ is less than 0, so there is no need to check for negative i and j because they will never be negative. Since it is only supposed to produce True for a positive Loeschian number, I don't have to do anything special for the negative case.

— Brad Gilbert b2gills

9 = (3*3)+(-3*-3)+(3*-3) is a positive Loeschian with i=3, j=-3; BUT I overread that every Loeschian number has non-negative i and j. So looking for negative numbers is not necessary. So actually we could delete those comments. Sorry for bugging; my fault.

— Titus

@Titus modifying the code to {grep ->(\i,\j){$_==i*i+j*j+i*j},(-$_..$_ X -$_..$_)}(9) results in ((-3,0),(-3,3),(0,-3),(0,3),(3,-3),(3,0)). Honestly I probably just adapted it from other answers.

— Brad Gilbert b2gills

Answer 17

PowerShell v2+, 63 56 55 bytes

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

Takes input $k, loops upwards twice (outer loop $i = 0 to $k, inner loop $j = 0 to $i), each iteration generates the result of i*i + j*j + i*j (shortened to i*(i+j) + j*j). Those results are encapsulated in parens, and passed as an array to -eq$k. This acts as a filter to select only elements that equal the input. Outputs a nonzero (the number back) for truthy, or nothing (empty) for falsey. Processes 1000 in about 15 seconds on my machine.

Test Cases

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>

Answer 18

Perl, 54 + 1 (-n flag) = 55 bytes

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

Needs -n and -M5.010 flags to run :

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

Outputs some stuffs if the number is a Loeschian number, and nothing otherwise.

This implementation is quite boring, so here is another one, for 87 bytes, regex-based, just for the eyes :

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

Carefull with this one, as the backtracking will use a lot of memory, so don't try to test numbers too big! (especially numbers that aren't Loeschians)

Answer 19

Dyalog APL, 19 bytes

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

Checks if k ∊ (i + j)² – ij, for any 0 ≤ i, j ≤ k.

    ⊢ is k
∊ a member of
    ∘. all combinations of
        × i times j
        -⍨ subtracted from
        2*⍨ the square of
        + i plus j
    ⍨ for all i and j in
    0, zero prepended to
    ⍳ the integers 1 through k

1000 takes 3.3 seconds on my M540 and even less on TryAPL.

Answer 20

Matlab, 53 52 bytes

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

Simple search over all possibilities.
Outputs empty array as falsy and a non-empty vector as truthy value.

Considering all-zeros matrix as falsy and not-all-zeros matrix as truthy we can get rid of the find function resulting in 47 46 bytes solution:

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

One byte saved thanks to @flawr

Comments

(a+b).^2-a.*b==n is shorter.

— flawr

Answer 21

C, 66 bytes

Call f() with the number to test. The function returns the number of solutions it found.

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

Try it on ideone.

Answer 22

Mathematica, 44 bytes

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

Unnamed function taking an integer as input and returning True or False. The command 0~Range~#~Tuples~2 creates all ordered pairs of integers both between 0 and the input #. The function (+##)^2-##& computes the square of the sum of its arguments minus the product of its arguments; when called on two arguments i and j, this is exactly i^2+j^2+ij as desired. So that function is called on all the tuples, and then MemberQ[...,#] checks whether the input is one of the resulting values.

Answer 23

ASP, 39 + 4 = 43 bytes

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

Output: the problem is satisfiable iff k is Loeschian.

Answer Set Programming is a logical language, similar to prolog. I use here the Potassco implementation, clingo.

Input is taken from parameters (-ck= is 4 bytes long). Call example:

clingo -ck=999

Output sample:

SATISFIABLE

Tried with 1000:

clingo -ck=1000

Output sample:

UNSATISFIABLE

You can try it in your browser ; unfortunately, this method doesn't handle call flags, so you need to add the line #const k=999 in order to make it work.

---

Ungolfed & explained code:

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)

Answer 24

PHP, 70 bytes

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

takes input from command line argument; exits with 1 for Loeschian number, with 0 else.
Run with -nr.

breakdown

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