(Nonostante le oltre 60 domande taggate a scacchi , non abbiamo una semplice sfida di n-regine.)

Negli scacchi, l' N-Queens Puzzle è descritto come segue: date una n x nscacchiera e delle nregine, disponete le regine sulla scacchiera in modo che non vi siano due regine che si minacciano a vicenda. Di seguito è una soluzione di esempio per n = 8, presa in prestito da Wikipedia.

Oppure, nel rendering ASCII:

xxxQxxxx
xxxxxxQx
xxQxxxxx
xxxxxxxQ
xQxxxxxx
xxxxQxxx
Qxxxxxxx
xxxxxQxx

La sfida qui sarà quella di prendere input ne output di una rappresentazione ASCII di una soluzione al npuzzle -Queens. Poiché esistono più soluzioni possibili (ad esempio, almeno una rotazione o una riflessione), il codice deve solo generare una soluzione valida.

Ingresso

Un singolo intero positivo ncon n >= 4 in qualsiasi formato conveniente . (n = 2 e n = 3 non hanno soluzioni e n = 1 è banale, quindi sono esclusi)

Produzione

La rappresentazione ASCII risultante di una soluzione al puzzle delle regine N, come indicato sopra. È possibile scegliere due valori ASCII distinti per rappresentare spazi vuoti e regine. Ancora una volta, questo può essere emesso in qualsiasi formato adatto (stringa singola, un elenco di stringhe, un array di caratteri, ecc.).

Regole

• Le nuove righe o spazi iniziali iniziali o finali sono tutti facoltativi, così come gli spazi bianchi tra i caratteri, a condizione che i caratteri stessi si allineino correttamente.
• Puoi utilizzare un algoritmo per calcolare le posizioni possibili o utilizzare lo stile esplicito di soluzione "gradino", a seconda di quale sia il più golfista per il tuo codice.
• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Se possibile, includi un link a un ambiente di test online in modo che altre persone possano provare il tuo codice!
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Esempi

n=4
xQxx
xxxQ
Qxxx
xxQx

n=7
xxQxxxx
xxxxxxQ
xQxxxxx
xxxQxxx
xxxxxQx
Qxxxxxx
xxxxQxx

n=10
xxxxQxxxxx
xxxxxxxxxQ
xxxQxxxxxx
xxxxxxxxQx
xxQxxxxxxx
xxxxxxxQxx
xQxxxxxxxx
xxxxxxQxxx
Qxxxxxxxxx
xxxxxQxxxx

MATL , 33 32 27 byte

