মাইনসুইপার গ্রিড তৈরি করা হচ্ছে


14

মাইনসুইপার বেশিরভাগ ওএস-তে পাওয়া যায় এমন একটি যুক্তিযুক্ত গেম। গেমের লক্ষ্যটি হ'ল গ্রিডে খনিগুলি কোথায় রয়েছে তা নির্ধারণ করা, সেই স্থানটির আশেপাশে খনিগুলির সংখ্যা নির্দেশ করে এমন নম্বর দেওয়া।

গ্রিড আকার এবং খনিগুলির একটি সেট দেওয়া, খনিগুলির সেটের জন্য মাইনসুইপার গ্রিড তৈরি করুন।

ইনপুট: দুটি পূর্ণসংখ্যা গ্রিডের আকার নির্দেশ করে এবং খনি অবস্থানের ইঙ্গিত দেয় এমন একটি সংখ্যক পূর্ণসংখ্যা। পদগুলি (কলাম অবস্থান, সারি অবস্থান) হিসাবে দেওয়া হবে, এবং সূচিগুলি সারি 1 এ শুরু হবে।

আউটপুট: মাইনসুইপার গ্রিড। যদি কোনও ব্লকের চারপাশে খনি না থাকে তবে একটি মুদ্রণ করুন x। প্রতিটি নতুন সারির জন্য একটি নতুন লাইন মুদ্রণ করুন। সমস্ত খনিকে একটি তারকা হিসাবে আউটপুট করুন *। মুদ্রণের সময় সারির মানগুলির মধ্যে কোনও শ্বেত স্থান ছেড়ে যাবেন না।

পরীক্ষার কেস:

ইনপুট "5 5 1 3 3 5 2 4":

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

ইনপুট "3 4 3 1 1 4 2 3 3 2":

x2*
13*
2*2
*21

সংক্ষিপ্ততম কোড জিতেছে।


আমরা কি সমস্ত ইনপুটগুলিতে সমান সংখ্যক আরগ থাকবে ধরে নেওয়া নিরাপদ? অর্থাৎ 5 5 1কখনই পাস হবে না?
গাফি

@ গাফি: হ্যাঁ ইনপুটটি সর্বদা বৈধ ইনপুট হবে।
beary605

স্পেকটি বর্তমানে অবস্থানগুলিতে 1-ভিত্তিক সূচকগুলি ব্যবহার করে এবং 1 সারিটি শীর্ষে রয়েছে এমন উদাহরণগুলি থেকে পাঠককে ছাড়িয়ে যায়। (নাকি আধুনিক, কমপক্ষে, আলোচনা সাপেক্ষে?)
পিটার টেলর

@ পিটারটেলর: হ্যাঁ আমার ধারণা এটি আরও সুস্পষ্ট করা উচিত।
beary605

1
সমস্যা নেই. আমি এখনও বেশ কয়েকটি অক্ষর শেভ করার উপায় খুঁজে নিতে এবং যদিও নেতৃত্বটি ফিরে পেতে এখনও দৃ to়প্রতিজ্ঞ। :-)
গ্যারেথ

উত্তর:


10

গল্ফস্ক্রিপ্ট 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*

অনলাইন ডেমো:

পরীক্ষার কেস 1: লিঙ্ক

পরীক্ষার কেস 2: লিঙ্ক


!!{a}{b}ifপ্রয়োজনের চেয়ে একটি চরিত্র বেশি ব্যবহার করে। '*'এর সাথে প্রতিস্থাপন করা যেতে পারে 42কারণ আপনি এটিকে একটি অ্যারেতে রেখেছেন এবং তারপরে অ্যারের স্ট্রিংফাই করছেন। একইভাবে আপনি অন্যান্য আউটপুট অক্ষরের জন্য ASCII কোড ব্যবহার করতে পারেন এবং orবিশেষ কেস পরিচালনা করতে একটি অক্ষর সংরক্ষণ করতে পারেন ।
পিটার টেলর

@ পিটারটেলর ওয়া, !!{a}{b}ifসত্যিই বোকা ছিল। :) এটি মজার যে বিবরণে মনোনিবেশ করার সময় আপনি কী উচ্চ-স্তরের ভুল করতে পারেন। আপনি ব্যবহার করে কী বোঝাতে চেয়েছিলেন তা বুঝতে পারি না or
ক্রিশ্চিয়ান লুপাস্কু

