เกมแห่งชีวิตที่มั่นคง


19

ท้าทาย:

ให้เมทริกซ์ (หรืออาร์เรย์ 2d) เป็น 0s และ 1s ส่งออกจำนวนขั้นตอนที่ใช้สำหรับเกมชีวิตของคอนเวย์เพื่อให้ถึงสถานะที่มั่นคงหรือ -1 ถ้ามันไม่ถึงหนึ่ง สถานะคงที่คือสถานะที่ไม่มีการเปิดหรือปิดเซลล์ในแต่ละขั้นตอน เกมจะต้องทำงานในเมทริกซ์ที่กำหนดโดยมีการเชื่อมต่อด้านบนและด้านล่างและการเชื่อมต่อด้านข้าง (เช่นได้รับเมทริกซ์ 4x3 ที่ควรรันบน 4x3 torus) เมทริกซ์อินพุตจะไม่ใหญ่กว่า 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

กระบวนการ:

สถานะเริ่มต้นมีเสถียรภาพ

กฎของเกมแห่งชีวิต

หากเซลล์ที่ถูกปิด (0) อยู่ถัดจากสามเซลล์ (1) เซลล์ที่แน่นอนจะเปิดใช้งาน มิฉะนั้นจะถูกทิ้งไว้ หากเซลล์ที่เปิดอยู่ถัดจาก 2 หรือ 3 บนกำลังสองมันจะบอกว่า มิฉะนั้นจะปิด


ดังนั้นสิ่งที่ควรออกถ้ารูปแบบซ้ำแล้วซ้ำอีกตลอดไป?
คดีกองทุนของโมนิกา

2
รูปแบบอินพุตที่เป็นไปได้หรือไม่ มีขอบเขตของขนาดเมทริกซ์หรือไม่? ถ้าไม่จะเกิดอะไรขึ้นถ้าเรามีเมทริกซ์ 100x100 นอกจากนี้คุณควรวางบทสรุปของกฎของเกมแห่งชีวิตในคำถามเพื่อให้มีความพร้อมในตัวเอง
El'endia Starman

3
อ้อเข้าใจแล้ว. ฉันอ่านผิดหนึ่งตัวอย่าง อีกคำถามหนึ่งเราควรถือว่า ณ จุดใดไม่มั่นคง? เพราะฉันแน่ใจว่ามีรูปแบบมากมายที่เสถียรหลังจากทำซ้ำเป็นร้อยหรือนับพัน มีแม้กระทั่งหมวดหมู่สำหรับมัน: Methuselah
คดีของกองทุนโมนิกา

18
ฉันค่อนข้างแน่ใจว่าความท้าทายนี้เป็นหลักขอให้ "แก้ปัญหาการหยุดพัก"
Mego

6
ในฐานะที่เป็นตัวอย่างที่แสดงให้เห็นถึง 250 รุ่นไม่เพียงพอเสมอ: สำหรับเมทริกซ์ 15 โดย 14 เครื่องร่อนเดี่ยวในเวทีที่ว่างเปล่าอย่างอื่นจะใช้เวลา 15 * 14 * 4 = 840 ชั่วอายุคนเพื่อกลับสู่สถานะดั้งเดิม หากจุดสิ้นสุดของเส้นทางที่ยาวนั้นถูกบล็อกโดยบล็อก 2 คูณ 2 เครื่องร่อนจะทำลายการตั้งค่าที่มั่นคง นี่จะเป็นเพียงไม่กี่แถวที่สั้นที่สุดของเส้นทางเพื่อหลีกเลี่ยงการทำลายเครื่องร่อนในตอนเริ่มต้น แต่ก็ยังดีกว่า 600 รุ่นก่อนเสถียรภาพ
trichoplax

คำตอบ:


10

Mathematica, 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 Nขั้นตอนโดยที่Nคือจำนวนเซลล์ในอินพุต สิ่งนี้รับประกันได้ว่าหากระบบเข้าสู่สถานะที่มั่นคงเราได้มาถึงแล้ว หลังจากนั้นเราจะพบคู่ที่เหมือนกันของสถานะที่เหมือนกันติดต่อกันในประวัติศาสตร์จำลอง

ลองดูรหัส:

