ক্রোমাটিক ধাঁধাটি সমাধান করুন

Question

পাজলিং.এসই- তে আমাদের বন্ধুদের সময়ে , নিম্নলিখিত ধাঁধাটি পোস্ট করা হয়েছিল: এই ক্রোম্যাটিক ধাঁধাটি কি সর্বদা দ্রবণযোগ্য? এডগার জি দ্বারা। আপনি এটি এখানে খেলতে পারেন ।

ধাঁধা ব্যাখ্যা

m x nতিনটি ভিন্ন রঙের টাইলস সহ একটি গ্রিড দেওয়া , আপনি যদি দুটি রঙের আলাদা হয় তবে দুটি সংলগ্ন টাইল বেছে নিতে পারেন । এই দুটি টাইলগুলি তৃতীয় রঙে রূপান্তরিত হয়, অর্থাত্, একটি রঙ যা এই দুটি টাইল দ্বারা প্রতিনিধিত্ব করে না। ধাঁধাটি সমাধান করা হয় যদি সমস্ত টাইলের রঙ একই থাকে । দৃশ্যত, এক করতে প্রমাণ যে, এই ধাঁধা সবসময় সমাধেয়, যদি তন্ন তন্ন mনা n3 দ্বারা বিভাজ্য হয়।

অবশ্যই, এটি একটি সমাধান অ্যালগরিদমের জন্য প্রার্থনা করে। আপনি একটি ফাংশন বা প্রোগ্রাম লিখবেন যা এই ধাঁধাটি সমাধান করে। নোট করুন যে 'পার্শ্ব প্রতিক্রিয়া' (যেমন, stdoutকিছু বিশ্রী ডেটা টাইপের রিটার্ন মানের চেয়ে আউটপুট চালু রয়েছে) সহ ফাংশনগুলি স্পষ্টভাবে অনুমোদিত।

ইনপুট আউটপুট

ইনপুট হল একটি হতে হবে m x nপূর্ণসংখ্যার গঠিত ম্যাট্রিক্স 1, 2এবং 3(অথবা 0, 1, 2সুবিধাজনক যদি)। আপনি এই ইনপুটটি কোনও বুদ্ধিমান বিন্যাসে নিতে পারেন। উভয় mএবং nহয় >1এবং 3. দ্বারা বিভাজ্য আপনি ধাঁধা অনুমান হতে পারে সমাধান হয় না

তারপরে আপনি ধাঁধাটি সমাধান করবেন। এটি 'রূপান্তরিত' হওয়ার জন্য দুটি সংলগ্ন টাইলগুলির একটি পুনরাবৃত্ত নির্বাচনকে জড়িত করবে (উপরে দেখুন)। আপনার সমাধান অ্যালগরিদম গৃহীত প্রতিটি পদক্ষেপের জন্য আপনি এই টাইলগুলির দুটি স্থানাঙ্ক আউটপুট দেবেন। এটি কোনও বুদ্ধিমান আউটপুট বিন্যাসেও হতে পারে। আপনার স্থানাঙ্কগুলির 0-ভিত্তিক এবং 1-ভিত্তিক সূচকের মধ্যে এবং সারি বা কলামগুলি প্রথমে সূচিযুক্ত কিনা তা বেছে নিতে আপনি নির্দ্বিধায়। তবে আপনার উত্তরে এটি উল্লেখ করুন।

আপনার অ্যালগরিদমটি আসল 8x8 ক্ষেত্রে উপযুক্ত সময়ের মধ্যে চলতে হবে। এটি সম্পূর্ণরূপে জোর করে জোর করে স্পষ্টভাবে অনুমোদিত নয়, অর্থাৎ আপনার অ্যালগরিদম সমাধানের জন্য প্রয়োজনীয় পদক্ষেপের সংখ্যার O(k^[m*(n-1)+(m-1)*n])সাথে চলতে kহবে। তবে সমাধান না অনুকূল হওয়া প্রয়োজন। লিঙ্কযুক্ত প্রশ্নে প্রদত্ত প্রমাণ আপনাকে কীভাবে এটি করা যায় সে সম্পর্কে ধারণা দিতে পারে (উদাহরণস্বরূপ, কেবলমাত্র সমস্ত উল্লম্ব কেবল উল্লম্ব সংলগ্ন টাইলস ব্যবহার করে এবং পরে সমস্ত সারি করুন)

পরীক্ষার মামলা

