Generando cuadrículas de Buscaminas

14

Buscaminas es un juego de lógica que se encuentra en la mayoría de los sistemas operativos. El objetivo del juego es determinar dónde están las minas en una cuadrícula, dados los números que indican el número de minas alrededor de ese lugar.

Dado un tamaño de cuadrícula y un conjunto de minas, genera la cuadrícula Buscaminas para ese conjunto de minas.

Entrada: Dos números enteros que indican el tamaño de la cuadrícula y un número indefinido de números enteros que indican las posiciones de la mina. Las posiciones se darán como (posición de columna, posición de fila), y los índices comenzarán en la fila 1.

Salida: la cuadrícula Buscaminas. Si no hay minas alrededor de un bloque, imprima un x. Para cada nueva fila, imprima una nueva línea. Imprima todas las minas como un asterisco *. No deje espacios en blanco entre los valores de la fila al imprimir.

Casos de prueba:

Entrada "5 5 1 3 3 5 2 4":

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

Entrada "3 4 3 1 1 4 2 3 3 2":

x2*
13*
2*2
*21

El código más corto gana.

code-golf minesweeper beary605
fuente
¿Podemos suponer que todas las entradas tendrán un número par de argumentos? es decir 5 5 1, nunca se aprobará?
Gaffi
@ Gaffi: Sí. La entrada siempre será válida.
beary605
La especificación actualmente deja al lector deducir de los ejemplos que las posiciones usan índices basados ​​en 1 y que la fila 1 está en la parte superior. (¿O es este último, al menos, negociable?)
Peter Taylor
@PeterTaylor: Sí. Supongo que debería hacerlo más obvio.
beary605
1
No hay problema. Sin embargo, todavía estoy decidido a encontrar una manera de afeitar a un par de personajes y recuperar el liderazgo. :-)
Gareth

Respuestas:

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*

Demos en línea:

Caso de prueba 1: enlace

Caso de prueba 2: enlace

Cristian Lupascu
fuente
!!{a}{b}ifusa un personaje más de lo necesario. '*'puede reemplazarse 42porque lo está colocando en una matriz y luego encadenando la matriz. De manera similar, puede usar códigos ASCII para los otros caracteres de salida y guardar un carácter orpara manejar el caso especial.
Peter Taylor
@PeterTaylor Wow, !!{a}{b}iffue realmente estúpido. :) Es curioso los errores de alto nivel que puedes cometer mientras te concentras en los detalles. No puedo entender lo que querías decir con usar or.
Cristian Lupascu
¡En efecto! Volver a un problema después del tiempo también ayuda. Cuando escribí un par de disecciones de código para mi blog GolfScript, vi mejoras considerables. Con respecto a mi última sugerencia, después de ,,tener un número. Desea convertirlo a la cadena correspondiente (o código ASCII) a menos que sea 0, en cuyo caso desea x. Los códigos ASCII para dígitos son secuenciales y se ejecutan desde 48. xes ASCII 120, que es 72 + 48. Entonces puede hacer 72or 48+y guardar un personaje sobre el enfoque basado en cadenas.
Peter Taylor
@PeterTaylor ¡Genial! Antes de que contestaras, logré reducir esa parte a .48 120if+, pero tu ortruco es dos caracteres más cortos.
Cristian Lupascu
@ w0lf Gah! ¡Justo cuando creo que he recuperado el liderazgo!
Gareth
8

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

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

Encontré lo que estaba buscando, una forma de deshacerme de los espacios ( 1":), y finalmente soy competitivo. Ahora solo necesito resolver el problema del conjunto vacío de minas.

Toma entrada del teclado.

Editar

La nueva versión utiliza un efecto secundario de 1":: los números mayores que 9 se reemplazan por *.

Gareth
fuente
He notado dos cosas: 1. Imprime espacios en lugar de 0, no x; 2. Falla si el conjunto de minas está vacío (por ejemplo: 10 10- debería imprimir un tablero vacío de 10x10, pero regresa |length error)
Cristian Lupascu
Pero de lo contrario funciona, entonces +1.
Cristian Lupascu
@ w0lf Ah, todavía estaba pensando en el primer borrador de la pregunta, en esa versión xsolo representaba un espacio. No me di cuenta de que había cambiado. Hmm, nunca pensé que el conjunto de minas estaría vacío ... tendré que trabajar en eso.
Gareth
ahora veo que la pregunta ha sido editada. No había visto la vieja revisión. :)
Cristian Lupascu
@ w0lf Gracias. Encontré un par de reorganizaciones buenas que ayudaron a eliminar algunos corchetes innecesarios. Puedo ver un espacio que podría eliminar, pero sospecho que estoy en mi límite. Y todavía existe el problema de la lista de minas vacías ... :-)
Gareth
2

Mathematica - 247 caracteres

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]

Ejemplos:

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

Salida:

salida

ChessboardDistancecalcula qué tan lejos está cada celda de una mina, donde 1 corresponde a "al lado de una mina". El Countde 1 produce el número de la celda. Luego las minas (*) se insertan en la matriz.

