ट्यूरिंग मशीन सिम्युलेटर

Question

ट्यूरिंग मशीन सिम्युलेटर लिखें ।

सादगी के लिए हम स्टेटस को पूर्णांक, प्रतीकों को चार, रिक्त प्रतीक को व्हाट्सएप के बराबर मान सकते हैं

वर्तमान स्थिति, इनपुट प्रतीक, अगले राज्य, आउटपुट प्रतीक, दिशा (बाएं या दाएं) के रूप में 5-ट्यूपल आदेश अनिवार्य नहीं है, लेकिन निर्दिष्ट करें कि क्या आप इसे स्वैप करते हैं

जब कोई अज्ञात स्थिति तक पहुँच जाता है, तो मशीन को रोकना चाहिए, किसी अन्य पड़ाव की अनुमति नहीं है।

टेप दोनों दिशाओं में अनंत है और आप हमेशा एक खाली चरित्र पढ़ सकते हैं।

इनपुट: प्रारंभिक टेप, एक प्रारंभिक स्थिति और एक कार्यक्रम। आप उस प्रारूप में कहीं से भी डेटा पढ़ने के लिए स्वतंत्र हैं

आउटपुट: कार्यक्रम के निष्पादन के बाद टेप

आवश्यक: एक उदाहरण कार्यक्रम जो आपके सिम्युलेटर के शीर्ष पर चलता है

यह एक कोड-कॉल है इसलिए सबसे छोटी कोड जीत।

मैं अगले कुछ घंटों में एक कार्यान्वयन और कुछ उदाहरण कार्यक्रम पोस्ट करूंगा।

Comments

ट्यूरिंग कम्प्लीटनेस ऑफ़ पॉवरपॉइंट (SIGBOVIK) पर

— सर्गियोल

Answer 1

GolfScript, 92 अक्षर

~:m;n\+{:^.n?)>1<]m{2<1$=},.{~2>~^n/~1>[@\+]n*1$%n/~\1$1<+[\1>.!{;" "}*]n*\%@}{;;^0}if}do n-

गोल्फस्क्रिप्ट में ट्यूरिंग मशीन का इरादा बहुत लंबा हो गया। अभी भी टेप के विभिन्न अभ्यावेदन के साथ खेल रहे हैं।

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

उदाहरण ( ऑनलाइन भी उपलब्ध )

> 0
> '101'
> [[0 '0' 0 1 '0']
>  [0 '1' 0 1 '1']
>  [0 ' ' 1 -1 ' ']
>  [1 '0' 2 1 '1']
>  [1 '1' 3 -1 '0']
>  [3 '0' 2 1 '1']
>  [3 ' ' 2 1 '1']
>  [3 '1' 3 -1 '0']] 

110 

Comments

आपने मेरे सेर कार्यान्वयन को एक चार से हराया, यह देखने के लिए कि क्या मैं बेहतर कर सकता हूं

— ज्योफ रेमी

Answer 2

जीएनयू सीड के साथ -r- 133 117 111 93 चार्ट

हां, सेड पूरी तरह से ट्यूरिंग है। GNU sed और -r(विस्तारित regexps) केवल कुछ वर्णों को बचाने के लिए है, यह POSIX sed के साथ काम करने के लिए केवल एक छोटा सा परिवर्तन है।

