मदद, मैं एक अनंत कारखाने में फंस गया हूँ!

यह चुनौती Zachtronics गेम Infinifactory से काफी हद तक प्रेरित है ।

आपको एक आयताकार ग्रिड के शीर्ष-नीचे का दृश्य दिया जाता है, जिसका प्रतिनिधित्व किया जाता है >v<^। वहाँ कन्वेयर के बिना कोशिकाओं हो सकता है, रिक्त स्थान द्वारा प्रतिनिधित्व किया। यहाँ एक उदाहरण है:

> <vv    <
 v ^ >v v 
  >v^^>vv^
    ^>^ v 
>  v<v  >>
  >v v<^

यह सेटअप कई अनंत स्थानों से घिरा हुआ है।

इसके अलावा, आपको कार्गो के एक आयताकार टुकड़े के आयाम दिए गए हैं जो ग्रिड के शीर्ष बाएं कोने में कन्वेयर पर रखा गया है। आपका काम यह पता लगाना है कि क्या कार्गो कभी आराम करता है या क्या यह एक लूप में आगे बढ़ जाएगा।

बेशक, कार्गो को एक साथ कई कन्वेयर को कवर करने की संभावना है, इसलिए यहां प्रत्येक में कार्गो की दिशा का पता लगाने के नियम हैं:

विरोधी कन्वेयर एक दूसरे को रद्द करते हैं। इसलिए यदि कोई 3x2 कार्गो किसी भी पैच को कवर करता है (स्पष्टता के लिए हाइफ़न और पाइप के साथ उल्लिखित), तो परिणाम समान होगा:
```
+---+   +---+   +---+
|>>^|   |  ^|   |v^^|
|^<<|   |^  |   |^^v|
+---+   +---+   +---+
```
वही इन के लिए जाता है:
```
+---+   +---+   +---+
|v^<|   |   |   |><>|
|>>>|   |>> |   |>><|
+---+   +---+   +---+
```
चूंकि कार्गो के नीचे एक कन्वेयर की सटीक स्थिति अप्रासंगिक है, इससे कोई फर्क नहीं पड़ता कि आप कौन से जोड़े रद्द करते हैं।

यह रद्दीकरण अन्य नियमों से पहले लागू किया जाता है। इसलिए, अन्य नियमों के लिए ज्यादातर दो दिशाओं में केवल कन्वेयर होंगे।
यदि कार्गो किसी भी कन्वेयर को कवर नहीं करता है (या तो क्योंकि सभी कन्वेयर रद्द हो जाते हैं, क्योंकि यह केवल रिक्त स्थान को कवर करता है या क्योंकि यह पूरी तरह से ग्रिड से दूर चला गया है), यह आराम करने के लिए आता है।
यदि कार्गो एक दिशा के अन्य से अधिक कन्वेयर को कवर करता है, तो कार्गो उस दिशा में आगे बढ़ता है। जैसे, यदि एक 3x2 कार्गो निम्नलिखित पैच को कवर करता है
```
>>
^>^
```
यह दाईं ओर ले जाएगा, क्योंकि वहाँ अधिक >से अधिक कर रहे हैं ^। दूसरी ओर, यदि यह कवर किया गया है
```
>>^
  ^
```
यह नियम लागू नहीं होगा, क्योंकि इसके बीच एक टाई है >और ^।
यह केवल उन मामलों को छोड़ता है जिसमें आसन्न दिशाओं के बीच एक टाई होती है (विपरीत दिशाओं के बीच एक टाई रद्द हो जाती थी)। इस स्थिति में, कार्गो उस अक्ष के साथ आगे बढ़ता रहता है, जिसमें वह पहले से ही घूम रहा होता है। जैसे अगर कोई दाईं-चलती या बाईं ओर घूम रहा 3x2 कार्गो अब पैच को कवर कर रहा है
```
>>^
^  
```
यह दाईं ओर ले जाएगा। यदि यह ऊपर या नीचे की ओर इस पैच पर आ जाता, तो यह अब ऊपर की ओर बढ़ता। यदि सिमुलेशन के पहले चरण पर इस तरह का संघर्ष होता है, तो मान लें कि कार्गो दाईं ओर जा रहा था।

