Eine positive ganze Zahl kist eine Loeschsche Zahl, wenn

• kausgedrückt werden kann als i*i + j*j + i*jfür i, jganze Zahlen sind .

Zum Beispiel sind die ersten positiven Loeschschen Zahlen: 1( i=1, j=0); 3( i=j=1); 4( i=2, j=0); 7( i=2, j=1); 9( i=-3, j=3); ... Beachten Sie, dass i, jfür eine gegebene ksind nicht eindeutig. Beispielsweise 9kann auch mit i=3, erzeugt werden j=0.

Andere äquivalente Charakterisierungen dieser Zahlen sind:

• kausgedrückt werden kann als i*i + j*j + i*jfür i, jnicht negative ganze Zahlen. (Für jedes Paar von ganzen Zahlen i, jgibt es ein Paar von nicht-negativen ganzen Zahlen , die die gleiche gibt k)

• Es gibt eine Reihe kzusammenhängender Sechsecke, die auf einem sechseckigen Gitter eine Tesselation bilden (siehe Abbildungen für k = 4und für k = 7). (Aufgrund dieser Eigenschaft finden diese Nummern Anwendung in Mobilfunknetzen .)

• Weitere Charakterisierungen finden Sie auf der OEIS-Seite der Sequenz.

Die Herausforderung

Geben Sie bei einer positiven Ganzzahl ein wahres Ergebnis aus, wenn es sich um eine Loeschsche Zahl handelt , oder ein falsches Ergebnis, wenn dies nicht der Fall ist.

Das Programm oder die Funktion sollte Eingaben bis zu 1000oder bis zu Datentypbeschränkungen verarbeiten (beispielsweise in weniger als einer Minute) .

Code Golf. Kürzeste Siege.

Testfälle

Die folgenden Zahlen sollten ein wahres Ergebnis liefern:

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

Die folgenden Zahlen sollten ein falsches Ergebnis ausgeben:

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

Jelly , 11 9 Bytes

ÆF‘%3,2ḄȦ

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Hintergrund

In Elementarergebnissen zur binären quadratischen Form a² + ab + b² beweist der Autor den folgenden Satz über Löschsche Zahlen.

Theorem 16. Die notwendige und ausreichende Bedingung für eine nicht negative ganze Zahl in der Form a² + ab + b² ist, dass in ihrer Primfaktorisierung alle Primzahlen außer 3 , die nicht in der Form (6k + 1) sind, gerade sind exponenten.

Wie auf der entsprechenden OEIS-Seite vermerkt , ist die Zahl 3 die einzige Primzahl, die mit 0 kongruent ist , und alle Zahlen der Form (6k + 1) sind mit kongruent , da alle Ganzzahlen mit 0 , 1 oder 2 Modulo 3 kongruent sind In 1 kann der Satz alternativ wie folgt angegeben werden.

Eine nicht negative ganze Zahl n ist genau dann eine Lösch'sche Zahl, wenn alle Primfaktoren von n , die zu 2 modulo 3 kongruent sind, gerade Exponenten haben.

Wie es funktioniert

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

Trotz des Titels "Retina" ist dies nur eine einfache .NET-Regex, die unäre Darstellungen von Loeschschen Zahlen akzeptiert .

Die Eingaben 999 und 1000 dauern weniger als eine Sekunde.

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite, und die nächsten beiden Zeilen kümmern sich der Einfachheit halber um die Konvertierung in Unary.)

Erläuterung

Die Lösung basiert auf der Klassifizierung, dass die Eingabe als i*i + j*(i + j)positiv iund nicht negativ geschrieben werden kann j(da wir keine Eingabe verarbeiten müssen 0), und das n*nist nur die Summe der ersten nungeraden ganzen Zahlen. Golfen war eine interessante Übung in Vorwärtsreferenzen.

