স্থির গেম অফ লাইফ


19

চ্যালেঞ্জ:

0 এবং 1 এর ম্যাট্রিক্স (বা 2 ডি অ্যারে) দেওয়া, কনওয়ের জীবনের গেমটি স্থিতিশীল অবস্থায় পৌঁছাতে যে পদক্ষেপ গ্রহণ করে তার সংখ্যা আউটপুট করুন, বা -1 এটি কখনও পৌঁছায় না যদি। একটি স্থিতিশীল রাষ্ট্র এমন একটি রাষ্ট্র যেখানে প্রতিটি পদক্ষেপে কোনও কোষ চালু বা বন্ধ হয় না। গেমটি অবশ্যই উপরের এবং নীচের সাথে সংযুক্ত এবং পাশগুলি সংযুক্ত করে প্রদত্ত ম্যাট্রিক্সে চালানো উচিত। (যেমন একটি 4x3 ম্যাট্রিক্স দেওয়া এটি একটি 4x3 টরাস উপর চালানো উচিত) ইনপুট ম্যাট্রিক্স 15x15 এর চেয়ে বড় হবে না।

দ্রষ্টব্য: ম্যাট্রিক্স স্থিতিশীল অবস্থায় শুরু হলে আউটপুট 0 হওয়া উচিত।

নমুনা:

ইনপুট:

[[0,0,0],  
 [0,1,1],  
 [0,1,0]]

আউটপুট:

2

প্রক্রিয়া: (এটি প্রদর্শনের দরকার নেই)

[[0,0,0],
 [0,1,1],
 [0,1,0]]

[[1,1,1],
 [1,1,1],
 [1,1,1]]

[[0,0,0],
 [0,0,0],
 [0,0,0]]

ইনপুট:

[[0,0,1,1],
 [0,1,1,1],
 [0,1,0,0],
 [0,1,1,1]]

আউটপুট:

2

প্রসেস:

[[0,0,1,1],
 [0,1,1,1],
 [0,1,0,0],
 [0,1,1,1]]

[[0,0,0,0],
 [0,1,0,1],
 [0,0,0,0],
 [0,1,0,1]]

[[0,0,0,0],
 [0,0,0,0],
 [0,0,0,0],
 [0,0,0,0]]

ইনপুট:

[[0,1,0,0],
 [0,1,0,0],
 [0,1,0,0],
 [0,0,0,0]]

আউটপুট:

-1

প্রসেস:

[[0,1,0,0],
 [0,1,0,0],
 [0,1,0,0],
 [0,0,0,0]]

[[0,0,0,0],
 [1,1,1,0],
 [0,0,0,0],
 [0,0,0,0]]

[[0,1,0,0],
 [0,1,0,0],
 [0,1,0,0],
 [0,0,0,0]]

চিরকাল পুনরাবৃত্তি

ইনপুট:

[[0,0,0,0],
 [0,0,0,1],
 [0,1,1,1],
 [0,0,1,0]]

আউটপুট:

4

প্রসেস:

[[0,0,0,0],
 [0,0,0,1],
 [0,1,1,1],
 [0,0,1,0]]

[[0,0,0,0],
 [1,0,0,1],
 [1,1,0,1],
 [0,1,1,1]]

[[0,1,0,0],
 [0,1,1,1],
 [0,0,0,0],
 [0,1,0,1]]

[[0,1,0,1],
 [1,1,1,0],
 [0,1,0,1],
 [1,0,1,0]]

[[0,0,0,0],
 [0,0,0,0],
 [0,0,0,0],
 [0,0,0,0]]

ইনপুট:

[[0,0,0,0],
 [0,1,1,0],
 [0,1,1,0],
 [0,0,0,0]]

আউটপুট:

0

প্রসেস:

শুরুর অবস্থা স্থিতিশীল is

গেম অফ লাইফের বিধিগুলি

(0) বন্ধ থাকা কোনও ঘর যদি (1) কোষের ঠিক তিনটির পাশে থাকে তবে এটি চালু করা হবে। অন্যথায়, এটি ছেড়ে দেওয়া হয়। যদি চালু একটি ঘর স্কোয়ারে 2 বা 3 এর পরে থাকে তবে এটি বলে। অন্যথায়, এটি বন্ধ আছে।


