Menghasilkan grid Minesweeper

14

Minesweeper adalah gim logika yang ditemukan di sebagian besar OS. Tujuan dari permainan ini adalah untuk menentukan di mana tambang berada di kotak, diberi angka yang menunjukkan jumlah tambang di sekitar tempat itu.

Dengan ukuran kotak, dan satu set ranjau, buat kisi Minesweeper untuk set ranjau itu.

Input: Dua bilangan bulat yang menunjukkan ukuran kisi, dan jumlah bilangan bulat yang tidak ditentukan yang menunjukkan posisi tambang. Posisi akan diberikan sebagai (posisi kolom, posisi baris), dan indeks akan dimulai pada baris 1.

Output: Kotak Minesweeper. Jika tidak ada ranjau di sekitar blok, cetak a x. Untuk setiap baris baru, cetak baris baru. Keluarkan semua tambang sebagai tanda bintang *. Jangan meninggalkan spasi kosong di antara nilai-nilai di baris saat mencetak.

Kasus uji:

Input "5 5 1 3 3 5 2 4":

xxxxx
11xxx
*21xx
2*21x
12*1x

Input "3 4 3 1 1 4 2 3 3 2":

x2*
13*
2*2
*21

Kode terpendek menang.

beary605
sumber
Apakah kita aman untuk mengasumsikan semua input akan memiliki jumlah argumen yang genap? yaitu 5 5 1tidak akan pernah disahkan?
Gaffi
@ Gaffi: Yap. Input akan selalu menjadi input yang valid.
beary605
Spesifikasi saat ini membuat pembaca menyimpulkan dari contoh bahwa posisi menggunakan indeks berbasis 1 dan baris 1 berada di atas. (Atau yang terakhir, paling tidak, bisa dinegosiasikan?)
Peter Taylor
@PeterTaylor: Yap. Saya kira saya harus membuatnya lebih jelas.
beary605
1
Tidak masalah. Saya masih bertekad untuk menemukan cara untuk mencukur beberapa karakter dan mendapatkan kembali memimpin. :-)
Gareth

Jawaban:

10

GolfScript 122 98 94 93 91 88 87 85 82 81 80 71

~]2/(\:m;~\:w*,{[.w%)\w/)]:^m\?)42{m{^*~-.*@@-.*+3<},,72or 48+}if}%w/n*

Demo online:

Test Case 1: tautan

Test Case 2: tautan

Cristian Lupascu
sumber
!!{a}{b}ifmenggunakan satu karakter lebih dari yang diperlukan. '*'dapat diganti dengan 42karena Anda memasukkannya ke dalam array dan kemudian meringkas array. Demikian pula Anda dapat menggunakan kode ASCII untuk karakter output lain dan menyimpan karakter dengan oruntuk menangani kasus khusus.
Peter Taylor
@ PeterTaylor Wow, !!{a}{b}ifbenar-benar bodoh. :) Lucu apa kesalahan tingkat tinggi yang dapat Anda lakukan sambil berkonsentrasi pada detail. Saya tidak tahu apa yang Anda maksud dengan menggunakan or.
Cristian Lupascu
Memang! Kembali ke masalah setelah beberapa waktu juga membantu. Ketika saya menulis beberapa pembedahan kode untuk blog GolfScript saya, saya melihat banyak perbaikan. Sehubungan dengan saran terakhir saya, setelah ,,Anda memiliki nomor. Anda ingin mengonversinya ke string yang sesuai (atau kode ASCII) kecuali 0, dalam hal ini Anda ingin x. Kode ASCII untuk digit berurutan dan dijalankan dari 48. xadalah ASCII 120, yaitu 72 + 48. Jadi, Anda dapat melakukan 72or 48+dan menyimpan karakter melalui pendekatan berbasis string.
Peter Taylor
@PeterTaylor Hebat! Sebelum Anda menjawab, saya berhasil mengurangi bagian itu .48 120if+, tetapi ortrik Anda lebih pendek dua karakter.
Cristian Lupascu
@ w0lf Gah! Tepat ketika saya pikir saya sudah mendapatkan petunjuk kembali!
Gareth
8

J, 124 116 112 101 87 86 85 84 83 82 79 76 75 72 68 karakter

'0x'charsub|:1":3 3(+/@,+9*4&{@,);._3[1(}.x)}0$~2+>{.x=._2<\".1!:1[1