विस्तृत उदाहरण

शीर्ष पर कन्वेयर ग्रिड और एक 3x2 कार्गो पर विचार करें। निम्नलिखित प्रक्रिया का चरण-दर-चरण दृश्य है। प्रत्येक चरण में ग्रिड होता है, जिसमें कार्गो द्वारा प्रतिनिधित्व किया जाता है #, एक छोटा बॉक्स जो कार्गो द्वारा कवर किए गए कन्वेयर को दर्शाता है, रद्द होने के बाद कन्वेयर के साथ एक और बॉक्स, और वह नियम जो निर्धारित करता है कि कार्गो कहां चलता है:

 ###vv    <    > <vv    <    > <vv    <    > <vv    <    > <vv    <    > <vv    <
 ###^ >v v     ###^ >v v      v ^ >v v      v ^ >v v      v ^ >v v      v ^ >v v 
   >v^^>vv^    ###v^^>vv^    ###v^^>vv^     ###^^>vv^      ###^>vv^      >###>vv^
     ^>^ v         ^>^ v     ### ^>^ v      ###^>^ v       ###>^ v        ###^ v 
 >  v<v  >>    >  v<v  >>    >  v<v  >>    >  v<v  >>    >  v<v  >>    >  v<v  >>
   >v v<^        >v v<^        >v v<^        >v v<^        >v v<^        >v v<^  

+---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+
|> <|  |   |  | v |  | v |  |  >|  |  >|  | >v|  | >v|  |>v^|  |> ^|  |v^^|  | ^^|
| v |  | v |  |  >|  |  >|  |   |  |   |  |   |  |   |  |  ^|  |   |  | ^>|  |  >|
+---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+  +---+

   Rule 3        Rule 4        Rule 3        Rule 4        Rule 4        Rule 3

 ================================================================================

 > <vv    <    > <###   <    > <vv    <
  v ###v v      v ###v v      v ###v v 
   >###>vv^      >v^^>vv^      >###>vv^
     ^>^ v         ^>^ v         ^>^ v 
 >  v<v  >>    >  v<v  >>    >  v<v  >>
   >v v<^        >v v<^        >v v<^  

+---+  +---+  +---+  +---+  +---+  +---+
|^ >|  |  >|  |vv |  | v |  |^ >|  |  >|
|v^^|  | ^^|  |^ >|  |  >|  |v^^|  | ^^|
+---+  +---+  +---+  +---+  +---+  +---+

   Rule 3        Rule 4        Rule 3

इस बिंदु पर, कार्गो अंतिम दो फ़्रेमों के बीच एक लूप में प्रवेश करता है।

अब इसके बजाय एक 2x3 कार्गो पर विचार करें:

 ##<vv    <    >##vv    <    > <vv    <    > <vv    <    > <vv    <    > <vv    <
 ## ^ >v v      ##^ >v v      ##^ >v v      v ^ >v v      v ^ >v v      v ^ >v v 
 ##>v^^>vv^     ##v^^>vv^     ##v^^>vv^     ##v^^>vv^      ##^^>vv^      >v^^>vv^
     ^>^ v         ^>^ v      ## ^>^ v      ## ^>^ v       ##^>^ v       ##^>^ v 
 >  v<v  >>    >  v<v  >>    >  v<v  >>    >##v<v  >>    > ##<v  >>    > ##<v  >>
   >v v<^        >v v<^        >v v<^        >v v<^        >v v<^        ## v<^  

 +--+  +--+    +--+  +--+    +--+  +--+    +--+  +--+    +--+  +--+    +--+  +--+
 |> |  |> |    | <|  |  |    |v |  |v |    | >|  | >|    |>v|  |>v|    |  |  |  |
 | v|  | v|    |v |  |v |    | >|  | >|    |  |  |  |    |  |  |  |    | v|  | v|
 |  |  |  |    | >|  |  |    |  |  |  |    |  |  |  |    | v|  | v|    |>v|  |>v|
 +--+  +--+    +--+  +--+    +--+  +--+    +--+  +--+    +--+  +--+    +--+  +--+

   Rule 4        Rule 3        Rule 4        Rule 3        Rule 3        Rule 3

 ================================================================================

 > <vv    <    > <vv    <    > <vv    <
  v ^ >v v      v ^ >v v      v ^ >v v 
   >v^^>vv^      >v^^>vv^      >v^^>vv^
     ^>^ v         ^>^ v         ^>^ v 
 > ##<v  >>    >  v<v  >>    >  v<v  >>
   ## v<^        ## v<^        >v v<^  
   ##            ##            ##
                 ##            ##
                               ##

 +--+  +--+    +--+  +--+    +--+  +--+
 | v|  | v|    |>v|  |>v|    |  |  |  |
 |>v|  |>v|    |  |  |  |    |  |  |  |
 |  |  |  |    |  |  |  |    |  |  |  |
 +--+  +--+    +--+  +--+    +--+  +--+

   Rule 3        Rule 4        Rule 2