Eine "Vorwärtsreferenz" ist, wenn Sie eine Rückwärtsreferenz in die Gruppe einfügen, auf die sie verweist. Dies funktioniert natürlich nicht, wenn die Gruppe zum ersten Mal verwendet wird, da noch keine Rückverweise vorhanden sind. Wenn Sie dies jedoch in eine Schleife einfügen, erhält die Rückverweisung jedes Mal die Erfassung der vorherigen Iteration. Auf diese Weise können Sie mit jeder Iteration ein größeres Capture erstellen. Dies kann verwendet werden, um sehr kompakte Muster für Dinge wie Dreieckszahlen, Quadrate und Fibonacci-Zahlen herzustellen.

Anhand der Tatsache, dass Quadrate nur Summen der ersten nungeraden Ganzzahlen sind, können wir beispielsweise eine Quadrateingabe wie die folgende zuordnen:

(^.|..\1)+$

..\1Kann bei der ersten Iteration nicht funktionieren, da \1noch kein Wert vorhanden ist. Also fangen wir damit an ^., ein einzelnes Zeichen in einer Gruppe festzuhalten 1. Bei nachfolgenden Iterationen werden ^.aufgrund des Ankers keine Übereinstimmungen mehr gefunden, sondern sind jetzt ..\1gültig. Es entspricht zwei Zeichen mehr als die vorherige Iteration und aktualisiert die Erfassung. Auf diese Weise passen wir steigende ungerade Zahlen an und erhalten nach jeder Iteration ein Quadrat.

Leider können wir diese Technik nicht so verwenden, wie sie ist. Nach dem Matching i*imüssen wir auch bekommen i, damit wir es multiplizieren können j. Ein einfache (aber lange) Weg , dies zu tun , ist die Tatsache zunutze zu machen , dass Anpassung i*inimmt iIterationen, so dass wir aufgenommen haben iDinge in der Gruppe 1. Wir könnten jetzt Bilanzkreise verwenden , um dies zu extrahieren i, aber wie gesagt, das ist teuer.

Stattdessen habe ich mir eine andere Methode ausgedacht, um diese "Summe aufeinanderfolgender ungerader Ganzzahlen" zu schreiben i, die sich am Ende auch in einer Erfassungsgruppe ergibt . Natürlich ist die iungerade Zahl gerade 2i-1. Dies gibt uns die Möglichkeit, die Vorwärtsreferenz bei jeder Iteration nur um 1 zu erhöhen. Das ist dieser Teil:

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

Dadurch wird ()nur ein leeres Capture auf die Gruppe 1verschoben (Initialisierung iauf 0). Dies entspricht ^.|in etwa der oben beschriebenen einfachen Lösung, ist jedoch |in diesem Fall etwas schwieriger.

Dann haben wir die Hauptschleife (\1(?<1>.\1)). \1Entspricht der vorherigen iund (?<1>.\1)aktualisiert die Gruppe 1mit i+1. In Bezug auf das Neue i haben wir nur 2i-1Charaktere gefunden. Genau das, was wir brauchen.

Wenn wir fertig sind, haben wir ein Quadrat gefunden i*iund die Gruppe enthält 1noch iZeichen.

Der zweite Teil ist näher an der einfachen quadratischen Übereinstimmung, die ich oben gezeigt habe. Ignorieren wir zunächst den Rückverweis auf 1:

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

Dies ist im Grunde dasselbe wie (^.|..\4)*, außer dass wir es nicht nutzen können, ^weil wir nicht am Anfang der Zeichenkette stehen. Stattdessen verwenden wir eine Bedingung, die .\1nur dann mit der zusätzlichen übereinstimmt, wenn wir bereits group verwendet haben 4. Tatsächlich ist dies jedoch genau das gleiche. Das gibt uns j*j.

Das einzige, was fehlt, ist der j*iBegriff. Wir kombinieren dies mit der j*jTatsache, dass für die j*jBerechnung noch jIterationen erforderlich sind. Bei jeder Iteration rücken wir den Cursor also um imit vor \1. Wir müssen nur sicherstellen, dass das nicht in Gruppen geschrieben wird 4, da dies mit übereinstimmenden ungeraden Zahlen in Konflikt geraten würde. So kommen wir zum:

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

