TTT: Turing Text Tape

Question

บทนำ

อ่า INTERCAL ...
เท่าที่ฉันอยากแนะนำให้ทุกคนลองใช้งานออนไลน์การส่งข้อความออกมานั้นเจ็บปวดมาก
ตามเอกสารจะใช้ "Turing Text Model" ในขณะที่แนวคิดที่น่าสนใจการใช้มันเป็นเรื่องสนุกพอ ๆ กับการถ่ายภาพตัวเองด้วยเท้า แล้วเราจะทำอย่างไรกับงานเช่นนี้? ทำให้เป็นอัตโนมัติ

แบบจำลองข้อความทัวริง

อักขระ INTERCAL รู้จะพิมพ์บนเทปวงกลมที่สามารถเคลื่อนย้ายไปในทิศทางบวกเท่านั้น การพิมพ์ทำได้โดยส่งคำสั่งการเคลื่อนหัวเทปในอาร์เรย์ไปยังREAD OUTคำสั่ง อักขระ ASCII ทุกตัวถูกเขียนไว้ที่ด้านในของเทปนั้น (ด้านนอกมีอักขระสำหรับอินพุตอยู่) ส่งผลให้ไบต์ของอักขระอยู่บนเทปในทางกลับกัน นอกจากนี้หัวเทปยังเคลื่อนไปข้างหลังตามรายการอักขระเนื่องจากการวางตำแหน่งจะขึ้นอยู่กับด้านนอกของเทป
หัวเริ่มต้นที่ตำแหน่ง 0

ตอนนี้เวทมนตร์เริ่มต้นขึ้น ผมจะใช้คำอธิบาย Truttle1 เกี่ยวกับวิธีการที่จะบรรลุผล

1. ตั้งค่าอาร์เรย์ที่มีความยาวเอาต์พุต
2. เติมรายการในอาร์เรย์ด้วยค่าการเคลื่อนที่ของหัวเทป
   1. ค้นหาค่า ASCII ของอักขระปัจจุบันในไบนารี
   2. nย้อนกลับมันและแปลงกลับเป็นจำนวนมาก
   3. ลบnออกจากตำแหน่งส่วนหัวปัจจุบันและโมดูโลด้วย 256 หากจำเป็นทำให้ได้ค่าr
   4. r คือค่าที่คุณต้องจัดเก็บในอาร์เรย์
   5. nหัวอยู่ในขณะนี้ในตำแหน่ง
3. DO READ OUT อาร์เรย์

โปรดทราบ

• Array ถูกกำหนดค่าเริ่มต้นล่วงหน้าด้วย0ดัชนีแรกคือ1
• INTERCAL ใช้อักขระ ASCII แบบขยาย 8 บิตดังนั้นความยาวเทป 256
• ระหว่างวันที่ 1/3 และ 1 / วันที่ 5 PLEASEของทุกสายต้องเริ่มต้นด้วย โปรดทราบว่าในกรณีนี้คุณจะวางDOfor 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

(ตัวอย่างที่ขโมยมาจากโปรแกรม FizzBuzz ของ Truttle1 จากวิดีโออย่างไร้ยางอาย)

คุณสามารถค้นหาการใช้งานอ้างอิงที่ไม่ได้รับการแก้ไขใน python 3 ได้ที่นี่

กฎ

• ไม่มีช่องโหว่มาตรฐาน
• นี่คือcode-golfรหัสที่สั้นที่สุดชนะ
• คุณสามารถคาดหวังอินพุต> = 1 อักขระ ASCII เท่านั้น
• โปรแกรมอาจไม่โยนความผิดพลาดใด ๆ นอกเหนือจากและICL774I RANDOM COMPILER BUG ICL666I COMPILER HAS INDIGESTIONสิ่งแรกเกิดขึ้นแบบสุ่มอย่างที่สองคือ C-Intercal มีหน่วยความจำไม่เพียงพอและการหลีกเลี่ยงซึ่งไม่ได้เป็นส่วนหนึ่งของความท้าทาย

Answer 1

Python 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\$.

-1 ไบต์ขอบคุณนีล

Answer 2

JavaScript (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เราแทรกข้อความที่สุภาพเมื่อใดก็ตามที่นิพจน์ต่อไปนี้เป็นเท็จ:

i++ && ~i & 3

ซึ่งหมายความว่าเราแทรก a 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 ไบต์โดยการพอร์ตคำตอบ Jelly ของ @ 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 ค่าจะถูกเก็บไว้ในรายการว่างที่กำหนดไว้ล่วงหน้าเนื่องจากเราสามารถแก้ไขค่าของรายการได้ในภายหลังโดยใช้ฟังก์ชัน Pop และ PushOperator แทนที่จะต้องใช้คำสั่ง

⭆θ⪫⟦...⟧ω

วนซ้ำอักขระและพิมพ์การเรียงต่อกันของ 5 นิพจน์สำหรับแต่ละอักขระ (นี่เป็นเรื่องที่น่าสนใจกว่าเล็กน้อยเนื่องจากการเรียงต่อกันจะกำหนดค่าตัวเลขสองค่าในรายการโดยอัตโนมัติ)

×PLEASE⊖﹪κ³

สุภาพทุกตัวละครที่สาม นอกจากนี้ยังมีPLEASEต่อท้ายด้วยเพื่อให้อัตราส่วนความสุภาพคือ ¹⁄₄, ¹⁄₅, ²⁄₆, ²⁄₇, ²⁄₈, ³⁄₉, ³⁄₁₀, ³⁄₁₁ ... หลังจากนั้น อัตราส่วนความสุภาพมีแนวโน้มที่จะเป็น ¹⁄₃

DO,1SUB#⊕κ<-#

พิมพ์ดัชนี 1 ดัชนีที่จุดเริ่มต้นของคำสั่งเพื่อส่งออกอักขระ

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

คำนวณไบนารีที่กลับรายการของอักขระปัจจุบันส่งออกความแตกต่างจากส่วนหัวและอัปเดตส่วนหัวด้วยไบนารีที่กลับด้านใหม่ทั้งหมดในนิพจน์เดียว ไบนารีถูกเข้ารหัสโดยใช้ช่องว่างเพื่อ0ให้สามารถปรับเป็น 8 บิตได้อย่างง่ายดายรวมทั้งการใช้สตริงจะหลีกเลี่ยงตัวคั่นที่ไม่จำเป็น

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

พิมพ์คำแนะนำต่อท้ายที่บีบอัดเพื่อส่งออกสตริงและออก การบีบอัดสตริงหมายความว่าฉันไม่ต้องกังวลเกี่ยวกับการเพิ่มประสิทธิภาพจำนวนครั้งที่ฉันส่งออกPLEASEอีกต่อไป

Answer 5

Python 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')

ลองออนไลน์!

สร้างผลลัพธ์ที่คล้ายกันกับโซลูชัน Jelly ของฉัน แต่เป็นการปรับเปลี่ยนโซลูชัน Python ของ Lynn มากพอ ๆ กัน

เดิมใช้โอเปอเรเตอร์ "walrus" ของ Python 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.