अंतिम चरण में, नियम 2 लागू होता है क्योंकि कार्गो ग्रिड से हट गया है, इसलिए यह आराम करने के लिए आता है और लूप नहीं होगा।

नियम और मान्यताएँ

आपका इनपुट कार्गो की चौड़ाई और ऊंचाई के साथ ऊपर वर्णित कन्वेयर ग्रिड होगा। आप किसी भी सुविधाजनक क्रम और प्रारूप में इन तीन मापदंडों को ले सकते हैं। ग्रिड के लिए, इसका मतलब है कि आप एक तार को नईलाइनों या अन्य वर्णों, या तार की एक सरणी, या वर्णों के सरणियों की एक सरणी के रूप में पढ़ सकते हैं, जब तक कि अलग-अलग ग्रिड कोशिकाएं अभी भी वर्णों का प्रतिनिधित्व करती हैं >v<^और रिक्त स्थान।

आप उत्पादन एक चाहिए truthy यदि कम से कम दो फ्रेम या एक के एक पाश में सेटअप परिणाम मूल्य falsy मूल्य अगर माल आराम आ जाएगा।

आप मान सकते हैं कि ग्रिड को रिक्त स्थान के साथ एक आयत में गद्देदार किया जाएगा, और यह कि कार्गो शुरू में ग्रिड में फिट होगा।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

परीक्षण के मामलों

परीक्षण मामलों को ग्रिड द्वारा समूहीकृत किया जाता है।

Grid (2x2):

>v
^<

Width  Height  Loop?
1      1       True
1      2       True
2      1       True
2      2       False

Grid (3x3):

> v

^ <

Width  Height  Loop?
1      1       False
1      2       False
1      3       False
2      1       False
2      2       True
2      3       True
3      1       False
3      2       True
3      3       False

Grid (4x3):

>^>v
v^v 
^ <<

Width  Height  Loop?
2      2       False

Grid (6x5):

>v>v>v
^v^v^v
^v^v^v
^>^>^v
^<<<<<

Width  Height  Loop?
1      1       True
1      2       False
2      1       True
2      2       True
2      4       True
2      5       False
3      1       False
3      2       True
3      3       True
3      5       True
6      2       False
6      3       True
6      5       False

Grid (10x6):

> <vv    <
 v ^ >v v 
  >v^^>vv^
    ^>^ v 
>  v<v  >>
  >v v<^  

Width  Height  Loop?
1      1       False
2      3       False
2      6       False
3      2       True
5      4       False
6      1       True
10     6       False

परीक्षण मामलों के एक अतिरिक्त सेट के रूप में, विचार करें कि किसी भी इनपुट जहां ग्रिड में पूरी तरह से रिक्त स्थान होते हैं, एक मिथ्या परिणाम प्राप्त करना चाहिए।

मैंने सभी परीक्षण मामलों को मैन्युअल रूप से जांचा है, इसलिए मुझे बताएं कि क्या आपको लगता है कि मैंने गलती की है।

code-golf decision-problem simulation

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

फिटिंग संगीत

— घातक

@ जानिए मैं पा रहा हूं ट्विच प्लेज़ पोकेमॉन फ्लैशबैक ...

— भूमिगत