Menemukan apa yang saya cari - cara untuk menghilangkan ruang ( 1":) - dan akhirnya saya kompetitif. Sekarang saya hanya perlu mencari tahu masalah set tambang yang kosong.

Mengambil input dari keyboard.

Edit

Versi baru memanfaatkan efek samping 1":- angka yang lebih besar dari 9 diganti oleh *.

Gareth
sumber
Saya memperhatikan dua hal: 1. Mencetak spasi alih-alih 0, bukan x; 2. Gagal jika set ranjau kosong (mis: 10 10- harus mencetak papan 10x10 kosong, tetapi kembali |length error)
Cristian Lupascu
Tapi jika berhasil, beri +1.
Cristian Lupascu
@ w0lf Ah, saya masih memikirkan konsep pertama pertanyaan - dalam versi itu xhanya mewakili spasi. Saya tidak memperhatikan bahwa itu telah berubah. Hmm, tidak pernah menyangka bahwa set ranjau akan kosong ... Saya harus bekerja pada itu.
Gareth
sekarang saya melihat bahwa pertanyaannya telah diedit. Saya belum melihat revisi lama. :)
Cristian Lupascu
@ w0lf Terima kasih. Saya menemukan beberapa pengaturan ulang yang baik yang membantu menyingkirkan beberapa tanda kurung yang tidak perlu. Saya dapat melihat satu ruang yang bisa saya hapus, tetapi saya curiga saya cukup banyak pada batas saya. Dan masih ada masalah daftar tambang kosong ... :-)
Gareth
2

Mathematica - 247 karakter

