स्काला , 764 बाइट्स
object B{
def main(a: Array[String]):Unit={
val v=false
val (m,l,k,r,n)=(()=>print("\033[H\033[2J\n"),a(0)toInt,a(1)toInt,scala.util.Random,print _)
val e=Seq.fill(k, l)(v)
m()
(0 to (l*k)/2-(l*k+1)%2).foldLeft(e){(q,_)=>
val a=q.zipWithIndex.map(r => r._1.zipWithIndex.filter(c=>
if(((r._2 % 2) + c._2)%2==0)!c._1 else v)).zipWithIndex.filter(_._1.length > 0)
val f=r.nextInt(a.length)
val s=r.nextInt(a(f)._1.length)
val i=(a(f)._2,a(f)._1(s)._2)
Thread.sleep(1000)
m()
val b=q.updated(i._1, q(i._1).updated(i._2, !v))
b.zipWithIndex.map{r=>
r._1.zipWithIndex.map(c=>if(c._1)n("X")else if(((r._2 % 2)+c._2)%2==0)n("O")else n("_"))
n("\n")
}
b
}
}
}
यह काम किस प्रकार करता है
एल्गोरिथ्म पहले गलत मूल्यों के साथ एक 2 डी अनुक्रम भरता है। यह निर्धारित करता है कि कमांड लाइन के तर्कों के आधार पर कितने पुनरावृत्तियों (खुले बक्से) मौजूद हैं। यह ऊपरी सीमा के रूप में इस मान के साथ एक गुना बनाता है। तह के पूर्णांक मान का उपयोग केवल इस बात के लिए किया जाता है कि एल्गोरिथ्म के लिए कितने पुनरावृत्तियों को गिनना चाहिए। भरा हुआ अनुक्रम जो हमने पहले बनाया था वह गुना के लिए शुरुआती अनुक्रम है। इसका उपयोग उनके सह-कार्यशील अनिर्णय के साथ झूठे मूल्यों के एक नए 2 डी अनुक्रम को उत्पन्न करने में किया जाता है।
उदाहरण के लिए,
[[false, true],
[true, false],
[true, true]]
में बदल दिया जाएगा
[[(false, 0)], [(false, 1)]]
ध्यान दें कि सभी सूची जो पूरी तरह से सच हैं (0 की लंबाई है) को परिणाम सूची से छोड़ दिया गया है। एल्गोरिथ्म तब इस सूची को लेता है और सबसे बाहरी सूची में एक यादृच्छिक सूची चुनता है। यादृच्छिक सूची को हमारे द्वारा चुनी गई यादृच्छिक पंक्ति चुना जाता है। उस यादृच्छिक पंक्ति से, हम फिर से एक यादृच्छिक संख्या, एक कॉलम इंडेक्स पाते हैं। एक बार जब हम इन दो यादृच्छिक सूचकांकों को पा लेते हैं, तो हम उस धागे को सोते हैं जो हम 1000 मील की दूरी पर हैं।
नींद पूरी होने के बाद, हम स्क्रीन को साफ करते हैं और trueहमारे द्वारा बनाए गए यादृच्छिक सूचकांकों में अद्यतन मूल्य के साथ एक नया बोर्ड बनाते हैं ।
इसे ठीक से प्रिंट करने के लिए, हम mapइसे मैप के इंडेक्स के साथ उपयोग और ज़िप करते हैं ताकि हमारे संदर्भ में ऐसा हो। हम करने के लिए है कि क्या हम एक प्रिंट चाहिए के रूप में अनुक्रम की सच्चाई मान का उपयोग Xया तो एक Oया _। उत्तरार्द्ध को चुनने के लिए, हम अपने गाइड के रूप में सूचकांक मूल्य का उपयोग करते हैं।
ध्यान देने योग्य बातें
यह पता लगाने के लिए कि क्या इसे एक Oया एक प्रिंट करना चाहिए _, सशर्त ((r._2 % 2) + c._2) % 2 == 0का उपयोग किया जाता है। वर्तमान कॉलम r._2इंडेक्स को c._2संदर्भित करता है जबकि वर्तमान कॉलम को संदर्भित करता है। यदि कोई एक विषम पंक्ति पर है, r._2 % 2तो 1 होगा, इसलिए c._2सशर्त में एक से ऑफसेट करना । यह सुनिश्चित करता है कि विषम पंक्तियों पर, स्तंभ 1 से अधिक के रूप में ले जाया जाता है।
स्ट्रिंग को प्रिंट करना "\033[H\033[2J\n" , कुछ Stackoverflow जवाब के अनुसार मैं पढ़ता हूं, स्क्रीन को साफ करता है। यह टर्मिनल को बाइट्स लिख रहा है और कुछ फंकी चीजें कर रहा हूं जो मुझे वास्तव में समझ नहीं आ रही हैं। लेकिन मैंने इसे इसके बारे में सबसे आसान तरीका माना है। यह Intellij IDEA के कंसोल एमुलेटर पर काम नहीं करता है, हालांकि। आपको इसे नियमित टर्मिनल का उपयोग करके चलाना होगा।
एक और समीकरण देखने में अजीब लग सकता है जब पहली बार इस कोड को देख रहा हो (l * k) / 2 - (l * k + 1) % 2। सबसे पहले, चर नामों को नष्ट करते हैं। lकार्यक्रम में पारित पहले तर्कों को kसंदर्भित करता है जबकि दूसरे को संदर्भित करता है। इसका अनुवाद करने के लिए, (first * second) / 2 - (first * second + 1) % 2। इस समीकरण का लक्ष्य सभी एक्स के अनुक्रम प्राप्त करने के लिए आवश्यक पुनरावृत्तियों की सटीक मात्रा के साथ आना है। पहली बार जब मैंने ऐसा किया, तो मैंने ऐसा ही किया (first * second) / 2। nप्रत्येक सबलिस्ट में प्रत्येक तत्वों के लिए , ऐसे n / 2बुलबुले हैं जिन्हें हम पॉप कर सकते हैं। हालाँकि, इनपुट्स से निपटने के दौरान यह टूट जाता है(11 13) । हमें दो नंबरों के उत्पाद की गणना करने की आवश्यकता है, अगर यह विषम है, और भले ही यह विषम है, तो इसे 2 से माप लें। 2. यह काम करता है क्योंकि पंक्तियां और स्तंभ जो विषम हैं उन्हें एक कम पुनरावृत्ति की आवश्यकता होती है अंतिम परिणाम के लिए।
mapइसके बजाय इसका उपयोग किया जाता है forEachक्योंकि इसमें कम वर्ण होते हैं।
चीजें जो शायद बेहतर हो सकती हैं
एक चीज जो वास्तव में मुझे इस समाधान के बारे में बताती है वह है लगातार उपयोग zipWithIndex। यह बहुत सारे पात्रों को उठा रहा है। मैंने इसे बनाने की कोशिश की ताकि मैं अपने स्वयं के एक चरित्र फ़ंक्शन को परिभाषित कर सकूं जो कि केवल zipWithIndexपारित मूल्य के साथ प्रदर्शन करेगा । लेकिन यह पता चला है कि स्काला एक अनाम फ़ंक्शन को टाइप पैरामीटर के लिए अनुमति नहीं देता है। वहाँ शायद एक और तरीका है जो मैं उपयोग किए बिना कर रहा हूं, zipWithIndexलेकिन मैंने इसे करने के लिए एक चतुर तरीके के बारे में बहुत अधिक नहीं सोचा है।
वर्तमान में, कोड दो पास में चलता है। पहला नया बोर्ड बनाता है जबकि दूसरा पास प्रिंट करता है। मुझे लगता है कि अगर इन दोनों में से किसी एक को पास कर दिया जाए, तो इससे एक-दो बाइट बच जाएंगी।
यह पहला कोड गोल्फ है जो मैंने किया है इसलिए मुझे यकीन है कि सुधार के लिए बहुत जगह है। यदि आप बाइट्स के लिए अनुकूलित करने से पहले कोड देखना चाहते हैं, तो यहां है।
1और के0बजायOऔरX?