তাহলে আউটপুটটি কী হওয়া উচিত যদি প্যাটার্নটি চিরতরে পুনরাবৃত্তি করে?
মনিকা এর মামলা মামলা

2
সম্ভাব্য ইনপুট ফর্ম্যাটগুলি? ম্যাট্রিক্স আকারের কোনও সীমানা? যদি না হয় তবে আমাদের যদি 100x100 ম্যাট্রিক্স থাকে? এছাড়াও, আপনার সম্ভবত গেম অফ লাইফের বিধিগুলির একটি সংক্ষিপ্তসার প্রশ্নে রাখা উচিত যাতে এটি স্বয়ংসম্পূর্ণ।
এল'েন্ডিয়া স্টারম্যান

3
আচ্ছা বুঝলাম. আমি এর একটি উদাহরণ ভুল লিখেছি। আরেকটি প্রশ্ন, যদিও - কোন স্থানে আমাদের ধরে নেওয়া উচিত যে এটি স্থিতিশীল হয় না? কারণ আমি নিশ্চিত যে প্রচুর পরিমাণে নিদর্শন রয়েছে যা শত বা হাজারো পুনরাবৃত্তির পরে স্থিতিশীল হয়ে ওঠে। এমনকি এর জন্য আরও একটি বিভাগ আছে: মথুশেলাহ
ফান্ড মনিকার লসুইট

18
আমি নিশ্চিত যে এই চ্যালেঞ্জটি মূলত "থামানো সমস্যার সমাধান করুন" জিজ্ঞাসা করছে pretty
মেগো

6
২৫০ প্রজন্মকে দেখানোর জন্য প্রতিলিপি হিসাবে সর্বদা পর্যাপ্ত হয় না: 15 বাই 14 ম্যাট্রিক্সের জন্য, অন্যথায় খালি ময়দানে একক গ্লাইডারটি তার মূল অবস্থায় ফিরে আসতে 15 * 14 * 4 = 840 প্রজন্মের সময় নেবে। যদি দীর্ঘ পথটির শেষটি 2 ​​বাই 2 ব্লক দ্বারা অবরুদ্ধ করা হয়, তবে গ্লাইডার স্থিতিশীল কনফিগারেশন রেখে ধ্বংস করে দেবে। শুরুতে গ্লাইডারটি ধ্বংস করতে এড়াতে এটি পথের শেষের কয়েক সারি সংক্ষেপে হবে, তবে স্থিরতার আগেও 600 প্রজন্মেরও ভাল।
ট্রাইকোপলাক্স

উত্তর:


10

গণিত, 130 129 বাইট

#&@@FirstPosition[Partition[CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},#,2^Length[Join@@#]],2,1],{x_,x_},0,1]-1&

আমি 4x4 এর বেশি ইনপুট চেষ্টা করার পরামর্শ দেব না, কারণ এটি চিরকাল (এবং অনেক স্মৃতি) গ্রহণ করতে চলেছে ।

ব্যাখ্যা

এটি কেবল 2 এন পদক্ষেপের জন্য গেম অফ লাইফের অনুকরণ করে যেখানে এন ইনপুটটিতে কোষের সংখ্যা। এটি গ্যারান্টি দেয় যে সিস্টেমটি যদি কোনও স্থিতিশীল অবস্থায় পরিণত হয় তবে আমরা এটি পৌঁছেছি। এরপরে, আমরা সিমুলেটেড ইতিহাসে একটানা অভিন্ন রাষ্ট্রের প্রথম জুড়িটি পাই।

কোডটি দিয়ে যাওয়া যাক:

2^Length[Join@@#]

এটি 2 এন গণনা করে , যেহেতু Join@@2D তালিকা সমতল করতে ব্যবহৃত হয়।

CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},#,...]