s[q_] :=
  Module[{d, r},
    d = ToExpression@Partition[Cases[Characters@q, Except@" "], 2];
    r = Rest@d;
    StringJoin @@@ 
    ReplacePart[
    Table[ToString@
       Count[ChessboardDistance[{i, j}, #] & /@ Reverse /@ r, 1], {i,d[[1, 2]]}, 
       {j, d[[1, 1]]}] /. {"0" -> "x"}, # -> "*" & /@ Reverse /@ r] // TableForm]

Contoh:

s@"5 5 1 3 3 5 2 4"
s@"3 4 3 1 1 4 2 3 3 2"

Keluaran:

keluaran

ChessboardDistancemenghitung seberapa jauh masing-masing sel dari tambang, di mana 1 berkorespondensi dengan "di sebelah tambang". Angka Count1 menghasilkan angka sel. Kemudian ranjau (*) dimasukkan ke dalam array.

DavidC
sumber
David, senang melihat pengguna Mathematica lain di sini. Saya akan melihat apakah saya bisa mengalahkan ini! :-)
Mr.Wizard
@ Mr.Wizard Saya akan tertarik melihat solusi Anda. Jangan ragu untuk memperbaiki milik saya jika Anda mau.
DavidC
2

Mathematica , 140 139 137

Grid[(ListConvolve[BoxMatrix@1,#,2,0]/. 0->x)(1-#)/. 0->"*"]&@Transpose@SparseArray[{##2}->1,#]&@@#~Partition~2&@@#~ImportString~"Table"&

Menulis itu dalam bentuk yang lebih mudah dibaca:

"5 5 1 3 3 5 2 4"

ImportString[%, "Table"][[1]] ~Partition~ 2

Transpose @ SparseArray[{##2} -> 1, #]& @@ %

ListConvolve[BoxMatrix@1, %, 2, 0]

(% /. 0 -> x) (1 - %%) /. 0 -> "*" // Grid
Tuan Wisaya
sumber
Anggun! Saya akui saya tidak bisa mengerti bagaimana ListCorrelate[BoxMatrix@1, %, 2, 0]keajaibannya.
DavidC
@ David Saya senang Anda (secara implisit) bertanya karena itulah bagian favorit saya. ListCorrelatesecara efektif overlay kernel ( BoxMatrix@1) pada setiap posisi di grid, mengalikan, dan memberikan jumlahnya. (ping saya di mma chat jika Anda ingin sebuah ilustrasi) - Komentar Anda mengingatkan saya bahwa ListConvolveharus bekerja di sini juga karena itu adalah semacam mirror image ListCorrelatedan kernel saya simetris. Itu akan menyelamatkan saya karakter. :-)
Mr.Wizard
Kode Anda menghasilkan tambang dengan salah pada (5,5). "5 5" memberikan dimensi grid.
DavidC
@ David Terima kasih. Anda benar, tetapi itu hanya dalam versi ruang putih; Saya entah bagaimana kehilangan 2dalam ##2. Saya akan memperbaikinya sekarang. ps: Bagaimana Anda bisa mengetahui hal ini setelah sekian lama?
Mr.Wizard
Pertanyaan kapal penyapu ranjau lain, codegolf.stackexchange.com/questions/10635/… , baru-baru ini muncul dan saya memutuskan untuk memberikan solusi Anda lagi.
DavidC
1

VBA - 298 karakter

Sub m(x,y,ParamArray a())
On Error Resume Next:ReDim b(x,y):For i=0 To (UBound(a)-1) Step 2:c=a(i):d=a(i+1):b(c,d)="*":For e=c-1 To c+1:For f=d-1 To d+1:v=b(e,f):If v<>"*" Then b(e,f)=v+1
Next:Next:Next:For f=1 To y:For e=1 To x:v=b(e,f):s=s & IIf(v<>"",v,"x")
Next:s=s & vbCr:Next:MsgBox s
End Sub

Melewatkan kesalahan dengan On Error Resume Nextmenyelamatkan saya beberapa karakter, tetapi ini masih tidak sebagus beberapa jawaban lainnya. : - /

Gaffi
sumber
1

Python, 192 182 180 karakter

Saya dapat menyimpan beberapa jika input dipisahkan dengan koma. Maka baris pertama adalah d=input()dan panjangnya 171 karakter.
Memiliki tambang mengoordinasikan berbasis 0 daripada berbasis 1 juga akan membantu. Harganya 8 karakter untuk diatasi.

d=map(int,raw_input().split())
m=zip(d[2::2],d[3::2])
for y in range(d[1]):print"".join((str(sum(abs(a-x-1)|abs(b-y-1)<2for a,b in m)or'x')+'*')[(x+1,y+1)in m]for x in range(d[0]))

Versi tidak disatukan:

d=map(int,raw_input().split())          # Read whitespace terminated numbers into a list of numbers
xsize,ysize = d[:2]                     # The first two numbers are the board size
mines=zip(d[2::2],d[3::2])              # Convert items 3,4,5,6... to pairs (3,4),(5,6) representine mine coordinates

def dist(point,mine):                   # Distance between point (0-based coordinates) and mine (1-based coordinates)
    dx = abs(mine[0]-(point[0]+1))
    dy = abs(mine[1]-(point[1]+1))
    return dx | dy                      # Should be max(dx,dy), but this is close enough. Wrong for d>=2, but returns >=2 in this case.

for y in range(ysize):                  # Print lines one by one
    line_chars = [
        (str(
            sum(dist((x,y),(a,b))<2 for a,b in mines)   # Number of neighboring mines
            or 'x'                                  # 'x' instead of 0
        )
        +'*')                                       # For a single neighbor, we get "1*"
        [(x+1,y+1)in mines]                         # If a mine, get the '*', else the neighbor number
        for x in range(xsize)
    ]
    print "".join(line_chars)
ugoren
sumber
1

Scala, 280 karakter

val n=readLine split" "map{_.toInt}
val b=Array.fill(n(1),n(0))(0)
n drop 2 sliding(2,2)foreach{case Array(x,y)=>b(y-1)(x-1)=9
for{i<-(x-2 max 0)to(x min n(0)-1);j<-(y-2 max 0)to(y min n(1)-1)}b(j)(i)+=1}
b.map{r=>println(r.map{case 0=>"x"case x if x>8=>"*"case x=>""+x}mkString)}
Don Mackenzie
sumber
0

C ++ - 454 karakter

Ini lebih buruk daripada jawaban VBA saya, yang mungkin berarti saya tidak tahu apa yang saya lakukan di C ++. Namun, saya mencoba membangun apa yang saya ketahui tentang C ++, jadi ini dia. Jika ada yang punya saran untuk perbaikan, saya akan berterima kasih untuk mendengarnya!

#define Z for(int i=
#define Y for(int j=
#define X d[i][j]
#define W Z 0;i<x;i++){
#define V Y 0;j<y;j++){
#define U cout<<
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
int main(){using namespace std;int x,y,a,b;cin>>y>>x;string c[x][y];int d[x][y];W V X=0;}}while(cin>>b>>a){c[--a][--b]="*";Z a-1;i<=a+1;i++){Y b-1;j<=b+1;j++){if(x>i&&i>=0&&y>j&&j>=0){X=X+1;}}}}W V if(c[i][j]!="*"){if(X>0){U X;}else{U"x";}}else{U"*";}}U endl;}return 0;}
Gaffi
sumber
kamu tidak perlu return 0. Dan Anda bisa #include<cstdio>, #include<cstdlib>. Anda bahkan dapat menghapus dua ini termasuk !. Terlebih lagi, using name.....terlalu lama, Anda bisa menggunakannya std::cin, std::cout, std::string.
Ray
@ Ray Aye, Anda benar tentang namespace ... Sudah lama sejak saya menyatukan ini, tapi saya pikir saya memiliki lebih banyak std::panggilan yang akan membuatnya lebih berharga (saya pikir satu lagi stringakan melakukannya ). Terima kasih atas info tentang #includedialognya juga. Saya bukan ahli C ++. ;-)
Gaffi
0

C # (691 Karakter)

using System;namespace M{class P{static char C(char[][] g,int r,int c){int n=0;for(int i=r-1;i<=r+1;i++){if(i<0||i>=g.Length)continue;for(int j=c-1;j<=c+1;j++){if((j<0||j>=g[0].Length)||(i==r&&j==c))continue;if(g[i][j]=='*')n++;}}return n==0?'x':(char)(n+48);}static char[][] G(int[] p){char[][] r=new char[p[1]][];for(int i=0;i<r.Length;i++)r[i]=new char[p[0]];for(int i=2;i<p.Length;){r[p[i+1]-1][p[i]-1]='*';i+=2;}for(int i=0;i<r.Length;i++)for(int j=0; j<r[0].Length;j++)if(r[i][j]!='*')r[i][j]=C(r,i,j);for(int i=0;i<r.Length;i++){for(int j=0;j<r[0].Length;j++)Console.Write(r[i][j]);Console.WriteLine();}return r;}static void Main(string[] args){G(new int[]{3,4,3,1,1,4,2,3,3,2});}}}

Versi Non-golf:

using System;
namespace M
{
    class P
    {
        static char C(char[][] g, int r, int c)
        {
            int n = 0;
            for (int i = r - 1; i <= r + 1; i++)
            {
                if (i < 0 || i >= g.Length) continue;
                for (int j = c - 1; j <= c + 1; j++)
                {
                    if ((j < 0 || j >= g[0].Length) || (i == r && j == c)) continue;
                    if (g[i][j] == '*') n++;
                }
            }
            return n == 0 ? 'x' : (char)(n + 48);
        }

        static char[][] G(int[] p)
        {
            char[][] r = new char[p[1]][];
            for (int i = 0; i < r.Length; i++)
                r[i] = new char[p[0]];
            for (int i = 2; i < p.Length; )
            {
                r[p[i + 1] - 1][p[i] - 1] = '*';
                i += 2;
            }
            for (int i = 0; i < r.Length; i++)
                for (int j = 0; j < r[0].Length; j++)
                    if (r[i][j] != '*') r[i][j] = C(r, i, j);
            for (int i = 0; i < r.Length; i++)
            {
                for (int j = 0; j < r[0].Length; j++)
                    Console.Write(r[i][j]);
                Console.WriteLine();
            } return r;
        } 
        static void Main(string[] args) 
        { 
            G(new int[] { 3, 4, 3, 1, 1, 4, 2, 3, 3, 2 }); 
        }
    }
}
Aamir
sumber
0

K, 175

f:{g::(y;x)#(x*y)#"x";{.[`g;x;:;"*"]}@'-1+|:'(_(#z)%2;2)#z;{if[~"0"~z;$["x"=g .(x;y);.[`g;(x;y);:;z];]]}.'i,'$s:+/'{"*"=g . x}''{,/((x-1)+!3),\:/:(y-1)+!3}.'i:,/(!x),\:/:!y;g}

.

k)f[5;5;1 3 3 5 2 4]
"xxxxx"
"11xxx"
"*21xx"
"2*21x"
"12*1x"
k)f[3;4;3 1 1 4 2 3 3 2]
"x2*"
"13*"
"2*2"
"*21"
tmartin
sumber
0

