TTT: ट्यूरिंग टेक्स्ट टेप

Question

परिचय

आह, INTERCAL ...
जितना मैं हर किसी को इसे ऑनलाइन करने के लिए प्रोत्साहित करना चाहूंगा , पाठ आउटपुट सिर्फ दर्दनाक है। डॉक्स के
अनुसार यह "ट्यूरिंग टेक्स्ट मॉडल" का उपयोग करता है। जबकि एक ... दिलचस्प अवधारणा, इसका उपयोग करने में पैर में अपने आप को गोली मारने जितना मज़ा है। और हम इस तरह एक कार्य के साथ क्या करते हैं? इसे स्वचालित करें।

ट्यूरिंग टेक्स्ट मॉडल

INTERCAL को पता है कि अक्षर केवल एक गोलाकार टेप पर मुद्रित होते हैं जिन्हें केवल सकारात्मक दिशा में स्थानांतरित किया जा सकता है। एक READ OUTबयान में टेप हेड मूवमेंट कमांड को पास करके प्रिंटिंग की जाती है । हर ASCII वर्ण उस टेप के अंदर लिखा होता है (बाहर उस पर इनपुट के लिए वर्ण हैं, दोह)। इससे वर्णों की बाइट्स का उल्टा टेप पर होता है। इसके अलावा टेप हेड चरित्र सूची के साथ पीछे की ओर बढ़ता है, क्योंकि इसकी स्थिति टेप के बाहर पर आधारित होती है।
सिर 0 की स्थिति में शुरू होता है।

अब जादू शुरू होता है। मैं आउटपुट प्राप्त करने के तरीके पर Truttle1 के स्पष्टीकरण का उपयोग करूँगा ।

1. आउटपुट लंबाई के साथ एक सरणी सेट करें।
2. सरणी में टेप सिर आंदोलन मूल्यों के साथ प्रविष्टियां भरें।
   1. बाइनरी में वर्तमान वर्ण का ASCII मान ज्ञात करें
   2. इसे उल्टा करें और वापस एक नंबर कन्वर्ट करें n।
   3. nयदि आवश्यक हो, तो वर्तमान हेड पोस्ट और मॉडुलो से 256 को घटाएंr
   4. r वह मूल्य है जिसे आपको सरणी में संग्रहीत करने की आवश्यकता है
   5. सिर अब स्थिति में है n।
3. DO READ OUT सरणी।

कृपया ध्यान दें

• ऐरे के साथ 0पहले इनिशियलाइज़ किया गया है , पहला इंडेक्स है1
• INTERCAL 8-बिट ASCII वर्णों का उपयोग करता है, इसलिए टेप की लंबाई 256 है।
• सभी लाइनों के 1 / 3rd और 1 / 5th के बीच शुरू करना होगा PLEASE। ध्यान दें कि उस स्थिति में आप के DOलिए ड्रॉप GIVE UPऔर READ OUT, लेकिन कुछ और के लिए नहीं, जैसा कि उदाहरणों में देखा गया है।

चुनौती

एक इनपुट स्ट्रिंग को देखते हुए, एक मान्य INTERCAL प्रोग्राम को आउटपुट करता है जो उस स्ट्रिंग और प्रिंट को प्रिंट करता है।

उदाहरण

प्रिंट "BUZZ"

DO ,1 <- #4
DO ,1 SUB #1 <- #190
DO ,1 SUB #2 <- #152
PLEASE DO ,1 SUB #3 <- #336
DO READ OUT ,1
PLEASE GIVE UP

व्हॉट्सएप वैकल्पिक है। निम्नलिखित प्रिंट "FIZZ"

DO,1<-#4DO,1SUB#1<-#158DO,1SUB#2<-#208DO,1SUB#3<-#312PLEASEREADOUT,1PLEASEGIVEUP

(वीडियो से Truttle1 के FizzBuzz कार्यक्रम से बेशर्मी से चुराए गए उदाहरण।)

आप यहां अजगर 3 में एक अनऑर्गलाइज्ड संदर्भ कार्यान्वयन पा सकते हैं

नियमों

• कोई मानक खामियां नहीं हैं
• यह कोड-गोल्फ है , सबसे छोटा कोड जीतता है।
• आप इनपुट> = 1, ASCII वर्णों की अपेक्षा कर सकते हैं।
• कार्यक्रम के अलावा ICL774I RANDOM COMPILER BUGऔर किसी भी त्रुटि नहीं फेंक सकते हैं ICL666I COMPILER HAS INDIGESTION। पहले एक यादृच्छिक पर होता है, दूसरा एक सी-इंटरकॉल मेमोरी से बाहर चल रहा है और इसे दरकिनार करना चुनौती का हिस्सा नहीं है

Answer 1

पायथन 3 , 157 बाइट्स

t=i=0
p=o='PLEASE'
for c in input():i+=1;k=int(f'{ord(c):08b}'[::-1],2);o+=i%4//3*p+f'DO,1SUB#{i}<-#{t-k&255}';t=k
print(f'DO,1<-#{i}{o}DOREADOUT,1DOGIVEUP')

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

