लागू एक ब्रूट फोर्स सुडोकू सॉल्वर

Question

अनुमान लगाते हुए सबसे छोटे सुडोकू सॉल्वर को लागू करें। चूँकि मुझे कुछ अनुरोध मिला है, इसलिए मैंने इसे एक वैकल्पिक प्रश्न के रूप में जोड़ा है , जो एक क्रूर बल सुडोकू सॉल्वर को लागू करने के इच्छुक लोगों के लिए एक वैकल्पिक प्रश्न है ।

सुडोकू पहेली:

 | 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

नियम:

1. मान लें कि सभी मज़ाक केवल तर्क द्वारा हल किए जा सकते हैं।
2. सभी इनपुट 81 वर्ण लंबे होंगे। अनुपस्थित वर्ण 0 होंगे।
3. एकल स्ट्रिंग के रूप में समाधान का उत्पादन।
4. "ग्रिड" को आंतरिक रूप से संग्रहीत किया जा सकता है लेकिन आप चाहें।
5. समाधान एक क्रूर बल अनुमान समाधान का उपयोग करना चाहिए।
6. समाधान एक उचित समय सीमा के भीतर हल करना चाहिए।

उदाहरण I / O:

>sudoku.py "030001000006000050500000983080006302000050000903800060714000009020000800000400030"
832591674496387251571264983185746392267953418943812765714638529329175846658429137

Comments

इनपुट 27 वर्णों का कैसे हो सकता है? यह 81 वर्ण लंबा होना चाहिए - 9 पंक्तियों x 9 कॉलम। आपका उदाहरण भी यही है। इसके अलावा, मुझे लगता है कि "लापता अक्षर 0 होंगे" इसका मतलब है कि यदि वर्णों की संख्या 81 से कम है, तो शून्य अंत में चले जाते हैं?

— जोनाथन एम डेविस

अरे रुको। मुझे लगता है कि लापता अक्षर 0 बिट होंगे। ओह। वे हैं जिन्हें अनुमान लगाने की आवश्यकता है। किसी भी स्थिति में, वर्णों की संख्या 81 होने की आवश्यकता है, 27 नहीं।

— जोनाथन एम डेविस

ऐसा लगता है कि नियम 5 और 6 थोड़े संघर्ष ....

— pseudonym117

Answer 1

k (72 बाइट्स)

इसका श्रेय k भाषा के निर्माता आर्थर व्हिटनी को जाता है।

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

Comments

क्लासिक! मैं यह भी पोस्ट करने जा रहा था!

— रात्रि विश्राम

Answer 2

पायथन, 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'।

तो आप इसके बजाय stdin पर इनपुट को स्वीकार करना चाहते हैं, तो आप बदल सकते हैं 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())

संपादित करें: यहाँ एक अधिक विस्तृत पूर्वाभ्यास की एक कड़ी है।

Comments

बहुत अच्छा समाधान है।

— प्राइमो

Answer 3

पायथन, 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())

Answer 4

डी में उत्तर:

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

नमूना इनपुट के साथ, यह मेरे Phenom II X6 1090T पर .033s लेता है जब dmd -w(यानी अनुकूलन के बिना) के साथ संकलित किया जाता है, और .011s के साथ संकलित किया जाता है dmd -w -O -inline -release(यानी अनुकूलन के साथ)।

Answer 5

जे, १०३

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

अपेक्षित रन समय: O (गजियन बिलियन वर्ष)

Comments