ECMAScript 2019 (Javascript Modern) - 116 byte

m.map((r,i)=>r.map((c,j)=>c=='X'?c:[,...m].splice(i,3).map(r=>[,...r].splice(j,3)).flat().filter(v=>v=='X').length))

versi tanpa ungolfed

m.map(
  (r,i) => r.map(
    (c,j) => c=='X' ? c :
      [,...m].splice(i,3).map(r=>[,...r].splice(j,3)).flat().filter(v=>v=='X').length
  )
)

solusi ini tidak sepenuhnya mematuhi format input / output tetapi menunjukkan algoritma yang ringkas.

contoh: https://gist.github.com/missinglink/ee02084cfb523665e8c9d34c24f01537

Peter Johnson
sumber
0

brainfuck , 1001 896 bytes

,[>,]-[<]>>++[<[<+<+>>-]<[>+<-]>[>]>[>>[>>>>]>]++[-<+]-[<]<++[>>[>]>[>>[>>>>]>]+<++[-<+]-[<]<-]>>>-]>[>]>[>>[>>>>]<<<->>>>]+[-<+]-[<]>>[[>]>--<<[<]>>[[>]+[->+]+>>[>>>>]>--<+[-<+]-[<]>>-]>[>]+[->+]+>>--<+[-<+]-[<]<[>>[>]+[->+]+>>>>--<+[-<+]-[<]<-]>>[>]+[->+]+>++[-<+]-[<]>>]>[+>>[>>>>]>]<<<<<[<<<<]>>-<+[-<+]>>>>[>>>>]>[-[--<<<<<[<<<<]>>>>--[>>>>]>>>[>>>>]>>>--<+[-<+]++>>>>>>[>[<--<<<[-[>>>>>>+<<<<<+<-]>+<]>[<+>-]>>>>+++[<<<+[-<+]->[-[+[->+]->>>+<<<<+[-<+]->>+<-]>+<]>[<+>-]+[->+]->>-[<<<+[-<+]+>>>>-->+[->+]->>[<<<+>>>-]]<<<[>>>+<<<-]>>>]<<<+[-<+]+<<<<-->+[->+]->>>>>[-[<<+>>>+<-]>+<]>[<+>-]<<<<+++[+[->+]->[-[<<+[-<+]->>>++[->+]->>+<-]>+<]>[<+>-]<<<+[-<+]->>-[+[->+]+>>>>--<+[-<+]->>[<<<+>>>-]]<<<[>>>+<<<-]>>>]+[->+]+<<<<--<+[-<+]->-[>>[-]<<++++++[>++++++<-]>.[-]+<<<]<[>>>[<++++++[>++++++++<-]>.[-]<]<<<[<++++++++[<+++++++++++>-]<.[-]>]<]>>>>+<<++>]>[<+>-]>>]->+[->+]++[-<+]++++++++++.[-]]>]