यह प्रिंट करता है \ _$n+3\$निर्देश, जिनमें से \$\left\lfloor \frac{n+5}{4} \right\rfloor\$विनम्र हैं। यही कारण है कि अनुपात अभी मुश्किल में फिट बैठता है \$[1/5, 1/3]\$विनम्रता सभी के लिए अंतराल \$n \geq 1\$।

नील को धन्यवाद।

Answer 2

जावास्क्रिप्ट (Node.js) ,  156  148 बाइट्स

s=>`DO,1<-#${Buffer(s).map(c=>o+=`${i++&&~i&3?'':'PLEASE'}DO,1SUB#${i}<-#`+(p-(g=k=>p=k--&&c>>k&1|g(k)*2)(8)&255),i=p=o=""),i+o}DOREADOUT,1DOGIVEUP`

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

INTERCAL में आउटपुट आज़माएं!

कैसे?

थोड़ा उलटा

हम एक पुनरावर्ती समारोह का उपयोग चरित्र के टुकड़े को उल्टा करने के ग ।

( g = k =>       // k = bit position counter 
  k-- &&         // decrement k; if it was not 0:
    c >> k & 1   //   bring the k-th bit of c at position 0 and isolate it
    | g(k)       //   bitwise OR with a recursive call,
      * 2        //   whose result is doubled
)(8)             // initial call with k = 8

शील

के साथ शुरू i = 0, हम एक विनम्र बयान डालने जब भी निम्नलिखित अभिव्यक्ति falsy है:

i++ && ~i & 3

इसका मतलब है कि हम PLEASEपहले संसाधित चरित्र के लिए सम्मिलित करते हैं , और फिर प्रत्येक 4 अक्षर 3 से शुरू होते हैं।

न तो प्रमुख निर्देश और न ही दो अनुगामी निर्देश विनम्र हैं। उन्हें निम्न तालिका में क्रमशः Lऔर TTक्रमशः चिह्नित किया गया है।

 length | output structure   | politeness ratio
--------+--------------------+------------------
    1   | LPTT               |   1/ 4 = 0.250
    2   | LP-TT              |   1/ 5 = 0.200 <-- lower bound
    3   | LP-PTT             |   2/ 6 ≈ 0.333 <-- upper bound
    4   | LP-P-TT            |   2/ 7 ≈ 0.286
    5   | LP-P--TT           |   2/ 8 = 0.250
    6   | LP-P---TT          |   2/ 9 ≈ 0.222
    7   | LP-P---PTT         |   3/10 = 0.300
    8   | LP-P---P-TT        |   3/11 ≈ 0.273
    9   | LP-P---P--TT       |   3/12 = 0.250
   10   | LP-P---P---TT      |   3/13 ≈ 0.231
   11   | LP-P---P---PTT     |   4/14 ≈ 0.286
   12   | LP-P---P---P-TT    |   4/15 ≈ 0.267
   13   | LP-P---P---P--TT   |   4/16 = 0.250
   14   | LP-P---P---P---TT  |   4/17 ≈ 0.235
   15   | LP-P---P---P---PTT |   5/18 ≈ 0.278
   ..   | ...                |   1/5 < r < 1/3

Answer 3

05AB1E , 77 74 54 बाइट्स