:s
s/^(.*@)(.*)>(.)(.*#\1\3([^@]*@)(..))/\5\2\6>\4/
T
s/(..)l>|r>/>\1/
s/>@/@> /
s/>#/> #/
bs

इनपुट प्रारूप है

[initial state]@[non-empty tape with > marking head position]#[state]@[input symbol][next state]@[output symbol][direction l or r]#...

सीमांकक @, #और सिर चरित्र >टेप पर एक प्रतीक के रूप में इस्तेमाल नहीं किया जा सकता। स्टेट लेबल में @ >या नहीं हो सकता है #।

यह इनपुट, एक प्रति पंक्ति में सभी प्रोग्राम चलाएगा

उदाहरण:

मार्को का ^एन बी ^एन कार्यक्रम

इनपुट

0@>aaabbb#0@a1@ r#0@ 4@ r#1@a1@ar#1@b1@br#1@ 2@ l#2@b3@ l#2@a5@al#3@b3@bl#3@a3@al#3@ 0@ r#4@ 5@Tr

उत्पादन

5@    T>  #0@a1@ r#0@ 4@ r#1@a1@ar#1@b1@br#1@ 2@ l#2@b3@ l#2@a5@al#3@b3@bl#3@a3@al#3@ 0@ r#4@ 5@Tr

मार्को का नमस्कार! कार्यक्रम

इनपुट

0@> #0@ 1@Hr#1@ 2@er#2@ 3@lr#3@ 4@lr#4@ 5@or#5@ 6@!r

उत्पादन

6@Hello!> #0@ 1@Hr#1@ 2@er#2@ 3@lr#3@ 4@lr#4@ 5@or#5@ 6@!r

Answer 3

इसलिए मुझे थोड़ी देर हो गई है, लेकिन मैंने सोचा कि मैं इसे यहाँ छोड़ दूँगा ...

ट्यूरिंग मशीन एक ट्यूरिंग मशीन का अनुकरण: 370 बाइट्स?

यहां मैं उनके 1936 के पेपर में उपयोग की गई संरचना ट्यूरिंग का उपयोग कर रहा हूं । मैं m-configs और संचालन सहित एक प्रतीक = एक बाइट का उपयोग कर रहा हूं।

╔═══════════════╦═══════╦═══════════════════╦═══════════════╗
║    m-config    ║ Symbol ║     Operations      ║ Final m-config ║
╠═══════════════╬═══════╬═══════════════════╬═══════════════╣
║ currentCommand ║ Any    ║ L                   ║ currentCommand ║
║                ║ *      ║ MR                  ║ readCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ nextCommand    ║ Any    ║ L                   ║ nextCommand    ║
║                ║ *      ║ E  R  R  R  P* R    ║ readCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommand    ║ P      ║ R                   ║ readCommandP   ║
║                ║ M      ║ R                   ║ readCommandM   ║
║                ║ G      ║ R                   ║ readCommandG   ║
║                ║ E      ║ R                   ║ MHPNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommandP   ║ 0      ║                     ║ MHP0           ║
║                ║ 1      ║                     ║ MHP1           ║
║                ║ e      ║                     ║ MHPe           ║
║                ║ x      ║                     ║ MHPx           ║
║                ║ None   ║                     ║ MHPNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommandM   ║ R      ║                     ║ MHMR           ║
║                ║ L      ║                     ║ MHML           ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommandG   ║ 1      ║                     ║ G2<1           ║
║                ║ 2      ║                     ║ G2<2           ║
║                ║ 3      ║                     ║ G2<3           ║
║                ║ 4      ║                     ║ G2<4           ║
║                ║ 5      ║                     ║ G2<5           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<1           ║ int(1) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G21            ║
║                ║ *      ║ E  L                ║ G2<1           ║
║                ║ @      ║ E  L                ║ G2<1           ║
║                ║ Any    ║ L                   ║ G2<1           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<2           ║ int(2) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G22            ║
║                ║ *      ║ E  L                ║ G2<2           ║
║                ║ @      ║ E  L                ║ G2<2           ║
║                ║ Any    ║ L                   ║ G2<2           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<3           ║ int(3) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G23            ║
║                ║ *      ║ E  L                ║ G2<3           ║
║                ║ @      ║ E  L                ║ G2<3           ║
║                ║ Any    ║ L                   ║ G2<3           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<4           ║ int(4) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G24            ║
║                ║ *      ║ E  L                ║ G2<4           ║
║                ║ @      ║ E  L                ║ G2<4           ║
║                ║ Any    ║ L                   ║ G2<4           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<5           ║ int(5) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G25            ║
║                ║ *      ║ E  L                ║ G2<5           ║
║                ║ @      ║ E  L                ║ G2<5           ║
║                ║ Any    ║ L                   ║ G2<5           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G21            ║ int(1) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G21            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G22            ║ int(2) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G22            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G23            ║ int(3) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G23            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G24            ║ int(4) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G24            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G25            ║ int(5) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G25            ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTS            ║ ^      ║ R                   ║ TS             ║
║                ║ Any    ║ R                   ║ GTS            ║
╠----------------╬--------╬---------------------╬----------------╣
║ TS             ║ 0      ║                     ║ RL0            ║
║                ║ 1      ║                     ║ RL1            ║
║                ║ e      ║                     ║ RLe            ║
║                ║ x      ║                     ║ RLx            ║
║                ║ None   ║                     ║ RLNone         ║
╠----------------╬--------╬---------------------╬----------------╣
║ RL0            ║ @      ║ R  R                ║ GTS0           ║
║                ║ Any    ║ L                   ║ RL0            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RL1            ║ @      ║ R  R                ║ GTS1           ║
║                ║ Any    ║ L                   ║ RL1            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RLe            ║ @      ║ R  R                ║ GTSe           ║
║                ║ Any    ║ L                   ║ RLe            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RLx            ║ @      ║ R  R                ║ GTSx           ║
║                ║ Any    ║ L                   ║ RLx            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RLNone         ║ @      ║ R  R                ║ GTSNone        ║
║                ║ Any    ║ L                   ║ RLNone         ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTS0           ║ 0      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTS0           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTS1           ║ 1      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTS1           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTSe           ║ e      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTSe           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTSx           ║ x      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTSx           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTSNone        ║ _      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTSNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHP0           ║ ^      ║ R                   ║ Print0         ║
║                ║ Any    ║ R                   ║ MHP0           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHP1           ║ ^      ║ R                   ║ Print1         ║
║                ║ Any    ║ R                   ║ MHP1           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHPe           ║ ^      ║ R                   ║ Printe         ║
║                ║ Any    ║ R                   ║ MHPe           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHPx           ║ ^      ║ R                   ║ Printx         ║
║                ║ Any    ║ R                   ║ MHPx           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHPNone        ║ ^      ║ R                   ║ PrintNone      ║
║                ║ Any    ║ R                   ║ MHPNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHMR           ║ ^      ║ R  R                ║ MHR            ║
║                ║ Any    ║ R                   ║ MHMR           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHML           ║ ^      ║ L                   ║ MHL            ║
║                ║ Any    ║ R                   ║ MHML           ║
╠----------------╬--------╬---------------------╬----------------╣
║ Print0         ║ ^      ║ R                   ║ Print0         ║
║                ║ None   ║ P0                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Print0         ║
╠----------------╬--------╬---------------------╬----------------╣
║ Print1         ║ ^      ║ R                   ║ Print1         ║
║                ║ None   ║ P1                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Print1         ║
╠----------------╬--------╬---------------------╬----------------╣
║ Printx         ║ ^      ║ R                   ║ Printx         ║
║                ║ None   ║ Px                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Printx         ║
╠----------------╬--------╬---------------------╬----------------╣
║ Printe         ║ ^      ║ R                   ║ Printe         ║
║                ║ None   ║ Pe                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Printe         ║
╠----------------╬--------╬---------------------╬----------------╣
║ PrintNone      ║ ^      ║ R                   ║ PrintNone      ║
║                ║ None   ║                     ║ nextCommand    ║
║                ║ Any    ║ E                   ║ PrintNone      ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHL            ║ ^      ║ R  R                ║ MHL            ║
║                ║ [      ║                     ║ SBL            ║
║                ║ Any    ║ L  P^ R  R  E       ║ nextCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHR            ║ ^      ║ R  R                ║ MHR            ║
║                ║ ]      ║                     ║ SBR            ║
║                ║ None   ║ P^ L  L  E          ║ nextCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ SBR            ║ ]      ║ E  R  R  P]         ║ currentCommand ║
╠----------------╬--------╬---------------------╬----------------╣
║ SBL            ║ ]      ║ R                   ║ SBLE           ║
║                ║ Any    ║ R                   ║ SBL            ║
╠----------------╬--------╬---------------------╬----------------╣
║ SBLE           ║ [      ║                     ║ currentCommand ║
║                ║ None   ║ L                   ║ SBLE           ║
║                ║ Any    ║ E  R  R  P] L       ║ SBLE           ║
╚═══════════════╩═══════╩═══════════════════╩═══════════════╝