2^Length[Join@@#]

สิ่งนี้คำนวณ2 Nเนื่องจากJoin@@ถูกใช้เพื่อทำให้รายการ 2D เรียบ

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

นี้เลียนแบบเกมชีวิตสำหรับ2 Nชั่วอายุคน เมทริกซ์ 3x3 ระบุย่านของออโตเมติก 2D แบบเบ็ดเสร็จและ224เป็นหมายเลขกฎของ Game of Life มาตรฐาน ผมเคยเขียนเกี่ยวกับวิธีการคำนวณจำนวนนี้มากกว่าที่นี่ใน Mathematica.SE

Partition[...,2,1]

สิ่งนี้จะได้รับรุ่นที่ต่อเนื่องกัน (ทับซ้อน) ทั้งหมด

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

นี้พบว่าคู่แรกของรุ่นเหมือนผิดนัด0ถ้าไม่มีพบและการ จำกัด 1การค้นหาให้ลึก หากคู่ดังกล่าวจะพบว่าผลที่ได้จะถูกส่งกลับในรายการแม้ว่า ดังนั้นเราจึงใช้:

#&@@...

ในการแยกองค์ประกอบแรกจากรายการนั้น (ค่าเริ่มต้นของ0การเป็นอะตอมไม่ได้รับผลกระทบจากสิ่งนี้)

...-1

ในที่สุดเราก็ลบออกเพราะความท้าทายคาดว่าจะมี0ดัชนีที่ใช้และ-1ความล้มเหลว


8

Lua, 531 509 488 487 464 424 405 404 ไบต์

ใครต้องการส่งงานครั้งใหญ่? \ O /

แก้ไข: ปรับปรุง แต่ไม่ทราบวิธีตีกอล์ฟอีกต่อไปดังนั้น ... คำอธิบายกำลังเพิ่มความคิดเห็น :)

บันทึกแล้ว ~ 60 ไบต์ด้วยความช่วยเหลือของ @ KennyLau

การเล่นกอล์ฟขนาดเล็กตัดอีกหนึ่งไบต์โดยเปลี่ยนชื่อ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ṪÇ$$?

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

กรณีทดสอบที่ใหญ่กว่า (จากคำตอบของ @ Katenkyo ): 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

Perl, 154 151 144 140 137 133 129 ไบต์

รวมถึง +3 สำหรับ -ap0

รันด้วยอินพุตเป็นบรรทัดของกลุ่มตัวเลขคั่นด้วยช่องว่าง

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

นี่เป็นสิ่งจำเป็นจริงๆเท่านั้นในกรณีที่อินพุตมีความเสถียรในทันที ในกรณีอื่น ๆ ทั้งหมดคุณสามารถกำหนดให้มันเป็นเส้นของตัวเลขได้อย่างสะดวกยิ่งขึ้น:

life.pl
0000
0001
0111
0010
^D

การป้อนข้อมูลด้วยวิธีนี้จะให้ 1 แทน 0 สำหรับการกำหนดค่าที่เสถียรทันที

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

เกือบเอาชนะ Mathematica ในอันนี้ ...

เฉพาะในเวอร์ชัน perl เก่ากว่า (ซึ่งคุณสามารถใช้ค่าคงที่เป็นตัวแปรได้) โซลูชัน 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 ไบต์นี้ใช้งานได้กับ perl ทุกรุ่น:

#!/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 matrix หมายความว่าเรามีบอร์ดที่เป็นไปได้ 2 ^ 225 ฉันสงสัยอย่างมากว่าคุณสามารถจดจำเมทริกซ์เหล่านั้นได้โดยใช้หน่วยความจำของคอมพิวเตอร์ทุกเครื่องในโลก (แม้ว่าเกมส่วนใหญ่อาจจะจบลงด้วยบอร์ดน้อยกว่า 1,000) โชคดี เครื่อง 64 บิต
GameDeveloper

1
@DarioOO แม้แต่ร่อนบนกระดานขนาด 15x14 ก็ต้องการรุ่น 840 เท่านั้น "เท่านั้น" ก่อนที่จะวนกลับไปสู่สถานะแรกดังนั้นเราจึงสามารถคาดหวังได้ว่าทุกอย่างจะต่ำกว่า 1,000 วงศ์ นอกจากนี้ 1000 gens บน 15x15 โดยใช้จำนวนเต็ม 32 บิตทำให้การใช้หน่วยความจำเท่ากับ15*15*4*1000-> 900 KB เหมาะสำหรับกรณีที่เราต้องการ 10k + gens :)
Katenkyo

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.