Ç₁+₁šb퀨C¥(₁%€‘‚µ,1<-#1€·,1—¨#1<-#ÿ€·‚Ø€Ä,1‘J‘ÿ€·†¿€¾

-20 बाइट्स @ UnrelatedString के जेली उत्तर को पोर्ट करके , इसलिए उसे उभारना सुनिश्चित करें !!

पर रिक्त स्थान के साथ आउटपुट #1 DO,1 SUB#, DO READ OUT, और DO GIVE UP।

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

INTERCAL में आउटपुट का प्रयास करें।

स्पष्टीकरण:

Ç               # Convert the (implicit) input-string to a list of codepoint integers
 ₁+             # Add 256 to each value
   ₁š           # Prepend 256 at the front of the list
     b          # Convert each value to a binary string
      í         # Reverse each
       ۬       # Remove the last digit of each
         C      # Convert each from binary back to a base-10 integer
          ¥     # Take the forward differences (deltas) of this list
           (    # Negate each difference
            ₁%  # Take modulo-256 on each
€               # Map over each integer:
 ‘‚µ,1<-#1€·,1—¨#1<-#ÿ€·‚Ø€Ä,1‘
                #  Push dictionary string "PLEASE,1<-#1 DO,1 SUB#1<-#ÿ DO READ OUT",
                #  where the `ÿ` is automatically filled with the integer
   J            # Join this list of strings together
    ‘ÿ€·†¿€¾    # Push string "ÿ DO GIVE UP", where the `y` is filled with the string
                # (after which the result is output implicitly)

मेरा यह 05AB1E टिप देखें (अनुभाग कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों ‘‚µ,1<-#1€·,1—¨#1<-#ÿ€·‚Ø€Ä,1‘है "PLEASE,1<-#1 DO,1 SUB#1<-#ÿ DO READ OUT"और ‘ÿ€·†¿€¾है "ÿ DO GIVE UP"।

Answer 4

चारकोल , 90 89 85 बाइट्स

DO,1<-#ＩＬθ⊞υ⁰⭆θ⪫⟦×PLEASE⊖﹪κ³DO,1SUB#⊕κ<-#﹪⁻⊟υΣ⊞Ｏυ⍘⮌◧⍘℅ι !⁸ !²⁵⁶⟧ω”Z1∨？ＡE₂-πK↷Y:γüD0←✂

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

DO,1<-#ＩＬθ

आउटपुट की लंबाई निर्धारित करने के लिए निर्देश प्रिंट करें।

⊞υ⁰

स्थिति 0. पर सिर के साथ शुरू करें। मूल्य वास्तव में पूर्वनिर्धारित खाली सूची में संग्रहीत किया जाता है क्योंकि हम सूची का मूल्य बाद में पॉप और PushOperator फ़ंक्शन का उपयोग करके एक आदेश का सहारा लेने के बजाय संशोधित कर सकते हैं।

⭆θ⪫⟦...⟧ω

वर्णों पर लूप करें और प्रत्येक वर्ण के लिए 5 अभिव्यक्तियों के संयोजन को प्रिंट करें। (यह थोड़ा गोल्फर है क्योंकि सूची में स्वचालित रूप से दो संख्यात्मक मानों को नियंत्रित करता है)।

×PLEASE⊖﹪κ³

हर तीसरे चरित्र के प्रति विनम्र रहें। PLEASEअंत में भी है , ताकि विनम्रता अनुपात ¹⁄₅, the, a, ²⁄₇, the, the, the, ³⁄₁₁ ... जिसके बाद हो राजनीति का अनुपात ends की ओर जाता है।

DO,1SUB#⊕κ<-#

चरित्र को आउटपुट करने के लिए निर्देश की शुरुआत में 1-अनुक्रमित सूचकांक प्रिंट करें।

﹪⁻⊟υΣ⊞Ｏυ⍘⮌◧⍘℅ι !⁸ !²⁵⁶

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

”Z1∨？ＡE₂-πK↷Y:γüD0←✂

स्ट्रिंग और बाहर निकलने के लिए संपीड़ित अनुगामी निर्देशों को प्रिंट करें। स्ट्रिंग संपीड़न का मतलब है कि मुझे PLEASEकिसी भी आगे आउटपुट की संख्या के अनुकूलन के बारे में चिंता करने की ज़रूरत नहीं है ।

Answer 5

पायथन 3 , 128 बाइट्स

t=0
for c in input():n=int(f'{ord(c):08b}'[::-1],2);print(f'PLEASE,1<-#1DO,1SUB#1<-#{t-n&255}DOREADOUT,1');t=n
print('DOGIVEUP')

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

का उत्पादन समान आउटपुट मेरी जेली समाधान के लिए है, लेकिन बस के रूप में ज्यादा लिन पायथन समाधान के एक संशोधन है।

मूल रूप से पायथन 3.8 के "वालरस" ऑपरेटर का उपयोग किया गया था , लेकिन यह 2 बाइट्स से कम नहीं निकला।

Answer 6

जेली , 62 59 बाइट्स

OŻ+⁹BUṖ€Ḅ_Ɲ%⁹“!![ẓ,ȮFẈẋ⁹⁾V!ĖÐĊnß6ṛ»;;“Œ°þ[ṪȦṄ»Ʋ€;“©⁴Œ½OлŒu

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

अनुक्रमणिका को सहेजने के लिए बार-बार 1 और प्रिंट की एक सरणी लंबाई का उपयोग करता है, और एक बार-बार लंबाई को राजनीति तर्क पर सहेजने के लिए सेट करता है: लंबाई-तत्व-प्रिंट 3 की एक बहुत सुविधाजनक इकाई बनाता है।

स्ट्रिंग संपीड़न के बिना:

OŻ+⁹BUṖ€Ḅ_Ɲ%⁹“please,1<-#1do,1sub#1<-#”;;“doreadout,1”Ʋ€;“dogiveup”Œu

ऑनलाइन परिणाम का प्रयास करें!

O                                      Codepoints of input.
 Ż                                     Prepend zero,
  +⁹                                   add 256 to each,
    B                                  convert each to binary.
     U                                 Reverse each,
      Ṗ€                               remove last element from each,
        Ḅ                              convert from binary.                                
         _Ɲ                            Subtract all adjacent pairs,
           %⁹                          and modulo 256.
                         Ʋ€            Map:
                  ;                    prepend to the number
             “...»                     "please,1<-#1do,1sub#1<-#",
                   ;                   append to that
                    “...»              "doreadout,1".
                           ;“...»      Append "dogiveup" to the whole result
                                 Œu    and uppercase.