लुकास बनाम। गेराज दरवाजा रिमोट

Question

अस्वीकरण

जबकि मुझे पता है कि यह विशेष रूप से संबंधित प्रश्न है , मेरा प्रश्न दो गेराज दरवाजे, एक यादृच्छिक घटक का उपयोग करता है, और मैं इसे वास्तविक जीवन की घटनाओं पर भी आधारित कर रहा हूं, अपने बेटे को गलती से उक्त गेराज दरवाजे में से एक को कम करते हुए देखकर, जब मैं बाहर चल रहा था। गेराज पिछले हफ्ते ... रचनात्मक रस बहने के लिए सिर पर एक झटका की तरह कुछ भी नहीं! ;)

पृष्ठ - भूमि

लुकास (मेरा 15 महीने का बेटा) गैरेज रिमोट से खेलना पसंद करता है। इस रिमोट पर दो बटन होते हैं, एक बाएं गैराज के दरवाजे के लिए और दूसरा दाएं गैराज के दरवाजे के लिए। दोनों बटन एक ही तरीके से काम करते हैं; खोलने के लिए दरवाजा पाने के लिए एक बार दबाएं, फिर से बंद करने के लिए फिर से दबाएं, बंद करने के लिए फिर से दबाएं, फिर से बंद करने के लिए फिर से दबाएं, और इसी तरह।

लुकास को यह रिमोट बहुत पसंद है, वह बेतरतीब ढंग से एक बटन दबाएगा, या दोनों, या कोई भी नहीं। यदि दोनों को दबाया जाता है, तो कोई संकेत नहीं भेजा जाता है, लेकिन एक बटन का एक प्रेस एक संकेत भेज देगा।

तो, कोड-गोल्फ चुनौती दो भागों में विभाजित है:

भाग एक

एक मिनट में लुकास यादृच्छिक बटन प्रेस का प्रतिनिधित्व करने वाला 60 वर्ण लंबा तार उत्पन्न करें। इस मामले में "यादृच्छिक" का अर्थ है "प्रत्येक टिक पर प्रत्येक इनपुट के समान अवसर के साथ"। वर्ण इस प्रकार हैं:

• 0: लुकास ने या तो कोई बटन नहीं दबाया है, या दोनों बटन दबाए हैं। किसी भी तरह से, कोई संकेत नहीं भेजा गया है।
• 1: लुकास द्वारा बाएं गैराज के दरवाजे का बटन दबाया गया है
• 2: सही गेराज दरवाजे के लिए बटन को लुकास द्वारा दबाया गया है

भाग दो

पार्ट वन में उत्पन्न स्ट्रिंग का उपयोग करके, इन दरवाजों को खोलने, रोकने और बंद करने के लिए ट्रिगर के रूप में संख्याओं का उपयोग करके दो-कार गैरेज के उद्घाटन और समापन का अनुकरण करें।

मेरे गेराज दरवाजे बहुत जल्दी हैं (ऊपर अस्वीकरण क्यों देखें)। एक बार जब आप बटन दबाते हैं तो पूरी तरह से खुला या बंद होने में चार सेकंड लगते हैं।

तो, अगर बंद:

• 0 सेकंड: 0% खुला (बंद); जब बटन दबाया जाता है, तो दरवाजा खुलने लगता है
• 1 सेकंड: 25% खुला
• 2 सेकंड: 50% खुला
• 3 सेकंड: 75% खुला
• 4 सेकंड: 100% खुला, दरवाजा बंद हो जाता है

और इसलिए, यदि खुला:

• 0 सेकंड: 100% खुला; जब बटन दबाया जाता है, तो दरवाजा बंद होने लगता है
• 1 सेकंड: 75% खुला
• 2 सेकंड: 50% खुला
• 3 सेकंड: 25% खुला
• 4 सेकंड: 0% खुला (बंद), दरवाजा बंद हो जाता है

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