CJam ( 16 15 Bytes)

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

Online-Demo

Dies ist ein Block (eine "anonyme Funktion"), der Eingaben auf dem Stapel entgegennimmt und den Stapel verlässt 0oder 1auf dem Stapel ablegt. Es wird die Charakterisierung verwendet, dass eine Zahl Loeschian ist, wenn sie keinen Primfaktor von 2 mod 3 mit ungerader Multiplizität hat.

Vielen Dank an Dennis für die Einsparung von einem 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]]

Anwendungsbeispiel: f 501-> False.

Versucht alle Kombinationen von ivon 0bis kund jvon 0bis i. orGibt zurück, Truewenn die Gleichheit k==i*i+j*j+i*jfür mindestens eine der Kombinationen gilt.

@flawr hat eine etwas andere Version mit der gleichen Byteanzahl gefunden:

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

einfache, naive umsetzung. zufälligerweise denselben Code wie C # , sondern verwendet ->statt =>.

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

Jelly , 15 14 13 12 Bytes

1 Byte dank Meilen.

²S+P
‘ṗ2’Ç€i

Probieren Sie es online!

Überprüfen Sie die kleineren Testfälle .

Ein Ratschlag beim Testen auf große Zahlen (größer als 50): Nicht.

Wahrheit ist eine positive Zahl. Falsey ist Null.

Erläuterung

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

Qualle , 56 43 41 29 28 Bytes

2 Bytes dank Zgarb

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

Probieren Sie es online!

Eine Gabel meiner Gelee-Antwort .

MATL , 14 13 Bytes

t:0hU&+HM&*+m

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Ausgänge 1oder 0.

Erläuterung

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

Verwendet die äquivalente quadratische Form nach OEIS von n == 3*i*i+j*j. Überprüfen Sie, ob n-3*i*ies sich für ein Quadrat um ein perfektes Quadrat handelt, iindem Sie die Quadratwurzel nehmen und prüfen, ob es sich um eine Ganzzahl handelt, dh 0 Modulo 1 entspricht. Dies +0jmacht es zu einer komplexen Zahl, um einen Fehler auf der Quadratwurzel eines Negativs zu vermeiden.

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

Eine naive Lösung. 1 = wahr, 0 = falsch

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 Suche, beginnend mit einer leichten Verlangsamung für n = 1000. Excel erkennt die Nullrückgabe als falsch, alle anderen Rückgaben als wahr.

Beachten Sie, dass die Untersuchung des negativen i und j nicht erforderlich ist, da i> j> = 0 gegeben ist :

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

(das gleiche Ergebnis wie für i und j )

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

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

(Wenn einer negativ ist, spielt es keine Rolle, welcher) und dann

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

Und da sowohl (ij) als auch j nicht negativ sind, kann jede Erzeugung von Loeschschen Zahlen, die eine negative Zahl beinhalten, unter Verwendung von nicht negativen Zahlen erreicht werden.

Ein Byte gespart, Next:Next-> Next b,adank Taylor Scott.

Javascript (mit externer Bibliothek - Enumerable) (63 Bytes)

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

Link zur Bibliothek: https://github.com/mvegh1/Enumerable Codeerklärung: Erstellen Sie einen Bereich von Ganzzahlen von 0 bis k (nennen Sie dies den "i" -Bereich), und testen Sie, ob ein "i" ein bestimmtes Prädikat erfüllt. Dieses Prädikat erstellt einen Bereich von 0 bis k (nenne dies den "j" -Bereich) und testet, ob irgendein "j" ein bestimmtes Prädikat erfüllt. Dieses Prädikat ist die Loeschsche Formel

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

Erläuterung:

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

Prüfung:

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

