Wenn Sie nicht wissen, was eine Königin im Schach ist, spielt es keine Rolle. Es ist nur ein Name :)

Ihre Eingabe wird ein Quadrat von beliebiger Breite und Höhe sein, das eine gewisse Anzahl von Königinnen enthält. Die Eingabekarte sieht folgendermaßen aus (diese Karte hat eine Breite und Höhe von 8):

...Q....
......Q.
..Q.....
.......Q
.Q......
....Q...
Q.......
.....Q..

Es gibt 8 Königinnen auf diesem Brett. Wenn es hier zum Beispiel 7 oder 1 oder 10 gäbe, wäre die Tafel nicht gültig.

Hier verwenden wir a .für einen leeren Raum und a Qfür eine Königin. Alternativ können Sie auch ein beliebiges Nicht-Leerzeichen verwenden.

Diese Eingabe kann als gültig überprüft werden, und Sie sollten einen Wahrheitswert ausgeben (oder zurückgeben) (falls sie nicht gültig ist, sollten Sie einen falschen Wert ausgeben (oder zurückgeben)). Es ist gültig, weil sich keine Dame in derselben Zeile, Spalte, Diagonale oder Antidiagonale wie eine andere befindet .

Beispiele (Dinge nicht in Klammern ausgeben):

...Q....
......Q.
..Q.....
.......Q
.Q......
....Q...
Q.......
.....Q..

1

...Q.
Q....
.Q...
....Q
..Q..

0

Q.
Q.

0

..Q
...
.Q.

0 (this is 0 because there are only 2 queens on a 3x3 board)


..Q.
Q...
...Q
.Q..

1

Q

1 (this is valid, because the board is only 1x1, so there's no queen that can take another)

Lassen Sie mich betonen, dass eine Eingabe nur gültig ist, wenn sich keine Dame in derselben Zeile, Spalte, Diagonale oder Antidiagonale wie eine andere befindet .

Regeln

• Sie werden niemals eine leere Eingabe erhalten
• Wenn die Eingabe weniger Damen als die Quadratwurzel des Bereichs der Tafel enthält, ist sie ungültig.
• Beachten Sie, dass es keine gültigen Lösungen für eine 2x2- oder 3x3-Platine gibt. Es gibt jedoch eine Lösung für jede andere quadratische Platinengröße, bei der Breite und Höhe eine natürliche Zahl sind.
• Die Eingabe kann in einem angemessenen Format gemäß den PPCG-Regeln erfolgen
• Die Eingabe wird immer ein Quadrat sein
• Ich habe in den Beispielen 1 und 0 verwendet, aber Sie können alle wahrheitsgemäßen oder falschen Werte (wie Why yes, sir, that is indeed the caseund Why no, sir, that is not the case) verwenden.

Da dies Codegolf ist , gewinnt der kürzeste Code!

Schnecken , 14 Bytes

&
o.,\Q!(z.,\Q

Probieren Sie es online!

Nichts geht über eine 2D-Pattern-Matching-Sprache für ein 2D-Entscheidungsproblem. :)

Erläuterung

Bei &der Option in der ersten Zeile handelt es sich um einen Übereinstimmungsmodus, bei dem das Muster in der zweiten Zeile von jeder möglichen Position in der Eingabe aus übereinstimmen muss. In diesem Fall wird das Programm gedruckt 1, andernfalls wird es gedruckt 0.

Beachten Sie, dass für das Muster selbst )am Ende ein Implizit steht.

o       ,, Move in any orthogonal direction (up, down, left or right).
.,\Q    ,, Make sure that there's a Q somewhere in that direction from the
        ,, starting position of the match.
!(      ,, After finding the Q, make sure that the following part _doesn't_ match:
  z     ,,   Move in any orthogonal or diagonal direction.
  .,\Q  ,,   Try to find another Q in a straight line.
)