`x,GZ@]1Z?tt!P!,w&TXds]h1>a

Provalo online!

Forza semi-bruta, approccio non deterministico:

1. Genera una permutazione casuale di posizioni di riga
2. Genera una permutazione casuale di posizioni di colonna
3. Verifica che nessuna regina condivida una diagonale o una anti-diagonale
4. Ripetere se necessario.

La soluzione ottenuta è casuale. Se si esegue nuovamente il codice, è possibile ottenere una configurazione valida diversa. Anche il tempo di esecuzione è casuale, ma il test case più lungo ( n = 10) termina in circa 30 secondi in TIO la maggior parte delle volte.

C, 114 byte

Q(n,o,y){o=n%2;n-=o;for(y=0;y<n+o;++y)printf("%*c\n",y<n?o+n-(n+y%(n/2)*2+(n%6?y<n/2?n/2-1:2-n/2:y<n/2))%n:0,81);}

Stampa direttamente una soluzione in O (1) tempo.

Mathematica, 103 108 110 117 byte

-5 byte per DuplicateFreeQ->E!=##&@@@

-7 byte per ReplacePart[Array[],]->SparseArray[]

SparseArray[Thread@#&@@Select[Permutations@Range@#~Tuples~2,And@@(E!=##&@@@{#-#2,+##})&@@#&]->1,{#,#}]&

Restituisce un array 2D. Ci vogliono 2,76 per calcolare f[6]e 135 per f[7]. (Nella versione corrente, -diventa 0e Qa 1.

L'algoritmo è simile alla risposta MATL ma qui il codice è completamente a forza bruta.

C - 222 byte

v,i,j,k,l,s,a[99];main(){for(scanf("%d",&s);*a-s;v=a[j*=v]-a[i],k=i<s,j+=(v=j<s&&(!k&&!!printf(2+"\n\n%c"-(!l<<!j)," #Q"[l^v?(l^j)&1:2])&&++l||a[i]<s&&v&&v-i+j&&v+i-j))&&!(l%=s),v||(i==j?a[i+=k]=0:++a[i])>=s*k&&++a[--i]);}

Il codice non è mio, ma dall'IOCCC . Spero di non infrangere alcuna regola. Inoltre, questo mostra tutte le soluzioni per N tra 4 e 99. In seguito proverò a ottenere un collegamento TIO.

Gelatina , 24 21 byte

,JŒc€IF€An/PC
ẊÇ¿=þRG

Provalo online!

Supponendo che ogni regina sia posizionata su file separate, dobbiamo solo trovare gli indici di colonna in cui posizionare ciascuna regina per evitare conflitti, che possono essere trovati generando una permutazione casuale [1, 2, ..., n]e testandola.

Spiegazione

,JŒc€IF€An/PC  Helper. Input: permutation of [1, 2, ..., n]
 J             Enumerate indices, obtains [1, 2, ..., n]
,              Join
  Œc€          Find all pairs in each
     I         Calculate the difference of each pair
      F€       Flatten each
        A      Absolute value
               (We now have the distance in column between each queen and
                the distance in rows between each queen. If they are unequal,
                the queens do not conflict with each other)
         n/    Reduce using not-equals
           P   Product, returns 1 only if they are all unequal
            C  Complement
               Returns 1 when there is a conflict, else 0

ẊÇ¿=þRG  Main.  Input: n
Ẋ        Shuffle (When given an integer, it will shuffle [1, 2, ..., n])
 Ç¿      While the helper returns 1, continue shuffling
     R   Range, gets [1, 2, ..., n]
   =þ    Equality table (Generates the board as a matrix)
      G  Pretty-print the matrix

Python 3, 204 189 byte

import itertools as p
n=int(input())
r=range(n)
b='.'*(n-1)+'Q'
for c in p.permutations(r):
 if len(set((x*z+c[x],z)for x in r for z in[1,-1]))==n+n:[print(*(b[x:]+b[:x]))for x in c];break

Ricerca della forza bruta attraverso tutte le permutazioni. Potrei rimuovere il * e stampare la comprensione dell'elenco, ma sembrano orribili.

Produzione:

10
Q . . . . . . . . .
. . Q . . . . . . .
. . . . . Q . . . .
. . . . . . . Q . .
. . . . . . . . . Q
. . . . Q . . . . .
. . . . . . . . Q .
. Q . . . . . . . .
. . . Q . . . . . .
. . . . . . Q . . .

Leggermente non golfato:

import itertools as p
n=int(input())
r=range(n)
b='.'*(n-1)+'Q'
for c in p.permutations(r):
    if len(set( (x*z+c[x],z) for x in r for z in[1,-1] )) == n+n:
        [print(*(b[x:] + b[:x])) for x in c]
        break

Befunge, 122 byte

&::2%-v>2*00g++00g%00g\-\00g\`*4>8#4*#<,#-:#1_$55+"Q",,:#v_@
/2p00:<^%g01\+*+1*!!%6g00-2g01\**!!%6g00-g012!:`\g01:::-1<p01

Provalo online!

Questo è più o meno basato sulla soluzione C di orlp .

Spiegazione

