20

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

সুডোকু ধাঁধা:

 | 1 2 3 | 4 5 6 | 7 8 9
-+-----------------------
A|   3   |     1 |
B|     6 |       |   5
C| 5     |       | 9 8 3
-+-----------------------
D|   8   |     6 | 3   2
E|       |   5   |
F| 9   3 | 8     |   6
-+-----------------------
G| 7 1 4 |       |     9
H|   2   |       | 8
I|       | 4     |   3

উত্তর:

 | 1 2 3 | 4 5 6 | 7 8 9
-+-----------------------
A| 8 3 2 | 5 9 1 | 6 7 4
B| 4 9 6 | 3 8 7 | 2 5 1
C| 5 7 1 | 2 6 4 | 9 8 3
-+-----------------------
D| 1 8 5 | 7 4 6 | 3 9 2
E| 2 6 7 | 9 5 3 | 4 1 8
F| 9 4 3 | 8 1 2 | 7 6 5
-+-----------------------
G| 7 1 4 | 6 3 8 | 5 2 9
H| 3 2 9 | 1 7 5 | 8 4 6
I| 6 5 8 | 4 2 9 | 1 3 7

নিয়মাবলী:

ধরুন সমস্ত ম্যাজগুলি কেবল যুক্তি দ্বারা সমাধানযোগ্য।
সমস্ত ইনপুট 81 টি অক্ষর দীর্ঘ হবে। অনুপস্থিত অক্ষরগুলি 0 হবে।
একক স্ট্রিং হিসাবে সমাধান আউটপুট।
"গ্রিড" আপনার ইচ্ছামত অভ্যন্তরীণভাবে সংরক্ষণ করা যেতে পারে।
সমাধানটি অবশ্যই একটি হিংস্র বল অনুমানের সমাধান ব্যবহার করে।
যুক্তিসঙ্গত সময়সীমার মধ্যে সমাধানগুলি সমাধান করা উচিত।

আই / ও উদাহরণ:

>sudoku.py "030001000006000050500000983080006302000050000903800060714000009020000800000400030"
832591674496387251571264983185746392267953418943812765714638529329175846658429137

— snmcdonald
সূত্র

ইনপুটটি কীভাবে 27 অক্ষর দীর্ঘ হতে পারে? এটি 81 টি অক্ষর দীর্ঘ হওয়া দরকার - 9 সারি x 9 কলাম। আপনার উদাহরণটি এটাই করে। এছাড়াও, আমি ধরে নিয়েছি যে "অনুপস্থিত অক্ষরগুলি 0 হবে" এর অর্থ হ'ল অক্ষরের সংখ্যা যদি 81 এরও কম হয়, তবে শূন্যগুলি শেষ হয়?

— জোনাথন এম ডেভিস

অপেক্ষা কর. আমি পেয়েছি অনুপস্থিত অক্ষর 0 বিট হবে। Duh। তারাই অনুমান করা দরকার। যাই হোক না কেন, চরিত্রের সংখ্যা ২ 27 নয়, ৮১ হওয়া দরকার

— জোনাথন এম ডেভিস

8

এটি 5 এবং 6 টির মতো বিবাদ বলে মনে হচ্ছে ....

— ছদ্মনাম

11

কে (by২ বাইট)

এর ক্রেডিট আর্থার হুইটনি, কে ভাষার স্রষ্টা।

