งาน

อ่านในสตรีมข้อความหรือไฟล์ที่ไม่มีที่สิ้นสุดที่เป็นไปhelloได้ส่งออกเนื้อหาจนกว่าคำนั้นจะได้รับการส่งออกปฏิบัติตามกฎต่อไปนี้

• เมื่อhelloออกแล้วรหัสของคุณควรจะออกทันที ไม่ควรรอขึ้นบรรทัดใหม่

• รหัสของคุณควรออกตามที่ไป นั่นคือไม่ควรอ่านในอินพุตจำนวนมากจากนั้นเริ่มเอาต์พุต

• หากกระแส / ไฟล์ไม่มีhelloรหัสของคุณควรดำเนินการในการส่งออกการป้อนข้อมูลตลอดไปหรือจนกว่าจะถึงจุดสิ้นสุดของกระแส / ไฟล์

• นี่คือความท้าทายที่มีความสำคัญกรณีจึงไม่เท่ากับhelloHello

• คุณอาจสันนิษฐานว่าการป้อนข้อมูลประกอบด้วยอักขระ ASCII ที่พิมพ์ได้และการขึ้นบรรทัดใหม่เท่านั้น

• โค้ดของคุณไม่สามารถคาดหวังได้ว่าข้อความจะถูกยกเลิกโดยการขึ้นบรรทัดใหม่หรือว่าจะมีการขึ้นบรรทัดใหม่ใด ๆ ในอินพุต นอกจากนี้คุณไม่สามารถสันนิษฐานได้ว่ามันจะทำงานบนเครื่องที่มีหน่วยความจำไม่ จำกัด

• คุณอาจคิดว่ารหัสของคุณจะถูกเรียกจากไดเรกทอรีว่าง

ตัวอย่างอินพุตสตรีม

I once had a horse called hellopina.

เอาท์พุต

I once had a horse called hello

ปลาย

เรียกใช้yes | tr -d \\n | <your program>เพื่อตรวจสอบว่าใช้ได้กับสตรีมที่ไม่มีที่สิ้นสุดหรือไม่ หากไม่ได้พิมพ์อะไรและ / หรือหน่วยความจำรั่วโปรแกรมไม่สอดคล้องกับข้อมูลจำเพาะ ควรพิมพ์yyyyyyyyyyyyyyyyyyyyyy...ตลอดไปโดยไม่มีบรรทัดใหม่

เยลลี่ 24 ไบต์

“Ṣẉ»ẇ⁸Ṇȧ®
ṫ-3;ƈ©Ȯ¤µ⁺Ç¿ṛ“

ลองออนไลน์!

คำอธิบาย:

ṫ-3;ƈ©Ȯ¤µ⁺Ç¿ṛ“ Main link. Arguments: 0
ṫ-3            Truncate the list to its 4 last elements.
   ;ƈ©Ȯ¤       Store a character from STDIN in the register, print it, and append it to the list (list is initially [0]).
        µ      Start a new monadic chain, everything to the left is a link.
          Ç    Execute the helper link with the existing list as its argument.
         ⁺ ¿   Do-while loop, left link is body, right link is condition.
            ṛ“ When the loop ends, replace the return value with [] (invisible on output).

“Ṣẉ»ẇ⁸Ṇȧ® Helper link. Arguments: string
“Ṣẉ»ẉ⁸Ṇ   Check if "hello" isn't in the string.
        ® Return the character we stored in the register.
       ȧ  Check if both of the above are truthy.

C (gcc) , 81 80 76 75 72 71 70 69 ไบต์

main(n,c){while(~(c=getchar())&n-0xb33def<<7)n=n<<5^putchar(c)/96*c;}

ลองออนไลน์!

มันทำงานอย่างไร

นี่เป็นโปรแกรมเต็ม เรากำหนดฟังก์ชันfเพื่อจุดประสงค์ของเรา หากต้องการบันทึกไบต์จะประกาศกับสองโต้แย้งว่าเริ่มต้นint นี่คือพฤติกรรมที่ไม่ได้กำหนด แต่ในทางปฏิบัติnจะเริ่มต้นเป็น1เมื่อรันโปรแกรมโดยไม่มีอาร์กิวเมนต์เพิ่มเติมcจะเก็บ 32 บิตที่ต่ำกว่าของตัวชี้ไปยังเวกเตอร์อาร์กิวเมนต์

ในขณะที่สภาพ

~(c=getchar())&n-0xb33def<<7

ถือเราจะดำเนินการในขณะที่ร่างกายของห่วง:

n=n<<5^putchar(c)/96*c

เพื่อให้เข้าใจสภาพอย่างสมบูรณ์เราต้องตรวจร่างกายก่อน สำหรับตอนนี้ทั้งหมดที่เราสังเกตก็คือว่าc=getchar()อ่าน byte เดียวจาก STDIN (ถ้าเป็นไปได้) และเก็บไว้ในตัวแปรค

ลำดับไบต์สวัสดีมีลักษณะดังต่อไปนี้ในการเป็นตัวแทนที่แตกต่างกัน

char     decimal     binary (8 bits)
'h'      104         0 1 1 0 1 0 0 0
'e'      101         0 1 1 0 0 1 0 1
'l'      108         0 1 1 0 1 1 0 0
'l'      108         0 1 1 0 1 1 0 0
'o'      111         0 1 1 0 1 1 1 1