Cobalah online! atau coba versi lama dengan input integer

Satu hari pemrograman dan tiga hari perbaikan bug ^^

Ini menggunakan beberapa bagian dari kode Game Of Life saya. Alih-alih menghitung sel hidup, ini malah menghitung bom. Karena input sebagai titik kode diizinkan oleh aturan umum, ini menggunakan input bukan bilangan bulat "yang dapat dibaca".

[
Data: colCount, rowCount, {BombCoordinates}, -1 (start of arrays/"soa"), 0, {RowData}
BombCoordinates: bombCol, bombRow
RowData: rowFlag, 0, {CellData}, 0
CellData: cellFlag, cellState, temp, bombCount

rowFlag: 0=EOF, 1=inactive (all cells inactive), 2=active
cellFlag: -1=marker for finding cell (cell to be counted or current cell), 0=EOF, 1=normal
cellState: 0=inactive, 1=normal, 2=bomb
temp: helper to exit if-statements
bombCount: count of neighbor cells that contain bombs
inactive cells or rows will not be printed. They are only used for an easier counting algorithm.
]

#### input values as codepoints ####
,[>,]

#### setup two dimensional array ####
-                   set soa
[<]>>               go to rowCount
++                  add two inactive rows
[                   for each row
  <[<+<+>>-]          copy colCount two times to the next left cells
  <[>+<-]             move one of the copies back to the original cell
  >[>]>[>>[>>>>]>]    go to new row position
  +                   set rowFlag (only 1 while initialization)
  +[-<+]-[<]<         go to copy of colCount
  ++                  add two inactive cells per row
  [                   for each col
    >>[>]>[>>[>>>>]>]   go to new cell position
    +<+                 set cellFlag and cellState = normal
    +[-<+]-[<]<         return to copy of colCount
    -                   decrement
  ]
  >>>-                decrement rowCount
]

