Gerando grades do Campo Minado

14

Campo Minado é um jogo de lógica encontrado na maioria dos sistemas operacionais. O objetivo do jogo é determinar onde as minas estão em uma grade, dados os números que indicam o número de minas em torno desse ponto.

Dado um tamanho de grade e um conjunto de minas, gere a grade do Campo Minado para esse conjunto de minas.

Entrada: Dois números inteiros indicando o tamanho da grade e um número indefinido de números inteiros indicando as posições da mina. As posições serão dadas como (posição da coluna, posição da linha) e os índices começarão na linha 1.

Saída: A grade do Campo Minado. Se não houver minas ao redor de um bloco, imprima um x. Para cada nova linha, imprima uma nova linha. Por favor, envie todas as minas como um asterisco *. Não deixe nenhum espaço em branco entre os valores na linha ao imprimir.

Casos de teste:

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

O menor código vence.

beary605
fonte
Estamos seguros de assumir que todas as entradas terão um número par de argumentos? ou seja 5 5 1, nunca será passado?
Gaffi
@ Gaffi: Sim. A entrada sempre será válida.
beary605
Atualmente, a especificação deixa o leitor deduzir dos exemplos que as posições usam índices baseados em 1 e que a linha 1 está no topo. (Ou é o último, pelo menos, negociável?)
Peter Taylor
@ PeterTaylor: Sim. Eu acho que deveria torná-lo mais óbvio.
beary605
1
Sem problemas. Ainda estou determinado a encontrar uma maneira de raspar alguns personagens e recuperar a liderança. :-)
Gareth

Respostas:

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 online:

Caso de teste 1: link

Caso de teste 2: link

Cristian Lupascu
fonte
!!{a}{b}ifusa um caractere mais que o necessário. '*'pode ser substituído por 42porque você está colocando em uma matriz e, em seguida, stringizando a matriz. Da mesma forma, você pode usar códigos ASCII para os outros caracteres de saída e salvar um caractere orpara lidar com o caso especial.
Peter Taylor
@ Peter Taylor Wow, !!{a}{b}iffoi realmente estúpido. :) É engraçado que erros de alto nível você pode fazer enquanto se concentra nos detalhes. Não consigo entender o que você quis dizer com usar or.
Cristian Lupascu
De fato! Voltar a um problema após o tempo também ajuda. Quando escrevi algumas dissecações de código para o meu blog GolfScript, vi melhorias consideráveis. Com relação à minha última sugestão, depois de ,,ter um número. Você deseja convertê-lo na string correspondente (ou código ASCII), a menos que seja 0, caso em que você deseja x. Os códigos ASCII para dígitos são seqüenciais e são executados a partir de 48. xé ASCII 120, que é 72 + 48. Assim, você pode fazer 72or 48+e salvar um caractere sobre a abordagem baseada em strings.
Peter Taylor
@PeterTaylor Great! Antes de você responder, eu consegui reduzir essa parte .48 120if+, mas seu ortruque é dois caracteres mais curto.
Cristian Lupascu
@ w0lf Gah! Apenas quando eu acho que tenho a liderança de volta!
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

Encontrei o que estava procurando - uma maneira de me livrar dos espaços ( 1":) - e, finalmente, sou competitivo. Agora só preciso descobrir o problema do conjunto vazio de minas.

Recebe entrada do teclado.

Editar

A nova versão utiliza um efeito colateral de 1":- números maiores que 9 são substituídos por *.

Gareth
fonte
Notei duas coisas: 1. Imprime espaços em vez de 0, não x; 2. falha se o conjunto de minas está vazio (ex: 10 10- deve imprimir uma 10x10 tabuleiro vazio, mas retorna |length error)
Cristian Lupascu
Mas, caso contrário, funciona, então +1.
Cristian Lupascu
@ w0lf Ah, eu ainda estava pensando no primeiro rascunho da pergunta - naquela versão xrepresentava apenas um espaço. Não percebi que havia mudado. Hmm, nunca pensei que o conjunto de minas estaria vazio ... Vou ter que trabalhar nisso.
Gareth
agora vejo que a pergunta foi editada. Eu não tinha visto a revisão antiga. :)
Cristian Lupascu
@ w0lf Obrigado. Encontrei alguns bons rearranjos que ajudaram a eliminar alguns suportes desnecessários. Consigo ver um espaço que poderia remover, mas suspeito que estou no meu limite. E ainda há o problema lista minas vazio ... :-)
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]

Exemplos:

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

Resultado:

resultado

ChessboardDistancecalcula a que distância cada célula está de uma mina, onde 1 corresponde a "próximo a uma mina". O número Count1 produz o número da célula. As minas (*) são inseridas na matriz.

