20

वीडियो गेम Minecraft सभी 3 डी पूर्णांक जाली में विभिन्न प्रकार के ब्लॉक रखने और हटाने के बारे में है जो आभासी दुनिया बनाता है। प्रत्येक जाली बिंदु में ठीक एक ब्लॉक हो सकता है या खाली हो सकता है (एक " वायु " ब्लॉक आधिकारिक रूप से)। इस चुनौती में, हम केवल 3 डी दुनिया के एक क्षैतिज 2 डी विमान से संबंधित होंगे, और एक प्रकार का ब्लॉक: चेस्ट ।

चेस्ट खिलाड़ियों को आइटम स्टोर करने देते हैं। जब दो चेस्ट समान क्षैतिज विमान में समीपस्थ रूप से सटे होते हैं, तो उनकी बनावट जुड़ जाती है और दो बार क्षमता के साथ दोहरी छाती बन जाती है। एक डबल छाती से बड़ा कुछ भी नहीं बनाया जा सकता है; कोई ट्रिपल चेस्ट नहीं हैं और न ही चौपाइयाँ चेस्ट हैं।

एक छाती ब्लॉक को केवल एक खाली जाली बिंदु में रखा जा सकता है यदि इसके चार orthogonally आसन्न बिंदु सभी खाली हैं, या यदि वास्तव में एक छाती ब्लॉक है जिसमें पहले से ही एक डबल छाती का हिस्सा नहीं है। ये प्लेसमेंट नियम यह सुनिश्चित करते हैं कि कोई भी अस्पष्टता कभी नहीं हो सकती है जिसके बारे में छाती ब्लॉक डबल चेस्ट बनाने के लिए लिंक करते हैं।

उदाहरण के लिए, मान लीजिए .कि खाली जगह है और Cएक छाती है: (संख्या भी खाली जगह है और सिर्फ पहचान के उद्देश्यों के लिए है।)

.......C..
.1.C2.C3..
........5C
.CC4..CC..
..........

छाती को 1 स्थान पर रखा जा सकता है क्योंकि उसके 4 पड़ोसी खाली हैं।
एक छाती को स्पॉट 2 में रखा जा सकता है क्योंकि पड़ोसी छाती एक डबल छाती का हिस्सा (अभी तक) नहीं है।
छाती को 3 जगह पर नहीं रखा जा सकता है क्योंकि डबल छाती के रूपों के बारे में अस्पष्टता होगी।
छाती को 4 जगह पर नहीं रखा जा सकता है क्योंकि पड़ोसी की छाती पहले से ही दोहरी छाती का हिस्सा है।
छाती को 5 जगह पर रखा जा सकता है। तिरछे पड़ोसी की दोहरी छाती किसी चीज को प्रभावित नहीं करती है।

ग्रिड से परे क्षेत्र को खाली मान लेने पर, यदि .ग्रिड को *छाती में रखा जा सकता है, तो इसे हर जगह बदल दिया जा सकता है:

******.C**
***C**C.**
*..***..*C
.CC.*.CC.*
*..***..**

सभी *रिक्त स्थान पर एक ही समय में चेस्ट के साथ कब्जा नहीं किया जा सकता है, लेकिन अगर आपके पास केवल एक छाती थी, तो इसे उनमें से किसी में भी रखा जा सकता है।

चुनौती

एक प्रोग्राम या समारोह है कि एक में लेता लिखें .और Cग्रिड, और हर बदलता है .एक करने के लिए *करता है, तो एक छाती वहाँ रखा जा सकता है, मुद्रण या जिसके परिणामस्वरूप ग्रिड लौटने।