প্রকৃতপক্ষে! সময়ের পরে কোনও সমস্যায় ফিরে আসাও সহায়তা করে। আমি যখন আমার গল্ফস্ক্রিপ্ট ব্লগের জন্য বেশ কয়েকটি কোড বিভেদ লিখেছিলাম তখন আমি যথেষ্ট উন্নতি লক্ষ্য করেছি। আমার শেষ পরামর্শটি সম্মানের সাথে, ,,আপনার একটি নম্বর থাকার পরে । আপনি যদি এটি x না চান তবে আপনি এটি সম্পর্কিত স্ট্রিংয়ে (বা ASCII কোড) রূপান্তর করতে চান। অঙ্কগুলির জন্য ASCII কোডগুলি অনুক্রমিক এবং 48 থেকে চালিত হয় AS xASCII 120, যা 72 + 48। সুতরাং আপনি 72or 48+স্ট্রিং-ভিত্তিক পদ্ধতির উপর একটি চরিত্রটি সংরক্ষণ এবং সংরক্ষণ করতে পারেন ।
পিটার টেলর

@ পিটারটেলর দুর্দান্ত! আপনি উত্তর দেওয়ার আগে আমি সেই অংশটি কমিয়ে আনতে সক্ষম হয়েছি .48 120if+, তবে আপনার orকৌশলটি দুটি অক্ষর কম।
ক্রিশ্চিয়ান লুপাস্কু

@ w0lf গাহ! আমি যখন মনে করি আমি নেতৃত্বটি ফিরে পেয়েছি!
গ্যারেথ

8

জে, 124 116 112 101 87 86 85 84 83 82 79 76 75 72 68 টি অক্ষর

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

আমি যা খুঁজছিলাম তা পেয়েছি - স্থানগুলি ( 1":) থেকে মুক্তি পাওয়ার উপায় - এবং অবশেষে আমি প্রতিযোগিতামূলক। এখন আমার খালি সমস্যার খালি সেটটি বের করা দরকার।

কীবোর্ড থেকে ইনপুট নেয়।

সম্পাদন করা

নতুন সংস্করণ এর পার্শ্ব প্রতিক্রিয়া ব্যবহার করে 1":- 9 টির চেয়ে বেশি সংখ্যক দ্বারা প্রতিস্থাপিত হয় *


আমি দুটি জিনিস লক্ষ্য করেছি: ১. এটি পরিবর্তে স্পেস প্রিন্ট করে 0, না x; 2. খনিগুলির সেটটি খালি থাকলে ব্যর্থ হয় (উদা: 10 10- একটি খালি 10x10 বোর্ড মুদ্রণ করা উচিত, তবে ফিরে আসে |length error)
ক্রিশ্চিয়ান লুপাস্কু

তবে অন্য দিক থেকে এটি কাজ করে, সুতরাং +1।
ক্রিশ্চিয়ান লুপাস্কু

@ w0lf আহ, আমি এখনও প্রশ্নের প্রথম খসড়াটি নিয়ে ভাবছিলাম - সেই সংস্করণে xকেবল একটি স্থান উপস্থাপন করা হয়েছিল। আমি লক্ষ্য করি না যে এটি পরিবর্তন হয়েছে। হুম, কখনও ভাবি নি যে খনিগুলির সেটটি খালি হয়ে যাবে ... আমাকে এটির জন্য কাজ করতে হবে।
গ্যারেথ

এখন আমি দেখতে পাচ্ছি যে প্রশ্নটি সম্পাদিত হয়েছে। আমি পুরানো রিভিশনটি দেখিনি। :)
ক্রিশ্চিয়ান লুপাস্কু

@ w0lf ধন্যবাদ আমি বেশ কয়েকটি ভাল পুনরুদ্ধার পেয়েছি যা কিছু অপ্রয়োজনীয় বন্ধনী থেকে মুক্তি পেতে সহায়তা করেছে। আমি অপসারণ করতে পারে এমন একটি জায়গা আমি দেখতে পাচ্ছি, তবে আমার সন্দেহ হয় যে আমি আমার সীমাতে বেশ। এবং এখনও খালি খনি তালিকার সমস্যা আছে ... :-)
গ্যারেথ

2

গণিত - 247 অক্ষর

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]

উদাহরণ:

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

আউটপুট:

আউটপুট

ChessboardDistanceপ্রতিটি ঘর খনি থেকে কত দূরে রয়েছে তা গণনা করে, যেখানে 1 "খনিটির পাশের" সাথে মিলে যায়। Count1-এর কোষের সংখ্যা উৎপাদ। তারপরে খনি (*) অ্যারে areোকানো হয়।