DavidC
fonte
David, é bom ver outro usuário do Mathematica aqui. Vou ver se consigo vencer isso! :-)
Mr.Wizard 28/06
@ Mr.Wizard Eu estarei interessado em ver sua solução. Sinta-se livre para melhorar o meu, se quiser.
DavidC
2

Mathematica , 140 139 137

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

Escrevendo isso de uma forma mais legível:

"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
Mr.Wizard
fonte
Elegante! Confesso que não consigo entender como ListCorrelate[BoxMatrix@1, %, 2, 0]é a sua mágica.
DavidC
@ David Estou feliz que você (implicitamente) perguntou como essa é a minha parte favorita. ListCorrelateefetivamente sobrepõe o kernel ( BoxMatrix@1) em cada posição na grade, multiplica e dá a soma. (envie um ping para mim no chat do mma, se você quiser uma ilustração) - Seu comentário me lembra que também ListConvolvedeve funcionar aqui, pois é uma espécie de imagem espelhada ListCorrelatee meu kernel é simétrico. Isso vai me salvar de um personagem. :-)
Mr.Wizard
Seu código gera incorretamente uma mina em (5,5). "5 5" fornece as dimensões da grade.
DavidC
@ David Obrigado. Você está certo, mas é apenas na versão em espaço em branco; Eu de alguma forma perdeu o 2no ##2. Eu vou consertar agora. ps: Como você percebeu isso depois de tanto tempo?
precisa saber é o seguinte
Outra pergunta sobre o caça- minas, codegolf.stackexchange.com/questions/10635/… , apareceu recentemente e eu decidi dar uma nova olhada na sua solução.
7263 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

Ignorar os erros On Error Resume Nextsalvou-me alguns caracteres, mas isso ainda não é tão bom quanto algumas das outras respostas. : - /

Gaffi
fonte
1

Python, 192 182 180 caracteres

Eu poderia salvar alguns se a entrada fosse separada por vírgula. Então a primeira linha seria d=input()e o comprimento 171 caracteres.
Ter as coordenadas da mina com base em 0 e não em 1 também ajudaria. Custou-me 8 caracteres para 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]))

Versão não destruída:

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

C ++ - 454 caracteres

Isso é pior do que minha resposta VBA, o que provavelmente significa que eu não sei o que estou fazendo em C ++. No entanto, estou tentando aproveitar o que sei sobre C ++, então aqui está. Se alguém tiver alguma sugestão de melhoria, ficaria grato em ouvi-las!

#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
fonte
você não precisa return 0. E você pode #include<cstdio>, #include<cstdlib>. Você pode até excluir essas duas inclusões! Além do mais, using name.....é muito longo, você pode usar std::cin, std::cout, std::string.
Raio
@ Ray Sim, você está certo sobre o espaço para nome ... Já faz um tempo desde que eu montei isso, mas estou pensando que tinha mais std::ligações que fariam valer a pena (acho que mais uma stringteria feito) ) Obrigado pela informação sobre as #includelinhas também. Não sou especialista em C ++. ;-)
Gaffi 15/02
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});}}}

Versão sem golfe:

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

versão 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
  )
)

Esta solução não segue rigorosamente o formato de entrada / saída, mas demonstra um algoritmo sucinto.

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

Peter Johnson
fonte
0

cérebro , 1001 896 bytes

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

Experimente online! ou tente a versão antiga com entrada inteira

Um dia de programação e três dias de correção de bugs ^^

Isso usa algumas partes do meu código do Game Of Life. Em vez de contar células vivas, isso conta bombas. Como a entrada como pontos de código é permitida pelas regras gerais, isso as utiliza em vez de números inteiros "legíveis".

[
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
fonte
0

Este é o começo de uma solução Brainfuck. Deve ser bem legível com comentários de indentação e pilha ( @indica o ponteiro da pilha):

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

No entanto, está longe de estar completo e estou começando a duvidar se minha abordagem é ótima. Até o momento, ele considera apenas os dois primeiros caracteres de entrada e imprime uma tabela de Xs. Por exemplo, "43" daria a você:

XXXX
XXXX
XXXX

Eu adoraria ver se alguém tem o que é preciso e é capaz de resolver esse problema no Brainfuck.

paldepind
fonte
Optimal é totalmente irrelevante em minha mente ao lidar com o BrainFuck. Quais especificações de intérprete você está alvejando? Como células de 8 bits ou o quê? Eu adoraria ver isso terminado.
Captncraig
Eu acho que é bem independente de algum intérprete específico? Contanto que os números não sejam excessivamente grandes.
paldepind
Trabalhando em uma soulution, mas é claro que sempre acaba sendo mais difícil do que parece inicialmente em Brainfuck.
Captncraig 02/07/2012
Passei os últimos dias para criar um código de cérebro cerebral em execução para isso.
Dorian