मेरी मशीन के लिए ऊपर दिए गए ट्यूरिंग के उदाहरणों में से एक है:

['<', None, 1, '0', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      '1', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      'e', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      'x', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      '_', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',

             None, 2, '1', None, 'M', 'R', None, 'P', 'x', None, 'M', 'L', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      '0', None, 'G', '3',

             None, 3, '0', None, 'M', 'R', None, 'M', 'R', None, 'G', '3',
                      '1', None, 'M', 'R', None, 'M', 'R', None, 'G', '3',
                      '_', None, 'P', '1', None, 'M', 'L', None, 'G', '4',

             None, 4, 'x', None, 'E', 'E', None, 'M', 'R', None, 'G', '3',
                      'e', None, 'M', 'R', None, 'G', '5',
                      '_', None, 'M', 'L', None, 'M', 'L', None, 'G', '4',

             None, 5, '0', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      '1', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      'e', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      'x', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      '_', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
        None, '[', '^', None, ']', None]

इसे ऑनलाइन आज़माएं! (एक व्याख्याकार के रूप में पायथन 3 का उपयोग करता है) - संपादित करें: मैंने अभी TIO की जांच की है, और यह वास्तव में सही काम नहीं करता है ... इसे अपने स्थानीय मशीन पर आज़माएं और इसे (उम्मीद) काम करना चाहिए। यह खान पर करता है।