Leggi il numero di regine, q , da stdin e calcola due variabili per un uso successivo:, n = q - q%2e hn = n/2
avvia il ciclo principale, ripetendo r , il numero di riga, da q fino a 0, diminuendo all'inizio del ciclo, quindi la prima r è q meno 1.
Calcola l'offset della regina in ogni riga con la seguente formula:

offset = (n - (
  (hn <= r) * (2 - hn) * !!(n % 6) + 
  (hn > r) * ((hn - 2) * !!(n % 6) + 1) + 
  (y % hn * 2) + n
) % n) * (n > r)

Caratteri di spazio offset di output per indentare la posizione della regina per la riga corrente, più uno spazio aggiuntivo solo perché semplifica il loop di output.
Invia a Qper la regina, seguito da una nuova riga per passare alla riga successiva.
Verifica se r è zero, nel qual caso abbiamo raggiunto la fine della scheda e possiamo uscire, altrimenti ripetiamo nuovamente il loop principale.

Haskell , 145 byte

L'ovvio approccio della forza bruta:

b=1>0
t[]=b
t(q:r)=all(/=q)r&&foldr(\(a,b)->(abs(q-b)/=a&&))b(zip[1..]r)&&t r
q n|y<-[1..n]=(\q->(' '<$[1..q])++"Q")<$>[x|x<-mapM(\_->y)y,t x]!!0

Provalo online!

Retina , 136 byte

.+
$* 
 
$_;$`Q¶
( +)\1( ?);
:$1;
:( +);\1\1
$1$1
:((   )+);( *)
 $1$1% $3$3
: ( +);( \1)?( *)
 $1 $1%$#2$* $#2$* $#2$* $1$3$3
( +)%\1?

Provalo online! Eccellente risposta C di Port of @ orlp. Spiegazione:

.+
$* 

Converti in unario, usando gli spazi (c'è uno spazio dopo il *).

$_;$`Q¶

Crea Nrighe con Nspazi, a ;, quindi 0..N-1spazi, quindi a Q. Le fasi rimanenti si applicano a tutte le righe.

( +)\1( ?);
:$1;

Numero intero diviso Nper 2. (Avvolgere anche il risultato :;per facilitare l'ancoraggio dei motivi.)

:( +);\1\1
$1$1

Se l'indice del loop è uguale N/2*2, lascia solo quegli spazi.

:((   )+);( *)
 $1$1% $3$3

Se N/2 è un multiplo di 3, prendi il doppio dell'indice del ciclo più uno, modulo N/2*2+1.

: ( +);( \1)?( *)
 $1 $1%$#2$* $#2$* $#2$* $1$3$3

Altrimenti, prendi il doppio dell'indice del loop più (N/2-1)più un extra 3 nella metà inferiore della scheda, moduloN/2*2 .

( +)%\1?

Effettuare effettivamente l'operazione del modulo.

Carbone , 44 byte

Ｎθ≔÷θ²ηＥθ◧Q⊕⎇⁼ι⊗ηι⎇﹪η³﹪⁺⁺⊗ι⊖η׳¬‹ιη⊗η﹪⊕⊗ι⊕⊗η

Provalo online! Il collegamento è alla versione dettagliata del codice. Un'altra porta dell'eccellente risposta C di @ orlp.

APL (Dyalog Unicode) , 18 byte ^SBCS

Programma completo che richiede nda stdin. Stampa la soluzione separata dallo spazio su stdout usando ·per i quadrati vuoti e ⍟per le Regine.

⎕CY'dfns'
⊃queens⎕

Provalo online!

⎕CY'dfns' C op y i "dfns" biblioteca

⎕ ottenere input da stdin

queens trova tutte le soluzioni Queens davvero uniche (nessun riflesso o rotazione)

⊃ scegli la prima soluzione

J , 49 byte

i.=/0({(1-.@e.,)@(([:(=#\){.|@-}.)\."1)#])!A.&i.]

Provalo online!

Forza bruta testando tutte le permutazioni di lunghezza n .