Nimmt Eingaben auf $k, schleift zweimal nach oben (äußere Schleife $i = 0 to $k, innere Schleife $j = 0 to $i), jede Iteration erzeugt das Ergebnis von i*i + j*j + i*j(verkürzt auf i*(i+j) + j*j). Diese Ergebnisse werden in Parens eingekapselt und als Array an übergeben -eq$k. Dies wirkt als Filter, um nur Elemente auszuwählen, die der Eingabe entsprechen. Gibt eine Zahl ungleich Null (die Zahl zurück) für Wahr oder nichts (leer) für Falsch aus. Verarbeitet 1000in ca. 15 Sekunden auf meinem Computer.

Testfälle

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 ( -nFlag) = 55 Bytes

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

Anforderungen -nund -M5.010Flaggen zum Ausführen:

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

Gibt ein paar Sachen aus, wenn die Nummer eine Loeschsche Nummer ist, und sonst nichts.

Diese Implementierung ist ziemlich langweilig. Hier ist eine weitere für 87 Bytes, die auf Regex basiert, nur für die Augen:

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

Vorsicht bei dieser Variante, da das Backtracking viel Speicherplatz beansprucht. Versuchen Sie also nicht, zu große Zahlen zu testen! (besonders Zahlen, die keine Löschianer sind)

Dyalog APL , 19 Bytes

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

Prüft, ob k ∊ ( i + j ) ² - ij ist , für 0 ≤ i , j ≤ k .

    ⊢ist k
∊ ein Glied
    ∘.aller Kombinationen von
        × i mal j,
        -⍨ subtrahiert vom
        2*⍨Quadrat von
        + i plus j
    ⍨ für alle i und j in
    0,Null, die
    ⍳den ganzen Zahlen 1 bis k vorangestellt sind

1000 dauert 3,3 Sekunden auf meinem M540 und noch weniger auf TryAPL .

Matlab, 53 52 Bytes

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

Einfache Suche über alle Möglichkeiten.
Gibt ein leeres Array als falsch und einen nicht leeren Vektor als Wahrheitswert aus.

Betrachtet man die Matrix mit allen Nullen als falsch und die Matrix mit nicht allen Nullen als wahr, kann man die findFunktion entfernen, was zu einer Lösung von 47 46 Bytes führt :

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

Ein Byte gespart dank @flawr

C 66 Bytes

f()Mit der Nummer anrufen, um zu testen. Die Funktion gibt die Anzahl der gefundenen Lösungen zurück.

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

Probiere es auf ideone aus .

Mathematica, 44 Bytes

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

Unbenannte Funktion, die eine Ganzzahl als Eingabe verwendet und Trueoder zurückgibt False. Der Befehl 0~Range~#~Tuples~2erstellt alle geordneten Ganzzahlpaare zwischen 0und der Eingabe #. Die Funktion (+##)^2-##&berechnet das Quadrat aus der Summe ihrer Argumente minus dem Produkt ihrer Argumente. Wenn auf zwei Argumente iund zugegriffen wird j, ist dies genau i^2+j^2+ijwie gewünscht. Diese Funktion wird also für alle Tupel aufgerufen und MemberQ[...,#]überprüft, ob die Eingabe einer der resultierenden Werte ist.

ASP, 39 + 4 = 43 Bytes

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

Ausgabe: Das Problem ist erfüllbar, wenn k Loeschian ist.

Answer Set Programming ist eine logische Sprache, ähnlich wie Prolog. Ich benutze hier die Potassco-Implementierung , Clingo .

Die Eingabe erfolgt über Parameter ( -ck=Länge 4 Byte). Aufrufbeispiel:

clingo -ck=999

Ausgabebeispiel:

SATISFIABLE

Versucht mit 1000:

clingo -ck=1000

Ausgabebeispiel:

UNSATISFIABLE

Sie können es in Ihrem Browser ausprobieren . Leider verarbeitet diese Methode keine Aufrufflags. Sie müssen daher die Zeile hinzufügen #const k=999, damit sie funktioniert.

Ungolfed & Erklärter 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)

PHP, 70 Bytes

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

Nimmt Eingaben vom Kommandozeilenargument entgegen; Ausgänge mit 1für Loeschian Nummer, mit 0sonst.
Laufen Sie mit -nr.

Nervenzusammenbruch

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