#### setup active/inactive flags of cells ####
>[>]>[              for each row
  >>[>>>>]<<<-        set last cell inactive
  >>>>                go to next row
]

#### mark the bombs ####
+[-<+]-[<]>>        go to bombRow
[                   while there are bombRow values left
  [>]>--              set rowFlag of first row = neg 1 (as a marker)
  <<[<]>>             return to bombRow
  [                   for each bombRow
    [>]+[->+]           find first marker after soa
    +                   set rowFlag = 1
    >>[>>>>]>           go to next rowFlag
    --                  make a marker of it
    <+[-<+]-[<]>>       return to bombRow
    -                   decrement
  ]
  >[>]+[->+]          go to selected rowFlag
  +                   set rowFlag = 1
  >>--                set cellFlag of first cell = marker
  <+[-<+]-[<]<        go to bombCol
  [                   for each bombCol
    >>[>]+[->+]         find first marker after soa
    +                   set cellState = 1
    >>>>                go to next cellState
    --                  set it neg 1 (as a marker)
    <+[-<+]-[<]<        return to bombCol
    -                   decrement
  ]
  >>[>]+[->+]         find first marker after soa
  +                   set cellFlag = normal
  >+                  set cellState = bomb
  +[-<+]-[<]>>        go to next bombRow
]

#### setup active/inactive flags of rows ####
>[                  for each row
  +                   set rowFlag = 2 (active)
  >>[>>>>]>           go to next rowFlag
]
<<<<<[<<<<]>>-      set rowFlag of last row = 1 (inactive)

#### count bombs in neighborhood ####
<+[-<+]>>>>[>>>>]>  go to second row
[                   for each row
  -[                  if active
    --                  set it neg 1 (marker)
    <<<<<[<<<<]>>>>     go to cellFlag of first cell in previous row
    --                  set it neg 1 (marker)
    [>>>>]>>>[>>>>]>>>  go to cellFlag of first cell in next row
    --                  set it neg 1 (marker)
    <+[-<+]             return to rowFlag
    ++                  set rowFlag = 2 (active)

    >> >>>>[            for each cell (starting with second)
      >[                  if active
        <--                 set cellFlag = neg 1 (marker)

        # check if cell to the left is a bomb
        < <<                go to cellState of previous cell
        [                   if active
          -[                  if bomb
            >> >>>>+            increment bombCount
            <<<< <              go back to checked cell
            +                   set temp = 1
            <-                  set cellState = 0 to exit if
          ]
          >+<                 increment temp
        ]
        >[<+>-]             restore cellState

        # check if cells on top are bombs
        > >>>               go to temp of current cell
        +++[                do three times
          <<<+[-<+]-          go to next marker to the left
          >[                  if active
            -[                  if bomb
              +[->+]-             return to current cell
              >>>+                increment bombCount
              <<<<+[-<+]->        return to counted cell
              >+                  set temp = 1
              <-                  set cellState = 0 to exit if
            ]
            >+<                 increment temp
          ]
          >[<+>-]             restore cellState
          +[->+]-             go to current cell
          >>-                 decrement temp
          [                   if temp != 0
            <<<+[-<+]           go to marked cell
            +                   set cellFlag = normal
            >>>>--              set cellFlag of next cell = marker
            >+[->+]->>          return to currentCell temp
            [<<<+>>>-]          store value of temp in previous cell bombCount (to exit if)
          ]
          <<<[>>>+<<<-]>>>    restore temp value
        ]
        <<<+[-<+]           go to marked cell
        +                   set cellFlag = normal
        <<<<--              set previous cellFlag = marker
        >+[->+]-            return to current cell

        # check if cell to the right is a bomb
        >>> >>              go to cellState of next cell
        [                   if active
          -[                  if bomb
            <<+                 increment bombCount
            >>>                 go back to checked cell
            +                   set temp = 1
            <-                  set cellState = 0 to exit if
          ]
          >+<                 increment temp
        ]
        >[<+>-]             restore cellState

        # check if cells below are bombs
        <<< <               go to currentCell temp
        +++[                do three times
          +[->+]-         go to next marker to the right
          >[              if active
            -[              if bomb
              <<+[-<+]-       return to current cell
              >>>+            increment bombCount
              +[->+]->        return to counted cell
              >+              set temp = 1
              <-              set cellState = 0 to exit if
            ]
            >+<             increment temp
          ]
          >[<+>-]         restore cellState
          <<<+[-<+]-      go to current cell
          >>-             decrement temp
          [               if temp != 0
            +[->+]          go to marked cell
            +               set cellFlag = normal
            >>>>--          set cellFlag of next cell = marker
            <+[-<+]->>      return to currentCell temp
            [<<<+>>>-]      store value of temp in previous cell bombCount (to exit if)
          ]
          <<<[>>>+<<<-]>>>restore temp value
        ]
        +[->+]          go to marked cell
        +               set cellFlag = normal
        <<<<--          set previous cellFlag = marker
        <+[-<+]-        return to current cell

        # print
        >-[             if bomb
          >>[-]<<         delete bombCount
          ++++++[>++++++<-]>.print "*"
          [-]+            set temp = 1
          <<<             use previous cell bombCount as exitIf
        ]
        <[              else
          >>>[            if bombCount != 0
            <++++++[>++++++++<-]add 48 to get ascii number
            >.              print
            [-]             set number = 0 (for use as exitIf from next cell)
            <               go to temp for exit if
          ]
          <<<[            else
            <++++++++[<+++++++++++>-]<.print "X"
            [-]             delete value (for use as exitIf from next cell)
            >               go to exitIf
          ]
          <               go to exitElse
        ]
        > >>>+          increment temp
        <<++>           set cellFlag = normal
      ]
      >[<+>-]         restore cellState
      >>              go to cellFlag of next cell
    ]
    -               set marker
    >+[->+]         go to next marker
    +               set cellFlag = normal
    +[-<+]          return to marker
    +++++ +++++.[-] print newline
  ]
  >               go to next row
]
Dorian
sumber
0