এটি 2 এন প্রজন্মের জন্য গেম অফ লাইফের অনুকরণ করে । 3x3 ম্যাট্রিক্স সর্বমোট 2D অটোমেটনের আশপাশ নির্দিষ্ট করে এবং 224এটি স্ট্যান্ডার্ড গেম অফ লাইফের নিয়ম সংখ্যা। আমি এখানে গাণিতিক.এসইতে এই সংখ্যাটি কীভাবে গণনা করব সে সম্পর্কে লিখেছি ।

Partition[...,2,1]

এটি প্রজন্মের সমস্ত ক্রমাগত (ওভারল্যাপিং) পায়।

FirstPosition[...,{x_,x_},0,1]

এটি অভিন্ন প্রজন্মের প্রথম জুটি আবিষ্কার করে, 0যদি কোনওটি পাওয়া না যায় তবে ডিফল্ট এবং অনুসন্ধানকে গভীরতায় সীমাবদ্ধ করে 1। যদি এ ধরনের একজোড়া হয় পাওয়া যায় নি, ফলাফলের যদিও তালিকার ফিরিয়ে দেওয়া হয়। সুতরাং আমরা ব্যবহার:

#&@@...

সেই তালিকা থেকে প্রথম উপাদানটি বের করতে ( 0পারমাণবিক হওয়ায় এর ডিফল্ট মান এটি দ্বারা প্রভাবিত হয় না)।

...-1

অবশেষে আমরা একটিকে বিয়োগ করি কারণ চ্যালেঞ্জটি 0ভিত্তিক সূচকগুলি এবং -1ব্যর্থতার প্রত্যাশা করে ।


8

লুয়া, 531 509 488 487 464 424 405 404 বাইট

কে একটি বিশাল জমা দিতে চায়? \ ণ /

সম্পাদনা করুন: এটি উন্নত হয়েছে, তবে কীভাবে এটি আর গল্ফ করবেন তা জানেন না, সুতরাং ... ব্যাখ্যাগুলি মন্তব্যগুলিতে যুক্ত হচ্ছে :)

@ কেনিলাউর সহায়তায় ~ 60 বাইট সংরক্ষণ করা হয়েছে

ইনলাইনড হেক্সাডেসিমাল রূপান্তরটি রোধ করতে পুনরায় নামকরণ aকরে ছোট গল্ফিং আরও একটি বাইট কাটাY