ডেভিড, এখানে আরও একটি ম্যাথমেটিকার ব্যবহারকারী দেখে ভাল লাগল । আমি এই মারতে পারি কিনা দেখব! :-)
মিঃ উইজার্ড

@ মিঃ উইজার্ড আমি আপনার সমাধানটি দেখতে আগ্রহী। আপনি যদি পছন্দ করেন তবে নির্দ্বিধায় আমার উন্নতি করুন।
ডেভিডসি

2

গণিত , 140 139 137

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

আরও পঠনযোগ্য আকারে লেখা:

"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

মার্জিত! আমি স্বীকার করি আমি বুঝতে পারি না ListCorrelate[BoxMatrix@1, %, 2, 0]এটির যাদু কীভাবে হয়।
ডেভিডসি

@ ডেভিড আমি আনন্দিত আপনি (অন্তর্নিহিত) এটি আমার প্রিয় অংশ হিসাবে জিজ্ঞাসা করেছেন। ListCorrelateকার্যকরভাবে BoxMatrix@1গ্রিডের প্রতিটি অবস্থানে কার্নেল ( ) কে ওভারলে করে , গুণিত করে এবং যোগফল দেয়। (আপনি উদাহরণ চাইলে এমএমএ চ্যাটে আমাকে পিং করুন) - আপনার মন্তব্য আমাকে মনে করিয়ে দেয় যে ListConvolveএখানেও কাজ করা উচিত কারণ এটি এক ধরণের মিরর চিত্র ListCorrelateএবং আমার কর্নেলটি প্রতিসম হয়। এটি আমার একটি চরিত্রকে বাঁচাবে। :-)
মিঃ উইজার্ড

আপনার কোডটি ভুলভাবে একটি খনি তৈরি করে (5,5)। "5 5" গ্রিডের মাত্রা দেয়।
ডেভিডসি

@ ডেভিড ধন্যবাদ আপনি ঠিক বলেছেন, তবে এটি কেবল সাদা-স্পেস সংস্করণে রয়েছে; আমি একরকম হারিয়ে 2মধ্যে ##2। আমি এখনই এটি ঠিক করব। PS: আপনি এত দিন পরে কিভাবে এটি নজরে এসেছেন?
মিঃ উইজার্ড

কোডগল্ফ.স্ট্যাকেক্সেঞ্জারভিউ / প্রশ্নগুলি ১০০6৩৫/২ , এর জন্য আরেকটি মাইনসুইপার প্রশ্ন সম্প্রতি হাজির হয়েছিল এবং আমি সিদ্ধান্ত নিয়েছি যে আপনার সমাধানটিকে অন্য চেহারা দেওয়ার চেষ্টা করব।
ডেভিডসি

1

ভিবিএ - 298 অক্ষর

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

ত্রুটিগুলি এড়িয়ে যাওয়া On Error Resume Nextআমাকে কিছু চরিত্রগুলি বাঁচিয়েছে, তবে এটি এখনও অন্য উত্তরগুলির মতো প্রায় ভাল হিসাবে দেখা যায় না। : - /


1

পাইথন, 192 182 180 অক্ষর

ইনপুটটি কমা দ্বারা পৃথক করা থাকলে আমি কিছু সঞ্চয় করতে পারি। তারপরে প্রথম লাইনটি হবে d=input()এবং দৈর্ঘ্য 171 হবে।
খনিটি 1-ভিত্তিক পরিবর্তে 0-ভিত্তিক স্থানাঙ্কগুলি তৈরি করতে সহায়তা করবে। এটি কাটিয়ে উঠতে আমার 8 টি খরচ হয়েছে।

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

অবরুদ্ধ সংস্করণ:

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

স্কালা, ২৮০ টি অক্ষর

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

সি ++ - 454 অক্ষর

এটি আমার ভিবিএ উত্তরের চেয়েও খারাপ, যার অর্থ সম্ভবত আমি C ++ এ কী করছি তা জানি না। যাইহোক, আমি সি ++ সম্পর্কে যা জানি তার ভিত্তিতে চেষ্টা করার চেষ্টা করছি, তাই এটি এখানে। কারও কাছে উন্নতির জন্য কোনও পরামর্শ থাকলে আমি তাদের শুনে কৃতজ্ঞ হব!

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