Ini adalah awal dari solusi Brainfuck. Itu harus cukup mudah dibaca dengan indentasi dan menumpuk komentar ( @menunjukkan penunjuk tumpukan):

>>,>,  |0|x|@y| Pop the first two characters
[>>+<<-]>>  |0|x|0|0|@y|
[<<+>+>-]<  |0|x|@y|y|0|
[  |0|x|y|@y|
  [>>+<<-]< |0|x|@y|0|0|y|
  [>>+<<-]< |0|@x|0|0|y|y|
  [>>+<<-]>> |0|0|0|@x|y|y|
  [<<+>+>-]<<  |0|@x|x|0|y|y|
  [>>+<<-]> |0|0|@x|x|y|y|
  [<< |@0|0|x|x|y|y|
    ++++++++[>+++++++++++<-]>>>>> |0|88|x|x|@y|y|
    [>+<-]< [>+<-]< [>+<-]< [>+<-]< |0|@88|0|x|x|y|y|
    [<+>-]>>-  |88|0|0|@x_1|x|y|y|
  ]<< |x x's|@0|0|0|x|y|y|
  ++++++++++>>> x's|\n|0|0|@x|y|y|
  [<+>-]>  x's|\n|0|x|0|@y|y|
  [<+>-]>  x's|\n|0|x|y|0|@y|
  [<+>-]<- |x 88s|0|x|@y_1|y|
] |@x 88s|0|x|y|

Namun itu masih jauh dari lengkap dan saya mulai ragu apakah pendekatan saya optimal. Sejauh ini hanya mempertimbangkan dua karakter input pertama dan mencetak tabel Xs. Misalnya "43" akan memberi Anda:

XXXX
XXXX
XXXX

Saya akan senang melihat apakah orang lain memiliki apa yang diperlukan dan mampu menyelesaikan masalah ini di Brainfuck.

paldepind
sumber
Optimal sepenuhnya tidak relevan dalam pikiran saya ketika berhadapan dengan BrainFuck. Spesifikasi juru bahasa apa yang Anda targetkan? Suka sel 8-bit atau apa? Saya ingin melihat ini selesai.
captncraig
Saya pikir ini cukup independen dari intepreter tertentu? Selama angkanya tidak terlalu besar.
paldepind
Bekerja pada soulution, tapi tentu saja ternyata selalu lebih sulit daripada yang tampak pada awalnya di Brainfuck.
captncraig
Saya menghabiskan beberapa hari terakhir untuk membangun kode brainfuck yang berjalan untuk ini.
Dorian