और अपेक्षित रन समय "ओ (गज़िलियन अरब वर्ष)" क्यों है? (क्या यह ओ के बिना सिर्फ "गजियन बिलियन वर्ष" नहीं होना चाहिए?

— जस्टिन

जब मैंने यह प्रश्न देखा तो मुझे तुरंत पता चल गया था कि J इस को कुचलने वाला है। के।

— Koko

@Quincunx, सख्ती से बोलना, यह बड़े-ओ का गलत उपयोग है; "मज़ाक" को "निरंतर चलने का समय, asymptotically gazillion बिलियन वर्ष" पढ़ना चाहिए था।

— 14

@ कोको, मुझे कुछ बेहतर नहीं मिला, लेकिन मैं अभी भी इस पर काम कर रहा हूं।

— आठवीं

Answer 6

पर्ल, 120 बाइट्स

ओह, मुझे याद है कि 2008 में वापस आ गया था ... और यह वास्तव में perl 5.12 में काम करना बंद कर दिया था क्योंकि विभाजन के बाद @_ की अंतर्निहित सेटिंग तब हटा दी गई थी। तो केवल एक पर्याप्त पुराने पर्ल पर यह प्रयास करें।

STDIN पर इनपुट के साथ चलाएँ:

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

Comments

यह क्लार्क का तीसरा नियम है , लेकिन इसके विपरीत!

— कॉनर ओ'ब्रायन

Answer 7

पर्ल, 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/

यह कुछ मैं कुछ साल पहले पर्ल मेलिंग सूची के साथ मज़ा के लिए एक गोल्फ संस्करण है : एक सुडोकू-सुलझाने regexp।

मूल रूप से, यह इनपुट को 81 लाइनों में विभाजित करता है, प्रत्येक में सभी संख्याएं होती हैं जो संबंधित वर्ग में हो सकती हैं। फिर यह पंक्ति, स्तंभ या क्षेत्र बाधाओं का उल्लंघन करने वाले समाधानों को अस्वीकार करने के लिए बैकरेफरेंस और नकारात्मक लुकहैड कथनों का उपयोग करते हुए प्रत्येक पंक्ति से एक संख्या से मेल खाने के लिए एक regexp का निर्माण करता है। फिर यह रेगेक्सपी के खिलाफ स्ट्रिंग से मेल खाता है, जिससे पर्ल के रेगेक्स इंजन को ट्रायल और बैकट्रैकिंग का कठिन काम मिलता है।

आश्चर्यजनक रूप से, यह एक एकल regexp बनाना संभव है जो किसी भी इनपुट के लिए काम करता है, जैसे मेरा मूल कार्यक्रम करता है। दुर्भाग्य से, यह काफी धीमा है, इसलिए मैंने हार्डकोडेड-गिवेंस संस्करण ( एफडब्ल्यूपी थ्रेड में बाद में पाया गया ) पर यहां गोल्फर कोड आधारित किया है , जो कि किसी भी समाधान को अस्वीकार करने के लिए regexp को ट्विस्ट करता है जिसे यह पता है कि बाद में एक बाधा का उल्लंघन होगा। यह आसान से मध्यम स्तर के सुडोकु के लिए काफी तेज बनाता है, हालांकि विशेष रूप से कठिन अभी भी हल करने के लिए एक लंबा समय ले सकता है।

perl -M5.010पर्ल 5.10+ sayसुविधा को सक्षम करने के लिए कोड के साथ चलाएँ । इनपुट को मानक इनपुट पर दिया जाना चाहिए, और समाधान मानक आउटपुट पर मुद्रित किया जाएगा; उदाहरण:

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

Answer 8

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'

Comments

व्हाट्सएप solveको बहुत कम करके छोटा किया जा सकता है (मुझे पता है कि यह महत्वपूर्ण है, लेकिन कई जगहों पर इसे हटाया जा सकता है), शब्दों के बजाय प्रतीकों का उपयोग करना (जैसे !=कि isnt), thenकीवर्ड के बजाय इंडेंटेशन का उपयोग करना , के [0...9]साथ प्रतिस्थापित करना [0..8]।

— कोनराड बोरोस्की

Answer 9

क्लोजर - 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"

थोड़ा असंगठित (और prettier) संस्करण:

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

Answer 10

पॉवरशेल , 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
}

Answer 11

D (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;
}

Answer 12

पर्ल (195 वर्ण)

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

सारा श्रेय यहाँ के रचनाकार को जाता है , और स्पष्टीकरण वहाँ भी मिल सकता है।

Comments

यदि आपने इसे स्वयं नहीं लिखा है, तो आपको "सामुदायिक विकी" बटन की जांच करनी चाहिए।

— काइल कानूनोस

कुछ शोध के बाद क्या है, यह मेरे लिए संभव नहीं लगता है। मेरे द्वारा चेकबॉक्स देखने के लिए स्पष्ट रूप से 100 प्रतिनिधि की आवश्यकता है ( इस पोस्ट के # 2 के तहत परिशिष्ट अनुभाग देखें )

— Qwix

हम्म, कि आवश्यकता के बारे में पता नहीं था।

— काइल कानोस

Answer 13

जे, 94 बाइट्स

K संस्करण के ठीक उसी तरह काम करता है, जैसे कि BFS के साथ (इसलिए यह सभी समाधानों का उत्पादन करेगा)। यह आउटपुट अंकों के बीच रिक्त स्थान को प्रिंट करता है, लेकिन K प्रोग्राम करता है। मैं "s =:" की गिनती नहीं कर रहा हूं क्योंकि यह केवल फ़ंक्शन का नामकरण कर रहा है (जैसे मैं किसी अन्य भाषा में फ़ाइल नाम नहीं गिनूंगा)।

   s=: [:<@((]i.0:)}"0 _~(>:i.9)-.{&((+./ .=|:)3(],.[,@#.<.@%~)9 9#:i.81)@i.&0#])"1^:(0 e.,)@;^:_"."0

   s'030001000006000050500000983080006302000050000903800060714000009020000800000400030'
8 3 2 5 9 1 6 7 4 4 9 6 3 8 7 2 5 1 5 7 1 2 6 4 9 8 3 1 8 5 7 4 6 3 9 2 2 6 7 9 5 3 4 1 8 9 4 3 8 1 2 7 6 5 7 1 4 6 3 8 5 2 9 3 2 9 1 7 5 8 4 6 6 5 8 4 2 9 1 3 7