สิ่งเหล่านี้ทั้งหมดอยู่ในช่วง[96, 192)ดังนั้นc/96จะประเมินเป็น1สำหรับแต่ละไบต์เหล่านี้และเป็น0สำหรับอักขระ ASCII ที่เหลือทั้งหมด วิธีนี้putchar(c)/96*c( putcharพิมพ์และส่งกลับอาร์กิวเมนต์) จะประเมินเป็นcถ้าcคือ`ตัวอักษรตัวเล็กตัวใดตัวหนึ่ง{|}~หรืออักขระ DEL; สำหรับอักขระ ASCII อื่น ๆ ทั้งหมดก็จะประเมิน0

nถูกอัพเดตโดยเลื่อนไปทางซ้ายห้าบิตจากนั้น XORing ผลลัพธ์ด้วยผลลัพธ์จากย่อหน้าก่อนหน้า เนื่องจากintมีความกว้าง 32 บิต (หรือเราคาดเดาในคำตอบนี้) บิตที่เลื่อนบางส่วนอาจ "หลุดไปทางซ้าย" (ล้นจำนวนเต็มที่ลงนามคือพฤติกรรมที่ไม่ได้กำหนด แต่ gcc จะทำงานตามคำสั่ง x64 ที่สร้างขึ้นที่นี่) เริ่มต้นด้วยค่าที่ไม่รู้จักเป็นnหลังจากอัปเดตสำหรับอักขระทั้งหมดของhelloเราจะได้ผลลัพธ์ดังนี้

 n  ?????????????????????????|???????
'h'                          |    01101000
'e'                          |         01100101
'l'                          |              01101100
'l'                          |                   01101100
'o'                          |                        01101111
-----------------------------+--------------------------------
    <------ discarded ------>|???????0101100110011110111101111

โปรดทราบว่า 25 บิตที่ต่ำกว่าจะเป็นจำนวนเต็ม0xb33defซึ่งเป็นค่าคงที่เวทย์มนตร์ในสภาพ ในขณะที่มีการทับซ้อนกันระหว่างบิตของสองไบต์ที่อยู่ติดกันการทำแผนที่ไบต์ด้านล่าง96ถึง0ทำให้แน่ใจว่าไม่มีผลบวกปลอมใด ๆ

เงื่อนไขประกอบด้วยสองส่วน:

• ~(getchar()) ใช้ bitwise ไม่ใช่ผลจากการอ่าน (หรือพยายามอ่าน) byte จาก STDIN

  ถ้าgetcharประสบความสำเร็จก็จะกลับค่าของไบต์อ่านเป็นint เนื่องจากอินพุตประกอบด้วยอักขระ ASCII ทั้งหมดไบต์การอ่านจึงสามารถมีการตั้งค่าได้ต่ำกว่า 7 บิตดังนั้นบิตมินิระดับบิตจะมี 25 บิตสูงสุดที่ตั้งไว้ในกรณีนี้

  ถ้าgetcharล้มเหลว (ไม่มีอินพุต) มันจะกลับมา -1และค่าที่เหมาะสมไม่ได้จะเป็น0

• n-0xb33def<<7ลบค่าคงที่เวทย์จากก่อนหน้าจากnจากนั้นเลื่อนผลลัพธ์ 7 หน่วยไปทางซ้าย

  หากการอ่าน 5 ไบต์สุดท้ายเป็นสวัสดี 25 บิตต่ำสุดของnจะเท่ากับ 0xb33defและการลบจะทำให้เป็นศูนย์ การเปลี่ยนความแตกต่างจะให้0เป็นบิตสูงสุด 7 จะ "หลุดซ้าย"

  ในทางตรงกันข้ามถ้า 5 ไบต์สุดท้ายที่อ่านไม่ได้ เป็นสวัสดีหนึ่งใน 25 บิตต่ำสุดของความแตกต่างจะถูกตั้งค่า; หลังจากขยับหนึ่งใน 25 บิตสูงสุดจะเป็น

ในที่สุดถ้าgetcharประสบความสำเร็จและเรายังไม่ได้พิมพ์hello , bitwise และทั้งหมด 25 บิตสูงสุดของตัวถูกดำเนินการด้านซ้ายและอย่างน้อยหนึ่งใน 25 บิตสูงสุดของขวาหนึ่งจะถูกตั้งค่า วิธีนี้&จะให้ผลเป็นจำนวนเต็มไม่ใช่ศูนย์และวนซ้ำต่อไป

ในทางกลับกันถ้าอินพุตหมดหรือเราพิมพ์helloแล้วหนึ่งในตัวถูกดำเนินการบิตและ AND จะเป็นศูนย์และผลลัพธ์จะเป็นเช่นนั้น ในกรณีนี้เราแยกออกจากลูปและโปรแกรมจะยุติ

Bash, 74 75 103 99 88 82 76 ไบต์

-10 ไบต์ขอบคุณ @DigitalTrauma!
-11 ไบต์ขอบคุณ @manatwork!
-6 ไบต์ขอบคุณ @Dennis!

IFS=
b=ppcg
while [ ${b/hello} ];do
read -rN1 a
b=${b: -4}$a
echo -n $a
done

คำอธิบาย:

IFS=    # making sure we can read whitespace properly
b=ppcg  # set the variable b to some arbitrary 4 letter string

while [ ${b/hello} ]; do  # while the variable b doesn't contain "hello", do the following
    read -rN1 a           # get input
    b=${b: -4}$a          # set b to its last 4 chars + the inputted char
    echo -n $a            # output the inputted char
done

ลองออนไลน์!

เขาวงกต , 43 41 ไบต์

ขอบคุณ Sp3000 สำหรับการบันทึก 2 ไบต์

<_%-742302873844_::%*:*:420#+.:%):,*652_>

ลองออนไลน์!

คำอธิบาย

แนวคิดพื้นฐานคือการเข้ารหัสอักขระห้าตัวสุดท้ายในฐาน 256 ในจำนวนเต็มเดียว เมื่อตัวละครใหม่เข้ามาเราสามารถ "ผนวก" มันโดยการคูณจำนวนเต็ม 256 และเพิ่มจุดรหัสใหม่ ถ้าเราต้องการดูเฉพาะอักขระ 5 ตัวสุดท้ายเรารับค่าโมดูโล 256 ⁵ = 2 ⁴⁰ = 1099511627776 จากนั้นเราสามารถตรวจสอบได้ว่าค่านี้เท่ากับ 448378203247 ซึ่งเป็นสิ่งที่เราได้รับเมื่อเราปฏิบัติกับจุดโค้ดของhelloเป็นฐาน 256 หลัก

สำหรับรหัส ... <...>เป็นบิตของเขาวงกตสำนวน มันช่วยให้คุณเขียนลูปไม่สิ้นสุดโดยไม่มีโฟลว์ควบคุมแบบมีเงื่อนไขใด ๆ บนบรรทัดเดียวประหยัดจำนวนไบต์บนช่องว่างและ linefeeds เงื่อนไขหลักสำหรับการทำงานนี้คือมีสองค่าทิ้งที่ด้านบนของสแต็กเมื่อเราไปถึง<(โดยปกติเราใช้0 s สำหรับที่ แต่ค่าที่แท้จริงคือโดยพลการ)

แน่นอนว่าโปรแกรมจำเป็นต้องมีเงื่อนไขบางอย่างที่จะต้องพิจารณาว่าเมื่อใดที่จะยุติ แต่การสิ้นสุดโปรแกรมโดยมีเงื่อนไขสามารถทำได้โดยการหารด้วยค่าซึ่งเป็นศูนย์เมื่อเราต้องการให้โปรแกรมสิ้นสุด <...>ก่อสร้างทำงานโดยการเลื่อนทั้งแถวไปทางซ้าย (เป็นวงกลม) เมื่อ IP อยู่ที่ปลายด้านซ้ายจากนั้นเลื่อนกลับไปที่ตำแหน่งเดิมทันที ซึ่งหมายความว่ารหัสจะถูกดำเนินการจากขวาไปซ้ายจริง ๆ ลองย้อนกลับ:

_256*,:)%:.+#024:*:*%::_448378203247-%_

นี่คือการวนซ้ำหนึ่งครั้งของลูปที่อ่านตัวอักษรยุติหากเราถึง EOF พิมพ์ตัวอักษรเพิ่มเข้าไปในการเข้ารหัสของเราตัดให้เหลือ 5 ตัวอักษรเพื่อตรวจสอบความเท่าเทียมกันhelloและการทำซ้ำ นี่คือวิธีการทำงานในรายละเอียด (โปรดจำไว้ว่าเขาวงกตนั้นเป็นแบบกองซ้อน):

_256*            Multiply the encoding by 256 in preparation for the next iteration.
,                Read one byte from STDIN.
:)%              Duplicate, increment, modulo. If we hit EOF, then , returns
                 -1, so incrementing and modulo terminates the program due to
                 the attempted division by zero. However, if we did read a
                 character, we've just compute n % (n+1), which is always n itself.
:.               Print a copy of the character we just read.
+                Add it to our encoding (we'll make sure to multiply the
                 encoding by 256 at the end of the iteration, so there's room
                 for our new character).
#024             Push 1024, using the stack depth to push the initial 1.
:*:*             Square it twice. That gives 2^40.
%                Take the encoding modulo 2^40 to truncate it to the last 5
                 characters.
::               Make two copies of the encoding.
_448378203247    Push the value that corresponds to "hello".
-                Subtract it from the encoding, giving zero iff the last 5
                 characters were "hello".
%                Take the other copy of the encoding modulo this value, again
                 terminating if we've reached "hello".
                 The actual value of this modulo - if it didn't terminate the
                 the program - is junk, but we don't really care, we just need
                 any disposable value here for the <...>
_                We push a zero as the second disposable value.

Brainfuck, 658 ไบต์

+[>,.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<,.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<,.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<,.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<,.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++[-<->]+<[>-<[-]]>[-<<->>]]]]]<<]

มากกว่า 500 ไบต์อยู่ในค่าคงที่ซึ่งฉันต้องตีกอล์ฟสักหน่อย

มันเป็นเครื่องจักรของรัฐดังนั้นอินพุตที่ไม่มีที่สิ้นสุดจึงไม่เป็นปัญหา

นี่เป็นรุ่นที่แสดงความคิดเห็นเล็กน้อย

+
[
  >,.
  >h
  [-<->]
  +<
  [
    >-<[-][in input spot, not h]
  ]
  >
  [
    -
    <
    [in input spot, h has been read]
    ,.
    >e
    [-<->]
    +<
    [
      >-<[-][in input spot, not e]
    ]
    >
    [
      -
      <
      [in input spot, e has been read]
      ,.
      >l
      [-<->]
      +<
      [
        >-<[-][in input spot, not l]
      ]
      >
      [
        -
        <
        [in input spot, l has been read]
        ,.
        >l
        [-<->]
        +<
        [
          >-<[-][in input spot, not l]
        ]
        >
        [
          -
          <
          [in input spot, l has been read]
          ,.
          >o
          [-<->]
          +<
          [
            >-<[-][in input spot, not o]
          ]
          >
          [
            -
            <
            [in input spot, o has been read]
            <->>
          ]
        ]
      ]
    ]
  ]
  <<
]

Bash , 73 68 66 ไบต์

IFS=
[[ $1 != olleh ]]&&read -rN1 c&&echo -n $c&&exec $0 $c${1::4}

ถือว่าไดเรกทอรีที่ไม่มีไฟล์ที่ซ่อนอยู่เท่านั้น <path/to/script>จะต้องทำงานเป็น

ลองออนไลน์!

มันทำงานอย่างไร (ล้าสมัย)

ที่จุดเริ่มต้นของwhile loop เราจะทดสอบก่อนว่าสตริงในตัวแปรs (เริ่มแรกว่างเปล่า) เท่ากับolleh ( hello backwards, olé) ​​และส่งกลับ0 (คู่) หรือ1 (ไม่ใช่คู่ที่ตรงกัน) ตามลำดับ ในขณะที่ส่วนหนึ่งอย่างเป็นทางการของเงื่อนไขของลูปผลจะไม่ส่งผลกระทบต่อมันด้วยตัวเองเป็นเพียงคำสั่งสุดท้ายก่อนที่จะdoกำหนดว่าเงื่อนไขถือ

ต่อไปเราจะตั้งตัวคั่นข้อมูลภายในเพื่อสตริงว่าง (ดังนั้นreadจะไม่สำลักช่องว่าง) อ่านไบต์ดิบ ( -r) จาก STDIN cและเก็บไว้ใน $?คือรหัสทางออกของคำสั่งก่อนหน้าดังนั้นจึงอ่านหนึ่ง-N1ไบต์( ) อย่างแน่นอนสำหรับการจับคู่ที่ไม่ตรงกันและศูนย์ไบต์ ( -N0) การอ่านค่าศูนย์ไบต์ไม่ว่าจะเกิดจากการกดปุ่ม EOF หรือเนื่องจาก-N0ถูกระบุreadจะทำให้ออกด้วยรหัสสถานะ1ดังนั้นขณะที่ลูปจะสิ้นสุด มิฉะนั้นร่างกายจะถูกประหารชีวิตและเราเริ่มต้นใหม่

ในร่างกายเราพิมพ์ครั้งแรกไบต์ที่เราอ่านแล้วปรับปรุงss=$c${s::4}ด้วย สิ่งนี้จะเป็นการเตรียมไบต์การอ่านถึง (สูงสุด) สี่ไบต์แรกในsดังนั้นsจะเท่ากับollehเมื่อสวัสดีถูกพิมพ์

brainfuck, 117 ไบต์

--->>>------>>>+>>>+>>>++++<,[.-----<-[>--<-----]<[<<<]>>>[<[<<<+>>>>->+<<-]>[>>
+>]<[+[-<<<]]>>[<+>-]>>]<[[-]<<<,<]>]

จัดรูปแบบ:

--->>>------>>>+>>>+>>>++++
<,
[
  .-----<-[>--<-----]<[<<<]
  >>>
  [
    <[<<<+>>> >->+<<-]
    >[>>+>]
    <[+[-<<<]]
    >>[<+>-]
    >>
  ]
  <[[-]<<<,<]
  >
]

ลองมันออนไลน์

เริ่มต้นเทปด้วยอักขระในhelloออฟเซ็ตโดย107เว้นระยะหนึ่งค่าทุกสามเซลล์จากนั้นติดตามอักขระห้าตัวสุดท้ายที่เห็นและตรวจสอบการจับคู่กับอักขระใหม่ทุกตัวที่ประมวลผลโดยใช้แฟล็กทางด้านขวาของสตริงเพื่อ ติดตามว่ามีการแข่งขันหรือไม่

Ruby , 46 60 ไบต์

a="";loop{q=$<.getc;~p if a[-5..-1]=="hello"||!q;a+=q;$><<q}

ลองออนไลน์!

อ่านอักขระจาก stdin จนถึง 5 ตัวสุดท้ายhelloจากนั้นส่งออกสตริง (หรือจนกว่าจะไม่มีตัวอักษรเหลืออยู่ใน stdin) สิ้นสุดด้วยข้อผิดพลาด

เทียบเท่ากับ:

a = ""
loop {
    q = $<.getc
    ~p if a[-5..-1] == "hello" || !q
    a += q
    $><< q
}

หรือเลวร้ายยิ่งกว่า:

a = ""
loop do
    q = STDIN.getc
    break if a[-5..-1] == "hello" or not q
    a += q
    print q
end

Python 3, 120 116 104 Bytes

ทำงานร่วมกับลำธารที่ไม่มีที่สิ้นสุดเล่นกอล์ฟเป็นครั้งแรกและมีเคล็ดลับใด ๆ

import sys
a=1
c=''
while(a):
    a=sys.stdin.read(1)
    if a:print(end=a)
    c=(c+a)[-5:]
    if c=='hello':break

ขอบคุณ @DJMcMayhem สำหรับการบันทึกบางไบต์ :)

Haskell, 41 47 43 ไบต์

f l|w@"hello"<-take 5l=w|a:b<-l=a:f b|1<2=l

ความเกียจคร้านของ Haskell จะจัดการกับอินพุต / เอาต์พุตที่ไม่สิ้นสุด

ลองออนไลน์!

แก้ไข: ไม่ได้จัดการกับอินพุต จำกัด - แก้ไขแล้ว ขอบคุณ @Leo สำหรับการชี้ให้เห็น

แก้ไข II: @ Ørjan Johansen บันทึกแล้ว 4 ไบต์ ขอบคุณ!

Cubix, 94 83 82 79 63 56 ไบต์

p>q'-?w.uh'e@U7.'hqi?oqB-!ul.-..$WWu_q<o'\;>....6t?.../!@

ขยาย:

        p > q '
        - ? w .
        u h ' e
        @ U 7 .
' h q i ? o q B - ! u l . - . .
$ W W u _ q < o ' \ ; > . . . .
6 t ? . . . / ! @ . . . . . . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

หมายเหตุ

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

ลองออนไลน์

คุณสามารถลองโปรแกรมที่นี่

คำอธิบาย

ความคิดทั่วไป

แนวคิดทั่วไปคือเราต้องการอ่านตัวอักษรจากนั้นตรวจสอบกับตัวละครที่แตกต่างกัน (ก่อนhแล้วeจึงlเป็นต้น) เพื่อติดตามตัวละครที่เราพลาดไปเราเก็บไว้ที่ด้านล่างสุดของสแต็ก เมื่อเราต้องการเราสามารถนำมันขึ้นไปด้านบนอีกครั้งได้อย่างง่ายดาย

อ่าน / เขียนลูป

ห่วงอ่านเขียนเป็นเพียง 5 ^THบรรทัด อักขระทั้งหมดที่ไม่ได้ใช้จะถูกแทนที่ด้วย no-ops ( .):

        . . . .
        . . . .
        . . . .
        @ . . .
' h q i ? o q B - ! u l . - . .
. . . . _ . . . . . . . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

สามารถแบ่งออกเป็นสองส่วนคือการอ่านและ (การเขียนและการตรวจสอบ) ส่วนแรกประกอบด้วยคำแนะนำถึงและรวมถึงเครื่องหมายคำถาม ส่วนที่สองคือส่วนที่เหลือของบรรทัด เนื่องจากสิ่งนี้วนรอบเราถือว่าเราเริ่มต้นด้วยสแต็กของ[...]

    @
'hqi?
    _

Explanation
'h          Push the character code of the h
            Stack: [..., 104]
  q         Send it to the bottom
            Stack: [104, ...]
   i        Read one character of the input (-1 for EOF)
            Stack: [104, ..., input]
    ?       Start of condition:
              if (input < 0):
    @           execute '@', ending the program
              if (input = 0):
                continue going right
              if (input > 0):
    _           turn to the right, reflect back ('_') and
                turn right again, effectively not changing 
                the direction at all

ส่วนที่สอง (การเขียนและตรวจสอบ) เป็นเส้นตรงอีกครั้ง [next-char, ..., input]สแต็คเริ่มเป็น เราแยกตัวอักษรตัวต่อไปเพราะการเปลี่ยนแปลงในโปรแกรม

oqB-!ul.-  Explanation
o          Output the character at the top of the stack
 q         Send the input to the bottom of the stack
           Stack: [input, next-char, ...]
  B        Reverse the stack
           Stack: [..., next-char, input]
   -       Push the difference of the top two characters, which
           is 0 if both are equal, something else otherwise
           Stack: [..., next-char, input, diff]
    !      if (diff = 0):
     u       make a u-turn to the right
           else:
      l.     execute two no-ops
        -    push [input - next-char - input], which is disregarded
             later, so it effectively is a no-op as well.

ตอนนี้ IP จะเริ่มต้นอีกครั้งที่จุดเริ่มต้นของวงนี้, hการตั้งค่าตัวอักษรถัดไปตรวจสอบเพื่อ

จับคู่ตัวละครถัดไป

หาก IP ทำการเลี้ยวกลับ (เช่นตัวอักษรที่เราอ่านและพิมพ์ตรงกับตัวละครตัวต่อไป'hello') เราต้องตรวจสอบว่าตัวอักษรที่ป้อนเข้านั้นขึ้นอยู่กับว่าตัวอักษรตัวต่อไปที่ด้านล่างของสแต็ค หลังจากนั้นเราต้องกลับไปที่ลูปการอ่าน / เขียนโดยไม่ต้องกดhไปที่สแต็กดังนั้นเราจึงต้องการวิธีอื่นในการไปที่นั่น

สิ่งแรกสิ่งแรก: พิจารณาว่าอักขระที่ป้อนเข้านั้นคืออะไร [..., prev-char, input, 0]สแต็คมีลักษณะเช่นนี้

        . . . .
        - ? . .
        u h ' e
        . . . .
. . . . . . . . . ! u . . . . .
. . . . . . . . . \ ; . . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

เพื่อเปรียบเทียบอินพุตเราใช้โค้ดอักขระhอีกครั้ง ในขั้นต้นนี่เป็นเพราะฉันไม่รู้จริง ๆ ว่าฉันจะจัดการกับเรื่องนี้อย่างไรและhเป็นตัวละครตัวแรกในสตริงที่จะตรวจสอบ แต่มันก็จบลงด้วยความสะดวก ถ้าเราลบรหัสอักขระของชั่วโมงจากการป้อนข้อมูลที่เราได้รับ-3ถ้าใส่เป็นe, 0ถ้าใส่เป็นh, 4ถ้าใส่เป็นlและถ้าใส่เป็น7o

สิ่งนี้มีประโยชน์เพราะ?คำสั่งให้เราแยกค่าลบจากค่าบวกและศูนย์ได้อย่างง่ายดาย เช่นถ้าเปลี่ยน IP ซ้ายแตกต่างเป็นลบดังนั้นการป้อนข้อมูลที่เป็นดังนั้นตัวอักษรถัดไปควรจะเป็นe lหากยังคง IP จะตรงความแตกต่างก็คือ0เพื่อให้การป้อนข้อมูลที่เป็นดังนั้นตัวอักษรถัดไปควรจะเป็นh eหากการป้อนข้อมูลเป็นlหรือ an oIP เลี้ยวขวา

คำแนะนำทั้งหมดดำเนินการก่อนเครื่องหมายคำถามข้างต้นคือ:

;!e'h-     Explanation
;          Delete the top of the stack
           Stack: [..., prev-char, input]
 !         if (input = 0):
  e          execute 'e' (no-op)
   'h      Push the character code of h
           Stack: [..., prev-char, input, 104]
     -     Push the difference of the input and 104
           Stack: [..., prev-char, input, 104, diff]

ตอนนี้ IP เปลี่ยนทิศทางตามรายละเอียดด้านบน เรามาดูความเป็นไปได้ที่แตกต่างกัน

อินพุต 'e'

ก่อนอื่นเราจะพิจารณาอินพุตeซึ่งทำให้ IP เลื่อนขึ้นจาก?เนื่องจากความแตกต่างคือ 3 อักขระที่ไม่เกี่ยวข้องทั้งหมดถูกลบออกจากคิวบ์

        . > q '
        . ? . .
        . . . .
        . . . .
. . q . . . . . . . . l . . . .
$ W W . . . . . . . . > . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

อักขระจะถูกดำเนินการตามลำดับนี้ (ไม่รวมอักขระการควบคุมโฟลว์บางตัว):

q'l$WWq
q           Save the difference (-3) to the bottom of the stack so
            we can tell whether the l on the bottom of the stack is
            the first or the second l in hello
            Stack: [-3, ...]
 'l         Push the character code of l to the stack
            Stack: [-3, ..., 108]
   $W       no-op
     W      Sidestep into the loop
      q     Send the character code to the bottom
            Stack: [108, -3, ...]

ตอนนี้ IP มาถึงลูปการอ่าน / เขียนอีกครั้ง

อินพุต 'h'

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

        . . . .
        . ? w .
        . . ' e
        . . . .
. . . . . . . . . ! . . . . . .
. . . u _ q < . . \ . . . . . .
. . ? & & & / . . & . . . . . .
. . & . . . . . . & . . . . . .
        . . . .
        & & & &
        . . . .
        . . . .

คำแนะนำดำเนินการคือ:

'e!\?q_
'e          Push the character code of the e
            Stack: [..., 101]
  !         if (101 = 0):
   \          reflect away (effectively a no-op)
    ?       if (101 > 0):
              turn right (always happens)
     q      Move 101 to the bottom of the stack
            Stack: [101, ...]
      _     No-op

และตอนนี้เรากำลังเข้าสู่ลูปการอ่าน / เขียนอีกครั้งดังนั้นเราเสร็จแล้ว

อินพุตอื่น ๆ

อินพุตอื่นทั้งหมดส่งผลให้เกิดความแตกต่างในเชิงบวกดังนั้น IP จะเลี้ยวขวาที่เครื่องหมายคำถาม เรายังต้องแยกlและoเพื่อให้เป็นสิ่งที่เราจะทำต่อไป

การแยก'l'และ'o'

เก็บไว้ในใจที่แตกต่างกันคือ 7 oและ 4 สำหรับและที่เราต้องจบโปรแกรมถ้าใส่เป็นl oนี่คือคิวบ์อีกครั้งด้วยชิ้นส่วนที่ไม่เกี่ยวข้องถูกแทนที่ด้วย a .และไอพีโอพีข้ามถูกแทนที่ด้วยเครื่องหมายแอมเปอร์แซนด์

        . . q .
        . ? w .
        . h ' .
        . U 7 .
. . . . . . . . . . . . . - . .
. . . . . . . . . . . . . & . .
. . . . . . / ! @ . . . . & . .
. . . . . . & . . . . . . & . .
        . . & .
        . . & .
        . . & .
        . . & .

h7'wq-!@    
h           no-op
 7          Push 7 to the stack
            Stack: [..., diff, 7]
  'wq       Push w to the stack and send it to
            the bottom. We don't care about it,
            so it's now part of the ellipsis.
            Stack: [..., diff, 7]
     -!     if (diff = 7):
       @        End the program

ฉลาดระหว่างสอง'l's

ดังนั้นตอนนี้เราจึงรู้ว่าอินพุตเป็นlแต่เราไม่รู้ว่าตัวlไหน ถ้ามันเป็นอันแรกเราต้องดันอีกอันlไปที่ด้านล่างของสแต็ก แต่ถ้ามันเป็นอันที่สองเราต้องกดoอัน จำได้ไหมว่าเราบันทึกไว้-3ที่ด้านล่างของสแต็กก่อนที่เราจะผลักครั้งแรกl? เราสามารถใช้มันเพื่อแยกสองสาขา

        . . . .
        . . . .
        . . . .
        . . . .
. . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
6 t ? . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . . 
        . . . .
        . . . .

สแต็กเริ่มต้นเป็น [..., -3 or 140, ...]

Explanation
6t?         
6t          Take the 6th item from the top and move
            it to the top (which is either -3 or 140)
  ?         If that's positive, turn right, otherwise,
            turn left

เป็นครั้งแรก 'l'

หากนี่เป็นครั้งแรก'l'เราจำเป็นต้องผลักดันอีก'l'ครั้ง 'l'หากต้องการบันทึกไบต์เราจะใช้ตัวอักษรเดียวกันเป็นครั้งแรก [...]เราสามารถลดความซับซ้อนของสแต็คที่จะ นี่คือส่วนที่เกี่ยวข้องของคิวบ์โดยไม่ต้องแทนที่ด้วยเครื่องหมายแอมเปอร์แซนด์

        p > q '
        . . . .
        . . . .
        . . . .
' . q . . . . . . . . l . . . .
$ W W . . . . . . . . > & & & &
. . ? . . . . . . . . . . . . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

ดำเนินการตามคำแนะนำต่อไปนี้:

$'pq'lq
$'          no-op
  pq        no-op
    'l      Push the character code of l
            Stack: [..., 108]
      q     Send it to the bottom
            Stack: [108, ...]

เรากำลังจะเข้าสู่ลูปการอ่าน / เขียนดังนั้นเราจึงดำเนินการกับสาขานี้

ที่สอง 'l'

หากการป้อนข้อมูลเป็นครั้งที่สอง'l'ใน'hello'IP จะเลี้ยวขวาที่เครื่องหมายคำถาม อีกครั้งเราสามารถทำให้สแต็คไปถึงได้ง่ายขึ้น[...]และ IP เริ่มต้น?โดยชี้ไปทางทิศใต้ในเวลานี้

        . . . .
        . . . .
        . . . .
        . . . .
. . . . . . . . . . . . . . . .
. . . u _ q < o ' \ . . . . . .
. . ? . . . . . . & . . . . . .
. . & . . . . . . & . . . . . .
        . . . .
        & & & &
        . . . .
        . . . .

คำแนะนำดำเนินการคือ:

'oq_
'o          Push the character code of 'o'
            Stack: [..., 111]
  q         Move the top item to the bottom
            Stack: [111, ...]
   _        No-op

และ IP กำลังจะเข้าสู่ลูปการอ่าน / เขียนอีกครั้งดังนั้นเราจึงทำกับสาขานี้เช่นกัน

C ++, 142 141 ไบต์

#import<iostream>
void f(std::istream&i){i>>std::noskipws;char c;for(std::string s="     ";s!="hello"&&i>>c;)s.erase(0,1),s+=c,std::cout<<c;}

ลองออนไลน์!

โหนด 124 ไบต์

with(process)with(stdin)on('data',d=>[...d].map(c=>(s=(stdout.write(c),s+c).slice(-5))=='hello'&&exit()),setEncoding(),s='')

ไม่ได้สมมติว่าสตรีมจะพอดีกับหน่วยความจำที่มีอยู่

C #, 134 ไบต์

using C=System.Console;class P{static void Main(){var s="";for(int c;(c=C.Read())>=0&!s.Contains("olleh");C.Write(s[0]))s=(char)c+s;}}

ลองใช้ออนไลน์

อ่านตัวอักษรตรวจสอบว่าไม่ใช่ -1 (EOS) และเรายังไม่เห็นคำว่า "สวัสดี" จากนั้นใส่อักขระนั้นลงในสตริงและเขียนอักขระออกมา เราเพิ่มเพราะs[0]สั้นกว่า(char)sมาก นี่มีค่ากำลังสองในความยาวของสตริงเนื่องจากต้องจัดสรรและสแกนอินพุตทั้งหมดในแต่ละครั้งที่อ่านอักขระ (ซึ่งจะล้มเหลวหลังจากอินพุต 2GB เนื่องจากข้อ จำกัด ใน CLR อนุญาตหรือไม่)

using C=System.Console;

class P
{
    static void Main()
    {
        var s="";
        for(int c;(c=C.Read())>=0&!s.Contains("olleh");C.Write(s[0]))
            s=(char)c+s;
    }
}

สำหรับเวอร์ชัน (ยาวกว่า: 142 ไบต์) ซึ่งจะไม่มีหน่วยความจำไม่เพียงพอและมีค่าใช้จ่ายต่อตัวอักษรคงที่ดูด้านล่าง:

using C=System.Console;class P{static void Main(){var s="     ";for(int c;(c=C.Read())>=0&s!="hello";C.Write(s[4]))s=s.Substring(1)+(char)c;}}

ตัวนี้เก็บอักขระ 5 ตัวสุดท้ายในสตริงความยาว 5 ตัวซึ่งหมายถึงการเปรียบเทียบสั้น ๆ และการค้นหาแบบอักขระสุดท้ายราคาถูก แต่มีราคาแพงกว่ามากในการอัปเดต

using C=System.Console;

class P
{
    static void Main()
    {
        var s="     ";
        for(int c;(c=C.Read())>=0&s!="hello";C.Write(s[4]))
            s=s.Substring(1)+(char)c;
    }
}

PHP, 57 55 53 ไบต์

while(hello!=$s=substr($s.$c,-5))echo$c=fgetc(STDIN);

เนื่องจากไม่มีไฟล์ที่ไม่มีที่สิ้นสุดฉันรับอินพุตจาก STDIN -nrทำงานด้วย

วนผ่านอินพุตพิมพ์อักขระปัจจุบันต่อท้าย$sตัด$sเป็นอักขระ 5 ตัวสุดท้าย แบ่งห่วงเมื่อเป็น$shello

เป็นกลุ่ม 39 ไบต์

:im hello hello:se noma
:map : i

i

ลองออนไลน์!

:im hello                        "Remap 'hello' in insert mode to
          hello                "write hello, then hit escape
                 :se noma       "then set the buffer to not-modifiable
:map : i                        "THEN remap ':' to 'i' so that can't be changed

i                                "enter insert mode and await an infinite stream of input

PowerShell ขนาด 111 ไบต์

อาจมีวิธีที่ดีกว่าในการทำเช่นนี้ แต่ฉันไม่เห็นในตอนนี้

while(($x=($x+$host.UI.RawUI.ReadKey("IncludeKeyDown").character+"     ").substring(1,5)).CompareTo("hello")){}

นี่เป็นการอ่านลายเส้นที่สำคัญโดยไม่รบกวนเสียงสะท้อน อักขระถูกเพิ่มใน $ x ซึ่งตัดให้เหลือ 5 อักขระและเปรียบเทียบกับ "hello" สิ่งนี้จะดำเนินต่อไปจนกว่าการเปรียบเทียบจะเป็นจริง

หมายเหตุ: สิ่งนี้ไม่ทำงานใน PowerShell ISE ReadKey ถูกปิดใช้งานในสภาพแวดล้อมนั้น

โครงการ 115 ไบต์

(do((c(read-char)(read-char))(i 0(if(eqv? c(string-ref"hello"i))(+ i 1)0)))((or(eof-object? c)(= i 5)))(display c))

รุ่นที่อ่านได้:

(do ((c (read-char) (read-char))                            ; read stdin
     (i 0 (if (eqv? c (string-ref "hello" i)) (+ i 1) 0)))  ; check target
    ((or (eof-object? c) (= i 5))) ; finish if end of stdin, or word found
  (display c))                     ; display each character

สิ่งนี้ใช้อักขระแต่ละตัวจาก stdin ในแต่ละครั้งที่วนรอบและทำเครื่องหมายตำแหน่งในคำเป้าหมายเมื่อตรงกับอักขระของ "hello"

หยุดเมื่ออินพุตหมดหรือเห็น "hello" ไม่มีการใช้หน่วยความจำในกระแสข้อมูลที่ไม่มีที่สิ้นสุด

AWK, 95 ไบต์

BEGIN{RS="(.)"
split("hello",h,"")}{for(j=0;++j<6;){c=RT
printf c
if(c!=h[j])next
getline}exit}

มี 2 ​​สิ่งที่ฉันได้เรียนรู้ที่นี่:
1) การแบ่งระเบียนระหว่างตัวละครที่ใช้RS="(.)"แล้วRTต้องใช้แทน$1
2) ORSใช้โดยprintและเป็นค่าเริ่มต้นที่"\n"
3) ฉันไม่สามารถนับได้ถึง 2 และใช้printf"ถูกกว่า" กว่าการกำหนดORSและ การใช้print

ตัวอย่างการใช้งาน: ใส่รหัสในไฟล์

awk -f FILE some_data_file

หรือ

some process | awk -f FILE

รหัสได้รับการทดสอบโดยใช้เดนนิสyes | ...ข้อเสนอแนะและผมเห็นจำนวนมากและจำนวนมากของys

FYI คุณสามารถทำการมอบหมาย RS เป็นตัวเลือกและดึงออกจากBEGINบล็อกผ่าน:

awk -v RS='(.)'

Python 3 (Linux), 73 72 ไบต์

s=c='_';I=open(0)
while'olleh'!=s>''<c:c=I.read(1);s=c+s[print(end=c):4]

ขอบคุณ @MitchSchwartz สำหรับการตีกอล์ฟ 1 ไบต์!

ลองออนไลน์!

รหัสเครื่อง 8086, 22 ไบต์

00000000  bf 11 01 b4 01 cd 21 ae  75 f6 81 ff 16 01 72 f3  |......!.u.....r.|
00000010  c3 68 65 6c 6c 6f                                 |.hello|
00000016

รหัสแอสเซมบลีที่เทียบเท่า:

org 0x100
use16
a:  mov di, msg
b:  mov ah, 1       ; read one byte from stdin with echo
    int 0x21        ; dos syscall -> result in AL
    scasb           ; if (DI++ == AL)
    jne a
    cmp di, msg+5
    jb b
    ret
msg db "hello"

Pyth, 49 47 ไบต์

Wn"hello"=>5+kp$__import__("sys").stdin.read(1)

Pyth ไม่ค่อยดีนักในการป้อนอักขระเดียว ทุกอย่างค่ะ$__import__("sys").stdin.read(1)นั้นเป็นเพียงการทำเช่นนั้น นอกจากนี้ยังหมายความว่าจะทำงานแบบออฟไลน์เท่านั้น

ทุกสิ่งทุกอย่างสั้น ...

โปรแกรมไม่มีส่วนในขณะที่วนซ้ำ ภายในสภาพโปรแกรมอ่านตัวอักษรพิมพ์มันกลับมาผนวกตัวละครที่จะk(ซึ่งเป็นครั้งแรกสตริงว่างเปล่า) จดจ้องออกทั้งหมด แต่ช่วง 5 ตัวละครและจากนั้นตรวจสอบว่าผลที่ได้คือไม่ได้k"hello"

32 ตัวอักษรได้รับหนึ่งไบต์ของการป้อนข้อมูล 15 ตัวอักษรทำส่วนที่เหลือ

ผ่านการทดสอบบน Linux ทำงานได้แม้ไม่มีบรรทัดใหม่อินพุตไม่สิ้นสุด ฯลฯ

Lua, 68 64 ไบต์

l=""while l~="hello"do c=io.read(1)io.write(c)l=l:sub(-4)..c end

Ruby, 59 49 48 43 ไบต์

ตอนนี้ไม่มีเวลาคุยโวสั้นลงและไม่มีการรั่วไหลของหน่วยความจำ

s=''
s=$>.putc$<.getc+s[0,4]until'olleh'==s

บันทึก 5 ไบต์โดยกำจัดวงเล็บและช่องว่างด้วยเดนนิส

Röda , 49 47 ไบต์

{a=[0]*5{|x|[x];a=a[1:]+x;z if[a&""="hello"]}_}

ลองออนไลน์!

นี่เป็นฟังก์ชั่นนิรนามที่อ่านตัวละครจากอินพุตสตรีมและส่งออกจนกระทั่งพบ "hello" มันใช้อาร์เรย์aเพื่อติดตามตัวละครตัวสุดท้าย

มันออกขยะบางอย่างเพื่อ STDERR แต่ผมเข้าใจว่าจะได้รับอนุญาต

คำอธิบาย:

{
    a=[0]*5                /* Initialize the array with 5 zeroes. */
    {|x|                   /* For each x in the input stream: */
        [x];               /* Print x */
        a=a[1:]+x;         /* Add x and remove the sixth last character. */
        z if[a&""="hello"] /* If "hello" is found, crash the program */
                           /* with an undefined variable. */
    }_                     /* End for loop. */
}

Java 7, 122 118 124 123 150 141 bytes

void c()throws Exception{String a="aaaaa";for(int b;!a.equals("hello")&(b=System.in.read())>=0;a=a.substring(1)+(char)b)System.out.write(b);}

Now stops when the end of the stream is reached. Now handles infinite input without running out of memory.

Ruby, 51 bytes

x="";$><<x[-1]while/hello./!~x=x[/.{0,5}$/]+$<.getc

• Does not expect newlines
• Works with infinite input

AHK, 116 bytes

Loop,Read,%1%
{a=%A_LoopReadLine%`n
Loop,Parse,a
{Send % c:=A_LoopField
If((f:=c SubStr(f,1,4))=="olleh")
ExitApp
}}