Warum dies funktioniert, ist am einfachsten zu erkennen, wenn Sie vom negativen Lookahead ausgehen: Wenn Sie sicherstellen, dass keine QGerade zu der Qbereits gefundenen Linie gehört , stellen Sie sicher, dass nicht mehr als N Königinnen vorhanden sind (andernfalls wäre dies der Fall) zwei in einer Reihe zu sein, und es wäre nicht möglich, diese Königinnen zu finden, ohne eine andere zu finden). Dann stellt der erste Teil sicher, dass es eine Königin gibt, die in einer orthogonalen Richtung von jeder Position aus erreichbar ist, dass es genau N Königinnen gibt. Wenn einer fehlen würde, gäbe es eine Reihe und eine Spalte ohne eine Königin. Ausgehend von deren Schnittpunkt wäre es nicht möglich, eine Königin nur in orthogonaler Richtung zu finden.

Gelee , 17 oder 15 Bytes

ỴµUŒD;ŒD;ZVṀ;V=1Ṃ

Probieren Sie es online!

Verwendet ‘für eine Königin und ¹für Leerzeichen. (Dies ist hauptsächlich eine Folge des Verbots, Eingaben als Array zu verwenden, da es die Eingabe zu Zeichenfolgen zwingt. Die Konvertierung von Zeichenfolgen in Ganzzahlen ist in Jelly schwierig, wobei die einfachste Methode die Auswertung ist 0 mit "add 1" ( ‘) und "add 0" ( ¹) ermöglichen das Weglassen mehrerer Summen- und Kartenanweisungen, da wir die Damen in einer Liste zählen können, indem wir sie auswerten.) Die Wahrheits- und Falschheitswerte sind Jellys normale 1und 0.

BEARBEITEN: Die Frage wurde geändert, seit ich diese Antwort geschrieben habe, damit Eingaben als Matrix verwendet werden können. Dies ermöglicht das Löschen der führenden Ỵµund spart 2 Bytes. Wahrscheinlich erlaubt es auch, das Eingabeformat auf etwas Normaleres zu ändern, indem Sman eher summiert als Vauswertet, aber ich glaube nicht, dass dies Bytes spart, und ich mag dieses irre Format.

Erläuterung

ỴµUŒD;ŒD;ZVṀ;V=1Ṃ
Ỵ                    Split on newlines.
 µ                   Set this value as the default for missing arguments.
     ;  ;            Concatenate the following three values:
  UŒD                - the antidiagonals;
      ŒD             - the diagonals;
         Z           - and the columns.
          V          Evaluate (i.e. count the queens on) all of those.
           Ṁ         Take the largest value among the results.
            ;V       Append the evaluation (i.e. queen count) of {each row}.
              =1     Compare each value to 1.
                Ṃ    Take the minimum (i.e. most falsey) result.

Die Grundidee ist also, dass wir sicherstellen, dass höchstens eine Dame auf jeder Antidiagonale, Diagonale und Säule steht. und genau eine Dame in jeder Reihe. Diese Bedingungen sind zusammen ausreichend, um zu erfordern, dass sich höchstens eine Dame auf jeder der vier Linienarten und eine der Seitenlänge des Brettes entsprechende Anzahl von Damen befindet.

Im Übrigen könnte Jelly wahrscheinlich ein eingebautes Gegenmittel gebrauchen, aber AFAICT scheint es nicht zu geben, also muss ich mich damit begnügen, das Brett zu reflektieren und dann die Diagonalen zu nehmen.

Eine weitere interessante Anmerkung ist, dass das Ändern =1Ṃauf E(alle gleich) einen verallgemeinerten n- Queens-Checker ergibt, der auch ein n × n- Board akzeptiert, bei dem jede Zeile, Spalte, Diagonale und Antidiagonale nicht mehr als k Queens enthält und das Board genau enthält kn Königinnen. Das Beschränken von k auf 1 kostet tatsächlich zwei Bytes.

Oktave, 57 70 67 51 52 Bytes

1 Byte mit flipanstatt rot90dank @LuisMendo gespeichert, aber einen Fehler im 1x1-Fall gefunden