এই পরীক্ষার ক্ষেত্রে, স্থানাঙ্কগুলি 1-ভিত্তিক হয় এবং সারিগুলি প্রথমে সূচিযুক্ত হয় (যেমন ম্যাটল্যাব / অক্টাভা এবং সম্ভবত আরও অনেকগুলি)।

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]

যদি ইচ্ছা হয় তবে আমি বৃহত্তর পরীক্ষার কেসগুলির একটি পেস্টবিন পোস্ট করতে পারি তবে আমি মনে করি এটি যথেষ্ট হবে।

Comments

আমি এর একটি কোড চ্যালেঞ্জ সংস্করণ দেখতে চাই, যেখানে লক্ষ্যটি সর্বনিম্ন মোট চালগুলি সহ ধাঁধাগুলির সেট সেট করা।

— মেগো

@ মেগো আমি অবশ্যই এটি বিবেচনা করেছি। তবে আমি আশঙ্কা করছি যে এটি একটি ডিএফএস বা বিএফএসে রূপান্তরিত হবে যা চালাতে চিরকালের জন্য লাগবে ; বা, এটি প্রতিরোধ করতে, অস্পষ্ট বিধিনিষেধের একটি সেট (যেমন 'এক ঘন্টার মধ্যে দৌড়াতে হবে' যা একটি বিশাল কম্পিউটার সহ লোকদের পক্ষে, বা যার জন্য আমার সমস্ত সমাধান পরীক্ষা করার প্রয়োজন হবে)। এবং তদ্ব্যতীত, বর্তমান চ্যালেঞ্জের শূন্য উত্তরগুলি অতিরিক্ত আমার রয়েছে, সুতরাং আমি সন্দেহ করি যে হিউরিস্টিক্স ইত্যাদির আরও একটি জটিল সংস্করণ আরও জনপ্রিয় হিসাবে প্রমাণিত হবে ... তবে সম্ভবত এই চ্যালেঞ্জটি যদি গতি বাড়িয়ে তুলতে পারে তবে আমি আপনার মতো একটি ভাইবোন চ্যালেঞ্জ পোস্ট করতে পারি perhaps বর্ণনা করে।

— Sanchises

আমি মনে করি

— লুয়ায়

@ কেটেনকিও কেবল এটির একটি উপায়! আমি আপনার সমাধান দেখার জন্য অপেক্ষা করছি।

— সান্চাইজস

দুঃখের জন্য আপনাকে কিছুটা অপেক্ষা করতে হবে, আপনি নিষ্ঠুর-শক্তি সমাধানকে

— থামিয়ে

Answer 1

রুবি, 266 বাইট

কম-বেশি বা কম-বেশি কেবল অক্টোব সমাধানের একটি বন্দর, এটি কলামগুলির পরিবর্তে প্রথম সারিগুলি সমাধান করে except ইনপুট হ'ল অ্যারেগুলির একটি অ্যারে, অভ্যন্তরীণ অ্যারেগুলি সারি হয়। আউটপুট মুভ হয় [row, column, row, column]। পরীক্ষা স্যুট

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

ব্যাখ্যার সাথে নিরবচ্ছিন্ন

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

Comments

দুইটি নন-গল্ফিং ভাষার মধ্যে একটি বন্দর এখনও ~ 20% পার্থক্য করতে পারে তা দেখার জন্য আকর্ষণীয়। আপনি কি একটি সংক্ষিপ্ত ব্যাখ্যা যোগ করতে পারেন? (বিশেষত 3 লাইন - আমি গোপনে আশা করছি যে আমি আমার উত্তরে এটি ব্যবহার করতে পারি যেহেতু intersectএ জাতীয় একটি মূল শব্দ)

— সানচাইস

@ সংশ্লেষে একটি ব্যাখ্যা যুক্ত করা হয়েছিল। সম্পর্কিত intersect, আমি জানি না যে আপনি যেভাবে আমার কাজ করেন তা ঠিক করতে পারেন কারণ রুবি findমূলত ফাংশনগুলিতে কাজ করে এবং আপনার functionকীওয়ার্ডটি ঠিক ততটাই বিশাল।

— মান কালি

আমি আসলে এখনও এর জন্য আপনার পদ্ধতিটি ব্যবহার করতে পারি find- ধন্যবাদ! তবুও, আপনাকে মারধরের খুব কাছাকাছি কোথাও নেই ...

— সান্চাইজস

Answer 2

অক্টাভা, 334 313 বাইট

