Puzzling.SE'deki arkadaşlarımıza şu bildiri gönderildi: Bu renk bulmacası her zaman çözülebilir mi? Edgar G. Burada oynayabilirsin .

Bulmaca açıklaması

Bir Verilen m x nüç farklı renk çinileri ile ızgara, sen seçebilirsiniz herhangi iki komşu fayans renkleri ise, farklı . Bu iki karo daha sonra üçüncü renge, yani bu iki karo tarafından temsil edilmeyen bir renge dönüştürülür. Tüm fayanslar aynı renge sahipse, bulmaca çözülür . Görünüşe göre, bir yapabilirsiniz kanıtlamak ne bu bulmaca, hep çözülebilir olduğunu mne de n3 ile bölünebilir.

Tabii ki, bu bir çözme algoritması için yalvarır. Bu bulmacayı çözen bir işlev veya program yazacaksınız. 'Yan etkileri' olan fonksiyonlara (yani, stdoutbazı garip veri tipi dönüş değerlerinden ziyade çıktı açık) açık bir şekilde izin verildiğine dikkat edin.

Giriş çıkış

Giriş, bir olacaktır m x ntamsayı oluşan matris 1, 2ve 3(veya 0, 1, 2uygun ise). Bu girişi herhangi bir aklı başında formatta alabilirsiniz. Her ikisi de mve 3 nile >1bölünemezler. Bulmacanın çözülmediğini varsayabilirsiniz.

Daha sonra bulmacayı çözeceksiniz. Bu, 'dönüştürülecek' bitişik iki fayansın tekrar tekrar seçilmesini içerecektir (yukarıya bakınız). Çözme algoritmanızın attığı her adım için bu döşemelerin iki koordinatını çıkartacaksınız. Bu, herhangi bir mantıklı çıktı biçiminde de olabilir. Koordinatlarınızın 0 tabanlı ve 1 tabanlı dizini arasında seçim yapmakta ve önce satırların mı yoksa sütunların mı endekslendiğini seçmekte özgürsünüz. Lütfen cevabınızda bunu belirtiniz.

Algoritmanız, orijinal 8x8 vakasında makul bir sürede çalışmalıdır. Açıkça izin verilmese tamamen Brute-zorlayarak, sizin algoritması altında çalışmalıdır yani O(k^[m*(n-1)+(m-1)*n])birlikte kçözüm için gereken adımların sayısını. Ancak çözümün optimal olması gerekli değildir . Bağlantılı soruda verilen ispat size bunun nasıl yapılacağına dair bir fikir verebilir (örneğin, tüm sütunları yalnızca dikey olarak bitişik karolar kullanarak ve sonra tüm satırları yapın)

Test durumları

Bu test durumlarında, koordinatlar 1 tabanlıdır ve ilk önce sıralar dizine alınır (MATLAB / Octave ve muhtemelen diğerleri gibi).

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]

İstenirse, daha büyük test vakaları içeren bir pastebin yayınlayabilirim, ancak bunun yeterli olması gerektiğini düşünüyorum.

Ruby, 266 bayt

Daha çok veya daha az, yalnızca sütunlar yerine ilk satırları çözmesi dışında, Octave çözümünün bir bağlantı noktası. Giriş, bir dizi dizisidir, iç diziler de sıralar. Çıkış hamleleri [row, column, row, column]. Test odası

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

Açıklama ile Ungolfed

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

Octave, 334 313 bayt

Meydan okuma biraz göz korkutucu göründüğü için kendi çözümümü sunuyorum. Resmen bu yöntemin işe yaradığını ispat etmedim (tahmin ediyorum ki algoritmanın asla bir döngüde sıkışıp kalmayacağını kanıtlayacak), ama şimdiye kadar mükemmel çalışıyor, 15 saniye içinde 100x100 test vitrini yapıyor. Bana bir kaç byte tasarruf sağlayandan beri tüm koordinatları döndüren bir işlev yerine yan etkileri olan bir işlev kullanmayı seçtiğime dikkat edin. Koordinatlar satır başı, 1 tabanlı ve olarak biçimlendirilmiş row1 col1 row2 col2. Girdi renkleri, 0,1,2bunun yerine modkullanmak zorunda kalmanın maliyeti ile daha iyi çalıştığı içindir . Golf sürümü: Düzenleme: Kevin Lau'nun cevabından bir teknik kullanarak birkaç bayt daha kaydedildi.numelnnz

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

Çözme algoritmasının örnek GIF'i:

Ungolfed versiyonu:

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 Bayt

Uyarı Bu golf oynamaya başlamadan önce hala çok iş var! Bunu en azından 500 Byte altında alabilmeliyim. Şimdilik, işe yarayan ilk çözüm oldu ve ben hala üzerinde çalışıyorum.

İşim bittiğinde tam bir açıklama yapacağım.

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