इस सिमुलेशन के साथ, दोनों गेराज दरवाजे शुरू में बंद स्थिति में होंगे। तो, आइए आज्ञाओं की 10 दूसरी सूची देखें और देखें कि क्या होता है अगर लुकास रिमोट पर उन्हें प्रदर्शन करने के लिए था:

2120221120
2: (L:0% stopped, R:0% opening)
1: (L:0% opening, R:25% opening)
2: (L:25% opening, R:50% stopped)
0: (L:50% opening, R:50% stopped)
2: (L:75% opening, R:50% closing)
2: (L:100% stopped, R:25% stopped)
1: (L:100% closing, R:25% stopped)
1: (L:75% stopped, R:25% stopped)
2: (L:75% stopped, R:25% opening)
0: (L:75% stopped, R:50% opening)

उत्पादन

आउटपुट के पहले भाग में "एक", "1", "1" और "2" वर्णों के 60 वर्ण लंबे स्ट्रिंग के प्रदर्शन की आवश्यकता होती है। जैसे। 212022112021202211202120221120212022112021202211202120221120

इस स्ट्रिंग के नीचे, इन "सिग्नल" का प्रसंस्करण ऊपर वर्णित नियमों के अनुसार है कि गेराज दरवाजे प्रत्येक संबंधित चरित्र के साथ कैसे व्यवहार करेंगे (एक सेकंड से दूसरे आधार पर)। आपको प्रारंभिक प्रदर्शन स्ट्रिंग के नीचे 60 लाइनों के साथ समाप्त होना चाहिए।

इनमें से प्रत्येक संसाधित रेखाएँ इस प्रकार होंगी: N: (L:X% XXXXXXX, R:Y% YYYYYYY)जहाँ:

• एन संबंधित यादृच्छिक स्ट्रिंग से nth वर्ण है, जो कि 0, 1, या 2 के रूप में होगा।
• X% बाएं दरवाजे के खुलेपन का प्रतिशत है (कोई शून्य पैडिंग नहीं है)
• XXXXXXX बाएं दरवाजे की स्थिति है। यदि दरवाजा गति में नहीं है (अर्थात खुलने या बंद नहीं होने पर) स्थिति "रोका" लागू है, तो इसका अर्थ है कि इसे गति में रोक दिया गया है (केवल 25%, 50% या 75% पर संभव है) या पूरी तरह से खुला होने पर रुका हुआ (100%) ) या पूरी तरह से बंद (0%)। अन्यथा, दरवाजा या तो "खोलना" या "बंद करना" होगा।
• Y% दाहिने दरवाजे के खुलेपन का प्रतिशत है (कोई शून्य पैडिंग नहीं है)
• YYYYYYY सही द्वार की स्थिति है। यदि दरवाजा गति में नहीं है (अर्थात खुलने या बंद नहीं होने पर) स्थिति "रोका" लागू है, तो इसका अर्थ है कि इसे गति में रोक दिया गया है (केवल 25%, 50% या 75% पर संभव है) या पूरी तरह से खुला होने पर रुका हुआ (100%) ) या पूरी तरह से बंद (0%)। अन्यथा, दरवाजा या तो "खोलना" या "बंद करना" होगा।

उदाहरण 10 "सिग्नल" और 10 संसाधित लाइनों का उपयोग करके नीचे दिखाया गया है

2120221120
2: (L:0% stopped, R:0% opening)
1: (L:0% opening, R:25% opening)
2: (L:25% opening, R:50% stopped)
0: (L:50% opening, R:50% stopped)
2: (L:75% opening, R:50% closing)
2: (L:100% stopped, R:25% stopped)
1: (L:100% closing, R:25% stopped)
1: (L:75% stopped, R:25% stopped)
2: (L:75% stopped, R:25% opening)
0: (L:75% stopped, R:50% opening)

यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड स्पष्ट विजेता होगा। मैंने "ओपनिंग", "रोका" और "क्लोज़िंग" जैसे वाक्यांशों का उपयोग करके इसे थोड़ा आसान बना दिया है, जो सभी सात अक्षर हैं ... इसलिए आप अपनी रणनीति में काम करना चाहते हैं।