Comments

कोई नुकसान नहीं, बस मेज पर सीमाओं को संरेखित करना।

— ग्रेग बेकन

@GregBacon कोई अपराध नहीं हुआ ... शायद कुछ अंतर है कि अलग-अलग कंप्यूटर कैसे कोडब्लॉक को प्रस्तुत करते हैं, लेकिन आपके संपादन ने मेरे संपादन स्क्रीन पर संरेखण को बहुत बदतर बना दिया ... मुझे यकीन है कि जब आपने संपादन का सुझाव दिया था तो यह ठीक लग रहा था; यकीन नहीं कि समस्या क्या है

— bendl

Answer 4

एपीएल (110)

(यह इतना छोटा भी नहीं है ...)

0(''⍞){×⍴X←0~⍨⍺∘{x y S T s m t←⍺,⍵⋄S T≡x,⊃⊃⌽y:s,⊂(⊃y){m:(¯1↓⍺)(⍵,⍨¯1↑⍺)⋄(⍺,⊃⍵)(1↓⍵)}t,1↓⊃⌽y⋄0}¨⍵:⍵∇⍨⊃X⋄,/⊃⌽⍺}⎕

यह कीबोर्ड से दो लाइनें पढ़ता है: पहला प्रोग्राम है और दूसरा प्रारंभिक टेप है।

प्रारूप है

(in-state in-tape out-state movement out-tape) 

और वे सभी एक ही पंक्ति में होने चाहिए। 'मूवमेंट' दाएं मूव करने के लिए 1 और बाएं मूव करने के लिए 1 है।

उदाहरण कार्यक्रम (स्पष्टता के लिए डाली गई रेखाएं, वे सभी एक पंक्ति में होनी चाहिए।)

(0 ' ' 1 0 '1')
(0 '1' 0 0 '1')
(1 '1' 1 0 '1')
(1 ' ' 2 1 ' ')
(2 '1' 3 1 ' ')

उदाहरण के लिए, कार्यक्रम दो संयुक्त संख्याओं को एक साथ जोड़ता है:

in:  1111 111
out: 1111111

उदाहरण 2 (मार्को मार्टिनली की प्रविष्टि से द्विआधारी वेतन वृद्धि कार्यक्रम से अनुकूलित):