যেহেতু চ্যালেঞ্জটি কিছুটা দুষ্কর বলে মনে হচ্ছে, তাই আমি নিজের সমাধানটি উপস্থাপন করছি। আমি আনুষ্ঠানিকভাবে প্রমাণ করতে পারি নি যে এই পদ্ধতিটি কাজ করে (আমি অনুমান করি যে আলগোরিদম কখনই কোনও লুপে আটকে যাবে না তা প্রমাণ করতে নেমে আসবে), তবে এখনও পর্যন্ত এটি 15 সেকেন্ডের মধ্যে 100x100 টেস্টকেসগুলি করে পুরোপুরি কাজ করে। নোট করুন যে আমি পার্শ্ব প্রতিক্রিয়াগুলির সাথে একটি ফাংশন ব্যবহার করার জন্য বেছে নিয়েছি যা সমস্ত স্থানাঙ্ক ফেরত দেয় যেহেতু এটি আমাকে কয়েক বাইট সংরক্ষণ করেছিল। স্থানাঙ্কগুলি সারি-প্রধান, 1-ভিত্তিক, এবং হিসাবে ফর্ম্যাট করা হয় row1 col1 row2 col2। ইনপুট রঙগুলি 0,1,2যেহেতু modএটি ব্যবহার numelনা করে ব্যয় করে ভাল কাজ করে nnz। গল্ফযুক্ত সংস্করণ: সম্পাদনা: কেভিন ল'র উত্তর থেকে একটি কৌশল ব্যবহার করে আরও কয়েকটি বাইট সংরক্ষণ করা হয়েছে।

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

সমাধানকারী অ্যালগরিদমের জিআইএফ উদাহরণ:

অবরুদ্ধ সংস্করণ:

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

Comments

কেবলমাত্র লক্ষ্য করা গেছে, তবে আমার নাম কেনি লাউ নয় ... এটি অন্য একজন ব্যবহারকারী এবং আমার ব্যবহারকারীর নামটি উল্লেখ করেছে যে আমি কেনেনি নই

— মান কালি

Answer 3

অ্যাপ্লিকেশন Lua, 594 575 559 বাইট

সতর্কতা এই গল্ফিংটি শেষ করার আগে এখনও প্রচুর কাজ বাকি আছে! আমার এটি খুব কমপক্ষে 500 বাইটের নিচে নিতে সক্ষম হওয়া উচিত। এই মুহূর্তের জন্য, এটি প্রথম সমাধান যা কাজ করেছিল এবং আমি এখনও এটি নিয়ে কাজ করছি।

আমার কাজ শেষ হয়ে গেলে আমি একটি সম্পূর্ণ ব্যাখ্যা সরবরাহ করব।

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

Answer 4

মরিচা, 496 495 বাইট

দুঃখজনকভাবে আমি ওপিকে হারাতে পারি না, তবে মরিচা জবাবের জন্য আমি বাইট কাউন্টে বেশ সন্তুষ্ট।

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

ইনপুট: সংখ্যার ভেক্টর পাশাপাশি কলামগুলির সংখ্যা। যেমন

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

আউটপুট

 (row1,col1,row2,col2)

কমান্ড লাইনে।

আমি প্রথমে প্রতিটি সারিতে সমাধান করি এবং তারপরে ফলাফল কলামটি কেবল একবারই সমাধান করি তবে সমস্ত কলামের পদক্ষেপগুলি মুদ্রণ করি। সুতরাং এটি আসলে বেশ দক্ষ :- পি।

গঠন সহ:

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

সম্পাদনা: এখন সমাধানের রঙটি দেয় যা আমাকে একটি সেমিকোলন ^^ সংরক্ষণ করে ^^

Answer 5

বেফুঞ্জ , 197 368 696 754 বাইট

---

(হ্যাঁ, আমি কিছু বিপরীত কোড গল্ফ করছি, আরও বাইট আরও ভাল)

আমি ভাবছিলাম বেফুঞ্জে এই অ্যালগরিদমটি লেখা একটি চ্যালেঞ্জ হতে পারে এবং এটি মজাদার হতে পারে

আমি এটি একটি সম্প্রদায় প্রোগ্রাম হতে চাই, সুতরাং কেউ যদি এটিতে কাজ করতে চান, দয়া করে, এটি করুন।

শেষ পর্যন্ত, আমি এতদূর সমস্ত কিছু একা করেছি, তাই আমি নিজেই শেষ করব (এটি প্রায় শেষ)

---

এখনও কী হয়েছে: একটি ট্রোল-আকারের কোড

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