शुभकामनाएँ!

Comments

आपको भाग 2 के लिए एक स्पष्ट आउटपुट फॉर्मेट को परिभाषित करना चाहिए

— LegionMammal978

@ LegionMammal978 आपको क्या लगता है आउटपुट से गायब है?

— वैलीवेस्ट

मैं इस समय नहीं हूं, लेकिन मुझे लगता है कि यह एक साफ सवाल है - मैं इससे निपट सकता हूं।

— DLosc

1आपके उदाहरण में अंतिम कमांड बाएं दरवाजे को 75% पर क्यों नहीं रोक रहा है?

— अरनुलद

क्या पहले भाग में 0,1, और 2 सभी समान रूप से दिखाई देने चाहिए, या नो-प्रेस, डबल-प्रेस, लेफ्ट-प्रेस, और राइट-प्रेस सभी समान रूप से दिखाई देंगे? (अर्थ, 0 अधिक होने की संभावना है क्योंकि यह दो परिदृश्यों का प्रतिनिधित्व करता है जो समान और परिणाम का कारण बनते हैं ...)

— सोक्रेटिक फीनिक्स

Answer 1

पायथ, 156 149 145 बाइट्स

jkJmO3U60K=G*]Z3=b*3]_1VJFHS2I&=T@KHq*2hT@XHGTH XbHT XKH0)) XKN*_@XbN|@KN@bNN!@KN%+N": (L:%s, R:%s)"m++*@Gd25"% "%3>"csoltpooespnipinengdg"h@KdS2

मेरे पायथन उत्तर का सीधा अनुवाद ।

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

jk                              " print ''.join(map(str,                   "
JmO3U60                         "  J = [randint(0,2) for _ in range(60)])) "
K=G*]Z3                         " K = copy(G = [0] * 3)                    "
=b*3]_1                         " b = [-1] * 3                             "
VJ                              " for N in J:                              "
FHS2                            "  for H in range(1, 3):                   "
I&=T@KH                         "   if ((T = K[H]) and                     "
q*2hT@XHGTH                     "       (2 * (T + 1) == (G[H] += T)[H]):   "
 XbHT                           "    b[H] = T                              "
 XKH0))                         "    K[H] = 0                              "
 XKN*_@XbN|@KN@bNN              "  K[N] = (-(b[N] = K[N] or B[N])[N] *     "
!@KN                            "   (not K[N]))                            "
%+N": (L:%s, R:%s)"             "  print(str(N) + ': (L:%s, R:%s)' %       "
m++                             "   map(lambda d:                          "
*@Gd25                          "    G[d] * 25 +                           "
"% "                            "    '% ' +                                "
%3>"csoltpooespnipinengdg"h@Kd  "    'csoltpooespnipinengdg'[K[d]+1::3]]   "
S2                              "   ), range(1, 3))                        "

Comments

वाह! इस उत्तर के लिए धन्यवाद, साथ ही साथ कोड की व्याख्या ... मैं वास्तव में जब तक मैं इसके अंत तक पहुंच गया था तब तक इसका अर्थ बना रहा था ...

— WallyWest

Answer 2

जावास्क्रिप्ट (ईएस 6), 277 275 263 253 250 247 234 बाइट्स

_=>(d=[0,0],l=s='',[...Array(60)].map(_=>(s+=`
${c=Math.random()*3|0}:(`,l+=c,d=d.map((v,i)=>(v=v&8?v&16?v-27?v+1:20:v-9?v-1:0:v,v^=c+~i?0:v&8||24,s+='LR'[i]+`:${(v&7)*25}% `+(v&8?v&16?'opening':'closing':'stopped')+',)'[i],v)))),l+s)

असहमति और टिप्पणी की