আপনি প্রয়োজন হবে না return 0। আর আপনি যা করতে পারেন #include<cstdio>, #include<cstdlib>। এমনকি আপনি এই দুটি অন্তর্ভুক্ত মুছতে পারেন! আরও কি, using name.....খুব দীর্ঘ, আপনি std::cin, std::cout, std::stringপরিবর্তে ব্যবহার করতে পারেন ।
রায়

@ রে আই, আপনি নামের স্থানটি সম্পর্কে ঠিক বলেছেন ... আমি একে একে একসাথে রাখার পরে অনেক সময় হয়ে গেছে, তবে আমি ভাবছি আমার আরও std::কল হয়েছে যা এটির জন্য আরও বেশি মূল্যবান হয়ে stringউঠবে (আমি মনে করি আরও একজন এটি করতে পারত )। #includeপাশাপাশি লাইন সম্পর্কে তথ্যের জন্য ধন্যবাদ । আমি কোনও সি ++ বিশেষজ্ঞ নই। ;-)
গাফি

0

সি # (691 চর)

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

নন-গল্ফ করা সংস্করণ:

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

কে, 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 (আধুনিক জাভাস্ক্রিপ্ট) - 116 বাইট

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

অসম্পূর্ণ সংস্করণ

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

এই সমাধানটি ইনপুট / আউটপুট ফর্ম্যাটটিকে কঠোরভাবে অনুসরণ করে না তবে একটি সংশ্লেষিত অ্যালগরিদম দেখায়।

উদাহরণ: https://gist.github.com/missinglink/ee02084cfb523665e8c9d34c24f01537


0

ব্রেনফাক , 1001 896 বাইট

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

এটি অনলাইন চেষ্টা করুন! অথবা পূর্ণসংখ্যার ইনপুট সহ পুরানো সংস্করণটি ব্যবহার করে দেখুন

প্রোগ্রামিংয়ের এক দিন এবং বাগফিক্সিংয়ের তিন দিন ^^

এটি আমার গেম অফ লাইফ কোডের কয়েকটি অংশ ব্যবহার করে। জীবন্ত কোষ গণনা করার পরিবর্তে, এটি বোমা গণনা করে। কোডপয়েন্ট হিসাবে ইনপুট সাধারণ নিয়ম দ্বারা অনুমোদিত তাই এটি "পঠনযোগ্য" পূর্ণসংখ্যার পরিবর্তে এগুলি ব্যবহার করে।

[
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

এটি ব্রেনফাক সমাধানের শুরু the এটি ইন্ডেনেশন এবং স্ট্যাক মন্তব্যের সাথে বেশ পঠনযোগ্য হওয়া উচিত ( @স্ট্যাক পয়েন্টারটি নির্দেশ করে):

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

এটি যদিও সম্পূর্ণ থেকে দূরে এবং আমি আমার পদ্ধতির অনুকূল কিনা সন্দেহ করতে শুরু করছি। এখন পর্যন্ত এটি কেবল প্রথম দুটি ইনপুট অক্ষর বিবেচনা করে এবং এক্স এর একটি সারণী মুদ্রণ করে। উদাহরণস্বরূপ "43" আপনাকে দেবে:

XXXX
XXXX
XXXX

আমি দেখতে চাই যে অন্য কারও কাছে যা লাগে যা তা নেয় এবং ব্রেইনফাক এ এই সমস্যাটি সমাধান করতে সক্ষম কিনা।


ব্রেইনফাকের সাথে ডিল করার সময় অনুকূলটি আমার মনে সম্পূর্ণ অপ্রাসঙ্গিক। আপনি কোন দোভাষী স্পেকগুলি লক্ষ্য করছেন? 8-বিট কোষের মতো বা কী? আমি এই শেষ দেখতে চাই।
ক্যাপচার্যাগ

আমি মনে করি এটি কোনও নির্দিষ্ট ইন্টারপ্রেটার থেকে বেশ স্বাধীন? যতক্ষণ না সংখ্যাগুলি অযৌক্তিকভাবে বড় হয় না।
পলপদীপ

একটি আত্মবিশ্বাসের উপর কাজ করা, তবে অবশ্যই এটি ব্রেইনফাকের প্রথম দিকের চেয়ে শক্ত হতে দেখা যায়।
ক্যাপচার্যাগ

আমি এর জন্য একটি চলমান ব্রেইনফাক কোড তৈরি করতে গত কয়েক দিন ব্যয় করেছি।
ডোরিয়ান
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.