Rust, 496 495 bayt

Maalesef OP’yi yenemiyorum, ancak bir Pas cevabı için bayttan oldukça memnunum.

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

Giriş: sayıların yanı sıra sütunların sayısının bir vektörü. Örneğin

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

çıktılar

 (row1,col1,row2,col2)

Komut satırına

Önce her satırı çözerim, sonra elde edilen sütunu sadece bir kez çözerim, ancak tüm sütunların adımlarını yazdırırım. Bu yüzden aslında oldukça verimli: - P.

Biçimlendirme ile:

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

Düzenleme: şimdi bana bir noktalı virgül ^ ^ kaydeder çözümün rengini döndürür

Befunge , 197 368 696 754 Bayt

(evet, bazı ters kod golf yapıyorum, ne kadar çok bayt o kadar iyi)

Bu algoritmayı Befunge'ye yazmanın zor olacağını ve eğlenceli olabileceğini düşünüyordum.

Bunun bir topluluk programı olmasını isterim, yani eğer birileri üzerinde çalışmak isterse, lütfen yapın.

Sonunda, şu ana kadar her şeyi yalnız yaptım, bu yüzden kendi başıma bitireceğim (neredeyse bitti)

Henüz ne yapılmadı: trol biçimli bir kod

&: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\,"[ ":<        <

(evet, bu bir trol, inan bana)

Temel olarak, bir diziyi okur ve satırları çözmek için yapılacak hareketi hesaplar.

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

(dizinin tamamı bir liste olarak iletilir [satır1, satır2, satır3,…])

çıktı

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

hem satırlar hem de sütunlar 0'dan başlar.

Şimdi bu satırlar çözüldü, neredeyse bitti! Yaşasın!

Açıklama: (daha sonra güncellenecektir)

Yani 5 ana bölüm var:

• İlki yeşil renkte giriş satırını okur ve dizinin bir satırını yazar.
• İkincisi, turuncu renkte, dizinin bir sonraki satırına geçer.
• Üçüncüsü, mavi renkte bir satır toplar
• Dördüncüsü, sıcak pembe renkte, toplamın 3 modülünü alır, ilgili satırın sağına kaydeder ve bir sonraki satıra gider.
• Son olarak, kırmızıda, hedef rengi önceden hesaplanan sayıdan hesaplayan kısım. Bu bölüm gerçekten çok aptal ve muhtemelen yeniden yazılmalı, ancak bunu nasıl güzel bir şekilde yapabileceğimi çözemedim (197 bayttan 368'e sadece bu bölümle geçti)

Gri kısımlar başlangıçlar

İşte birleştirilecek kutuları bulan modülün daha derin bir açıklaması (bu arada, burada kodlanmıştır)

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

ÇAĞRI bölümü, talimat işaretçisinin kutularla birleştirmek için başka bir modüle gittiği zamandır. 'B' girişi ile bu modüle geri dönüyor

İşte bazı sözde kodu: (currentx dizi okuması ile ilgilidir)

    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:

Sınamak istiyorsanız, bağladığım yorumlamayı kullanmak istiyorsanız, sondaki bir boşluk koymanız ve yeni satırları izlemeniz gerekir, böylece diziyi depolamak için yeterli alan olur . 22 + girişteki satır sayısını iz bırakan satırlar olarak, 34 + bir satırda iz bırakılan boşlukları olarak sütun sayısını okumanız gerekir.

C, 404 bayt

İlk kod golf, nasıl çıktığı ile oldukça mutluyum. Yine de çok uzun sürdü. Tamamen standart C değil, sadece gcc altında özel bayraklar olmadan (ve uyarıları görmezden gelenler) ne derleyecektir. Yani orada iç içe geçmiş bir işlev var. İşlev fboyutları alır mve nilk argümanları olarak, üçüncü argümanı alırsa (int işaretçisi) bir beden büyüklüğüne m× alır n(önce satırlarla indekslenir). Diğer argümanlar kukla argümanlar, onları içeri aktarmanıza gerek yok, sadece değişkenleri bildirerek baytları kurtarmak için oradalar. Değiştirilen her çifti row1,col1:row1,col1;, çiftleri ayıran noktalı virgül ile, formatta STDOUT'a yazar . 0 tabanlı endeksleme kullanır.

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

Tek tek satırları / sütunları çözmek için OP'den biraz farklı bir algoritma kullandım. Böyle bir şey gider (sözde kodu):

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)

for(;~b;b--)Döngü yürütür tam iki kez, ikinci geçişte yerine satır sütun çözer. Bu değiştirerek yapılır nve mve değerlerini değiştirmek ove pdizi gidermek için işaretçi Aritmetik kullanıldığı.

İşte bir test ana sistemiyle ungolfed olan ve her hareketten sonra tüm diziyi basan bir versiyon (1 tur için enter'a basın):

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