_ => (
  // Initialize array:
  //   - d = door states as integers
  //     - bits 0 to 2: door opening state (from 0b000 = 0% to 0b100 = 100%)
  //     - bit #3: door in motion (0: no, 1: yes)
  //     - bit #4: door direction (0: closing, 1: opening)
  d = [0, 0],

  // Initialize strings:
  //   - l = list of commands
  //   - s = door states in plain text
  l = s = '',

  // Iterate on an array of 60 entries.
  [...Array(60)].map(_ => (
    // c = new random command (0, 1 or 2)
    // Append new line and new command to s.
    s += `\n${c = Math.random() * 3 | 0}:(`,

    // Append new command to l.
    l += c,

    // For each door ...
    d = d.map((v, i) => (
      // If the door is in motion, update its opening state.
      // Clear the 'in motion' bit if a bound is reached (either closed or fully open).
      v = v & 8 ? v & 16 ? v - 27 ? v + 1 : 20 : v - 9 ? v - 1 : 0 : v,

      // If the current command is intended for this door, update its direction and
      // 'in motion' bit. Direction is changed on the 'stopped => moving' transition.
      v ^= c + ~i ? 0 : v & 8 || 24,

      // Translate the door state in plain text and append it to s
      s +=
        'LR'[i] +
        `:${(v & 7) * 25}% ` +
        (v & 8 ? v & 16 ? 'opening' : 'closing' : 'stopped') +
        ',)'[i],

      // Value to be taken into account by map()
      v
    ))
  )),

  // Final result to be returned
  l + s
)

डेमो

let f = 
_=>(d=[0,0],l=s='',[...Array(60)].map(_=>(s+=`
${c=Math.random()*3|0}:(`,l+=c,d=d.map((v,i)=>(v=v&8?v&16?v-27?v+1:20:v-9?v-1:0:v,v^=c+~i?0:v&8||24,s+='LR'[i]+`:${(v&7)*25}% `+(v&8?v&16?'opening':'closing':'stopped')+',)'[i],v)))),l+s)

console.log(f())

Comments

वाह, मैं एक लाइनर से प्रभावित हूं और इसे कंसोल में फेंक रहा हूं। बहुत बढ़िया!

— वैलीवेस्ट

उत्सुकता से फ़ायरफ़ॉक्स में काम नहीं कर रहा है, आउटपुट में सिर्फ 4 लाइनें, इस तरह 112200001100122021010101012100000010011200201022122021012211 [ "L:25% stopped", "R:25% stopped" ](कॉमा और ब्रैकेट के बाद की नई लाइनें)

— edc65

@ edc65 - मेरा बुरा, वास्तव में। मैं आउटपुट फॉर्मेट के निर्देशों को गलत बताता हूं। यह तय है।

— अरनुलद

@ अरनल्ड आप v^=(c-i-1?0:v&8||24)दो बाइट्स को बचाने के लिए कोष्ठक को भी हटा सकते हैं ।

— 3

PS @ अरनल्ड, भाग लेने के लिए धन्यवाद!

— 4

Answer 3

पायथन 2, 377 370 361 357 345 335 326 316 312 306 304 बाइट्स

दूसरा इंडेंट स्तर एक कच्चा टैब ( \t) है, जो मार्कडाउन के साथ वास्तव में बुरी तरह से खेलता है , इसलिए इसे दो स्थानों से बदल दिया गया है।

from random import*
p=[randint(0,2)for d in[[0]*3]*60]
print`p`[1::3]
v=[-1]*3
c=[0]*3
f=lambda y:str(c[y]*25)+'% '+'csoltpooespnipinengdg'[d[y]+1::3]
for x in p:
 for i in 1,2:
  q=d[i];c[i]+=q
  if(2*-~q==c[i])*q:v[i]=q;d[i]=0
 z=d[x]
 if z:v[x]=z
 d[x]=-v[x]*(z==0);print'%d: (L:%s, R:%s)'%(x,f(1),f(2))

मैं लगभग निश्चित हूं कि इसे और आगे बढ़ाया जा सकता है।

टिप्पणियों के साथ असंगठित:

import random

# Generate the random string - represented as a list of ints
presses = [random.randint(0, 2) for _ in range(60)]
print ''.join(map(str, presses))

