जियांग्शी और tcl

इस तरह की एक दुर्लभ अल्पज्ञात प्रोग्रामिंग भाषा है। विकिपीडिया पर, यह अच्छी तरह से लिखा गया है, लेकिन एक कार्यक्रम लिखते समय सवाल उठेंगे।
जानशीजी एक ऐसा चीनी खेल है (नाम से देखते हुए), "पत्थरों को उठाते हुए" के रूप में अनुवादित, यह अपने आप में दिलचस्प है: किसी भी संख्या में पत्थरों के दो ढेर हैं, दो खेलते हैं। प्रत्येक खिलाड़ी किसी भी ढेर से किसी भी संख्या में पत्थर ले सकता है, साथ ही साथ एक ही बार में दोनों से बराबर राशि ले सकता है। जो आखिरी पत्थर लेता है वह जीतता है। एक अधिक विस्तृत विवरण यहाँ है । संतुलन बनाए रखने के लिए एक खेल: एक तरफ, यह आवश्यक है कि ढेर में संख्या दूसरे पर, ताकि अंतर बहुत बड़ा न हो। शुरू करने के लिए, गेम में जीतने की रणनीति है, जिसकी उत्पत्ति हम विचार नहीं करेंगे। एक संक्षिप्त विवरण लें। ढेर के आकार के संयोजन होते हैं जिसमें खिलाड़ी जो अगले चाल को खो देगा।




स्क्वायर कोष्ठक पूरे भाग पर कब्जा करने का संकेत देते हैं। नहीं, पहला सूत्र फाइबोनैचि संख्या नहीं है, हालांकि गुणांक समान है, लेकिन यहां अंकगणितीय प्रगति है, और ज्यामितीय नहीं है। बस ध्यान दें कि जोड़ी की संख्या के बीच का अंतर n है।

पहले एक हब पर 64 लाइनों में टीसीएल पर रिवर्सी और 10 लाइनों में टीसीएल पर पंद्रह थे जिसमें एक कॉम्पैक्ट और सुंदर कोड था, यहां आपको ऐसा नहीं दिखेगा। इसके अलावा, वह शायद अच्छे शिष्टाचार से दूर है। सामान्य तौर पर, अगर कुछ आपको गोवनोकॉड जैसा लगता है, तो सबसे अधिक संभावना है। दूसरी ओर, यह और भी अच्छा है, क्योंकि भविष्य में इसमें कुछ सुधार होगा। आंशिक रूप से इस तथ्य के कारण कि भाषा मेरे लिए नई है, आंशिक रूप से स्पष्टीकरण बनाने के लिए इसे और अधिक सुविधाजनक बनाने के लिए। इसके अलावा गायब हैं वैकल्पिक जांच।
आगे कार्यक्रम के टुकड़े होंगे। यह इष्टतम से बहुत दूर है, लेकिन यह भाषा की विशेषताओं और कार्यों को दर्शाता है।

कार्यक्रम की शुरुआत है:

#!/usr/bin/tclsh #---  (+ ab)    #---  ,   , (a + b)     namespace path {::tcl::mathop ::tcl::mathfunc} #---   proc lsum L {expr [join $L +]+0} proc random range {expr int(rand()*$range)} 

जोड़े खोने के लिए कोड:

 set n_max 20 ;#  for {set i 1} {[<= $i $n_max]} {incr i} { set q [/ [+ [sqrt 5] 1 ] 2] ;# " " set a [int [* $q $i]] ;#i-  a set b [+ $a $i] ;#ie  b lappend lPair1 "$a $b" ;#   lPair1  a  b } 

आप सूची को इस तरह देख सकते हैं:

  puts lPair1; #    ;  ,  ,       

यहाँ उत्पादन है:
{० ०} {१ २} {३ ५} {४ 6} {६ १०} {} १३} {९ १५} {११ १}} {१२ २०} {१४ २३} {१६ २६} {१} २ {} {१ ९ 31} {21 34} {22 36} {24 39} {25 41} {27 44} {29 47} {30 49} {32 52}}

