Génération de grilles de démineur


14

Démineur est un jeu de logique que l'on trouve sur la plupart des OS. Le but du jeu est de déterminer où se trouvent les mines sur une grille, étant donné les nombres indiquant le nombre de mines autour de cet endroit.

Étant donné une taille de grille et un ensemble de mines, générez la grille de démineur pour cet ensemble de mines.

Entrée: deux entiers indiquant la taille de la grille et un nombre indéfini indiquant les positions de la mine. Les positions seront données comme (position de colonne, position de ligne) et les index commenceront à la ligne 1.

Sortie: La grille du démineur. S'il n'y a pas de mines autour d'un bloc, imprimez un x. Pour chaque nouvelle ligne, imprimez une nouvelle ligne. Veuillez afficher toutes les mines sous forme d'astérisque *. Ne laissez aucun espace entre les valeurs de la ligne lors de l'impression.

Cas de test:

Entrée "5 5 1 3 3 5 2 4":

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

Entrée "3 4 3 1 1 4 2 3 3 2":

x2*
13*
2*2
*21

Le code le plus court gagne.


Sommes-nous sûrs de supposer que toutes les entrées auront un nombre pair d'arguments? c'est-à 5 5 1- dire ne sera jamais adopté?
Gaffi

@Gaffi: Oui. L'entrée sera toujours une entrée valide.
beary605

La spécification laisse actuellement le lecteur déduire des exemples que les positions utilisent des index basés sur 1 et que la ligne 1 est en haut. (Ou ce dernier, au moins, est-il négociable?)
Peter Taylor

@PeterTaylor: Oui. Je suppose que je devrais le rendre plus évident.
beary605

1
Aucun problème. Je suis toujours déterminé à trouver un moyen de raser quelques personnages et de reprendre la tête. :-)
Gareth

Réponses:


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*

Démos en ligne:

Cas de test 1: lien

Cas de test 2: lien


!!{a}{b}ifutilise un caractère de plus que nécessaire. '*'peut être remplacé par, 42car vous le placez dans un tableau, puis vous stringifiez le tableau. De même, vous pouvez utiliser des codes ASCII pour les autres caractères de sortie et enregistrer un caractère avec orpour gérer le cas spécial.
Peter Taylor

@PeterTaylor Wow, !!{a}{b}ifc'était vraiment stupide. :) C'est drôle quelles erreurs de haut niveau vous pouvez faire tout en vous concentrant sur les détails. Je ne peux pas comprendre ce que vous vouliez dire en utilisant or.
Cristian Lupascu

En effet! Revenir à un problème après le temps aide aussi. Quand j'ai écrit quelques dissections de code pour mon blog GolfScript, j'ai repéré des améliorations considérables. En ce qui concerne ma dernière suggestion, après ,,avoir un chiffre. Vous voulez le convertir dans la chaîne correspondante (ou code ASCII) à moins que ce ne soit 0, auquel cas vous voulez x. Les codes ASCII pour les chiffres sont séquentiels et vont de 48. xest ASCII 120, qui est 72 + 48. Vous pouvez donc faire 72or 48+et enregistrer un caractère sur l'approche basée sur les chaînes.
Peter Taylor

@PeterTaylor Super! Avant que vous ne répondiez, j'ai réussi à réduire cette partie à .48 120if+, mais votre orastuce est de deux caractères plus courte.
Cristian Lupascu

@ w0lf Gah! Juste au moment où je pense que j'ai repris la tête!
Gareth

8

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

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

J'ai trouvé ce que je cherchais - un moyen de me débarrasser des espaces ( 1":) - et finalement je suis compétitif. Maintenant, je dois juste comprendre le problème de l'ensemble vide de mines.

Prend l'entrée du clavier.

Éditer

La nouvelle version utilise un effet secondaire de 1":- les nombres supérieurs à 9 sont remplacés par *.


J'ai remarqué deux choses: 1. Il imprime des espaces au lieu de 0, non x; 2. Échoue si l'ensemble de mines est vide (ex: 10 10- devrait imprimer un tableau 10x10 vide, mais revient |length error)
Cristian Lupascu

Mais sinon ça marche, donc +1.
Cristian Lupascu

@ w0lf Ah, je pensais toujours à la première ébauche de la question - dans cette version, elle xne représentait qu'un espace. Je n'ai pas remarqué que cela avait changé. Hmm, je n'ai jamais pensé que l'ensemble des mines serait vide ... Je vais devoir y travailler.
Gareth

maintenant je vois que la question a été modifiée. Je n'avais pas vu l'ancienne révision. :)
Cristian Lupascu

@ w0lf Merci. J'ai trouvé quelques bons réarrangements qui ont aidé à se débarrasser de quelques supports inutiles. Je peux voir un espace que je pourrais supprimer, mais je pense que je suis à peu près à ma limite. Et il y a toujours le problème de la liste des mines vides ... :-)
Gareth

2

Mathematica - 247 caractères

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]

Exemples:

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

Production:

production

ChessboardDistancecalcule la distance entre chaque cellule d'une mine, où 1 correspond à "à côté d'une mine". Le Count1 donne le nombre de cellules. Ensuite, les mines (*) sont insérées dans le tableau.


