Nei nostri amici di Puzzling.SE è stato pubblicato il seguente puzzle: Questo puzzle cromatico è sempre risolvibile? di Edgar G. Puoi giocarci qui .

Spiegazione del puzzle

Data una m x ngriglia con tessere di tre colori diversi, è possibile selezionare due tessere adiacenti , se i loro colori sono diversi . Queste due tessere vengono quindi convertite nel terzo colore, ovvero l'unico colore non rappresentato da queste due tessere. Il puzzle è risolto se tutte le tessere hanno lo stesso colore . A quanto pare, si può dimostrare che questo puzzle è sempre risolvibile, se non mne nsono divisibile per 3.

Naturalmente, ciò richiede un algoritmo di risoluzione. Scriverai una funzione o un programma che risolve questo enigma. Si noti che le funzioni con "effetti collaterali" (ovvero, l'output è attivo stdoutanziché in un valore di ritorno del tipo di dati scomodo) sono esplicitamente consentite.

Input Output

L'ingresso sarà una m x nmatrice costituita da numeri interi 1, 2e 3(o 0, 1, 2se conveniente). Puoi prendere questo input in qualsiasi formato sano. Sia me nsono >1e non divisibile per 3. Si può assumere il puzzle non è risolto

Quindi risolverai il puzzle. Ciò comporterà una ripetuta selezione di due tessere adiacenti da "convertire" (vedi sopra). Verranno emesse le due coordinate di queste tessere per ogni passaggio effettuato dall'algoritmo di risoluzione. Questo può anche essere in qualsiasi formato di output sano. Sei libero di scegliere tra l'indicizzazione in base 0 e in base 1 delle tue coordinate e se le righe o le colonne devono essere indicizzate per prime. Per favore, menzionalo nella tua risposta, comunque.

Il tuo algoritmo dovrebbe essere eseguito in tempi ragionevoli sul case originale 8x8. La forzatura bruta completamente è esplicitamente vietata, ovvero l'algoritmo dovrebbe essere eseguito O(k^[m*(n-1)+(m-1)*n])con kil numero di passaggi necessari per la soluzione. Tuttavia, non è necessario che la soluzione sia ottimale. La prova fornita nella domanda collegata può darti un'idea di come farlo (ad esempio, prima fai tutte le colonne usando solo tessere adiacenti verticalmente, quindi fai tutte le righe)

Casi test

In questi casi di test, le coordinate sono basate su 1 e le righe vengono prima indicizzate (come MATLAB / Octave e probabilmente molte altre).

Input: 
[1 2]
Output: (result: all 3's)
[1 1],[1,2]


Input:
[ 1 2
  3 1 ]
Output: (result: all 1's)
[1 1],[2 1]        (turn left column into 2's)
[2 1],[2 2]        (turn right column into 3's)
[1 1],[1 2]        (turn top row into 1's)
[2 1],[2 2]        (turn bottom row into 1's)

Input:
[1 2 3 2
 3 2 1 1]

Output: (result: all 3's)
[1 1],[1 2] 
[1 3],[1 4] 
[1 2],[1 3] 
[1 1],[1 2] 
[1 2],[1 3] 
[1 1],[1 2]
[1 3],[1 4]
[2 1],[2 2]
[1 1],[2 1]
[1 2],[2 2]
[1 3],[2 3]
[1 4],[2 4]

Se lo si desidera, potrei pubblicare una pastebin di casi di test più grandi, ma penso che questo dovrebbe essere sufficiente.

Rubino, 266 byte

Più o meno solo una porta della soluzione Octave, tranne che risolve prima le righe anziché le colonne. L'input è una matrice di matrici, con le matrici interne come file. Le mosse di output sono [row, column, row, column]. Suite di test

->m{t=->v{v.size*v.inject(:+)%3}
s=->a,x,r{g=t[a]
(q=(r=0..a.size-2).find{|i|a[i]!=a[i+1]&&g!=a[i]}||r.find{|i|a[i]!=a[i+1]}
a[q,2]=[t[a[q,2]]]*2
p r ?[x,q,x,q+1]:[q,x,q+1,x])while[]!=a-[g]}
m.size.times{|i|s[m[i],i,1]}
m=m.shift.zip *m
m.size.times{|i|s[m[i],i,p]}}

Ungolfed con spiegazione

->m{                                  # Start lambda function, argument `m`
  t=->v{v.size*v.inject(:+)%3}        # Target color function
  s=->a,x,r{                          # Function to determine proper moves
                                      #   a = row array, x = row index, r = horizontal
    g=t[a]                            # Obtain target color
    (
      q=(r=0..a.size-2).find{|i|      # Find the first index `i` from 0 to a.size-2 where...
        a[i]!=a[i+1]                  # ...that element at `i` is different from the next...
        &&g!=a[i]                     # ...and it is not the same as the target color
      } || r.find{|i|a[i]!=a[i+1]}    # If none found just find for different colors
      a[q,2]=[t[a[q,2]]]*2            # Do the color flipping operation
      p r ?[x,q,x,q+1]:[q,x,q+1,x]    # Print the next move based on if `r` is truthy
    ) while[]!=a-[g]}                 # While row is not all the same target color, repeat
m.size.times{|i|                      # For each index `i` within the matrix's rows...
  s[m[i],i,1]                         # ...run the solving function on that row
                                      #   (`r` is truthy so the moves printed are for rows)
}
m=m.shift.zip *m                      # Dark magic to transpose the matrix
m.size.times{|i|s[m[i],i,p]}}         # Run the solving function on all the columns now
                                      #   (`r` is falsy so the moves printed are for columns)

Ottava, 334 313 byte

Dal momento che la sfida può sembrare un po 'scoraggiante, presento la mia soluzione. Non ho dimostrato formalmente che questo metodo funzioni (immagino che si ridurrà a dimostrare che l'algoritmo non si bloccherà mai in un ciclo), ma finora funziona perfettamente, facendo 100x100 test in 15 secondi. Nota che ho scelto di usare una funzione con effetti collaterali piuttosto che una che restituisca tutte le coordinate poiché mi ha salvato alcuni byte. Le coordinate sono le righe principali, basate su 1 e formattate come row1 col1 row2 col2. I colori di input sono 0,1,2poiché funziona meglio mod, a costo di dover usare numelpiuttosto che nnz. Versione golfata: Modifica: salvato altri pochi byte usando una tecnica dalla risposta di Kevin Lau.

function P(p)
k=0;[m,n]=size(p);t=@(v)mod(sum(v)*numel(v),3);for c=1:n
p(:,c)=V(p(:,c));end
k=1;for r=1:m
p(r,:)=V(p(r,:));end
function a=V(a)
while any(a-(g=t(a)))
isempty(q=find(diff(a)&a(1:end-1)-g,1))&&(q=find(diff(a),1));
a([q q+1])=t(a([q q+1]));if k
disp([r q r q+1])
else
disp([q c q+1 c])
end;end;end;end

Esempio GIF dell'algoritmo di risoluzione:

Versione non golfata:

function solveChromaticPuzzle(p)
[m,n]=size(p);                           % Get size
t=@(v)mod(sum(v)*numel(v),3);            % Target colour function
for c=1:n                                % Loop over columns
    p(:,c)=solveVec(p(:,c));             % Solve vector
end
for r=1:m                                % Loop over rows
    p(r,:)=solveVec(p(r,:));
end
    function a=solveVec(a)               % Nested function to get globals
        g=t(a);                          % Determine target colour
        while(any(a~=g))                 % While any is diff from target...
            % Do the finding magic. Working left-to-right, we find the
            % first pair that can be flipped (nonzero diff) that does not
            % have the left colour different from our goal colour
            q=min(intersect(find(diff(a)),find(a~=g)));
            if(isempty(q))               % In case we get stuck...
                q=find(diff(a),1);       % ... just flip the first possible
            end;
            a([q q+1])=t(a([q q+1]));    % Do the actual flipping.
            if(exist('r'))               % If we're working per row
                disp([r q r q+1])        % Print the pair, using global row
            else
                disp([q c q+1 c])        % Print the pari, using global col
            end
        end
    end
end

Lua, 594 575 559 byte

Avvertenza C'è ancora molto lavoro da fare prima che io abbia finito con questo golf! Dovrei essere in grado di prenderlo a meno di 500 byte, almeno. Per il momento, è la prima soluzione che ha funzionato e ci sto ancora lavorando.

Fornirò una spiegazione completa una volta terminato.

function f(t)s=#t a=","for i=1,s do p=t[i]for i=1,s
do p.Q=p.Q and p.Q+p[i]or p[i]end p.Q=(p.Q*#p)%3 for i=1,s do for j=1,#p-1 do
x=p[j]y=p[j+1]u=x~=y and(p.S and p.R==p.S or x~=p.Q)v=(x+y)*2p[j]=u and v%3or x
p[j+1]=u and v%3or y print(i..a..j,i..a..j+1)end
p.R=p.S p.S=table.concat(p)end end
for i=1,s do Q=Q and Q+t[i][1]or t[i][1]end Q=(Q*s)%3 for i=1,s
do for j=1,s-1 do p=t[j]q=t[j+1]x=p[1]y=q[1]u=x~=y and(S and R==S or x~=Q)v=(x+y)*2
for k=1,#p do p[k]=u and v%3or x q[k]=u and v%3or y
print(j..a..k,j+1..a..k)end Y=Y and Y..x or x end
R=S S=Y end end

Ruggine, 496 495 byte

Purtroppo non riesco a battere OP, ma per una risposta Rust sono abbastanza soddisfatto del bytecount.

let s=|mut v:Vec<_>,c|{
let p=|v:&mut[_],f,t|{
let x=|v:&mut[_],i|{
let n=v[i]^v[i+1];v[i]=n;v[i+1]=n;
for k in f..t+1{print!("{:?}",if f==t{(k,i,k,i+1)}else{(i,k,i+1,k)});}};
let l=v.len();let t=(1..4).find(|x|l*x)%3==v.iter().fold(0,|a,b|a+b)%3).unwrap();
let mut i=0;while i<l{let c=v[i];if c==t{i+=1;}else if c==v[i+1]{
let j=if let Some(x)=(i+1..l).find(|j|v[j+1]!=c){x}else{i-=1;i};x(v,j);}else{x(v,i);}}t};
p(&mut (0..).zip(v.chunks_mut(c)).map(|(i,x)|{p(x,i,i)}).collect::<Vec<_>>(),0,c-1usize)};

Input: un vettore di numeri e il numero di colonne. Per esempio

s(vec!{1,2,1,3},2);

uscite

 (row1,col1,row2,col2)

alla riga di comando.

Prima risolvo ogni riga e poi risolvo la colonna risultante solo una volta, ma stampo i passaggi per tutte le colonne. Quindi in realtà è abbastanza efficiente :-P.

Con formulazione:

let s=|mut v:Vec<_>,c|{  
    let p=|v:&mut[_],f,t|{     // solves a single row/column
        let x=|v:&mut[_],i|{   // makes a move and prints it 
            let n=v[i]^v[i+1]; // use xor to calculate the new color
            v[i]=n;
            v[i+1]=n;
            for k in f..t{
                print!("{:?}",if f==t{(k,i,k,i+1)}else{(i,k,i+1,k)});
            }
        };
        let l=v.len();
        // find target color
        // oh man i am so looking forward to sum() being stabilized
        let t=(1..4).find(|x|(l*x)%3==v.iter().fold(0,|a,b|a+b)%3).unwrap();
        let mut i=0;
        while i<l{
            let c=v[i];
            if c==t{             // if the color is target color move on
                i+=1;
            }else if c==v[i+1]{ // if the next color is the same
                                // find the next possible move
                let j=if let Some(x)=(i+1..l).find(|j|v[j+1]!=c){x}else{i-=1;i};
                x(v,j);
            }else{              // colors are different so we can make a move
                x(v,i);         
            }
        }
        t
    };
    // first solve all rows and than sovle the resulting column c times 
    p(&mut (0..).zip(v.chunks_mut(c)).map(|(i,x)|p(x,i,i)).collect::<Vec<_>>(),0,c-1usize)
};

Modifica: ora restituisce il colore della soluzione che mi fa risparmiare un punto e virgola ^^

Befunge , 197 368 696 754 byte

(sì, sto facendo un po 'di golf a codice inverso, più byte meglio è)

Stavo pensando che potrebbe essere una sfida scrivere questo algoritmo in Befunge e che potrebbe essere divertente

Vorrei che fosse un programma comunitario, quindi se qualcuno vuole lavorarci su, per favore, fallo.

Alla fine, ho fatto tutto da solo finora, quindi finirò da solo (è quasi finito)

Cosa è ancora fatto: un codice a forma di troll

&:19p&:09p:v:p94g92g90  <
 v94+1:g94&_$59g1+59p1-:|
 >p59gp1-: ^    vp95g93$<
v94\-1<v:g<     >  v
>g:1+v^_$v^90p94g92<
v5p94<   3>1+59p   ^
>9gg+\:^ %g   v93:g95<           v3_2         v
v1pg95g94<^95<>g-v>$v^           v ^-%3*2\gg9<
>9g39g+59g-1-|v-1_^ #^pg95+g92g90<1_09g:29g+5^
       ;  >  >  09g:29g+59gg\3%-# !^v         <
          ^p95<                  ^  <
     v  p96-1+g90g92<
     v                  p95_@
            >59g1+:39g-19g-^
     v    >p 79g:59gg\1+59gp$$$$$29g49pv
    > p59g^ |<<<<<<<<<<<<<<<<<<!-g96g94<
>:79^>29g49p>69g1+59gg49g:59gg\1+49p- v
^\-\6+gg95+1\g< v         !-g96:<-1g94_^
>"]",52*,::59g^v_::1+59gg\59gg-v^ <
^ .-g93g95,.-g<>:69g- v  v-g96:_1+^
>+" [,]",,,\29^       >#v_$:49g2-v
^1:.-g93g95,.-g92\,"[ ":<        <

(sì, è un troll, credimi)

Fondamentalmente, legge un array e calcola la mossa da fare per risolvere le righe, dato un input come

(number of rows) (number of columns) 1 2 3 1 1 3 2 1 2 ....

(l'intero array viene passato come un elenco [riga1, riga2, riga3, ...])

l'uscita è

[col row],[col',row']
[col2 row2],[col2',row2']
...

righe e colonne iniziano entrambe da 0.

Ora che le righe sono state risolte, è quasi finito! Evviva!

Spiegazione: (verrà aggiornato in seguito)

Quindi ci sono 5 parti principali:

• Il primo, in verde, legge la riga di input e scrive una riga dell'array
• Il secondo, in arancione, passa alla riga successiva dell'array
• Il terzo, in blu, somma una riga
• Il quarto, in rosa caldo, prende il modulo 3 della somma, lo salva a destra della riga interessata e passa alla riga successiva
• Infine, in rosso, la parte che calcola il colore target dal numero precedentemente calcolato. Questa parte è davvero stupida e probabilmente dovrebbe essere riscritta, ma non ho capito come potrei farlo in un modo carino (passato da 197 byte a 368 con solo quella parte)

Le parti grigie sono inizializzazioni

Ecco una spiegazione più approfondita del modulo che trova le caselle to da combinare (che è codificato qui, a proposito)

                                       B
            @                          v
            |                  !-g96g94<
ENTRY>29g49p>69g1+59gg49g:59gg\1+49p- v
                v         !-g96:<-1g94_^
               v_::1+59gg\59gg-v^ <
               >:69g- v  v-g96:_1+^
                      >#v_$:49g2-v
                    CALL<        <

La parte CHIAMATA è quando il puntatore dell'istruzione sta andando su un altro modulo, da combinare con le caselle. Ritorna a questo modulo attraverso la voce 'B'

Ecco alcuni pseudo-codice: (currentx è correlato alla lettura dell'array) Per:

    69g1+59gg  // read target color
    49g:59gg\1+49p // read current color and THEN shift the currentx to the next box
    if ( top != top ){  // if the current color is bad
        49g1-          //  put the current place  (or currentx - 1) in the stack
        While:
            if ( :top != 69g ){   // if you didn't reach the end of the list
                ::1+              // copy twice, add 1
                if ( 59gg == \59gg ){ // if the next color is the same than current
                   1+                // iterate
                   break While;
                }
            }

        : // copies j (the previous raw iterator)
        if ( top == 69g ){  // if you reached the end of the row (which mean you can't swap with the color after that point)
            $:              // discard j's copy and copy target
            49g2-           // put the place just before the color change on the stack
            combine_with_next;
        } else {
            combine_with_next;
        }
        29g49p   // back to the beginning of the row (there was some changes int the row)
    }

    if ( 49g != 69g ) // if you didn't reach the end of the list
        break For:

Si noti che se si desidera testarlo, è necessario inserire un po 'di spazio finale e nuove righe in modo che vi sia spazio sufficiente per memorizzare l'array, se si desidera utilizzare l'interpretazione che ho collegato. 22 + il numero di righe in input come righe finali e 34 + il numero di colonne come spazi finali su una riga dovrebbe essere ok.

C, 404 byte

Il mio primo codice golf, sono abbastanza contento di come è venuto fuori. Ci è voluto troppo tempo, però. Non è C completamente standard, qualunque cosa verrà compilata sotto gcc senza flag speciali (e ignorando gli avvisi). Quindi c'è una funzione nidificata lì dentro. La funzione fprende le dimensioni me ncome i suoi primi argomenti, e come il suo terzo argomento prende un (puntatore int) a una matrice di dimensioni m× n(indicizzata per prima dalle righe). Gli altri argomenti sono argomenti fittizi, non è necessario passarli, sono solo lì per salvare i byte sulla dichiarazione delle variabili. Scrive ogni coppia modificata su STDOUT nel formato row1,col1:row1,col1;, con il punto e virgola che separa le coppie. Utilizza l'indicizzazione basata su 0.

#define A a[i*o+p
#define B A*c
f(m,n,a,i,j,o,p,b,c,d)int*a;{
int t(x){printf("%d,%d:%d,%d;",b?i:c+x,b?c+x:i,b?i:c+1+x,b?c+1+x:i);}
o=n;p=b=1;for(;~b;b--){
for(i=0;i<m;i++){c=j=0;
for(;j<n;)c+=A*j++];d=c*n%3;
for(j=0;j<n-1;j++) 
while(A*j]^d|A*j+p]^d){
for(c=j;B]==B+p];c++);
if(c<n-2&B]==d&2*(B+p]+A*(c+2)])%3==d)
B+p]=A*(c+2)]=d,t(1);else
B]=B+p]=2*(B]+B+p])%3,
t(0);}}o=m;p=m=n;n=o;o=1;}}