# Constants for door states used for easier reading
CLOSING = -1
STOPPED = 0
OPENING = 1

# Variables representing the state of the garage doors
# There's a third element in these so that x[0] resolves to a dummy slot
# (this way, we can avoid a conditional down the road)
prev_states = [CLOSING, CLOSING, 0]
door_states = [STOPPED, STOPPED, 0]
door_pcts = [0, 0, 0]  # delta 1 = 25%

for press in presses:
  # Close/open the door 1 more
  for i in 1, 2:
    if door_states[i] != STOPPED:
      delta_pct, stop_pct = (-1, 0) if door_states[i] == CLOSING else (1, 4)
      door_pcts[i] += delta_pct
      if door_pcts[i] == stop_pct:
        prev_states[i] = door_states[i]
        door_states[i] = STOPPED

  # Handle pressing a button
  # If the press is 0 (no press), the 0th element resolves to a dummy
  # door, thus saving us an expensive conditional

  if door_states[press] == STOPPED:
    door_states[press] = -prev_states[press]
  else:
    prev_states[press] = door_states[press]
    door_states[press] = STOPPED

  # Print the status update
  print '%d: (L:%d%% %s, R:%d%% %s)' % (
    press,
    door_pcts[0]*25,
    ['closing', 'stopped', 'opening'][door_states[0]+1],
    door_pcts[1]*25,
    ['closing', 'stopped', 'opening'][door_states[1]+1],
  )

सहेजे गए 4 14 15 बाइट्स @TheBikingViking के लिए धन्यवाद!

सहेजे गए 6 बाइट @ValueInk को धन्यवाद!

Comments

आप बदल सकते हैं range(60)करने के लिए [0]*60।

— बाइकिंग बाइक

@ साइकिलिंग धन्यवाद! अब में संपादित कर रहा हूँ।

— कॉपर

आप 'p'[1::3]इसके बजाय (बैकस्टिक्स के साथ एपोस्ट्रोफिस को बदल सकते हैं ) कर सकते हैं ''.join(map(str,p))।

— बाइकिंग बाइक

(4,0)[q<0]==c[i]and q->((4,0)[q<0]==c[i])*q

— TheBikingViking

@ValueInk वह पंक्ति Python 2 की सूची में एक बग का दुरुपयोग करती है जो nउस स्ट्रिंग को सेट करने के लिए समझती है । nनिकालने के लिए अंतिम सीमा पर प्रयोग किया जाता है closing, stopped, openingकि स्ट्रिंग से।

— कॉपर

Answer 4

रूबी, 263 261 260 254 बाइट्स

जावास्क्रिप्ट का जवाब इतना छोटा कैसे मिला ??? यह मेरा दूर हो गया जब मैं दूर था और अभी भी जीत रहा है ...

s=(1..60).map{rand 3}
puts s*''
D=1,2
d=[25]*3;a=[0]*3;m=[p]*3
s.map{|i|D.map{|j|m[j]&&a[j]+=d[j];(0..100)===a[j]+d[j]||i!=j&&(d[j]*=-1;m[j]=p)}
(m[i]^=1)||d[i]*=-1
puts"#{i}: (L%s, R%s)"%D.map{|j|":#{a[j]}% #{%w"stopped opening closing"[m[j]?d[j]:0]}"}}

Answer 5

सी, 420 433 424 374 बाइट्स

#define F(X,x) X=x==1?X+1:x==2?X-1:X;X=X<0?0:X>4?4:X;x=X==0?0:X==4?3:x
#define G(x) x=x==1?3:x==2?0:x==3?2:x+1
#define H(X,x) X*25,x==0||x==3?"stopped":x==1?"opening":"closing"
c,i,l,r,L,R,x[60];main(){while(i<60)printf("%d",x[i++]=random()%3);while(c<60){if(x[c]==1)G(l);else if(x[c]==2)G(r);printf("\n%d: (L:%d%% %s, R:%d%% %s)",x[c++],H(L,l),H(R,r));F(L,l);F(R,r);}}