David, ravi de voir un autre utilisateur de Mathematica ici. Je vais voir si je peux battre ça! :-)
Mr.Wizard

@ Mr.Wizard Je serais intéressé de voir votre solution. N'hésitez pas à vous améliorer si vous le souhaitez.
DavidC

2

Mathematica , 140 139 137

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

Écrire cela sous une forme plus lisible:

"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

Élégant! J'avoue que je ne peux pas comprendre comment ListCorrelate[BoxMatrix@1, %, 2, 0]fonctionne sa magie.
DavidC

@David, je suis content que vous ayez (implicitement) demandé car c'est ma partie préférée. ListCorrelatesuperpose efficacement le noyau ( BoxMatrix@1) à chaque position dans la grille, multiplie et donne la somme. (envoyez-moi un ping dans mma chat si vous souhaitez une illustration) - Votre commentaire me rappelle que cela ListConvolvedevrait fonctionner ici aussi car c'est une sorte d'image miroir de ListCorrelateet mon noyau est symétrique. Cela me sauvera un personnage. :-)
Mr.Wizard

Votre code génère incorrectement une mine à (5,5). "5 5" donne les dimensions de la grille.
DavidC

@David Merci. Vous avez raison, mais ce n'est que dans la version à espace blanc; J'ai perdu en quelque sorte le 2dans ##2. Je vais le réparer maintenant. ps: Comment avez-vous remarqué cela après si longtemps?
Mr.Wizard

Une autre question sur le dragueur de mines, codegolf.stackexchange.com/questions/10635/… , est récemment apparue et j'ai décidé de donner à votre solution un autre regard.
DavidC

1

VBA - 298 caractères

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

Ignorer les erreurs avec On Error Resume Nextm'a sauvé certains caractères, mais ce n'est toujours pas aussi bon que certaines des autres réponses. : - /


1

Python, 192 182 182 180 caractères

Je pourrais en enregistrer si l'entrée était séparée par des virgules. Ensuite, la première ligne serait d=input()et la longueur 171 caractères.
Il serait également utile que les coordonnées de la mine soient basées sur 0 plutôt que sur 1. Cela m'a coûté 8 caractères à surmonter.

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

Version non golfée:

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)

1

Scala, 280 caractères

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

0

C ++ - 454 caractères

C'est pire que ma réponse VBA, ce qui signifie probablement que je ne sais pas ce que je fais en C ++. Cependant, j'essaie de construire sur ce que je sais de C ++, alors le voici. Si quelqu'un a des suggestions d'amélioration, je serais reconnaissant de les entendre!

#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;}

vous n'en avez pas besoin return 0. Et vous pouvez #include<cstdio>, #include<cstdlib>. Vous pouvez même supprimer ces deux inclus!. De plus, using name.....c'est trop long, vous pouvez utiliser à la std::cin, std::cout, std::stringplace.
Ray

@Ray Aye, vous avez raison sur l'espace de noms ... Cela fait un moment que je n'ai pas mis cela ensemble, mais je pense que j'ai eu plus d' std::appels qui auraient valu la peine (je pense qu'un autre l' stringaurait fait ). Merci aussi pour les informations sur les #includelignes. Je ne suis pas un expert en C ++. ;-)
Gaffi

0

C # (691 caractères)

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

Version sans 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 }); 
        }
    }
}

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"

0

ECMAScript 2019 (Javascript moderne) - 116 octets

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

version non golfée

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

cette solution n'adhère pas strictement au format d'entrée / sortie mais montre un algorithme succinct.

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


0

brainfuck , 1001 896 octets

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

Essayez-le en ligne! ou essayez l'ancienne version avec entrée entière

Un jour de programmation et trois jours de correction de bugs ^^

Cela utilise quelques parties de mon code Game Of Life. Au lieu de compter les cellules vivantes, cela compte les bombes. Étant donné que l'entrée en tant que points de code est autorisée par les règles générales, celle-ci les utilise à la place d'entiers "lisibles".

[
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
]

0

C'est le début d'une solution Brainfuck. Il devrait être assez lisible avec des commentaires d'indentation et de pile ( @indique le pointeur de pile):

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

Elle est cependant loin d'être achevée et je commence à douter que mon approche soit optimale. Jusqu'à présent, il ne considère que les deux premiers caractères d'entrée et imprime un tableau de X. Par exemple, "43" vous donnerait:

XXXX
XXXX
XXXX

J'aimerais voir si quelqu'un d'autre a ce qu'il faut et est capable de résoudre ce problème dans Brainfuck.


Optimal est totalement hors de propos dans mon esprit lorsqu'il s'agit de BrainFuck. Quelles spécifications d'interprète visez-vous? Comme des cellules 8 bits ou quoi? J'adorerais voir cela terminé.
captncraig

Je pense qu'il est assez indépendant de tout interprète spécifique? Tant que les chiffres ne sont pas déraisonnablement grands.
paldepind

Travailler sur une soulution, mais bien sûr, cela s'avère toujours plus difficile qu'il n'y paraît au début dans Brainfuck.
captncraig

J'ai passé les derniers jours à construire un code de brainfuck en cours d'exécution pour cela.
Dorian
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.