@(A)all(sum([A A' (d=@spdiags)(A) d(flip(A))],1)==1)

Übernimmt die Eingabe als binäre Matrix, wobei 1 für eine Dame und 0 für ein leeres Feld steht.

Erstellt eine anonyme Funktion, die zuerst die Eingabematrix und ihre Transponierung verkettet.

spdiagsErstellt eine Matrix mit der gleichen Anzahl von Zeilen wie das Argument, wobei die Diagonalen in Spalten umgewandelt werden (nach Bedarf mit Nullen aufgefüllt). Verketten Sie also spdiagsdie Eingabematrix, um die Diagonalen zu erhalten, und spdiagsdie Matrix horizontal, um die Antidiagonalen zu erhalten.

Nehmen Sie nun die Summe jeder Spalte der verketteten Matrix und stellen Sie sicher, dass jede Spalte genau 1 ist.

Probelauf auf ideone .

MATL , 38 34 Bytes

4 Bytes weniger dank @beaker !

sG!sGt&n_w&:&XdsGP5M&Xdsv2<GnGzU=*

Die Eingabe ist ein 2D-Array aus Nullen und Einsen, wobei Semikolons als Zeilentrennzeichen verwendet werden.

Dies gibt einen Spaltenvektor von Eins als wahr und einen Spaltenvektor mit mindestens einer Null als falsch aus.

Probieren Sie es online! Der Footer-Code ist eine ifVerzweigung, um Wahrhaftigkeit oder Falschheit zu demonstrieren.

Oder überprüfen Sie alle Testfälle .

Erläuterung

s      % Input binary matrix implicitly. Sum of columns. Gives a row vector
G!     % Paste input again. Transpose
s      % Sum of columns (rows in the original matrix). Gives a row vector
G      % Paste input again
t&n    % Duplicate. Push number of rows and number of columns (will be equal)
_w     % Negate, flip
&:     % Binary range. Gives [-n -n+1 ... n] for input of size n×n
&Xd    % Get diagonals -n through n. This gives all diagonals as colums
s      % Sum of each column (diagonals of original matrix). Gives a row vector
GP     % Paste input again. Flip vertically
5M     % Push [-n -n+1 ... n] again
&Xd    % Get diagonals -n through n (anti-diagonals of original matrix)
s      % Sum of each column. Gives a row vector
v      % Concatenate everything into a column vector
2<     % True for elements that are less than 2
Gn     % Paste input again. Number of elements
Gz     % Paste input again. Number of nonzeros (i.e. of queens)
U      % Square
=      % True if equal
*      % Mutiply, element-wise

J , 37 Bytes

(+/&,=#)*1=[:>./+//.,+//.&|.,+/,+/&|:

Anonymer Funktionszug, der die Boolesche Matrix als Argument verwendet.

Probieren Sie es online!

( +/die Summe &von ,Ravel =gleich #der tally der Zeilen)

* und (lit. times)

1eins =entspricht [:dem >./Maximum von

+/die Summen /.diagonal ,und (wörtlich verkettet)

+/die Summen /.diagonal &von |.der Rückseite ,und

+/die Summen über ,und

+/die Summen &von |:den transponieren

SnakeEx , 67 Bytes

m:({q<>}({q<R>}[{q<RF>}{n<RF>}].)*{e<>}<R>)%{4}
e:.$
q:_*Q_*$
n:_+$

Verwendet _anstelle von .in der Eingabe. Gibt 1 oder mehr Übereinstimmungen für die Wahrheit zurück, 0 Übereinstimmungen für Falsey. Einen Online-Dolmetscher finden Sie unter dem Link in der Kopfzeile.

Erläuterung

SnakeEx ist eine Sprache aus der 2-D Pattern Matching Challenge . Es definiert "Schlangen", die sich um das Gitter bewegen, das zum Material passt. Schlangen können andere Schlangen hervorbringen, was die Sprache sehr mächtig macht.

Lassen Sie uns dieses Programm von unten nach oben betrachten.

n:_+$

Dies definiert eine Schlange n, die einem oder mehreren Unterstrichen und dann der Kante des Gitters entspricht. Beachten Sie, dass dies in eine der 8 Hauptrichtungen erfolgen kann - die Richtung wird bestimmt, wenn die Schlange erzeugt wird.

q:_*Q_*$

Ähnlich wie noben definiert diesq eine Schlange, die mit einer beliebigen Anzahl von Unterstrichen, einer einzelnen Q, einer beliebigen Anzahl von Unterstrichen und der Kante des Gitters übereinstimmt . Mit anderen Worten, eine Zeile / Spalte / Diagonale, die nur eine Dame enthält.

e:.$

e ist eine Schlange, die einem Charakter und dem Rand des Gitters entspricht.

m:({q<>}({q<R>}[{q<RF>}{n<RF>}].)*{e<>}<R>)%{4}

Die Hauptschlange m benutzt diese Bausteine, um das gesamte Board zu überprüfen. Konzeptionell läuft es um die Außenkanten des Gitters herum und erzeugt andere Schlangen, um zu überprüfen, ob alle Spalten und Zeilen genau eine Dame haben und alle Diagonalen höchstens eine Dame. Wenn eine der hervorgebrachten Schlangen nicht übereinstimmt, schlägt die gesamte Übereinstimmung fehl. Lassen Sie es uns aufschlüsseln.

• ( )%{4}Führt den Inhalt der Klammern viermal aus, und zwar einmal für jede Seite. (Im Folgenden ist es hilfreich, sich eine bestimmte Seite vorzustellen, z. B. die obere Kante des Rasters, beginnend mit der linken oberen Ecke und nach rechts bewegend.)
• {q<>}erzeugt eine qSchlange in der gleichen Richtung, in der sich die Hauptschlange bewegt. Dies stellt sicher, dass die aktuelle Flanke der Regel "genau eine Dame" entspricht. Beachten Sie, dass gespawnte Schlangen den Match-Zeiger der Hauptschlange nicht bewegen, sodass wir uns immer noch am Rand befinden.
• ( )* Stimmt mit 0 oder mehr der Angaben in Klammern überein.
• {q<R>}erzeugt eine qSchlange, die von der Richtung der Hauptschlange nach rechts gedreht ist. (Wenn sich die Hauptschlange z. B. am oberen Rand nach rechts bewegt, bewegt sich diese Schlange nach unten.) Dies überprüft jede Spalte / Zeile.
• [ ] Entspricht einer der Optionen in den Klammern:
  • {q<RF>}erzeugt eine qSchlange, die um 45 Grad nach rechts (dh nach Rrechts und nach Frechts) von der Richtung der Hauptschlange gedreht ist. Die qSchlange passt, wenn die Diagonale genau eine Dame enthält.
  • {n<RF>}bringt nstattdessen eine Schlange hervor. Die nSchlange passt, wenn die Diagonale keine Königinnen enthält.
• . Stimmt mit einem beliebigen Zeichen überein, wobei der Übereinstimmungszeiger nach vorne bewegt wird.
• Nachdem wir so viele Horizontale und Diagonalen wie möglich überprüft haben, stellen wir durch Laichen sicher, dass wir am Rand sind {e<>} .
• Zum Schluss wird <R>die Hauptschlange nach rechts gedreht, um mit der nächsten Kante übereinzustimmen.

Komisches Zeug

• Es gibt nichts im Programm, was sicherstellen könnte, dass das Matching an einer Außenecke beginnt. Tatsächlich ergeben die wahrheitsgemäßen Testfälle mehrere Übereinstimmungen, von denen einige irgendwo von innen beginnen. Trotzdem hat keiner der von mir ausprobierten Falsey-Fälle einen Fehlalarm ausgelöst.
• Wenn ich die Sprachspezifikation richtig lese , hätte ich in der Lage sein sollen X(in alle diagonalen Richtungen zu verzweigen), anstelle von RF. Leider hat der Online-Interpreter einen Syntaxfehler gemeldet. Ich habe auch versucht *(in alle Richtungen abzweigen), aber das hat den Dolmetscher aufgehängt.
• Theoretisch sollte so etwas _*Q?_*$funktionieren, um "höchstens eine Königin" in den Diagonalen zu finden, aber das hat auch den Dolmetscher aufgehängt. Ich vermute, dass die Möglichkeit leerer Übereinstimmungen Probleme verursacht.

Ruby, 120 Bytes

Die Lambda-Funktion basiert auf der ursprünglichen Spezifikation, für die eine Eingabe als Zeichenfolge erforderlich war.

->s{t=k=0
a=[]
s.bytes{|i|i>65&&(a.map{|j|t&&=((k-j)**4).imag!=0};a<<k)
k=i<11?k.real+1:k+?i.to_c}
t&&~a.size**2>s.size}

wandelt die Qs in komplexe Zahlen um und subtrahiert sie voneinander. Wenn der Unterschied zwischen den Koordinaten von zwei Königinnen horizontal, vertikal oder diagonal ist, ergibt das Erhöhen auf die 4. Potenz eine reelle Zahl und die Anordnung ist ungültig.

Ungolfed im Testprogramm

f=->s{                                 #Take input as string argument.
  t=k=0                                #k=coordinate of character. t=0 (truthy in ruby.)
  a=[]                                 #Empty array for storing coordinates.
  s.bytes{                             #Iterate through all characters as bytes.
    |i|i>65&&(                         #If alphabetical, compare the current value of k to the contents of a
      a.map{|j|t&&=((k-j)**4).imag!=0} #If k-j is horizontal, vertical or diagonal, (k-j)**4 will be real and t will be false
      a<<k)                            #Add the new value of k to the end of a.
    k=i<11?k.real+1:k+?i.to_c          #If not a newline, increment the imaginary part of k. If a newline, set imaginary to 0 and increment real
  }                                    #s.size should be a*a + a newlines. ~a.size = -1-a.size, so ~a.size**2 = (a.size+1)**2
t&&~a.size**2>s.size}                  #compare a.size with s.size and AND the result with t. Return value. 


p f["...Q....
......Q.
..Q.....
.......Q
.Q......
....Q...
Q.......
.....Q.."]

p f["...Q.
Q....
.Q...
....Q
..Q.."]

p f["Q.
Q."]

p f["..Q
...
.Q."]

p f["..Q.
Q...
...Q
.Q.."]

p f["Q"]

Python 3 , 232 200 155 Bytes

d=1
f=input()
Q=[]
for i in f:d=[0,d][i.count('Q')==1];Q+=[(len(Q),i.index('Q'))]
print[0,d][sum(k[1]==i[1]or sum(k)==sum(i)for k in Q for i in Q)==len(Q)]

Probieren Sie es online!

-32 Bytes dank @beaker, der eine Änderung der Eingangsspezifikationen bemerkt; Ich habe die Sprache von Python 3 auf 2 geändert, sodass ich sie verwenden kanninput Eingaben als Array von Zeichenfolgen oder als Array von Zeichenarrays verwenden kann.

-45 Bytes dank @Leaky Nun

JavaScript (ES6), 115 Byte

a=>!a.some((b,i)=>b.some((q,j)=>q&&h[i]|v[j]|d[i+j]|e[i-j]|!(h[i]=v[j]=d[i+j]=e[i-j]=1))|!h[i],h=[],v=[],d=[],e=[])

Ungolfed:

function queens(arr) {
    horiz = [];
    vert = [];
    diag = [];
    anti = [];
    for (i = 0; i < arr.length; i++) {
        for (j = 0; j < arr.length; j++) {
            if (arr[i][j]) { // if there is a queen...
                if (horiz[i]) return false; // not already on the same row
                if (vert[j]) return false; // or column
                if (diag[i + j]) return false; // or diagonal
                if (anti[i - j]) return false; // or antidiagonal
                horiz[i] = vert[j] = diag[i + j] = anti[i - j] = true; // mark it
            }
        }
        if (!horiz[i]) return false; // fail if no queen in this row
    }
    return true;
}

Ruby, 155 Bytes

->x{(y=x.map{|r|(i=r.index ?Q)==r.rindex(?Q)?i:p or-2}).zip(y.rotate).map.with_index{|n,i|n.max-n.min==1&&i<y.size-1?-2:n[0]}.inject(:+)*2==(s=x.size)*~-s}

Das ist schrecklich zu lesen, deshalb habe ich unten eine etwas weniger golfene Version

->x{
    (y=x.map{|r|(i=r.index ?Q)==r.rindex(?Q)?i:p or-2})
    .zip(y.rotate)
    .map.with_index{|n,i|n.max-n.min==1&&i<y.size-1?-2:n[0]}
    .inject(:+)*2==(s=x.size)*~-s
}

Dies ist derselbe Code, aber mit einigen Zeilenumbrüchen, um herauszufinden, was passiert.

Der Code selbst ist eine anonyme Lambda-Funktion, die ein Array von Strings ( x) im Format annimmt ["..Q", "Q..", ".Q."].

Die erste Zeile ordnet jede Zeichenfolge dem Index des Q-Zeichens in dieser Zeichenfolge zu. Wenn es kein Q-Zeichen gibt, wird es durch -2 ^{1 ersetzt} . Dieses neue Array von Indizes wird der Variablen zugewiesen y.

In der nächsten Zeile wird dieses Indexarray mit einem Versatz von eins (gedreht) gezippt. Dies führt zu einer Reihe von Paaren aufeinanderfolgender Indizes.

Die nächste Zeile ist besonders kompliziert. Es durchläuft jedes der Indexpaare und subtrahiert das kleinere vom größeren. Wenn dies 1 ist (und wir sind nicht beim letzten Paar ²⁾ ), dann gibt es zwei Damen, die sich auf derselben Diagonale befinden, und ein Wert von -2 wird eingefügt, andernfalls wird der ursprüngliche Index der Dame in der Zeichenfolge eingefügt .

Die letzte Zeile fasst alle Indizes für jeden zusammen und prüft, ob es sich um die Dreieckszahl für n-1 handelt, wobei n die Breite (oder Höhe) des Quadrats ist.

1: -1 wäre mein Anliegen gewesen, aber es ist 1, abgesehen von 0, also würde ich mich mit dem Prüfen von Diagonalen herumschlagen. Die Negativität ist wichtig, um die Endsumme falsch zu machen. Ich habe über eine hohe Zahl (mit einzelnen Ziffern) wie 9 nachgedacht, kann jedoch nicht sicher sein, dass dies nicht zu einer falschen Bestätigung führt.
2: Das Board wickelt sich nicht um, wohingegen Rubys rotateArray-Funktion dies tut, und wenn sich das letzte Paar um eins unterscheidet, spielt es keine Rolle - das ist keine Diagonale.

PHP, 137 143 Bytes

inspiriert von Neils Lösung

for($n=1+strlen($s=$argv[1])**.5|0;($c=$s[$p])&&!(Q==$c&&$v[$x=$p%$n]++|$h[$x=$p/$n]++|$d[$y-$x]++|$a[$y+$x]++);$p++);echo$n-1==count($a)&&!$c;

Nimmt Eingaben vom ersten Befehlszeilenargument entgegen; renn mit -r. Erfordert Einzelbyte-Zeilenumbrüche.
^{Eigentlich kann man jedes Zeichen außer 0für den Zeilenumbruch verwenden.}
Gibt true ( 1) oder false (leere Zeichenfolge) aus.

Nervenzusammenbruch

for($n=1+strlen($s=$argv[1])**.5|0; // copy input to $s, $n=size+1 (for the linebreak)
    ($c=$s[$p])&&!(                 // loop through characters
        Q==$c&&                         // if queen: test and increment lines
            $v[$x=$p%$n]++|$h[$x=$p/$n]++|$d[$y-$x]++|$a[$y+$x]++
    );                                  // break if a line had been marked before
    $p++);
echo$n-1==count($a)             // print result: true for $n-1(=size) marks
    &&!$c;                      // and loop has finished

Python 3 , 185 176 175 172 171 Bytes

lambda x,c=lambda x:x.count("Q")==1:all([*map(c,x+[[l[i]for l in x]for i in range(len(x[0]))])])*~any(map(lambda s:"Q%sQ"%(s*".")in"".join(x),[len(x[0]),len(x[0])-2]))==-1

Eine anonyme Funktion, die eine Liste von Zeichenfolgen als Eingabe verwendet.

Python 2 , 175 Bytes

lambda x:all([a.count("Q")==1for a in x]+[[l[i]for l in x].count("Q")==1for i in range(len(x[0]))]+[all(map(lambda s:"Q%sQ"%(s*".")not in"".join(x),[len(x[0]),len(x[0])-2]))])