There's nothing clever or magical in there, really. The variable %1% is the first passed argument and should be a file path with the stream. The file must be saved as it is updated but the code will read to the end even if it expands after the reading starts.

Mathematica, 107 bytes

i="";EventHandler[Dynamic@i,"KeyDown":>(i=i<>CurrentValue@"EventKey";If[StringTake[i,-5]=="hello",Exit[]])]

The output becomes a field where the user can infinitely type text (including newlines) until the last 5 characters are equal to "hello"; at that point, it exits.

brainfuck, 281 bytes

>++++++++[<+++++++++++++>-]>++++++++++[<++++++++++>-]<+>>+++++++++[<++++++++++++>-]>++++++++++[<+++++++++++>-]<+>+[[[[[,.<<<<[->>>>->+<<<<<]>>>>>[-<<<<<+>>>>>]<],.<<<[->>>->+<<<<]>>>>[-<<<<+>>>>]<],.<<[->>->+<<<]>>>[-<<<+>>>]<],.<<[->>->+<<<]>>>[-<<<+>>>]<],.<[->->+<<]>>[-<<+>>]<]

I'm not sure why, but I just felt like brainfuck was the right thing to do this. Doesn't require infinite memory, and can output forever.

Explained

Set up the buffers with helo
This is done Naively; sue me
>++++++++[<+++++++++++++>-]     h
>++++++++++[<++++++++++>-]<+>   e
>+++++++++[<++++++++++++>-]     l
>++++++++++[<+++++++++++>-]<+>  o

THE MAIN LOOP
+
[ matches o
    [ matches l
        [ matches l
            [ matches e
                [ matches h
                    ,. Read a character and immediently write it
                    <<<<[->>>>->+<<<<<] Subtract it from h
                    >>>>>[-<<<<<+>>>>>] Correct the h
                    < Terminate this part of the loop if it matches h
                ]
                ,. Same as above
                <<<[->>>->+<<<<] Subtract it from e
                >>>>[-<<<<+>>>>] Correct the e
                < Terminate this part of the loop if it matches e
            ]
            ,. Same as above
            <<[->>->+<<<] Subtract it from l
            >>>[-<<<+>>>] Correct the l
            < Terminate this part of the loop if it matches l
        ]
        ,. Same as above
        <<[->>->+<<<] Subtract it from l
        >>>[-<<<+>>>] Correct the l
        < Terminate this part of the loop if it matches l
    ]
    ,. Same as above
    <[->->+<<] Subtract it from o
    >>[-<<+>>] Correct the o
    < Terminate this part of the loop if it matches o
]

Try it online!