(0 '0' 0 0 '0')
(0 '1' 0 0 '1')
(0 ' ' 1 1 ' ')
(1 '0' 2 0 '1')
(1 '1' 3 1 '0')
(3 '0' 2 0 '1')
(3 ' ' 2 0 '1')
(3 '1' 3 1 '0')

Comments

मैं इसे कैसे आज़मा सकता हूँ? मैं लिनक्स का उपयोग कर रहा हूँ और अधिशेष के साथ प्रयास किया गया है, लेकिन यह काम नहीं करता है (अपरिभाषित टोकन :()। मुझे कौन से दुभाषिया / संकलक की कोशिश करनी चाहिए?

— मार्को मार्टिनली

मैं Dyalog APL का उपयोग कर रहा हूं। मैं किसी भी Dyalog- विशिष्ट कार्यों का उपयोग करने के बारे में नहीं जानता लेकिन A + पूरी तरह से एक ही चीज नहीं है। Dyalog का एक निःशुल्क संस्करण है, लेकिन यह केवल Windows के लिए है। (यह शराब के तहत चल सकता है, लेकिन यह अपने स्वयं के इनपुट विधि का उपयोग करता है ताकि आप एपीएल टाइप कर सकें।) यदि आपको डायलाग चल रहा है, तो एपीएल कोड दर्ज करें / पेस्ट करें (एक पंक्ति पर), फिर ट्यूरिंग मशीन प्रोग्राम (दूसरी पंक्ति पर) ), फिर प्रारंभिक टेप (तीसरी पंक्ति पर)।

— मारीनस

ठीक है, मैं कोशिश करूंगा कि, धन्यवाद

— मार्को मार्टिनली

Answer 5

पायथन, 101 189 152 142

a=dict(zip(range(len(b)),b))
r=eval(p)
i=s=0
while 1:
 c=a.get(i,' ')
 s,m,a[i]=r[s,c]
 if 0==m:exit([x[1]for x in sorted(a.items())])
 i=i+m

बी और पी इनपुट हैं, बी प्रारंभिक टेप है, पी नियमों को (स्ट्रिंग का प्रतिनिधित्व) के रूप में एक (इन-स्टेट, इन-टेप) से टपल करता है (आउट-स्टेट, हेड मूव, आउट-टेप) टपल। । यदि चाल 0 है कार्यक्रम समाप्त हो गया है, 1 दाईं ओर है और -1 बाईं ओर है।

b="aaba"

p="""{(0, 'a'): (1, 1, 'a'),
      (0, 'b'): (0, 1, 'b'),
      (1, 'a'): (1, 1, 'a'),
      (1, 'b'): (0, 1, 'b'),
      (1, ' '): (1, 0, 'Y'),
      (0, ' '): (0, 0, 'N')}"""

यह सैंपल प्रोग्राम टेस्ट करता है कि क्या स्ट्रिंग का आखिरी अक्षर (खाली टेप से पहले) 'ए' है, अगर ऐसा है तो यह स्ट्रिंग के अंत में 'वाई' लिखता है (पहला खाली स्थान)।

1 संपादित करें:

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

2 संपादित करें:

सुधार के एक महान सौदे के लिए Strigoides के लिए धन्यवाद।

3 संपादित करें:

मैंने अनावश्यक रूप से इसे बनाया था इसलिए 0 आउटपुट के रूप में इस जगह को छोड़ देगा। मैंने इसे हटा दिया क्योंकि हम आउटपुट को इनपुट के समान लिख सकते हैं।

Comments

मुझे नहीं लगता कि यह एक वैध समाधान है क्योंकि आपके कार्यान्वयन में टेप सीमित है। इस तरह से आपको अपने प्रोग्राम की मेमोरी खपत को पहले से जानना होगा। और समस्याएँ बाएं चल रही हैं। संकेत: एक टेप दो संशोधित ढेर से बनाया जा सकता है जो आप हमेशा एक खाली प्रतीक पॉप कर सकते हैं।

— मार्को मार्टिनेली