(হ্যাঁ, এটি একটি ট্রল, বিশ্বাস করুন)

মূলত, এটি একটি অ্যারে পড়ে এবং সারিগুলি সমাধান করার জন্য যে পদক্ষেপটি গণনা করে তা হিসাবে একটি ইনপুট দেওয়া হয়

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

(পুরো অ্যারেটি একটি তালিকা হিসাবে পাস করা হয়েছে [সারি 1, সারি 2, সারি 3,…]))

আউটপুট হয়

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

সারি এবং কলস উভয়ই 0 থেকে শুরু হয়।

এখন যে সারিগুলি সমাধান হয়ে গেছে, এটি প্রায় শেষ! হুররে !

---

ব্যাখ্যা: (পরে আপডেট করা হবে)

সুতরাং 5 টি প্রধান অংশ রয়েছে:

• প্রথমটি, সবুজ রঙে, ইনপুট লাইনটি পড়ে এবং অ্যারের এক সারি লিখে writes
• দ্বিতীয়টি কমলা রঙের, অ্যারের পরবর্তী সারিতে চলে যায়
• তৃতীয়, নীল রঙে, একটি সারির যোগফল
• চতুর্থটি, গরম গোলাপী রঙের, যোগফলের 3 টি মডেলটি নিয়ে এটি সম্পর্কিত সারির ডানদিকে সংরক্ষণ করে এবং পরবর্তী সারিতে যান
• শেষ অবধি, লাল অংশটি পূর্বের গণনা করা নম্বর থেকে লক্ষ্য রঙকে গণনা করে। এই অংশটি সত্যিই বোবা এবং সম্ভবত এটি আবারও লেখা উচিত, তবে আমি কীভাবে এটি একটি সুন্দর উপায়ে করতে পারি তা বুঝতে পারিনি (197 বাইট থেকে 368 এ কেবল সেই অংশটি দিয়ে গেছে)

ধূসর অংশগুলি সূচনা হয়

---

এখানে মডিউলের আরও গভীর ব্যাখ্যা দেওয়া হয়েছে যা সংযুক্ত করার জন্য বাক্সগুলি খুঁজে পায় (যা এখানে কোড করে দেওয়া হয়)

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

CALL অংশটি যখন নির্দেশের পয়েন্টারটি অন্য মডিউলে যায়, বাক্সগুলিতে একত্রিত করতে। এটি 'বি' এন্ট্রির মাধ্যমে এই মডিউলে ফিরে আসে

এখানে কয়েকটি ছদ্ম কোড রয়েছে: (কারেন্টেক্স অ্যারে পড়ার সাথে সম্পর্কিত) এর জন্য:

    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:

---

মনে রাখবেন যে আপনি যদি এটি পরীক্ষা করতে চান তবে আপনাকে কিছু ট্রেলিং স্পেস এবং নতুন লাইনগুলি অনুসরণ করতে হবে যাতে অ্যারে সংরক্ষণের জন্য পর্যাপ্ত জায়গা থাকে, যদি আপনি আমার সাথে যুক্ত লিখিত ব্যাখ্যাটি ব্যবহার করতে চান তবে । 22 + ইনপুটটিতে চলমান রেখা হিসাবে সারিগুলির সংখ্যা এবং 34 + এক লাইনের পিছনে স্থান হিসাবে কলামগুলির সংখ্যা ঠিক হওয়া উচিত।

Comments

শুধু কৌতুহলী, কেন এই প্রতিযোগিতা হয়?

— মূল্য কালি

এই অংশটির কারণে: 'আমি এটি একটি সম্প্রদায় প্রোগ্রাম হতে চাই'। আমি ভেবেছিলাম আমি অন্যথায় কিছুটা প্রতারণা করব

— মালিয়াফো

আমার 1977 বাইটের ফলাফল আছে, আপনি উইন্ডোসের নীচে কাজ করেন? (এবং কেবল \r\nপরিবর্তে গণনা করা হয়েছে \n?)

— ক্যাটেনকিও

এইচএম, আমি অনুমান করি যে বাইটগুলি গণনা করার সময় আমি কিছুটা পিছনে কপি করেছি, আপনাকে ধন্যবাদ

— মালিয়াফো

শেষ পর্যন্ত যদি আমি একমাত্র এটি তৈরি করেছি তবে আমি উল্লেখটি মুছে ফেলব, তবে আমি আশা করব না

— মালিয়াফো

Answer 6

সি, 404 বাইট