"आपका इनपुट कार्गो ग्रिड की चौड़ाई और ऊंचाई के साथ ऊपर वर्णित कन्वेयर ग्रिड होगा। आप इन तीन मापदंडों को किसी भी सुविधाजनक क्रम और प्रारूप में ले सकते हैं।" - क्या इसका मतलब है कि एरे के ग्रिड के रूप में लिया गया कन्वेयर ग्रिड हमारे पास हो सकता है? यही है, 2x2 ग्रिड [^^/v<]बन जाता है [[0,1] [0,1];[0,-1] [-1,0]]? या आप इसका मतलब यह है कि यह हमारे ऊपर है कि क्या यह एक तार इनपुट, एक चार सरणी इनपुट, आदि है, लेकिन यह अभी भी ^, v,> और <के रूप में होना चाहिए?

— ग्लेन ओ

@ गेलो आप एक नई पंक्ति (या अन्य वर्ण) अलग किए गए तार, तार की एक सरणी, या वर्णों के सारणियों की एक सरणी ले सकते हैं, लेकिन प्रत्येक कोशिका को अभी भी वर्ण ><^vया एक स्थान द्वारा दर्शाया जाना चाहिए । मैं स्पष्ट कर दूंगा।

— मार्टिन एंडर

तो क्या होगा यदि कार्गो एक संघर्ष पर चलता है जहां निरंतर दिशा विकल्पों में से एक नहीं है? यही है, अगर यह सही चल रहा था, और अब ऊपर और बाएं के बीच चयन करना होगा।

— जोशुआ

जवाबों:

रूबी, 306 298 251 204 198

->g,w,h{m=->y,x,d,v=[]{q=y,x
r=->s{([""]*h+g)[y+h,h].map{|l|(?x*w+l)[x+w,w]}.join.count s}
z=k=r[?v]-r[?^],j=r[?>]-r[?<]
q[d=[d,1,0][j*j<=>k*k]]+=z[d]<=>0
v&[q<<d]!=[]?q!=v[-1]:m[*q,v<<q]}
m[0,0,1]}

संपादित करें: वेंचरो को बहुत धन्यवाद, जिन्होंने कुछ अद्भुत ट्रिक्स लागू करके कोड को बहुत छोटा कर दिया!

इनपुट और आउटपुट

कोड एक रूबी फ़ंक्शन का प्रतिनिधित्व करता है जो तीन पैरामीटर लेता है:

ग्रिड, स्ट्रिंग के एक सरणी के रूप में दर्शाया गया है (प्रत्येक पंक्ति एक अलग स्ट्रिंग है)
कार्गो की चौड़ाई
कार्गो की ऊंचाई

यह रिटर्न 1मामले में (truthy) वहाँ एक पाश, या है nilमामले में (falsy) कार्गो टिकी हुई है।

टेस्ट

यहाँ यह मार्टिन के सभी परीक्षणों को पार कर रहा है: http://ideone.com/zPPZdR

व्याख्या

कोड में कोई चतुर चाल नहीं है; यह नियमों का बहुत सीधा कार्यान्वयन है।

नीचे दिए गए कोड में, moveएक पुनरावर्ती कार्य है जो नियमों के अनुसार एक चाल बनाता है, और:

लूप के मामले में सत्यता देता है
बाकी के मामले में मिथ्या रिटर्न
अन्यथा खुद को अगले कदम को निष्पादित करने के लिए कहता है

एक अधिक पठनीय संस्करण यहां उपलब्ध है ।

नोट: गोल्फ कोड कई संशोधनों से गुजरा है और अब पठनीय संस्करण के समान नहीं है।

— क्रिस्टियन लुपस्कू
स्रोत

चूंकि यह मायने नहीं रखता है कि rचार दिशाओं के अलावा अतिरिक्त प्रविष्टियां हैं या नहीं , इसलिए r[y>=0&&x>=0&&g[y]&&g[y][x]]+=1कुछ बाइट्स बचाएं।

— वेंतोरो

मैंने गोल्फ चीजों की स्वतंत्रता को थोड़ा और आगे बढ़ाया, आशा है कि आप बुरा नहीं मानेंगे

— वेंचरो