आह, सच। क्षमा करें, यह बहुत दूर नहीं लगता था।

— शायना

उम्म .. अफिक टेप दोनों दिशाओं में अनंत है और आप हमेशा एक खाली चरित्र पढ़ सकते हैं। मैं जवाब में यह निर्दिष्ट करूंगा।

— मार्को मार्टिनेली

आप सही थे (हमारे अभ्यासों में अधिक कठोर नियम थे)। मैंने कम से कम कुछ खामियों को ठीक किया।

— शियोना

आप पहली पंक्ति में स्थान को हटा सकते हैं, r=0;s=0बन सकते हैं r=s=0(और उस पंक्ति के अंत में अर्धविराम अनावश्यक है), आप फ़ंक्शन को हटा सकते हैं w, जैसा कि अप्रयुक्त है, कोष्ठक में हटाया जा सकता है (s,m,t)=r[s,c], try/ exceptब्लॉक को छोटा किया जा सकता है तानाशाही का उपयोग कर; c=a.get(i,' '), चूंकि mया तो 0 या 1 है, आप उपयोग कर सकते हैं if m-1:, और आप अपनी map()कॉल को एक सूची समझ में परिवर्तित करके छोटा कर सकते हैं ।

— स्ट्राइगोइड्स

Answer 6

परिशिष्ट भाग (205) (156) (150) (135)