আমার প্রথম কোড গল্ফ, এটি কীভাবে পরিণত হয়েছিল তা নিয়ে আমি বেশ খুশি। যদিও অনেক দীর্ঘ পথ ধরেছে। এটি পুরোপুরি স্ট্যান্ডার্ড সি নয়, কেবল কোনও বিশেষ পতাকা (এবং সতর্কতা উপেক্ষা করে) সহ সিসিটির অধীনে সংকলন করা হবে। সুতরাং সেখানে একটি নেস্টেড ফাংশন আছে। ফাংশনটি fমাত্রাগুলি mএবং nতার প্রথম আর্গুমেন্ট হিসাবে গ্রহণ করে এবং এটি তৃতীয় আর্গুমেন্ট হিসাবে আকারের অ্যারেতে একটি (int পয়েন্টার) লাগেm × n(প্রথম সারিতে সূচিত)। অন্যান্য আর্গুমেন্টগুলি ডামি আর্গুমেন্ট, আপনার এগুলি পাস করার দরকার নেই, ভেরিয়েবলগুলি ডিক্লেয়ারিংয়ে বাইটগুলি সংরক্ষণ করার জন্য এগুলি কেবল সেখানে রয়েছে। এটি প্রতিটি পরিবর্তিত জোড়াটি row1,col1:row1,col1;সেমিকোলন জোড়গুলি পৃথক করে ফর্ম্যাটে লিখেছে ST 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;}}

আমি পৃথক সারি / কলামগুলি সমাধানের জন্য ওপির চেয়ে কিছুটা আলাদা অ্যালগোরিদম ব্যবহার করেছি। এটি এর মতো কিছু হয় (সিউডোকোড):

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--)লুপ, executes ঠিক দুইবার, দ্বিতীয় পাস তে এটি সারির পরিবর্তে কলাম solves। এই সোয়াপিং দ্বারা সম্পন্ন করা হয় nএবং m, এবং মান পরিবর্তন oএবং pযা অ্যারে মোকাবেলার পয়েন্টার এরিথমেটিক ব্যবহার করা হয়।

পরীক্ষার প্রধান সহ নিখরচায় এমন একটি সংস্করণ এখানে রয়েছে এবং প্রতিটি পদক্ষেপের পরে পুরো অ্যারেটি মুদ্রণ করে (1 পদক্ষেপে পদক্ষেপ এন্টার টিপুন):

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

Comments

কৌতূহলের বাইরে: কেন আপনি আলাদা অ্যালগরিদম বেছে নিয়েছেন (বাইট সাশ্রয়ের ক্ষেত্রে)?

— Sanchises

আমি মনে করি লোকেরা যখন বিভিন্ন সমাধান নিয়ে আসে তখন এটি আরও আকর্ষণীয় এবং কিছু দ্রুত পরীক্ষা থেকে আমি অনুমান করেছি যে দুটি পদ্ধতি বাইট গণনায় একই হবে। আমি সম্ভবত আপনার অ্যালগরিদমও চেষ্টা করে দেখব এবং আরও কমতে পারি কিনা।

— Norg74

এখানে পোস্ট করা কারণ প্রশ্নটিতে মন্তব্য করার মতো পর্যাপ্ত পরিমাণে আমার কাছে নেই। প্রতিটি সারি, তারপর প্রতিটি কলাম পৃথকভাবে জোর করে প্রয়োগ করা কি বৈধ হবে? এটি প্রযুক্তিগতভাবে "নিখুঁতভাবে এটি পুরোপুরি জোর করে" নয় এবং নির্দিষ্ট সময়ের জটিলতার চেয়ে কম হওয়া উচিত। আমি আসলে এটি করার বিষয়টি বিবেচনা করেছি।

— Norg74

নিষ্ঠুর-জোর করে উল্লেখ করার অর্থ 'যুক্তিসঙ্গত সময়' মন্তব্যকে তীব্র করে তোলা হয়েছিল, সুতরাং এটি টি-ও (...) হিসাবে দেখুন। আমি জানি ব্রুট ফোর্স এবং যুক্তিসঙ্গত অ্যালগরিদমের মধ্যে ধূসর অঞ্চল রয়েছে, তাই আপনি ধাঁধাটি সমাধান করার দিকে কাজ করছেন বলে মনে করছেন বা ডিএফএস বা বিএফএসে কেবল সামান্য পরিবর্তন হয়েছে যা 'অগ্রগতির' অজগনীয় তাই বলে আপনার নিজের রায় ব্যবহার করুন ।

— সান্চাইজস