यादृच्छिक जनरेटर बीज नहीं है, लेकिन एक बेहतर वितरण के लिए यादृच्छिक का उपयोग करता है। इस तर्क को गोल्फ के लिए एक बेहतर तरीका होना चाहिए ...

110121100121212100112200222111200020111100022122202112202211002
1: (L:0% opening, R:0% stopped)
1: (L:25% stopped, R:0% stopped)
0: (L:25% stopped, R:0% stopped)
1: (L:25% closing, R:0% stopped)
2: (L:0% stopped, R:0% opening)
1: (L:0% opening, R:25% opening)
1: (L:25% stopped, R:50% opening)
0: (L:25% stopped, R:75% opening)
0: (L:25% stopped, R:100% stopped)
1: (L:25% closing, R:100% stopped)
2: (L:0% stopped, R:100% closing)
1: (L:0% opening, R:75% closing)
2: (L:25% opening, R:50% stopped)
1: (L:50% stopped, R:50% stopped)
2: (L:50% stopped, R:50% opening)
1: (L:50% closing, R:75% opening)
0: (L:25% closing, R:100% stopped)
0: (L:0% stopped, R:100% stopped)
1: (L:0% opening, R:100% stopped)
1: (L:25% stopped, R:100% stopped)
2: (L:25% stopped, R:100% closing)
2: (L:25% stopped, R:75% stopped)
0: (L:25% stopped, R:75% stopped)
0: (L:25% stopped, R:75% stopped)
2: (L:25% stopped, R:75% opening)
2: (L:25% stopped, R:100% closing)
2: (L:25% stopped, R:75% stopped)
1: (L:25% closing, R:75% stopped)
1: (L:0% opening, R:75% stopped)
1: (L:25% stopped, R:75% stopped)
2: (L:25% stopped, R:75% opening)
0: (L:25% stopped, R:100% stopped)
0: (L:25% stopped, R:100% stopped)
0: (L:25% stopped, R:100% stopped)
2: (L:25% stopped, R:100% closing)
0: (L:25% stopped, R:75% closing)
1: (L:25% closing, R:50% closing)
1: (L:0% opening, R:25% closing)
1: (L:25% stopped, R:0% stopped)
1: (L:25% closing, R:0% stopped)
0: (L:0% stopped, R:0% stopped)
0: (L:0% stopped, R:0% stopped)
0: (L:0% stopped, R:0% stopped)
2: (L:0% stopped, R:0% opening)
2: (L:0% stopped, R:25% stopped)
1: (L:0% opening, R:25% stopped)
2: (L:25% opening, R:25% closing)
2: (L:50% opening, R:0% opening)
2: (L:75% opening, R:25% stopped)
0: (L:100% stopped, R:25% stopped)
2: (L:100% stopped, R:25% closing)
1: (L:100% closing, R:0% stopped)
1: (L:75% stopped, R:0% stopped)
2: (L:75% stopped, R:0% opening)
2: (L:75% stopped, R:25% stopped)
0: (L:75% stopped, R:25% stopped)
2: (L:75% stopped, R:25% closing)
2: (L:75% stopped, R:0% opening)
1: (L:75% opening, R:25% opening)
1: (L:100% closing, R:50% opening)

पुराना संस्करण 1:

c,i,l,r,L,R,x[60];main(){while(i<60)printf("%d",x[i++]=random()%3);while(c<60){if(x[c]==1)l=l==1?3:l==2?0:l==3?2:l+1;else if(x[c]==2)r=r==1?3:r==2?0:r==3?2:r+1;printf("\n%d: (L:%d%% %s, R:%d%% %s)",x[c++],L*25,l==0||l==3?"stopped":l==1?"opening":"closing",R*25,r==0||r==3?"stopped":r==1?"opening":"closing");L=l==1?L+1:l==2?L-1:L;R=r==1?R+1:r==2?R-1:R;L=L<0?0:L>4?4:L;R=R<0?0:R>4?4:R;l=L==0?0:L==4?3:l;r=R==0?0:R==4?3:r;}}