<<
>>begin
/${stopped}def([){add dup{load}${exit}if}def
0 A{1 index{load}${pop( )}if
get{exec}${exit}if}loop
3{-1[pop}loop{1[print}loop

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

सभी राज्य नामों को निष्पादन योग्य बनाकर अतिरिक्त बचत, इसलिए वे ऑटो- लोड करते हैं।

एम्बेडेड "हैलो" कार्यक्रम के साथ अनगुल्ड। एक अतिरिक्त 52 चार्ट स्टड से टेप को पढ़ने के लिए एक लूप खरीदते हैं।के साथ चला gsnd -q tm.ps।

%!
<<
    /A<<( ){dup(H)def 1 add B}>>
    /B<<( ){dup(e)def 1 add C}>>
    /C<<( ){dup(l)def 1 add D}>>
    /D<<( ){dup(l)def 1 add E}>>
    /E<<( ){dup(o)def 1 add F}>>
>>begin %ds: int-keys=tape name-keys=prog
0 A %pos state
{ %loop
    1 index{load}stopped{pop( )}if  %pos state tape(pos)
    get    {exec}stopped{exit  }if  %new-pos new-state
} loop
% Loop from tape position 0 to left until left tape end is found
0{                                  %pos
  -1 add                            %new-pos
  dup{load}stopped{exit}if          %new-pos tape(new-pos)
  pop                               %new-pos tape(new-pos)
}loop
% Move to the right and print all chars until right end is hit
{                                   %pos
  1 add                             %new-pos
  dup{load}stopped{exit}if          %new-pos tape(new-pos)
  print                             %new-pos tape(new-pos)
}loop

तो टेबल-प्रारूप है

/in-state<<in-tape{dup out-tape def movement add out-state}
           in-tape2{dup out-tape2 def movement2 add out-state2}>>

जहां in-stateएक नाम है, in-tapeऔर out-tapeवर्ण (अर्थात। पूर्णांकों, या भाव जो उपज पूर्णांक), कर रहे हैं movementहै -1छोड़ के लिए या 1सही के लिए, और out-stateएक है निष्पादन योग्य नाम। एक in-tapeही राज्य के लिए एकाधिक संक्रमण को ऊपर के रूप में जोड़ा जाना चाहिए।

Comments

एक और समस्या यह है कि टेप का कौन सा हिस्सा दिलचस्प है इसकी खोज के लिए कोई प्रावधान नहीं है। यह एक बहुत कुछ करने की लागत है currentdict{search-for-min-and-max}forall juggle-params-for-for। :(

— लूसर डॉग

मेरी खुद की कोशिश की, लेकिन आपकी समझ से परे था। लेकिन मैंने आपके कोड में कुछ सुधार सुझाए हैं।

— थॉमस डब्ल्यू।

BTW, शुरुआती टेप के बारे में क्या? मैंने गैर-गोल्फ कोड से टिप्पणी की गई पंक्ति को हटा दिया क्योंकि यह काम नहीं करता था। ("0" रिटर्न -1 नहीं, इसलिए लूप का कोई पुनरावृत्ति नहीं)

— थॉमस डब्ल्यू।

उत्कृष्ट सुधार! ... शुरुआती टेप कोड के बारे में, मुझे लगता है कि मैंने इसे अपनी नोटबुक से गलत समझा। एस.बी. 0 1 0 not{(%stdin)(r)file read not{exit}if def}for। मुझे यकीन नहीं है कि मैंने क्यों सोचा कि मैं गोल्फ संस्करण से चूकने के साथ दूर हो सकता हूं। : पी

— लूसर ड्रॉ

ओह, रुको, -1! तो 0 notहोना चाहिए 16#7fffffff। माफ़ करना। अहा! इसलिए यह टिप्पणी की गई थी! यह सीधे नोटबुक से बाहर आया, परीक्षण नहीं किया गया, और जब मैंने इसे देखा तो मैंने सभी टिप्पणियों को बिना देखे ही ट्रिम कर दिया। अजगर आदमी को मत बताना! : पी

— लूजर ने

Answer 7

सी (अभी तक गोल्फ नहीं)

मुझे लगता है कि मैं इससे नहीं जीत सकता, फिर भी काम करने में मजा आ रहा था। यह अब और भी सच है कि यह वास्तव में काम करता है । :)

सिवाय इसके कि यह केवल एक दिशा में अनंत है। मुझे लगता है कि यह भी एक नकारात्मक टेप की जरूरत है। आह ....

नकारात्मक इतना बुरा नहीं था। हम evens और बाधाओं के रूप में दो पक्षों interleave। जटिलता को अब टेप को अनुक्रमिक क्रम में प्रदर्शित करने की आवश्यकता है , क्योंकि फाइल अब खुद ही जंबल है। मुझे लगता है कि यह एक वैध परिवर्तन है। ट्यूरिंग ने खुद को इस तरह सरल बनाया।

#include<stdio.h>
int main(int c, char**v){
    int min=0,max=0;
    int pos=0,qi;sscanf(v[1],"%d",&qi);
    FILE*tab=fopen(v[2],"r");
    FILE*tape=fopen(v[3],"r+");
    setbuf(tape,NULL);
    do {
        min = pos<min? pos: min;
        max = pos>max? pos: max;
        fseek(tape,(long)(abs(pos)*2)-(pos<0),SEEK_SET);
        int c = fgetc(tape), qt=qi-1,qr;
        fseek(tape,(long)(abs(pos)*2)-(pos<0),SEEK_SET);
        char x = c==EOF?' ':c, xt=x-1,xr,d[2];
        if (x == '\n') x = ' ';
printf("%d '%c' %d (%d)\n", qi, x, pos, (int)ftell(tape));
        while((qt!=qi)||(xt!=x)){
            fscanf(tab, "%d '%c' %d '%c' %1[LRN]", &qt, &xt, &qr, &xr, d);
            if (feof(tab)){
                goto HALT;
            }
printf("%d '%c' %d '%c' %s\n", qt, xt, qr, xr, d);
        }
        qi=qr;
        rewind(tab);
        fputc(xr,tape);
        pos+=*d=='L'?-1:*d=='R'?1:0;
    } while(1);
HALT:
printf("[%d .. %d]:\n", min, max);
    for (pos = min; pos <= max; pos++){
        fseek(tape,(long)(abs(pos)*2)-(pos<0),SEEK_SET);
        //printf("%d ",pos);
        putchar(fgetc(tape));
        //puts("");
    }
    return qi;
}

और यहाँ परीक्षण-रन है:

522(1)04:33 AM:~ 0> cat bab.tm
0 'a' 0 'b' R
0 'b' 0 'a' R
523(1)04:33 AM:~ 0> echo aaaaa > blank; make tm ; tm 0 bab.tm blank; echo; cat blank
make: `tm' is up to date.
0 'a' 0 (0)
0 'a' 0 'b' R
0 'a' 1 (2)
0 'a' 0 'b' R
0 'a' 2 (4)
0 'a' 0 'b' R
0 ' ' 3 (6)
0 'a' 0 'b' R
0 'b' 0 'a' R
[0 .. 3]:
bbbÿ
babab

कार्यक्रम टेप को अनुक्रमिक क्रम में आउटपुट करता है, लेकिन फ़ाइल नकारात्मक और सकारात्मक पक्षों का प्रतिनिधित्व करती है।

Comments

आपके कार्यान्वयन में समस्याएं हैं। इस प्रोग्राम को आज़माएं जो कि 0 'a' 0 'b' R; 0 'b' 0 'a' Rइनपुट एएए के साथ a और b स्वैप करता है आउटपुट bbb के बजाय बाबा है। और समस्याएँ बाएं चल रही हैं।

— मार्को मार्टिनेली

ध्यान देने के लिए धन्यवाद! अपडेट दोनों को ठीक करता है, मुझे लगता है (आशा)।

— लूसर

उह .. अभी भी बाबा हो रहे हैं

— मार्को मार्टिनेली

हाँ, लेकिन इस बार यह सही है! 'आआ' टेप पर स्थित [0, -1,1] से मेल खाती है। लेकिन आउटपुट जो इसे स्पष्ट रूप से दिखाना चाहिए उसे काम करने की आवश्यकता है।

— लूजर ने

Answer 8

ग्रूवी 234 228 154 153 149 139 124

n=[:];i=0;t={it.each{n[i++]=it};i=0};e={p,s->a=p[s,n[i]?:' '];if(a){n[i]=a[1];i+=a[2];e(p,a[0])}else n.sort()*.value.join()}

पठनीयता के लिए प्रारूपित

n=[:];
i=0;
t={it.each{n[i++]=it};i=0};
e={p,s->
    a=p[s,n[i]?:' '];
    if(a){
        n[i]=a[1];
        i+=a[2];
        e(p,a[0])
    }else n.sort()*.value.join()
}

t वह कार्य है जो टेप e को सेट करता है वह फ़ंक्शन है जो प्रोग्राम का मूल्यांकन करता है

उदाहरण 1 - प्रिंट "हैलो!" टेप पर :)

t('')
e([[0,' ']:[1,'H',1],
   [1,' ']:[2,'e',1],
   [2,' ']:[3,'l',1],
   [3,' ']:[4,'l',1],
   [4,' ']:[5,'o',1],
   [5,' ']:[6,'!',1]],0)

उदाहरण 2 - टेप पर एक टी छोड़ दें यदि प्रारंभिक स्ट्रिंग एक ⁿ b ^{n के रूप में है} , तो अन्यथा रोकें।

t('aaabbb')
e([[0,'a']:[1,' ',1],
   [0,' ']:[4,' ',1],
   [1,'a']:[1,'a',1],
   [1,'b']:[1,'b',1],
   [1,' ']:[2,' ',-1],
   [2,'b']:[3,' ',-1],
   [2,'a']:[5,'a',-1],
   [3,'b']:[3,'b',-1],
   [3,'a']:[3,'a',-1],
   [3,' ']:[0,' ',1],
   [4,' ']:[5,'T',1]],0)

उदाहरण 3 - एक बाइनरी नंबर की वृद्धि

t('101')
e([[0,'0']:[0,'0',1],
   [0,'1']:[0,'1',1],
   [0,' ']:[1,' ',-1],
   [1,'0']:[2,'1',1],
   [1,'1']:[3,'0',-1],
   [3,'0']:[2,'1',1],
   [3,' ']:[2,'1',1],
   [3,'1']:[3,'0',-1]],0)

उदाहरणों में 1 का मतलब दाईं ओर और -1 का मतलब बाईं ओर है