@ वेंटरो वाह, आपने कोड के लिए अद्भुत चीजें की हैं। मैंने कभी हैश को मेमने में बदलने के बारे में नहीं सोचा होगा। मैं कार्यक्रम को छोटा करने के लिए अपने कुछ विचारों को आज़मा रहा था, लेकिन आपने जो किया उसके आस-पास कहीं नहीं था। आपका बहुत बहुत धन्यवाद!

— क्रिस्टियन लुपस्कु

नकारात्मक सूचकांकों की थोड़ी कम संभाल के माध्यम से इसे 200 तक नीचे ले जाओ, मुझे लगता है कि मैं इसे अभी के लिए छोड़ दूंगा

— वेंटरो

दरअसल, 198: ideone.com/ptKrzf :)

— वेंटरो

पायथन 2, 207 बाइट्स

def f(L,w,h,u=0,v=0,D=1,S=[]):a,b,c,d=map(`[r[u*(u>0):u+w]for r in L[v*(v>0):v+h]]`.count,"v^><");D=cmp(abs(a-b),abs(c-d))<D;T=u,v,D;return T in S or a-b|c-d and f(L,w,h,u+cmp(c,d)*D,v+cmp(a,b)*0**D,D,S+[T])

ग्रिड को पंक्तियों की सूची के रूप में इनपुट करें, जैसे

['>v>v>v', '^v^v^v', '^v^v^v', '^>^>^v', '^<<<<<']

चौड़ाई और ऊंचाई के बाद। रिटर्न 0या Trueतदनुसार।

व्याख्या

def f(L,          # Grid
      w,h,        # Width, height of cargo
      u=0,v=0,    # Position of top-left of cargo, initially (0, 0)
      D=1,        # Moving left/right = 1, up/down = 0
      S=[]        # Seen (pos, axis) pairs, initially empty
     ):     

     # Arrows under cargo - no need for "".join since we only need to count v^<>
     A = `[r[u*(u>0):u+w]for r in L[v*(v>0):v+h]]`

     # Count for each arrow
     a,b,c,d=map(A.count,"v^><")

     # Golfed form of abs(a-b) < abs(c-d) or (abs(a-b) == abs(c-d) and D == 1)
     D=cmp(abs(a-b),abs(c-d))<D
     T=u,v,D

     return (T in S                # Return True if (pos, axis) previously seen
             or a-b|c-d               # Return 0 if all conveyors cancel
             and f(L,w,h,             # Otherwise, recurse
                   u+cmp(c,d)*D,      # Update u if moving left/right
                   v+cmp(a,b)*0**D,   # Update v if moving up/down
                   D,
                   S+[T]          # Add (pos, axis) to seen
                  )
            )

— Sp3000
स्रोत

क्या आप cmpएक चर को निर्दिष्ट करके इसे छोटा नहीं कर सकते ?

— ब्लू

क्या पहले से ही देखे गए पदों के लिए जाँच करके चक्रों का पता लगाना पर्याप्त है? नियम 4 के आधार पर, अगला चरण पिछली दिशा से भी प्रभावित हो सकता है। इसलिए यह संभव है कि आप एक ही स्थिति में दो बार पहुंच सकते हैं, लेकिन एक चक्र नहीं है क्योंकि आप अलग-अलग दिशाओं में अलग-अलग दिशाओं में चलते हैं।

— रेटो कोराडी

@muddyfish जो अभी भी टूट

— जाएगी

@RetoKoradi उम्मीद से तय किया गया

— Sp3000

हां, Dपोजीशन की में जोड़ना चाहिए।

— रेटो कोराडी

जूलिया - 394 300 246 214 बाइट्स

f(A,x,y)=(Z=sign;(S,T)=size(A);X=x+1;Y=y+1;G=fill(5,S+2y,T+2x);G[Y:S+y,X:T+x]=A;C=0G;D=1;while C[Y,X]!=D C[Y,X]=D;i,j=sum(i->1-[19 8]i%82%3,G[Y:Y+y-1,X:X+x-1]);D=Z(2i^2-2j^2+(i!=0)D);X+=Z(i+D*i);Y+=Z(j-D*j)end;D^2)