इनपुट स्टडिन या एक फाइल से या एक फ़ंक्शन के लिए एक स्ट्रिंग तर्क के रूप में हो सकता है।
आप यह मान सकते हैं कि इनपुट अच्छी तरह से बना है - यानी पाठ का एक पूरी तरह से आयताकार ग्रिड, कम से कम 1 वर्ण चौड़ा और लंबा, केवल युक्त .और Cआप वैकल्पिक रूप से मान सकते हैं कि अंतिम पंक्ति के बाद एक अनुगामी नई रेखा है (और आउटपुट में एक हो सकता है )।
आप मान सकते हैं कि इनपुट में चेस्ट की व्यवस्था ऊपर दिए गए नियमों के अनुरूप है। वहाँ कभी अस्पष्टता नहीं होगी जिसके बारे में चेस्ट डबल चेस्ट बनाते हैं।
यदि वांछित है, तो आप , और , के स्थान पर किसी भी तीन अलग मुद्रण योग्य ASCII वर्ण का उपयोग कर सकते हैं । हो सकता है कि आप नई कहानियों के स्थान पर कुछ और उपयोग न करें.C*
सभी छाती सामान्य छाती हैं। नहीं फंस चेस्ट या Ender चेस्ट ।

स्कोरिंग

सबसे कम बाइट्स के साथ सबमिशन जीत जाता है।

^{एक Minecraft संबंधित चुनौती के लिए जो थोड़ा अधिक चुनौतीपूर्ण है, नीदरलैंड पोर्टल डिटेक्शन का प्रयास करें ।}

code-golf

— केल्विन के शौक
स्रोत

5

एक छोटी सी बात से, मैं इस खेल में बहुत कष्टप्रद पाया। अच्छी बात है कि फंसे हुए चेस्ट हैं: P

— Sp3000

स्टड या एकल स्ट्रिंग तर्क से ग्रिड इनपुट लेते समय, क्या ग्रिड आयामों को अतिरिक्त इनपुट के रूप में लेना स्वीकार्य है? या क्या इसे नए सिरे से और स्ट्रिंग की लंबाई से पता लगाना है?

— लेवल रिवर सेंट

@steveverrill इसका अनुमान लगाना होगा।

— केल्विन के शौक

जिज्ञासा से बाहर, मेरे अपने सहित हर उत्तर में एक गिरावट क्यों है? मैं केवल यह मान सकता हूं कि यह एक ही व्यक्ति है, क्या वे समझाने की परवाह करेंगे?

— लेवल रिवर सेंट

एक अतिरिक्त चुनौती के लिए, एक छाती के लिए इष्टतम स्थान खोजने के लिए एक कार्यक्रम लिख सकता है; यही है, एक कॉन्फ़िगरेशन ढूंढें जो अधिकतम चेस्टों को नए चेस्टों के बीच भी नियमों को तोड़ने के बिना रखा जा सकता है।

— AJMansfield

11

CJam, 82 76 66 62 58 54 बाइट्स

qN/::~4{[8_]f/[9_]f*z{[{1$8-g)+}*]W%}%}*{_8<\2<8?}f%N*

इनपुट प्रारूप 0हवा सेल के लिए और 8एक छाती सेल के लिए उम्मीद करता है । आउटपुट में 1सभी कोशिकाएं होती हैं जिन्हें चेस्ट के साथ रखा जा सकता है।

अद्यतन : ~~एक बग फिक्स्ड। 3 बाइट्स से वृद्धि हुई :(~~ और आगे गोल्फ :)। 4 बाइट्स @ Sp3000 की बदौलत बच गए

उदाहरण इनपुट:

आउटपुट:

मुझे लगता है कि मैं अभी के लिए गोल्फ कर रहा हूँ ...

व्याख्या

qN/::~                   "This part converts the input into array of integer array";
qN/                      "Split input on new line";
   ::~                   "Parse each character in each row as integer";

4{[8_]f/[9_]f*z{[{1$8-g)+}*]W%}%}*

4{   ...z{       W%}%}*  "Run the logic 4 times, first, columns in correct order, then,";
                         "columns in reverse order, then for rows";
  [8_]f/[9_]f*           "Convert adjacent chests represented by two 8 into two 9";
                         "This happens for all the rows in the columns iterations and";
                         "for all the columns in the rows iterations";
  {               }%     "For each row/column";
   [{        }*]         "Reduce and wrap it back in the array";
     :I8-                "Store the second number in I, remove 8 from it";
         g               "Do signum. Now we have -1 for < 8 number, 0 for 8 and 1 for > 8";
          )+I            "Increment to get 0, 1 & 2. Add it to first number and put I back";