पुराना संस्करण 2:

c,i,l,r,L,R,x[60];g(){while(i<60)printf("%d",x[i++]=random()%3);}main(){g();while(c<60){if(x[c]==1)l=l==1?3:l==2?0:l==3?2:l+1;else if(x[c]==2)r=r==1?3:r==2?0:r==3?2:r+1;printf("%d: (L:%d%% %s, R:%d%% %s)\n",x[c++],L*25,l==0||l==3?"stopped":l==1?"opening":"closing",R*25,r==0||r==3?"stopped":r==1?"opening":"closing");L=l==1?L+1:l==2?L-1:L;R=r==1?R+1:r==2?R-1:R;L=L<0?0:L>4?4:L;R=R<0?0:R>4?4:R;l=L==0?0:L==4?3:l;r=R==0?0:R==4?3:r;}}

Comments

क्या आप इसे कोड में बदल सकते हैं?

— हयकम

Answer 6

PHP, 254 247 246 245 235 230 226 बाइट्स

ईएस फिर से पिटाई!

for($t=60;$t--;)$s.=rand()%3;echo$s;for(;++$t<60;print"
$c: ($o[1], $o[2])")for($i=3;--$i;$o[$i]='.LR'[$i].':'.$d[$i]*25 .'% '.[opening,stopped,closing][abs($z-1)])if(((1&$z=&$r[$i])&&!(3&$d[$i]+=2-$z))|$i&$c=$s[$t])$z=++$z%4;

इन 311 से नीचे गोल्फ (पहला पूर्ण संस्करण, पहले से ही कुछ गोल्फ था):

<?for($i=60;$i--;)$s.=rand(0,2);echo$s;$d=$r=[0,0];$n=[L,R];$p=[stopped,opening,stopped,closing];for($t=-1;++$t<60;print"
$c: (".join(', ',$x).")")for($m=$c=$s[$t],$i=-1;$i++<1;){if($r[$i]&1)if(!($d[$i]+=2-$r[$i])||4==$d[$i])$m|=$i+1;if($m&$i+1)$r[$i]=(1+$r[$i])%4;$x[$i]="$n[$i]:".($d[$i]*25)."% ".$p[$r[$i]];}

टूट - फूट

for($t=60;$t--;)$s.=rand()%3;   // part 1               also initializes $t to -1
echo$s;
for(
    ;
    ++$t<60;
    print"\n$c: ($o[1], $o[2])" // print output
)
    for($i=3;--$i;  // loop $i from 2 to 1 (door number)
        // generate output
        $o[$i]='.LR'[$i].':'.$d[$i]*25 .'% '
        .[opening,stopped,closing][abs($z-1)]           // map 0123 to 1012
    )
        if(((1&$z=&$r[$i])  // if door in motion        ... and reference the array item
            &&!(3&              // 2. if end position   "&&" needed for short circuit
            $d[$i]+=2-$z        // 1. move door         2-$z maps 1,3 to 1,-1 = delta
            )
        )|$i&$c=$s[$t])     // 3. or if button $i pressed   "|" needed for no short circuit
            $z=++$z%4;          // rotate direction     ++$z%4 maps 0,1,2,3 to 1,2,3,0
        // generate output (loop post condition)
    // print output (loop post condition)

Comments

@ अरनल्ड: आपको मिल गया! :)

— टाइटस

Answer 7

जावा 8 लंबोदर, 500 वर्ण

मैंने अपना सर्वश्रेष्ठ प्रदर्शन किया, यहाँ मैं आया हूँ:

()->{String r="";int i=0,l=0,m=0,n=1,o=1,p=0,q=0;for(;i++<60;)r+=(int)(Math.random()*3);for(char s:r.toCharArray()){l+=p;m+=q;if(l>99&p>0){l=100;p=25*(((n=++n%4)-1)%2);}if(l<1&p<0){l=0;p=25*(((n=++n%4)-1)%2);}if(m>99&q>0){m=100;q=25*(((o=++o%4)-1)%2);}if(m<1&q<0){m=0;q=25*(((o=++o%4)-1)%2);}if(s<49);else if(s>49)q=25*(((o=++o%4)-1)%2);else p=25*(((n=++n%4)-1)%2);r+="\n"+s+": (L:"+l+"% "+(p<0?"closing":p>0?"opening":"stopped")+", R:"+m+"% "+(q<0?"closing":q>0?"opening":"stopped")+")";}return r;}

एक पूरी कक्षा में अनगढ़

public class Q91479 {

    public static String movedDoorsCombined() {
        String result = "";
        int i = 0, leftDoor = 0, rightDoor = 0, stepLeft = 1, stepRight = 1, changeLeft = 0, changeRight = 0;

        for (; i++ < 60;) {
            result += (int) (Math.random() * 3);
        }

        for (char step : result.toCharArray()) {
            // update stats
            leftDoor += changeLeft;
            rightDoor += changeRight;

            if (leftDoor > 99 & changeLeft > 0) {
                leftDoor = 100;
                changeLeft = 25 * (((stepLeft = ++stepLeft % 4) - 1) % 2);
            }
            if (leftDoor < 1 & changeLeft < 0) {
                leftDoor = 0;
                changeLeft = 25 * (((stepLeft = ++stepLeft % 4) - 1) % 2);
            }
            if (rightDoor > 99 & changeRight > 0) {
                rightDoor = 100;
                changeRight = 25 * (((stepRight = ++stepRight % 4) - 1) % 2);
            }
            if (rightDoor < 1 & changeRight < 0) {
                rightDoor = 0;
                changeRight = 25 * (((stepRight = ++stepRight % 4) - 1) % 2);
            }

            if (step < 49) {
                // 0
            }
            else if (step > 49) {
                // right
                changeRight = 25 * (((stepRight = ++stepRight % 4) - 1) % 2);
            }
            else {
                // left
                changeLeft = 25 * (((stepLeft = ++stepLeft % 4) - 1) % 2);
            }
            result += "\n" + step + ": (L:" + leftDoor + "% "
                        + (changeLeft < 0 ? "closing" : changeLeft > 0 ? "opening" : "stopped")
                        + ", R:" + rightDoor + "% "
                        + (changeRight < 0 ? "closing" : changeRight > 0 ? "opening" : "stopped")
                        + ")";
        }
        return result;
    }
}

बहुत सीधा। 0-3 से stepLeft / stepRight वैरिएबल सर्कल। कुछ सरल गणित बदल कर बदलाव करें / बदलाव करें प्रति चरण संबंधित सापेक्ष परिवर्तन करें, जिसे बाएं / दाएंडूर में जोड़ा जाएगा। जब दरवाजे को खुद ही बंद करना पड़ता है तो पकड़ने के लिए कई बयान।

बेझिझक मेरी मदद करो इसे छोटा करो, मुझे लगता है कि बहुत कुछ करना बाकी है।

Answer 8

हास्केल (लैम्बडाबोट) - 409 बाइट्स

p=(cycle[0,1,0,-1],0)
t(d:q,s)=(if d/=0&&(s+d<1||3<s+d)then q else d:q,s+d)
k i(a,b)=[o i,": (L:",j a,", ","R:",j b,")"]>>=id
j(d:_,s)=o(round$(fromIntegral s/4)*100)++"% "++words"closing stopped opening"!!(d+1)
s=scanl$ \(a,b)i->i(t a,t b)
main=do b<-(fmap(round.(*(2::Float))).take 60<$>randoms)<$>getStdGen;putStrLn.unlines$(o=<<b):(zipWith k b.w.s(p,p)$([id,f$f w,second$f w]!!)<$>b)
o=show;f=first;w=tail

Comments

कृपया सभी आवश्यक जोड़ने importsके लिए, उदाहरण के लिए randomsअपने कोड (और बाइट गिनती) करने के लिए। यदि कोई दुभाषिया है जो डिफ़ॉल्ट रूप से आयात करता है, तो इसे भाषा के नाम से देखें।

— nimi