p,:3/:_(p:9\:!81)%3
s:{*(,x)(,/{@[x;y;:;]'&21=x[&|/p[;y]=p]?!10}')/&~x}

— skeevey
সূত্র

সর্বোত্তম! আমি এই পোস্ট করতে যাচ্ছি!

— নাইটট্রেভারস

9

পাইথন, 188 বাইট

এটি কোডসপ্রিন্ট সুডোকুর পক্ষে আমার বিজয়ী জমা দেওয়ার আরও সংক্ষিপ্ত সংস্করণ, স্টিডিনের পরিবর্তে কমান্ড লাইন ইনপুট জন্য সংশোধিত (ওপি অনুসারে):

def f(s):
 x=s.find('0')
 if x<0:print s;exit()
 [c in[(x-y)%9*(x/9^y/9)*(x/27^y/27|x%9/3^y%9/3)or s[y]for y in range(81)]or f(s[:x]+c+s[x+1:])for c in'%d'%5**18]
import sys
f(sys.argv[1])

আপনি যদি পাইথন 2 ব্যবহার করছেন তবে 3 বাইট সংরক্ষণের '%d'%5**18সাথে প্রতিস্থাপন করা `5**18`যেতে পারে।

এটি দ্রুত চালিত করতে, আপনি 1 বাইট ব্যয়ে যে '%d'%5**18কোনও ক্রম ছাড়িয়ে প্রতিস্থাপন করতে পারেন '123456789'।

পরিবর্তে আপনি যদি স্টিনের ইনপুটটি গ্রহণ করতে চান তবে আপনি এটির import sys;f(sys.argv[1])সাথে প্রতিস্থাপন করতে পারেনf(raw_input()) এটিকে নিচে এনে 177 বাইট ।

def f(s):
 x=s.find('0')
 if x<0:print s;exit()
 [c in[(x-y)%9*(x/9^y/9)*(x/27^y/27|x%9/3^y%9/3)or s[y]for y in range(81)]or f(s[:x]+c+s[x+1:])for c in'%d'%5**18]
f(raw_input())

সম্পাদনা: এখানে আরও বিশদ ওয়াকথ্রুয়ের লিঙ্ক।

— Cyphase
সূত্র

খুব সুন্দর সমাধান।

— primo

8

পাইথন, 197 অক্ষর

def S(s):
 i=s.find('0')
 if i<0:print s;return
 for v in'123456789':
  if sum(v==s[j]and(i/9==j/9or i%9==j%9or(i%9/3==j%9/3and i/27==j/27))for j in range(81))==0:S(s[:i]+v+s[i+1:])
S(raw_input())

— কিথ র্যান্ডাল
সূত্র

6

ডি তে উত্তর:

import std.algorithm;
import std.conv;
import std.ascii;
import std.exception;
import std.stdio;

void main(string[] args)
{
    enforce(args.length == 2, new Exception("Missing argument."));
    enforce(args[1].length == 81, new Exception("Invalid argument."));
    enforce(!canFind!((a){return !isDigit(to!dchar(a));})
                     (args[1]),
                      new Exception("Entire argument must be digits."));

    auto sudoku = new Sudoku(args[1]);
    sudoku.fillIn();

    writeln(sudoku);
}

class Sudoku
{
public:

    this(string str) nothrow
    {
        normal = new int[][](9, 9);

        for(size_t i = 0, k =0; i < 9; ++i)
        {
            for(size_t j = 0; j < 9; ++j)
                normal[i][j] = to!int(str[k++]) - '0';
        }

        reversed = new int*[][](9, 9);

        for(size_t i = 0; i < 9; ++i)
        {
            for(size_t j = 0; j < 9; ++j)
                reversed[j][i] = &normal[i][j];
        }

        boxes = new int*[][](9, 9);
        indexedBoxes = new int*[][][](9, 9);

        for(size_t boxRow = 0, boxNum = 0; boxRow < 3; ++boxRow)
        {
            for(size_t boxCol = 0; boxCol < 3; ++boxCol, ++boxNum)
            {
                for(size_t i = 3 * boxRow, square = 0; i < 3 * (boxRow + 1); ++i)
                {
                    for(size_t j = 3 * boxCol; j < 3 * (boxCol + 1); ++j)
                    {
                        boxes[boxNum][square++] = &normal[i][j];
                        indexedBoxes[i][j] = boxes[boxNum];
                    }
                }
            }
        }
    }

    void fillIn()
    {
        fillIn(0, 0);
    }

    @property bool valid()
    {
        assert(full);

        for(size_t i = 0; i < 9; ++i)
        {
            for(int n = 1; n < 10; ++n)
            {
                if(!canFind(normal[i], n) ||
                   !canFind!"*a == b"(reversed[i], n) ||
                   !canFind!"*a == b"(boxes[i], n))
                {
                    return false;
                }
            }
        }

        return true;
    }

    override string toString() const
    {
        char[81] retval;

        for(size_t i = 0, k =0; i < 9; ++i)
        {
            for(size_t j = 0; j < 9; ++j)
                retval[k++] = to!char(normal[i][j] + '0');
        }

        return to!string(retval);
    }

private:

    @property bool full()
    {
        for(size_t i = 0; i < 9; ++i)
        {
            if(canFind(normal[i], 0))
                return false;
        }

        return true;
    }

    bool fillIn(size_t row, size_t col)
    {
        if(row == 9)
            return valid;

        size_t nextRow = row;
        size_t nextCol = col + 1;

        if(nextCol == 9)
        {
            nextRow = row + 1;
            nextCol = 0;
        }

        if(normal[row][col] == 0)
        {
            for(int n = 1; n < 10; ++n)
            {
                if(canFind(normal[row], n) ||
                   canFind!"*a == b"(reversed[col], n) ||
                   canFind!"*a == b"(indexedBoxes[row][col], n))
                {
                    continue;
                }

                normal[row][col] = n;

                if(fillIn(nextRow, nextCol))
                    return true;
            }

            normal[row][col] = 0;

            return false;
        }
        else
            return fillIn(nextRow, nextCol);
    }

    int[][] normal;
    int*[][] reversed;
    int*[][] boxes;
    int*[][][] indexedBoxes;
}

নমুনা ইনপুট সঙ্গে, এটা লাগে .033s যখন সঙ্গে কম্পাইল আমার ফেনম X6 1090T উপর dmd -w(অর্থাত অপ্টিমাইজেশন ছাড়া), এবং এটা লাগে .011s যখন সঙ্গে কম্পাইল dmd -w -O -inline -release(অপ্টিমাইজেশন সঙ্গে অর্থাত)।

— জোনাথন এম ডেভিস
সূত্র

4

জে, 103

'p n'=:(;#)I.0=a=:("."0)Y
((a p}~3 :'>:?n#9')^:([:(27~:[:+/[:(9=#@~.)"1[:,/(2 2$3),;.3],|:,])9 9$])^:_)a

প্রত্যাশিত রান সময়: ও (গাজিলিয়ন বিলিয়ন বছর)

— Eelvex
সূত্র

1

এবং কেন প্রত্যাশিত রান সময় "ও (গাজিলিয়ন বিলিয়ন বছর)"? (ওকে ছাড়া এটি কি "গাজিলিয়ন বিলিয়ন বছর" হওয়া উচিত নয়?

— জাস্টিন

1

আমি যখন এই প্রশ্নটি দেখেছি তখনই আমি তাত্ক্ষণিকভাবে জানতাম যে জে এইটিকে চূর্ণ করতে চলেছে। কে। থেকে আরও খাটো করার একটি উপায় থাকতে হবে

— কোকো

1

@ কুইনকুনস, কঠোরভাবে বলতে গেলে, এটি বিগ-ও-এর একটি ভুল ব্যবহার; "রসিকতা" পড়ার কথা ছিল "ধ্রুব রান সময়, asympototically gazillion বিলিয়ন বছর"।

— ইভেলেক্স

@ কোকো, আমি এর থেকে ভাল কিছু খুঁজে পাচ্ছি না তবে আমি এটি নিয়ে এখনও কাজ করছি।

— ইভেলেক্স

4

পার্ল, 120 বাইট

ওহ, আমি ২০০৮ সালে গল্ফ করার কথা মনে করি ... এবং প্রকৃতপক্ষে পার্ল 5.12 এ কাজ করা বন্ধ করে দেওয়া হয়েছে কারণ বিভক্ত হয়ে @_র অন্তর্নিহিত সেটিংটি তখন সরিয়ে দেওয়া হয়েছিল। সুতরাং কেবল পর্যাপ্ত পুরানো পার্লটিতে এটি ব্যবহার করে দেখুন।

এসটিডিআইএন ইনপুট দিয়ে চালান:

sudoku.pl <<< "030001000006000050500000983080006302000050000903800060714000009020000800000400030"

sudoku.pl:

${/[@_[map{$i-($i="@-")%9+$_,9*$_+$i%9,9*$_%26+$i-$i%3+$i%9-$i%27}0..8%split""]]/o||do$0}for$_=$`.$_.$'.<>,/0/||print..9

— টন হসপেল
সূত্র

2

এটি ক্লার্কের তৃতীয় আইন , কিন্তু বিপরীতে!

— কনর ও ব্রায়ান

3

পার্ল, 235 অক্ষর

$_=$s=<>;$r=join$/,map{$n=$_;'.*(?!'.(join'|',map+($_%9==$n%9||int($_/9)==int($n/9)||int($_/27)==int($n/27)&&int($_/3%3)==int($n/3%3)and$_<$n?'\\'.($_+1):$_>$n&&substr$s,$_,1)||X,@a).')(.).*'}@a=0..80;s!.!($&||123456789).$/!eg;say/^$r/

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

মূলত, এটি 81 টি লাইনে ইনপুটটিকে ম্যাঙ্গেল করে, যার প্রত্যেকটি সংশ্লিষ্ট স্কোয়ারে ঘটতে পারে এমন সমস্ত সংখ্যার সমন্বয় করে। এরপরে সারি, কলাম বা অঞ্চল সীমাবদ্ধতা লঙ্ঘন করে এমন সমাধানগুলি প্রত্যাখ্যান করার জন্য ব্যাকরেফারেন্স এবং নেতিবাচক বর্ণনাকারী অবস্থানগুলি ব্যবহার করে প্রতিটি লাইন থেকে একটি সংখ্যার সাথে মেলে একটি রেজিপেক্স তৈরি করে। তারপরে এটি পার্জের রেইগএক্সএক্স ইঞ্জিনটিকে ট্রায়াল এবং ব্যাকট্র্যাকিংয়ের কঠোর পরিশ্রম করতে দিয়ে রেজিএক্সএক্সের বিপরীতে স্ট্রিংয়ের সাথে মেলে।

আশ্চর্যজনকভাবে, এমন কোনও একক রিজেক্সপ তৈরি করা সম্ভব যা কোনও মূল ইনপুট যেমন আমার মূল প্রোগ্রামটির মতো কাজ করে। দুর্ভাগ্যক্রমে, এটি বেশ ধীর, তাই আমি এখানে হার্ডকডযুক্ত দেওয়া সংস্করণে গল্ফ কোডটি ভিত্তি করেছিলাম ( পরে এফডাব্লুপি থ্রেডে পাওয়া যায়) ) , যা প্রাথমিকভাবে যে কোনও সমাধানগুলি জানায় যা পরবর্তীকালে একটি সীমাবদ্ধতা লঙ্ঘন করবে তা প্রত্যাখ্যান করতে রেজিএক্সপিক্সকে টুইট করে। এটি মাঝারি স্তরের সুডোকাসকে সহজতর করার জন্য এটি যুক্তিসঙ্গতভাবে দ্রুত করে তোলে, যদিও বিশেষত কঠোররা এখনও সমাধান করতে বরং একটি দীর্ঘ সময় নিতে পারে।

perl -M5.010পার্ল ৫.১০+ sayবৈশিষ্ট্যটি সক্ষম করতে কোডটি চালান । ইনপুটটি স্ট্যান্ডার্ড ইনপুটটিতে দেওয়া উচিত, এবং সমাধানটি স্ট্যান্ডার্ড আউটপুটে মুদ্রিত হবে; উদাহরণ:

$ perl -M5.010 golf/sudoku.pl
030001000006000050500000983080006302000050000903800060714000009020000800000400030
832591674496387251571264983185746392267953418943812765714638529329175846658429137

— ইলমারি করোনেন
সূত্র

2

1-লাইনার কফি স্ক্রিপ্ট

solve = (s, c = 0) -> if c is 81 then s else if s[x = c/9|0][y = c%9] isnt 0 then solve s, c+1 else (([1..9].filter (g) -> ![0...9].some (i) -> g in [s[x][i], s[i][y], s[3*(x/3|0) + i/3|0][3*(y/3|0) + i%3]]).some (g) -> s[x][y] = g; solve s, c+1) or s[x][y] = 0

এখানে নমুনা ব্যবহার সহ আরও বড় সংস্করণ :

solve = (sudoku, cell = 0) ->
  if cell is 9*9 then return sudoku

  x = cell%9
  y = (cell - x)/9

  if sudoku[x][y] isnt 0 then return solve sudoku, cell+1

  row = (i) -> sudoku[x][i]
  col = (i) -> sudoku[i][y]
  box = (i) -> sudoku[x - x%3 + (i - i%3)/3][y - y%3 + i%3]

  good = (guess) -> [0...9].every (i) -> guess not in [row(i), col(i), box(i)]

  guesses = [1..9].filter good

  solves = (guess) -> sudoku[x][y] = guess; solve sudoku, cell+1

  (guesses.some solves) or sudoku[x][y] = 0

sudoku = [
  [1,0,0,0,0,7,0,9,0],
  [0,3,0,0,2,0,0,0,8],
  [0,0,9,6,0,0,5,0,0],
  [0,0,5,3,0,0,9,0,0],
  [0,1,0,0,8,0,0,0,2],
  [6,0,0,0,0,4,0,0,0],
  [3,0,0,0,0,0,0,1,0],
  [0,4,0,0,0,0,0,0,7],
  [0,0,7,0,0,0,3,0,0]
]
console.log if solve sudoku then sudoku else 'could not solve'

— pathikrit
সূত্র

1

সংক্ষিপ্ত করে সংক্ষিপ্ত করে solveঅনেকগুলি শ্বেতস্পেস সরিয়ে ফেলা যায় (আমি জানি এটি গুরুত্বপূর্ণ, তবে অনেক স্থানে এটি মুছে ফেলা যেতে পারে), শব্দের পরিবর্তে প্রতীক ব্যবহার ( !=পরিবর্তে পছন্দ মতো isnt), thenকীওয়ার্ডের পরিবর্তে ইনডেন্টেশন ব্যবহার করে প্রতিস্থাপন [0...9]করা [0..8]।

— কনরাড বোরোস্কি

1

ক্লোজার - 480 বাইট

আকারটি বিস্ফোরিত হয়েছিল, তবে কমপক্ষে এটি একটি সুন্দর সংখ্যা। আমি মনে করি কেবল 1 ডি-ভেক্টর ব্যবহার করে এটি অনেক উন্নত হতে পারে। যাইহোক, পরীক্ষার কেসটি আমার ল্যাপটপে চার সেকেন্ডের মধ্যে খানিকটা সময় নেয়। আমি ভেবেছিলাম কোনও ফাংশন সংজ্ঞায়িত করা উপযুক্ত হবে কারণ এটি সর্বোপরি একটি কার্যকরী ভাষা।

(defn f[o &[x y]](if x(if(> y 8)(apply str(map #(apply str %)o))(first(for[q[(o y)]v(if(=(q x)0)(range 1 10)[(q x)])d[(assoc o y(assoc(o y)x v))]s[(and(every? true?(concat(for[i(range 9)](and(or(not=((d y)i)v)(= i x))(or(not=((d i)x)v)(= i y))))(for[m[#(+ %2(- %(mod % 3)))]r[(range 3)]a r b r c[(m y b)]e[(m x a)]](or(and(= e x)(= c y))(not=((d y)x)((d c)e))))))(f d(mod(+ x 1)9)(if(= x 8)(+ 1 y)y)))]:when s]s)))(f(vec(for[a(partition 9 o)](vec(map #(Integer.(str %))a))))0 0)))

উদাহরণ:

(f "030001000006000050500000983080006302000050000903800060714000009020000800000400030")
=> "832591674496387251571264983185746392267953418943812765714638529329175846658429137"
(f "004720900039008005001506004040010520028050170016030090400901300100300840007085600")
=> "654723981239148765871596234743819526928654173516237498482961357165372849397485612"

একটি সামান্য উজ্জীবিত (এবং সুন্দর) সংস্করণ:

(defn check-place [o x y v]
  (and (every? true? (for [i (range 9)]
                       (and (or (not= ((o y) i) v) (= i x))
                            (or (not= ((o i) x) v) (= i y)))))
       (every? true?
         (for [r [(range 3)]
               a r
               b r
               c [(+ b (- y (mod y 3)))]
               d [(+ a (- x (mod x 3)))]]
           (or (and (= d x) (= c y)) (not= ((o y) x) ((o c) d)))))))

(defn solve-sudoku [board & [x y]]
  (if x
    (if (> y 8)
      (apply str (map #(apply str %) board))
      (first
        (for [v (if (= ((board y) x) 0) (range 1 10) [((board y) x)])
              :let [a (mod (+ x 1) 9)
                    b (if (= x 8) (+ 1 y) y)
                    d (assoc board y (assoc (board y) x v))
                    s (and (check-place d x y v) (solve-sudoku d a b))]
              :when s]
          s)))
    (solve-sudoku (vec (for [a (partition 9 board)]
                         (vec (map #(Integer. (str %)) a)))) 0 0)))

— seequ
সূত্র

1

পাওয়ারশেল , 244 242 218 215 বাইট

$a=(24,24,6)*3|%{,(0..8|%{($r++)});,(0..8|%{$c%81;$c+=9});$c++;,((1,1,7)*3|%{+$q;$q+=$_});$q-=$_}
$f={param($s)$l,$r=$s-split0,2;if($p=$a|?{$l.length-in$_}){1..9|?{"$_"-notin($p|%{$s[$_]})}|%{&$f "$l$_$r"}}else{$s}}

এটি অনলাইন চেষ্টা করুন!

স্ক্রিপ্টটি সুডোকুর সমস্ত সমাধান সন্ধান করে।

Unrolled:

$a=(24,24,6)*3|%{                       # array of indexes for a sudoku...
    ,(0..8|%{($r++)})                   # rows
    ,(0..8|%{$c%81;$c+=9});$c++         # columns
    ,((1,1,7)*3|%{+$q;$q+=$_});$q-=$_   # and squares
}

$f = {
    param($s)

    # optional log. remove this statement in a release version.
    if($script:iter++ -lt 100 -or ($script:iter%100)-eq0){
        Write-Information ('{0}: {1,6}: {2}'-f (get-Date), $script:iter, ($s-replace0,' ')) -InformationAction Continue
    }

    $left,$right=$s-split0,2                # split by a first 0; $left.length is a position of this 0 if $s contains the 0
    if( $parts=$a|?{$left.length-in$_} ){   # get sudoku parts (rows, columns, squares) contain the position
        1..9|?{                             # try a digit
            "$_"-notin($parts|%{$s[$_]})    # all digits in these parts will be unique if parts do not contain the digit
        }|%{
            &$f "$left$_$right"             # recursive call with the digit
        } #|select -f 1                     # uncomment this to get a first result only
    }
    else{
        $s
    }

}

পরীক্ষার কেস:

@(
    # 5 iterations, my notebook: 00:00:00, all
    # 5 iterations, my notebook: 00:00:00, first only
    , ( "832591674496387251571264983185746392267953418943812765714638529329175846658400030",
        "832591674496387251571264983185746392267953418943812765714638529329175846658429137" )

    # ~29600 iterations, my notebook: 00:01:27, all
    #  ~2100 iterations, my notebook: 00:00:10, first only
    # , ( "830001000006000050500000983080006302000050000903800060714000009020000800000400030",
    #     "832591674496387251571264983185746392267953418943812765714638529329175846658429137" )

    # ~49900 iterations, my notebook: 00:02:39, all
    # ~22400 iterations, my notebook: 00:01:20, first only
    # , ( "030001000006000050500000983080006302000050000903800060714000009020000800000400030",
    #     "832591674496387251571264983185746392267953418943812765714638529329175846658429137" )

) | % {
    $sudoku, $expected = $_
    $time = Measure-Command {
        $result = &$f $sudoku
    }
    "$($result-contains$expected): $time"
    $result
}

— mazzy
সূত্র

0

ডি (322 অক্ষর)

প্রতিটি অমীমাংসিত স্কোয়ারের জন্য এটি উপলব্ধ বিকল্পগুলির একটি অ্যারে তৈরি করে এবং তারপরে এটি লুপ করে।

import std.algorithm,std.range,std.stdio;void main(char[][]args){T s(T)(T p){foreach(i,ref c;p)if(c<49){foreach(o;"123456789".setDifference(chain(p[i/9*9..i/9*9+9],p[i%9..$].stride(9),p[i/27*27+i%9/3*3..$][0..21].chunks(3).stride(3).joiner).array.sort)){c=o&63;if(s(p))return p;}c=48;return[];}return p;}s(args[1]).write;}

সাদা স্থান সহ:

import std.algorithm, std.range, std.stdio;

void main(char[][] args) {
    T s(T)(T p) {
        foreach (i, ref c; p) if (c < 49) {
            foreach (o; "123456789".setDifference(chain(
                    p[i/9*9..i/9*9+9],
                    p[i%9..$].stride(9),
                    p[i/27*27+i%9/3*3..$][0..21].chunks(3).stride(3).joiner
                ).array.sort))
            {
                c = o&63;
                if (s(p)) return p;
            }
            c=48;
            return [];
        }
        return p;
    }
    s(args[1]).write;
}

— mleise
সূত্র

0

পার্ল (১৯৫ টি চর)

use integer;@A=split//,<>;sub R{for$i(0..80){next if$A[$i];my%t=map{$_/9==$/9||$_%9==$i%9||$_/27==$i/27&&$_%9/3==$i%9/3?$A[$_]:0=>1}0..80;R($A[$i]=$_)for grep{!$t{$_}}1..9;return$A[$i]=0}die@A}R

সমস্ত কৃতিত্ব এখানে স্রষ্টার কাছে যায় এবং ব্যাখ্যাটি সেখানেও পাওয়া যাবে।

— Qwix
সূত্র

1

আপনি যদি এটি নিজে না লিখে থাকেন তবে আপনার "সম্প্রদায় উইকি" বোতামটি পরীক্ষা করা উচিত।

— কাইল কানোজ

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

— কিউইউইক্স

হুম, সেই প্রয়োজনীয়তা সম্পর্কে সচেতন ছিল না।