Ho usato un algoritmo leggermente diverso da OP per risolvere singole righe / colonne. Va qualcosa del genere (pseudocodice):

for j in range [0, rowlength):
    while row[j] != targetCol or row[j+1] != targetCol:
        e=j
        while row[e] == row[e+1]:
            e++             //e will never go out of bounds
        if e<=rowLength-3 and row[e] == targetCol 
                and (row[e+1] != row[e+2] != targetCol):
            row.changeColor(e+1, e+2)
        else:
            row.changeColor(e, e+1)

Il for(;~b;b--)ciclo viene eseguito esattamente due volte, al secondo passaggio risolve le colonne anziché le righe. Questo viene fatto scambiando ne m, e cambiando i valori di oe pche sono usati nell'aritmetica del puntatore per indirizzare l'array.

Ecco una versione non modificata, con un test principale, e stampa l'intero array dopo ogni mossa (premi invio al passaggio 1 giro):

#define s(x,y)b?x:y,b?y:x
#define A a[i*o+p
#define B A*e
f(m,n,a,i,j,o,p,b,c,d,e)int*a;{

    int t(x){
        printf("%d,%d:%d,%d;\n",s(i,e+x),s(i,e+1+x));
        getchar();
        printf("\n");
        for(int i2=0;i2<(b?m:n);i2++){
            for(int j2=0;j2<(b?n:m);j2++){
                printf("%d ",a[i2*(b?n:m)+j2]);
            }
            printf("\n");
        }
        printf("\n");
    }

    printf("\n");
    b=1;
    for(int i2=0;i2<(b?m:n);i2++){
        for(int j2=0;j2<(b?n:m);j2++){
            printf("%d ",a[i2*(b?n:m)+j2]);
        }
        printf("\n");
    }
    printf("\n");

    o=n;p=1;
    for(b=1;~b;b--){
        for(i=0;i<m;i++){
            c=0;
            for(j=0;j<n;j++) c+= a[i*o+p*j];
            d=0;
            d = (c*n)%3;
            for(j=0;j<n-1;j++) {
                while(a[i*o+p*j]!=d||a[i*o+p*j+p]!=d){
                    for(e=j;a[i*o+p*e]==a[i*o+p*e+p];e++);
                    if(e<=n-3 && a[i*o+p*e]==d 
                            && 2*(a[i*o+p*e+p]+a[i*o+p*(e+2)])%3==d){
                        a[i*o+p*e+p]=a[i*o+p*(e+2)]=d;
                        t(1);
                    }else{
                        a[i*o+p*e]=a[i*o+p*e+p] = 2*(a[i*o+p*e]+a[i*o+p*e+p])%3;
                        t(0);
                    }
                }
            }
        }
        o=m;p=m=n;n=o;o=1;
    }
}

main(){
    int g[11][11] = 
    {
        {0,2,1,2,2,1,0,1,1,0,2},
        {2,1,1,0,1,1,2,0,2,1,0},
        {1,0,2,1,0,1,0,2,1,2,0},
        {0,0,2,1,2,0,1,2,0,0,1},
        {0,2,1,2,2,1,0,0,0,2,1},
        {2,1,1,0,1,1,2,1,0,0,2},
        {1,0,2,1,0,1,0,2,2,1,2},
        {0,0,2,1,2,0,1,0,1,2,0},
        {1,2,0,1,2,0,0,2,1,2,0},
        {2,1,1,0,1,1,2,1,0,0,2},
        {0,2,1,0,1,0,2,1,0,0,2},
    };
    #define M 4
    #define N 7
    int grid[M][N];
    for(int i=0;i<M;i++) {
        for(int j=0;j<N;j++) {
            grid[i][j] = g[i][j];
        }
    }
    f(M,N,grid[0],0,0,0,0,0,0,0,0);
};