{_8<\2<8?}f%N*           "This part converts the output from previous iterations";
                         "to 3 character based final output and prints it";
{        }f%             "Map each row using the code block";
 _8<   8?                "If the value is greater than 7, make it 8, else:";
    \2<                  "If the value is greater than 1, make it 0, else 1";
            N*           "Join the arrays using new line";

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

8

.NET Regex ( रेटिना ), 434 416 310 + 1 = 311 बाइट्स

आखिरी चुनौती के बाद मैंने regex में जवाब दिया (इस चुनौती में जुड़ा नीदरलैंड पोर्टल चैलेंज), मैंने आखिरकार एक कमांड-लाइन टूल लिखने के लिए सेट किया, जो .NET-शैली के नियमित भावों के लिए दुभाषिया के रूप में काम करता है, इसलिए मैं सवालों के जवाब दे सकता हूं रेगेक्स के साथ चुनौती दिए बिना कि वे स्टैंड-अलोन भाषा नहीं हैं। मैंने इसका नाम रेटिना रखा है।

अब, यह चुनौती एक रेगेक्स सबमिशन के लिए बहुत अच्छी तरह से उधार नहीं देती है, लेकिन मुझे अभी रेटिना का उपयोग करना था। ;) (प्लस, Sp3000 ने मुझे चैट में ऐसा करने के लिए चुनौती दी।) तो यहाँ यह है:

रेगेक्स फ़ाइल

m`(?<=(?=.(.)*).*)(?<=((?<=(?<2>C|C(?(1)!)(\n|(?<-1>.))*)?)C(?=(?<2>C|(\n|(?<-1>.))*(?(1)!)C)?)(()(?(6)!)|(?<=^(?(7)!)(?<-7>.)*C).*\n(.)*()(?(8)!)))?){2}_(?=(?<2>((?(10)!)()|(?(11)!)()(.)*\n.*(?=C(?<-12>.)*(?(12)!)$))(?<=(?<2>C|C(?(1)!)(\n|(?<-1>.))*)?)C(?=(?<2>C|(\n|(?<-1>.))*(?(1)!)C)?))?){2}(?<-2>)?(?(2)!)

प्रतिस्थापन फ़ाइल

रेगेक्स फ़ाइल ज्यादातर रेगेक्स ही है, सिवाय इसके कि `आप फ़ाइल में कुछ विकल्प डाल सकते हैं, इस मामले में बस मल्टीलाइन मोड। जब दो फाइलें दी जाती हैं, तो रेटिना स्वचालित रूप से प्रतिस्थापित-सभी मोड मान लेती है। ये दो फाइलें एक प्रोग्राम को परिभाषित करती हैं जो STDIN से इनपुट पढ़ता है और परिणाम को STDOUT में प्रिंट करता है।

आप इसे RegexHero और RegexStorm पर भी टेस्ट कर सकते हैं । रेगेक्स नईलाइन के साथ और उसके बिना काम करता है, और _इसके स्थान पर उपयोग करता है .। (जाहिरा तौर पर, RegexStorm को कभी-कभी समस्या होती है अगर कोई अनुगामी न्यूलाइन नहीं है, लेकिन RegexHero या तो मामले को ठीक से संभालता है।)

रेगेक्स में एक भयानक मात्रा में दोहराव है, और मेरे पास इसे छोटा करने के लिए कुछ विचार हैं ... मैं बाद में एक कोशिश करूँगा और फिर एक स्पष्टीकरण जोड़ूंगा। इस बीच, मुझे बताएं कि क्या आपको कोई इनपुट मिल सकता है जो गलत परिणाम देता है।

— मार्टिन एंडर
स्रोत