function f(m)c={}t=table.concat::z::c[#c+1]={}p=c[#c]Y={}for i=1,#m do k=m[i]p[#p+1]=t(k)Y[i]={}for j=1,#k
do v=m[i%#m+1]l=j%#k+1w=m[(i-2)%#m+1]h=(j-2)%#k+1Y[i][j]=v[l]+k[l]+w[l]+v[h]+v[j]+w[h]+w[j]+k[h]end
end s=''for i=1,#m do k=m[i]for j=1,k do
x=Y[i][j]k[j]=k[j]>0 and((x<2or x>3)and 0or 1)or (x==3 and 1or 0)end
s=s..t(k)end for i=1,#c do
if(s==t(c[i]))then return#c>i and-1or i-1
end end goto z end

Ungolfed

function f(m)                -- takes a 2D array of 0 and 1s as input
  c={}                       -- intialise c -> contains a copy of each generation
  t=table.concat             -- shorthand for the concatenating function 
  ::z::                      -- label z, used to do an infinite loop
    c[#c+1]={}               -- initialise the first copy 
    p=c[#c]                  -- initialise a pointer to this copy
    a={}                     -- initialise the 2D array of adjacency
    for i=1,#m               -- iterate over the lines of m
    do
      k=m[i]                 -- shorthand for the current line
      p[#p+1]=t(k])          -- saves the current line of m as a string
      a[i]={}                -- initialise the array of adjacency for the current line
      for j=1,#k             -- iterate over each row of m
      do
                             -- the following statements are used to wraps at borders
        v=m[i%#m+1]          -- wrap bottom to top
        l=j%#k+1             -- wrap right to left
        w=m[(i-2)%#m+1]      -- wrap top to bottom
        h=(j-2)%#k+1         -- wrap left to right

        a[i][j]= v[l]        -- living cells are 1 and deads are 0
                +k[l]        -- just add the values of adjacent cells
                +w[l]        -- to know the number of alive adjacent cells
                +v[h]
                +v[j]
                +w[h]
                +w[j]
                +k[h]
      end
    end

    s=''                     -- s will be the representation of the current generation
    for i=1,#m               -- iterate over each line
    do
      k=m[i]                 -- shorthand for the current line
      for j=1,#k             -- iterate over each row
      do
        x=a[i][j]            -- shorthand for the number of adjacent to the current cell
                             -- the next line change the state of the current cell
        k[j]=k[j]>0          -- if it is alive
                and((x<2     --   and it has less than 2 adjacent
                    or x>3)  --   or more than 3 adjacent
                  and 0      --     kill it
                  or 1)      --     else let it alive
                or           -- if it is dead
                  (x==3      --   and it has 3 adjacent
                  and 1      --     give life to it
                  or 0)      --     else let it dead
      end
      s=s..t(k)              -- save the representation of the current line
    end
    for i=1,#c               -- iterate over all the generation done until now
    do                       
      if(s==t(c[i]))         -- if the representation of the current generation
      then                   -- is equal to one we saved
        return#c>i           -- check if it is the latest generation
              and-1          -- if it isn't, it means we are in a loop -> return -1
              or i-1         -- if it is, we did 2 generations without changing
                             --  -> return the number of generation
      end
    end
  goto z                     -- if we reach that point, loop back to the label z
end

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

এখানে কিছু পরীক্ষার মামলা রয়েছে

function f(m)c={}t=table.concat::z::c[#c+1]={}p=c[#c]a={}for i=1,#m do k=m[i]p[#p+1]=t(k)a[i]={}for j=1,#k
do v=m[i%#m+1]l=j%#k+1w=m[(i-2)%#m+1]h=(j-2)%#k+1
a[i][j]=v[l]+k[l]+w[l]+v[h]+v[j]+w[h]+w[j]+k[h]end
end s=''for i=1,#m do k=m[i]for j=1,k do
x=a[i][j]k[j]=k[j]>0 and((x<2or x>3)and 0or 1)or (x==3 and 1or 0)end
s=s..t(k)end for i=1,#c do
if(s==t(c[i]))then return#c>i and-1or i-1
end end goto z end




print(f({{0,0,0},{0,1,1},{0,1,0}}))
print(f({{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,0,0,0}}))
-- 53 generation, 15x15, takes 50-100 ms on a bad laptop
print(f({{0,0,0,0,1,1,0,1,0,0,0,0,1,0,0},
       {0,1,1,0,1,1,1,1,1,1,1,0,0,0,0},
       {0,1,1,1,0,1,0,1,0,0,0,0,1,0,0},
       {0,0,1,0,1,1,1,0,0,1,1,1,0,1,1},
       {1,1,0,0,1,1,1,0,1,1,0,0,0,1,0},
       {0,0,0,0,1,1,0,1,0,0,0,0,1,0,0},
       {0,1,1,0,1,1,1,1,1,1,1,0,0,0,0},
       {0,1,1,1,0,1,0,1,0,0,0,0,1,0,0},
       {0,0,1,0,1,1,1,0,0,1,1,1,0,1,1},
       {1,1,0,0,1,1,1,0,1,1,0,0,0,1,0},
       {0,0,1,0,1,1,1,0,0,1,1,1,0,1,1},
       {1,1,0,0,1,1,1,0,1,1,0,0,0,1,0},
       {0,0,0,0,1,1,0,1,0,0,0,0,1,0,0},
       {0,0,0,0,1,1,0,1,0,0,0,0,1,0,0},
       {0,1,1,0,1,1,1,1,1,1,1,0,0,0,0}}))
-- Glider on a 15x14 board
-- 840 distinct generation
-- loop afterward -> return -1
-- takes ~4-5 seconds on the same bad laptop
print(f({{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,1,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,1,0,0,0,0,0,0,0,0,0},
       {0,0,0,1,1,1,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
       {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}}))

5

জেলি, 26 25 বাইট

ṙ-r1¤SZµ⁺_|=3
ÇÐĿ-LiṪÇ$$?

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন

বৃহত্তর পরীক্ষার কেস ( @ কেটেনকিওর উত্তর থেকে ): 15 × 15 স্থির | 15 × 14 গ্লাইডার

কিভাবে এটা কাজ করে

ṙ-r1¤SZµ⁺_|=3  Helper link. Argument: G (grid)
               This link computes the next state of G.

    ¤          Evaluate the three links to the left as a niladic chain.
 -               Yield -1.
   1             Yield 1.
  r              Range; yield [-1, 0, 1].
ṛ              Rotate the rows of G -1, 0 and 1 units up.
     S         Compute the sum of the three resulting grids.
               Essentially, this adds the rows directly above and below each given
               row to that row.
      Z        Zip; transpose rows and columns.
       µ       Convert the preceding chain into a link and begin a new chain.
        ⁺      Apply the preceding chain once more.
               This zips back and adds the surrounding columns to each column.
         _     Subtract G from the result.
               Each cell now contains the number of lit cells that surround it.
          |    That the bitwise OR of the result and G.
               Notably, 3|0 = 3|1 = 2|1 = 3.
           =3  Compare each resulting number with 3.


ÇÐĿ-LiṪÇ$$?    Main link. Argument: G (grid)

ÇÐL            Repeatedly apply the helper link until the results are no longer
               unique. Collect all unique results in a list.
         $     Evaluate the two links to the left as a monadic chain:
        $        Evaluate the two links to the left as a monadic chain:
      Ṫ            Pop the last element of the list of grids.
       Ç           Apply the helper link to get the next iteration.
     i           Get the index of the grid to the right (the first non-unique one)
                 in the popped list of grids. This yields 0 iff the popped list
                 doesn't contain that grid, i.e., the grid reached a stable state.
          ?    If the index is non-zero:
   -             Return -1.
    L            Else, return the length of the popped list of grids.

5

পার্ল, 154 151 144 140 137 133 129 বাইট

জন্য +3 অন্তর্ভুক্ত -ap0

স্থান দ্বারা পৃথক করা অঙ্কগুলির গ্রুপগুলির একটি লাইন হিসাবে ইনপুটটি চালান

life.pl <<< "0000 0001 0111 0010"

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

life.pl
0000
0001
0111
0010
^D

এইভাবে ইনপুট দেওয়া তাৎক্ষণিকভাবে স্থিতিশীল কনফিগারেশনের জন্য 0 এর পরিবর্তে 1 দেয়।

life.pl:

#!/usr/bin/perl -ap0
map{@f=map$F[$_%@F]x3,$i-1..++$i;s%.%"0+($&+33)=~grep\$_,map{(//g)[@--1..@+]}\@f"%eeg}@Q=@F;$_=/@Q/?keys%n:$n{$_="@Q"}--||redo

প্রায় একটিকে ম্যাথমেটিকাকে মারছে ...

কেবল পুরানো পার্ল সংস্করণগুলিতে (যেখানে আপনি চলক হিসাবে ধ্রুবকটি ব্যবহার করতে পারেন) এই 126 বাইট সমাধানের কাজ করে:

#!/usr/bin/perl -p0a
map{@f=map$F[$_++%@F]x2,-1..1;s%.%"0+($&+33)=~grep\$_,map{(//g)[@--1..@+]}\@f"%eeg}@Q=@F;$_=/@Q/?keys%n:$n{$_="@Q"}--||redo

যদি কমপক্ষে 2 টি সারি থাকে তবে এই 123 বাইট সমাধানটি সমস্ত পার্ল সংস্করণে কাজ করে:

#!/usr/bin/perl -p0a
@F=@F[-$#F..!s%.%"0+($&+33)=~grep\$_,map{(//g,//g)[@--1..@+]}\@F[-1..1]"%eeg]for@Q=@F;$_=/@Q/?keys%n:$n{$_="@Q"}--||redo

1

রুবি, 207 বাইট

->a{r=[];(r<<a;a=(0...a.size).map{|i|(0...a[i].size).map{|j|n=0;(-1..1).map{|u|(-1..1).map{|v|n+=a[(i+u)%a.size][(j+v)%a[i].size]}};[n==3,n>2&&n<5][a[i][j]]?1:0}})while(!r.index(a));(a==r[-1])?r.index(a):-1}

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


15x15 ম্যাট্রিক্স মানে আমাদের 2 ^ 225 সম্ভাব্য বোর্ড রয়েছে, আমি অত্যন্ত সন্দেহ করি আপনি এমনকি বিশ্বের সমস্ত কম্পিউটারের মেমরি ব্যবহার করে সেই ম্যাট্রিকগুলি মুখস্ত করতে পারেন (এমনকি বেশিরভাগ গেমগুলি সম্ভবত 1000 এরও কম বোর্ডের সাথে শেষ হবে) এমনকি শুভেচ্ছা 64 বিট মেশিন।
গেম ডেভেলপার

1
@ ডারিওও এমনকি একটি 15x14 বোর্ডের গ্লাইডারটির প্রথম অবস্থায় ফিরে আসার আগে "কেবল" 840 প্রজন্মের প্রয়োজন হবে, তাই আমরা আশা করতে পারি যে প্রায় সব কিছুই 1000 জিনের অধীনে থাকবে। এছাড়াও, 32 বিটস ইন্টিজার ব্যবহার করে 15x15 এ 1000 জিনগুলি 15*15*4*1000-> 900 কেবি মেমরির ব্যবহারের ফলস্বরূপ , আমাদের ক্ষেত্রে 10 কে + জিন প্রয়োজন :) এর ক্ষেত্রে যথেষ্ট good
কাটেনকিও

1

জুলিয়া, 92 88 বাইট

f(x,r...)=x∈r?(r[k=end]==x)k-1:f(sum(i->circshift(x,[i÷3,i%3]-1),0:8)-x|x.==3,r...,x)

প্রতিপাদন

julia> f(x,r...)=x∈r?(r[k=end]==x)k-1:f(sum(i->circshift(x,[i÷3,i%3]-1),0:8)-x|x.==3,r...,x)
f (generic function with 1 method)

julia> f([0 0 0;0 1 1;0 1 0])
2

julia> f([0 0 1 1;0 1 1 1;0 1 0 0;0 1 1 1])
2

julia> f([0 1 0 0;0 1 0 0;0 1 0 0;0 0 0 0])
-1

julia> f([0 0 0 0;0 0 0 1;0 1 1 1;0 0 1 0])
4

julia> f([0 0 0 0;0 1 1 0;0 1 1 0;0 0 0 0])
0

julia> f([0 0 0 0 1 1 0 1 0 0 0 0 1 0 0;0 1 1 0 1 1 1 1 1 1 1 0 0 0 0;0 1 1 1 0 1 0 1 0 0 0 0 1 0 0;0 0 1 0 1 1 1 0 0 1 1 1 0 1 1;1 1 0 0 1 1 1 0 1 1 0 0 0 1 0;0 0 0 0 1 1 0 1 0 0 0 0 1 0 0;0 1 1 0 1 1 1 1 1 1 1 0 0 0 0;0 1 1 1 0 1 0 1 0 0 0 0 1 0 0;0 0 1 0 1 1 1 0 0 1 1 1 0 1 1;1 1 0 0 1 1 1 0 1 1 0 0 0 1 0;0 0 1 0 1 1 1 0 0 1 1 1 0 1 1;1 1 0 0 1 1 1 0 1 1 0 0 0 1 0;0 0 0 0 1 1 0 1 0 0 0 0 1 0 0;0 0 0 0 1 1 0 1 0 0 0 0 1 0 0;0 1 1 0 1 1 1 1 1 1 1 0 0 0 0])
53

julia> f([0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 1 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 1 0 0 0 0 0 0 0 0 0;0 0 0 1 1 1 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;0 0 0 0 0 0 0 0 0 0 0 0 0 0 0])
-1
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.