इसलिए, हमारे पास उन जोड़ियों की एक सूची है, जिनका उपयोग किसी व्यक्ति के पाठ्यक्रम पर प्रतिक्रिया देने के लिए किया जाना चाहिए; आपको यह सीखने की आवश्यकता है कि एक विशिष्ट जोड़ी कैसे चुनें। नए राज्य में जाने के लिए 3 विकल्प हैं:

• एक ढेर का परिवर्तन: 9 5 -> 4 5;
• एक और ढेर बदलना: 9 5 -> 9 2;
• दोनों को एक साथ बदलें: ९ ५ -> ६ २

चूंकि हमें केवल पत्थरों को लेना चाहिए, प्रत्येक कदम के साथ पत्थरों का योग घटता है।
कंप्यूटर चालन कमांड पर चलते हैं:

 #--- : #----st -  , #----lAns -             #----lPair -      , #--------------         proc turn {st lAns lPair} { set st_cur_sum [lsum $st] ;#   #---   ,    0    0, #---  ,      if {[== 0 $st_cur_sum]} {return {you win}} set a [lindex $st 0] ;#      set b [lindex $st 1] ;#      #---lindex -       , #---           set c [abs [- $a $b]] #--- ,     #---    ,     set a1 [min $a [lindex $lAns $b]] set b1 [min $b [lindex $lAns $a]] set cPair1 [lindex $lPair $c] #---      set a2 [random $a] set b2 [random $b] set c2 [random [+ 1 [min $a $b]]] set cPair2 [list [- $a $c2] [- $b $c2]] set st_next1 [list "$a $b1" [+ $a $b1]] set st_next2 [list "$a1 $b" [+ $a1 $b]] set st_next3 [list "$cPair1" [lsum $cPair1]] #---    set lst_next [list $st_next1 $st_next2 $st_next3] #---     set st_next [lindex [lsort -integer -index 1 $lst_next] 0] set st_next_sum [lindex $st_next 1] if {[== 0 $st_next_sum]} {return {i won}} ;#   -  ,   #--- ,     #---  ,    - , #--- :   ,      ,   #---   ,     if {[> $st_cur_sum $st_next_sum]} { return [lindex $st_next 0] } else { #---     -    switch [random 3] { 0 {return "$a $b2"} 1 {return "$a2 $b"} 2 {return "$cPair2"} } } } 

LAns और lPair क्या हैं, इसके बारे में थोड़ा विवरण। एक जीत वापसी कदम ऊपर तीन विकल्पों में से एक से मेल खाना चाहिए। इसके अलावा, पहले दो में ही क्या से अलग करने के लिए अलग है। पहले विकल्प पर विचार करें, हम पहले ढेर से लेते हैं, जिसका अर्थ है कि दूसरा ढेर नहीं बदलता है, और इसमें पत्थरों की संख्या से आप पहले के वांछित आकार को निर्धारित कर सकते हैं, अर्थात्। हम कितना नहीं लेते, लेकिन कितना छोड़ते हैं। LAns की सामग्री है:
0 2 1 5 7 3 10 4 13 15 6 18 20 8 23 9 26 28 11 31 31 12 34 36 14 39 41 ...
सूची में सूचकांक ढेर में पत्थरों की संख्या है, जो नहीं बदलता है, इस सूचकांक के लिए मूल्य हीप में पत्थरों की नई संख्या है, जिसमें से हम पत्थर लेंगे।
LPair की सामग्री उपरोक्त lPair1 की सामग्री से अलग नहीं है। इस मामले में सूचकांक मूल्य सूचकांक के बराबर अंतर के साथ पत्थरों की मात्रा की एक नई जोड़ी का प्रतिनिधित्व करता है।
और यहां हम उपयोगकर्ता के साथ बातचीत को व्यवस्थित करते हैं:

 puts {Enter heap sizes:} #--- ,     if {[< 0 [gets stdin state]]} { #---    set n_max [lindex [lsort -integer $state] end] #---    genAnsList $n_max lPair lAns #---   set state [turn $state $lAns $lPair] #   puts $state #---      while {[< 0 [gets stdin state]]} { set state [turn $state $lAns $lPair] puts $state } } 

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