7

जे, 75 73 बाइट्स

((,.|.)0 _1 0 1)(+:@](LF,@:,.~'*.C'{~>.)(2=f)+.[f]*f=.[:+/|.!.0)'C'&=;._2

सवाल में प्रारूप का उपयोग करता है का उपयोग करते हुए ./ */ C, अंतरिक्ष के लिए / प्रयोग करने योग्य अंतरिक्ष / छाती क्रमशः।

संपादित करें: एक छोटी बग को ठीक करता है (मैंने गलती से आसपास के खाली स्थान को ठीक से इलाज करने के बजाय एक टोरस का इस्तेमाल किया था)।

व्याख्या

## Preparation
              'C'&=;._2  NB. Map ./C to 0/1, turn into matrix
((,.|.)0 _1 0 1)         NB. Compute offsets to shift into each direction
                         NB. (i.e. [[_1 0], [1 0], [0 _1], [0 1]] in any order)


## "Part B"
(2=f)+.[f]*f=.[:+/|.!.0  NB. This part computes a matrix that is 1 for cells that
                         NB. cannot contain a chest:
              [:+/|.!.0  NB. Sum of shifts: shift in each of the four cardinal
                         NB. directions (using the array above) and then sum up.
           f=.           NB. Define this function as `f`; we'll use it some more.
         ]*              NB. Multiply by the "is chest" matrix: this isolates
                         NB. double-chests.
       [f                NB. Sum of shifts--1 for double-chest neighbours.
(2=f)                    NB. Isolate cells with two neighbouring chest.
     +.                  NB. Boolean or--either two neighbouring chests or next
                         NB. to a double-chest.

## Wrap up the result
(+:@] (fmt >.) PartB)    NB. Maximum of the array from the above and twice the "is
 +:@]      >.  PartB     NB. chest" matrix--this is 0,1,2 for '*', '.' or chest,
                         NB. respectively.

## Output formatting
LF,@:,.~'*.C'{~          NB. Format output...
        '*.C'{~          NB. Map 0,1,2 to '*.C' by using the value as index
LF   ,.~                 NB. Append line feed at end of each line
  ,@:                    NB. Ravel into one line

— जुगनू
स्रोत

4

सी, 193

स्पष्टता के लिए 2 अनावश्यक नए समाचार। असंबद्ध कोड के संबंध में परिवर्तन में शामिल हैं: चरित्र शाब्दिक के बजाय एससीआई कोड के रूप में वर्ण; वर्णों को बचाने के लिए v = 0, strlen, और strchr का पुनर्व्यवस्था (strchr सबसे पुराना है, क्योंकि इसका मतलब है कि एक गणना जिसे अन्यथा केवल एक बार किया जाएगा, प्रति सेल 5 बार किया जाता है!)

सी फ़ंक्शन स्ट्रिंग्स को तर्क के रूप में स्वीकार नहीं करते हैं या उन्हें मूल्यों के रूप में वापस करते हैं, इसलिए मैं जो सबसे अच्छा कर सकता हूं वह निम्नलिखित है: qइनपुट स्ट्रिंग के लिए एक सूचक है। फ़ंक्शन स्ट्रिंग को संशोधित करता है और जब फ़ंक्शन रिटर्न करता है तो आउटपुट मूल स्ट्रिंग में पाया जाता है।

g(char*q){int v,j,w,l;
int f(p,d){int s=0,i=w=strchr(q,10)-q+1,r;for(;w/i;i-=i-1?w-1:2)r=p+i,r>-1&r<l&&q[r]==67&&++s&&d&&f(r,0);v|=s>d;}
for(j=l=strlen(q);j--;f(j,1),46-q[j]||v||(q[j]=42))v=0;}

नियमों को संक्षेप में प्रस्तुत करने के लिए:

एक रिक्त वर्ग (जिसमें C या newline शामिल नहीं है) को परिवर्तित किया जा सकता है यदि इसमें C के साथ अधिकतम 1 पड़ोसी है

... और उस पड़ोसी का कोई पड़ोसी नहीं है।

फंक्शन g में एक फंक्शन f होता है जो 1 से लेकर डेढ़ तक की गहराई तक लेटता है। रिकर्सन के केवल 2 स्तरों के साथ, एक साधारण f(r,0)रीक्रसिव कॉल करेगा, इसकी कोई आवश्यकता नहीं है f(r,d-1)!

परीक्षण कार्यक्रम में असम्बद्ध कोड

इनपुट परीक्षण स्ट्रिंग हार्डकोड है। getsऔर scanfइसमें नए सिरे के साथ एक इनपुट स्ट्रिंग स्वीकार नहीं करेगा; वे इसे प्रत्येक न्यूलाइन पर टुकड़ों में काटते हैं।

char n[]=".......C..\n...C..C...\n.........C\n.CC...CC..\n..........";

g(char*q){

  int v,j,w,l;

  int f(p,d){                    //p=cell to be checked,d=recursion depth
    int s=0,i=w,r;               //sum of C's found so far=0, i=width
    for(;w/i;i-=i-1?w-1:2)       //For i in   w,1,-1,-w   = down,right,left,up
      r=p+i,                     //r=cell adjacent to p
      r>-1&r<l&&q[r]=='C'&&++s   //If r not out of bounds and equal to C, increment s...
        &&d&&f(r,0);             //...and if recursion depth not yet at zero, try again one level deeper. 
    v|=s>d;                      //If the local s exceeds d, set global v to true to indicate invalid.
  }

  w=strchr(q,10)-q+1;            //width equals index of first newline + 1                   
  l=strlen(q);                   //length of whole string;
  for(j=l;j--;)                  //for l-1 .. 0 
    v=0,                         //clear v
    f(j,1),                      //and scan to see if it should be set
    '.'-q[j]||v||(q[j]='*');     //if the character is a '.' and v is not invalid, change to '*'
}

main(){
  g(n);
  puts(n);
}

प्रश्न उदाहरण के आधार पर आउटपुट

******.C**
***C**C.**
*..***..*C
.CC.*.CC.*
*..***..**

— स्तर नदी सेंट
स्रोत

1

जावास्क्रिप्ट (ईएस 6) 124 129

वर्ण 0 (*), 6 (C), 7 (।) का उपयोग करना

F=s=>[for(c of(d=[o=~s.search('\n'),-o,1,i=-1],s))
   d.map(j=>t-=s[i+j]==6&&~d.some(k=>s[i+j+k]==6),t=i++)|c<7|t>i&&c
].join('')

अनगढ़ और समझाया गया

F=s=>
{
  o=~s.search('\n') // offset to prev row (~ is shorter than +1 and sign does not matter)
  d=[o,-o,1,-1] // array of offset to 4 neighbors
  i=-1
  result = '' // in golfed code, use array comprehension to build the result into an array, then join it
  for (c of s) // scan each char
  {
    t = i++ // set a starting value in t and increment current position in i
    d.forEach(j => // for each near cell, offset in j
    {         
      if (s[i+j]==6) // if cell contains a Chest, must increment t
      {  
        // In golfed code "~some(...)" will be -1(false) or -2(true), using decrement instead of increment
        if (d.some(k=>s[i+j+k]==6)) // look for another Cheast in the neighbor's neighbors
        {
          // more than one chest, position invalid
          t += 2
        }
        else
        {
          t += 1
        }
      }
    })
    if (c < 7 // current cell is not blank
        || t > i) // or t incremented more than once, position invalid
    {
       result += c // curent cell value, unchanged
    }
    else
    {
       result += 0 // mark a valid position 
    }
  }
  return result
}

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

a='\
7777777677\n\
7776776777\n\
7777777776\n\
7667776677\n\
7777777777\n';

console.log(F(a))

उत्पादन

— edc65
स्रोत

1

पर्ल, 66

रेगेक्सप मिलान छाती संघर्ष लंबे समय तक समाप्त हो गया, इसलिए इस बार सीजेएम के साथ कोई प्रतिस्पर्धा नहीं है।

#!perl -p0
/.
/;$"=".{@-}";s%0%s/\G0/2/r!~/2((.$")?2(.$")?|2$"|$"2)2/s*1%eg

इनपुट पर रिक्त और छाती रिक्त स्थान के लिए 0 और 2 का उपयोग करता है, 1 आउटपुट पर स्पॉट को चिह्नित करने के लिए।

इसे यहाँ आज़माएँ ।

— nutki
स्रोत

0

पायथन 2 - 281 बाइट्स

f=lambda x,y:sum(m[y][x-1:x+2])+m[y-1][x]+m[y+1][x]
m=[];o=''
try:
 while 1:m+=[map(int,'0%s0'%raw_input())]
except:a=len(m[0]);l=len(m);m+=[[0]*a]
for y in range(l*2):
 for x in range(1,a-1):
    if y<l:m[y][x]*=f(x,y)
    else:o+=`2if m[y-l][x]else +(f(x,y-l)<5)`
 if y>=l:print o;o=''

(लाइनें 8 और 9 एक एकल टैब वर्ण के साथ अभिप्रेत हैं, जो एसई 4 स्थानों में कनवर्ट करता है। इस कार्यक्रम की प्रत्येक पंक्ति में प्रमुख व्हाट्सएप के 0 या 1 बाइट्स हैं।)

इनपुट: 0बिना छाती के लिए, 2छाती के लिए
Ouput: 0बिना छाती के लिए, 2मौजूदा छाती के लिए, 1संभव नई छाती के लिए

भगवान, यह भयानक है। मुझे गंभीरता से अभ्यास से बाहर होना चाहिए। मैंने हर उस ट्रिक को फेंका जो मुझे पता है और यह सामने आया ... ठीक है, यह 281 बाइट्स के रूप में सामने आया, रेगेक्स , हाहा में एक को छोड़कर हर उत्तर से हार गया । मैं ईमानदारी से ऐसा महसूस करता हूं कि मैंने इसे अच्छी तरह से हासिल किया है, इसलिए मैं अनुमान लगा रहा हूं कि मेरा एल्गोरिदम आदर्श से कम था।

Ungolfed:

def f(x,y):
    """Given x,y coords of the board, return the sum of that point and all
    adjacent points.
    """
    return (sum(board[y][x-1:x+2]) # (x-1,y) + (x,y) + (x+1,y)
            + board[y-1][x]
            + board[y+1][x])
board=[]
output=''
try:
    while True:
        row = '0%s0' % raw_input() # line from stdin with a leading and trailing 0
        board.append(map(int, row)) # convert to list of ints
except:
    pass # exception is thrown when stdin is empty

board_width = len(board[0])
board_height = len(board)

board.append([0]*board_width) # new row of all 0s

for y in xrange(board_height*2):
    # board_height multiplied by 2 so we can use this loop to simulate two
    for x in xrange(1,board_width-1):
        if y < board_height: # "first loop"
            board[y][x] *= f(x,y) # multiply everything on the board by itself + sum
                                  # of neighbours
                                  # empty cells (0) stay 0 no matter what
                                  # lone chests (2 surrounded by 0) become 2*2==4
                                  # double chests (2 touching another 2) are weird:
                                  # - one chest becomes 2*(2+2)==8
                                  # - the other chest becomes 2*(2+8)==20
        else: # "second loop"
            if board[y - board_height][x] != 0:
                output += '2' # anything not equal to 0 is an existing chest
            else:
                valid = f(x, y - board_height) < 5 # if the sum of neighbours > 4, the
                                                   # current cell is either beside a
                                                   # double chest or more than one
                                                   # single chest
                output += '01'[valid]
    if y >= board_height: # only print during the "second loop"
        print output
        output=''

— undergroundmonorail
स्रोत

Minecraft चेस्ट प्लेसमेंट