यदि माल रुकता है तो 1 और रिटर्न अगर 1 बंद हो जाता है। यह "कड़ाई" सत्य / झूठे नहीं है, इसमें जूलिया बूलियन संदर्भों में 0 और 1 की अनुमति नहीं देता है ... लेकिन मैं उन मूल्यों पर विचार करता हूं xजिनके bool(x)==trueलिए सत्य हैं और bool(x)==falseमिथ्या हैं।

इनपुट Aएक चरित्र सरणी के रूप में होना चाहिए। यदि आप कन्वेयर ग्रिड को कॉपी / पेस्ट कर रहे हैं, तो आपको इसे उपयुक्त फॉर्म में लाना होगा। आपको इसे मैन्युअल रूप से संभालने से बचाने के लिए, निम्नलिखित का उपयोग करें:

A=foldl(hcat,map(collect,split("""(PASTE GRID HERE)""","\n")))'

जहां जाहिर है, (PASTE GRID HERE)ग्रिड के साथ ही प्रतिस्थापित किया जाना चाहिए। प्रत्येक पंक्ति के अंत में रिक्त स्थान को दोबारा जांचें, यह सुनिश्चित करने के लिए कि उसमें वास्तव में सभी स्थान हैं (यह सुनिश्चित करने के लिए जांच नहीं करता है कि सभी लाइनें समान लंबाई हैं)। ध्यान दें कि यह लाइन वास्तविक समाधान कोड का हिस्सा नहीं है, बस कोड का एक सुविधाजनक टुकड़ा समाधान कोड का उपयोग करके थोड़ा आसान है।

Ungolfed:

function f(A,x,y)
  # Determine size of grid for use later
  (S,T)=size(A)
  # Initialise starting position (performed here to save characters)
  X=x+1
  Y=y+1
  # Create an expanded field that is functionally "spaces" (to provide
  # spaces at edges for the cargo to stop in)
  G=fill(5,S+2y,T+2x)
  # Put the conveyor grid into centre of the expanded field
  G[Y:S+y,X:T+x]=A
  # Create an array storing the most recent movement direction:
  # will use 1=horizontal, -1=vertical, 0=stopped
  C=0G
  # Initialise current direction (same system as C)
  D=1
  # Loop until it finds itself repeating a coordinate/direction pair
  while C[Y,X]!=D
    # Mark current coordinate/direction pair in array
    C[Y,X]=D
    # Determine the net coordinate pairing, stored in two variables
    # for golf purposes *SEE NOTE*
    i,j=sum(i->1-[19 8]i%82%3,G[Y:Y+y-1,X:X+x-1])
    # Determine new movement axis (if D=0, cargo stopped)
    D=sign(2i^2-2j^2+(i!=0)D)
    # Update X or Y depending on signs of D and the appropriate direction
    X+=sign(i+D*i)
    Y+=sign(j-D*j)
  end
  # if D=±1, return 1 (cargo is still moving), otherwise return 0
  return D^2
end

नोट: 1-[19 8]i%82%3पाँच संभावित वर्णों को उपयुक्त तालमेल युग्मों के लिए मैप करने के लिए चुना गया है जो सबसे कुशल विधि है जो मुझे मिल सकती है। Gइसे बनाते समय रिक्त स्थान को भरने के लिए 5 का उपयोग करने का कारण भी है - यह एक एकल-अंक वाला चरित्र है जो मानचित्र बनाता है [0 0]।

उपयोग का उदाहरण:

julia> A=foldl(hcat,map(collect,split(""">v>v>v
       ^v^v^v
       ^v^v^v
       ^>^>^v
       ^<<<<<""","\n")))';

julia> f(A,2,1)
true

julia> f(A,3,3)
true

julia> f(A,5,2)
false

— ग्लेन हे
स्रोत

f(A,x,y)=से छोटा है f=(A,x,y)->।

— एलेक्स ए।

@AlexA। - सच है, लेकिन फिर, मैं शायद f=इसे हटा दूंगा और इसे गुमनाम कर दूंगा जब मैं इसे पूरा करूंगा।

— ग्लेन ओ

यह एक ही लंबाई होगी यदि यह एक नामित फ़ंक्शन बनाम एक अनाम फ़ंक्शन है जब कई पैरामीटर हैं। f()=बनाम ()->।

— एलेक्स ए।