DavidC
fuente
David, es bueno ver a otro usuario de Mathematica aquí. ¡Veré si puedo vencer esto! :-)
Mr.Wizard
@ Mr.Wizard, me interesará ver su solución. Siéntase libre de mejorar el mío si lo desea.
DavidC
2

Mathematica , 140 139 137

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

Escribiendo eso en una forma más legible:

"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
Señor mago
fuente
¡Elegante! Confieso que no puedo entender cómo ListCorrelate[BoxMatrix@1, %, 2, 0]funciona su magia.
DavidC
@David Me alegro de que (implícitamente) preguntes, ya que esa es mi parte favorita. ListCorrelatesuperpone efectivamente el kernel ( BoxMatrix@1) en cada posición de la cuadrícula, se multiplica y da la suma. (envíeme un ping en mma chat si desea una ilustración): su comentario me recuerda que también ListConvolvedebería funcionar aquí, ya que es una especie de imagen especular ListCorrelatey mi núcleo es simétrico. Eso me salvará un personaje. :-)
Mr.Wizard
Su código genera incorrectamente una mina en (5,5). "5 5" da las dimensiones de la cuadrícula.
DavidC
@David Gracias. Tienes razón, pero solo está en la versión de espacio en blanco; De alguna manera perdido el 2en ##2. Lo arreglaré ahora. PD: ¿Cómo llegaste a notar esto después de tanto tiempo?
Mr.Wizard
Recientemente apareció otra pregunta sobre el buscaminas, codegolf.stackexchange.com/questions/10635/… y decidí darle a su solución otra revisión .
DavidC
1

VBA - 298 caracteres

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

Omitir errores con On Error Resume Nextalgunos personajes me salvó, pero esto todavía no es tan bueno como algunas de las otras respuestas. : - /

Gaffi
fuente
1

Python, 192 182 180 caracteres

Podría guardar algunos si la entrada estuviera separada por comas. Entonces la primera línea sería d=input()y la longitud 171 caracteres.
Tener las coordenadas de la mina basadas en 0 en lugar de 1 también ayudaría. Me costó 8 caracteres superar.

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ón sin golf:

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
fuente
1

Scala, 280 caracteres

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
fuente
0

C ++ - 454 caracteres

Esto es peor que mi respuesta de VBA, lo que probablemente significa que no sé lo que estoy haciendo en C ++. Sin embargo, estoy tratando de construir sobre lo que sé de C ++, así que aquí está. Si alguien tiene alguna sugerencia para mejorar, ¡agradecería escucharla!

#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
fuente
No necesitas hacerlo return 0. Y que pueda #include<cstdio>, #include<cstdlib>. ¡Incluso puede eliminar estos dos incluye! Además, using name.....es demasiado largo, puedes usarlo std::cin, std::cout, std::stringen su lugar.
Ray
@ Ray Aye, tienes razón sobre el espacio de nombres ... Ha pasado un tiempo desde que armé esto, pero creo que tuve más std::llamadas que lo hubieran hecho más valioso (creo que uno más stringlo habría hecho ) Gracias por la información sobre las #includelíneas también. No soy un experto en C ++. ;-)
Gaffi
0

C # (691 caracteres)

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ón sin 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
fuente
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
fuente
0

ECMAScript 2019 (Javascript moderno) - 116 bytes

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ón sin golf

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

Esta solución no se adhiere estrictamente al formato de entrada / salida, pero demuestra un algoritmo sucinto.

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

Peter Johnson
fuente
0

brainfuck , 1001 896 bytes

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

Pruébalo en línea! o prueba la versión anterior con entrada entera

Un día de programación y tres días de corrección de errores ^^

Esto usa algunas partes de mi código de Game Of Life. En lugar de contar las células vivas, esto cuenta las bombas. Dado que la entrada como puntos de código está permitida por las reglas generales, esto los usa en lugar de enteros "legibles".

[
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
]
dorio
fuente
0

Este es el comienzo de una solución Brainfuck. Debería ser bastante legible con sangría y comentarios de pila ( @indica el puntero de la pila):

>>,>,  |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|

Sin embargo, está lejos de estar completo y estoy empezando a dudar si mi enfoque es óptimo. Hasta ahora solo considera los dos primeros caracteres de entrada e imprime una tabla de Xs. Por ejemplo, "43" te daría:

XXXX
XXXX
XXXX

Me encantaría ver si alguien más tiene lo que se necesita y es capaz de resolver este problema en Brainfuck.

paldepind
fuente
Óptimo es totalmente irrelevante en mi mente cuando se trata de BrainFuck. ¿A qué especificaciones de intérprete apunta? ¿Como las celdas de 8 bits o qué? Me encantaría ver esto terminado.
captncraig
¿Creo que es bastante independiente de cualquier intérprete específico? Mientras los números no sean excesivamente grandes.
paldepind
Trabajando en una soulution, pero por supuesto siempre resulta ser más difícil de lo que parece al principio en Brainfuck.
captncraig
Pasé los últimos días para construir un código de brainfuck en ejecución para esto.
Dorian