นี่คือการท้าทายประจำสัปดาห์ # 2 ธีม: การแปล

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

ภาษาที่ป้อน: โหมโรง

Python interpreter:

#!/usr/bin/python

import sys

NUMERIC_OUTPUT = True
NUMERIC_INPUT = True

try:
    filename = sys.argv[1]
except:
    print "Usage:", sys.argv[0], "<filename>"
    raise SystemExit

try:
    inFile = file(filename)
except:
    print "Error when opening", filename
    raise SystemExit

# code is kept as a list of voices, each voice a string

code = []
firstLine = True
eof = False
while not eof:
    # read batch of lines
    batch = []
    while 1:
        line = inFile.readline()
        if line == '': eof = True
        if line == '' or line.rstrip() == '*':
            break
        batch.append(line.rstrip())
    maxLen = max([len(b) for b in batch])
    batch = [b + ' '*(maxLen - len(b)) for b in batch]
    if firstLine:
        code = batch
        firstLine = False
    else:
        if len(batch) != len(code):
            print "Error in the program: number of voices changes"
            raise SystemExit
        for i in range(len(batch)):
            code[i] += batch[i]


class Stack:
    def __init__(self):
        self.data = []
    def push(self, value):
        if self.data or value != 0: self.data.append(value)
    def drop(self):
        if self.data: self.data.pop()
    def top(self):
        if self.data: return self.data[-1]
        return 0
    def pop(self):
        value = self.top()
        self.drop()
        return value




numVoices = len(code)
numInstructions = len(code[0])
stacks = [Stack() for x in range(numVoices)]
topValues = [0 for x in range(numVoices)]
# establish loop couplings
loopStack = []
loops = {}
for cp in range(numInstructions):
    curr = [voice[cp] for voice in code]
    if curr.count('(') + curr.count(')') > 1:
        print "Error in the program: More than one bracket; position", cp
        raise SystemExit
    if '(' in curr:
        loopStack.append((cp, curr.index('(')))
    if ')' in curr:
        if not loopStack:
            print "Error in the program: extraneous closing bracket; position", cp
            raise SystemExit
        openingPosition, openingVoice = loopStack.pop()
        loops[openingPosition] = cp
        loops[cp] = openingPosition, openingVoice

if loopStack:
    print "Error in the program: not enough closing brackets"
    raise SystemExit


# now, actually execute the program
cp = 0 # code pointer
while cp < numInstructions:
    # technically we're supposed to shuffle our voices to make sure to perform IO
    # in random order, but screw that for now
    next_cp = cp+1 # can be modified by ( )
    for voice in range(numVoices):
        i = code[voice][cp] # current instruction
        if i == '^':
            stacks[voice].push(topValues[(voice-1) % numVoices])
        elif i == 'v' or i == 'V':
            stacks[voice].push(topValues[(voice+1) % numVoices])
        elif i == '+':
            stacks[voice].push(stacks[voice].pop() + stacks[voice].pop())
        elif i == '-':
            b = stacks[voice].pop()
            a = stacks[voice].pop()
            stacks[voice].push(a-b)
        elif i == '#':
            stacks[voice].drop()
        elif i == '?':
            if NUMERIC_INPUT:
                try: num = int(raw_input())
                except ValueError: num = 0
                stacks[voice].push(num)
            else:
                char = sys.stdin.read(1)
                if not char: char = '\0'
                stacks[voice].push(ord(char))
        elif i == '!':
            if NUMERIC_OUTPUT:
                print stacks[voice].pop()
            else:
                sys.stdout.write(chr(stacks[voice].pop()))
        elif i == '(':
            if stacks[voice].top() == 0:
                next_cp = loops[cp] + 1
        elif i == ')':
            openingPosition, openingVoice = loops[cp]
            if topValues[openingVoice] != 0:
                next_cp = openingPosition + 1
        elif i in '0123456789':
            stacks[voice].push(int(i))
    topValues = [stacks[i].top() for i in range(numVoices)]
    cp = next_cp

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

ข้อกำหนดเบื้องต้นสำหรับความท้าทายนี้:

Digits 0-9      Push onto the stack a number from 0 to 9. Only single-digit
                    numeric literals can be used.
^               Push onto the stack the top value of the stack of the above 
                    voice.
v               Push onto the stack the top value of the stack of the below 
                    voice.
#               Remove the top value from the stack.
+               Pop the top two integers from the stack and push their sum.
-               Pop the top two integers from the stack, subtract the topmost 
                    from the second, and push the result.
(               If the top of the stack is 0, jump to the column after the 
                    matching `)` after the current column executes.
)               If the top of the stack is not 0, jump to the column after 
                    the matching `(` after the current column executes.
?               Read an integer from STDIN.
!               Pop one value from the stack and print it to STDOUT as an
                    integer.
<space>         No-op

หมายเหตุ

• vและ^ทำหน้าที่เป็นวนรอบดังนั้นvเสียงที่ด้านล่างจะคัดลอกองค์ประกอบสแต็คของเสียงด้านบนและเสียงที่^อยู่ด้านบนจะคัดลอกมาจากเสียงด้านล่าง ข้อสรุป:ทั้งคู่vและ^ซ้ำด้านบนสุดของสแต็กในโปรแกรมเสียงเดียว
• A (และการจับคู่)อาจอยู่ในบรรทัดที่ต่างกัน อย่างไรก็ตาม a )จะดูที่สแต็คของเสียงที่(วางเสียงนั้น ๆ เสมอไม่ใช่สแต็กที่)วางเสียงนั้น
• ค่าที่ผลิตโดยคำสั่ง^และvคำสั่งจะทำงานกับค่าที่มีอยู่ก่อนที่การดำเนินการอื่น ๆ จะเสร็จสิ้นในคอลัมน์เดียวกัน
• ?และ!ดำเนินการแตกต่างจากข้อกำหนดที่พบใน esolangs.org ดังนั้นโปรดทดสอบกับล่ามดัดแปลงเล็กน้อยที่ให้ไว้ในโพสต์นี้

อินพุตรับประกันว่าจะมี:

• วงเล็บที่ตรงกัน
• ไม่เกินหนึ่งวงเล็บในคอลัมน์
• จำนวนอักขระเท่ากันในแต่ละบรรทัด
• อย่างน้อยหนึ่งบรรทัด
• ไม่มีคอลัมน์ที่มีมากกว่าหนึ่ง I / O ( !หรือ?) การเรียนการสอน
• อักขระป้อนบรรทัดหนึ่งตัวหลังจากคำแนะนำสำหรับแต่ละเสียง
• ไม่มีตัวละครอื่นนอกเหนือจากที่กล่าวไว้ข้างต้น

ภาษาเอาท์พุท: Befunge-93

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

Digits 0-9      Push onto the stack a number from 0 to 9. Only single-digit
                        numeric literals can be used.
    +               Pop the top two integers from the stack and push their sum.
    -               Pop the top two integers from the stack, subtract the topmost 
                        from the second, and push the result.
    *               Pop the top two integers from the stack and push their product.
    /               Pop the top two integers from the stack, divide the second by
                        the topmost, and push the result. Rounds down.
    %               Pop the top two integers from the stack, divide the second by
                        the topmost, and push the remainder.
    !               Pop a value, push 1 if it's zero, push 0 otherwise.
    `               Pop the top two integers from the stack, push 1 if the second
                        is greater than the topmost, push 0 otherwise.
    >               Set PC direction to right.
    <               Set PC direction to left.
    ^               Set PC direction to up.
    v               Set PC direction to down.
    ?               Set PC direction randomly.
    _               Pop a value, if it's 0 set PC direction to right, left otherwise.
    |               Pop a value, if it's 0 set PC direction to down, up otherwise.
    "               Toggle string mode. While in string mode, push each character's
                        ASCII value instead of executing it.
    :               Duplicate top stack element.
    \               Swap top two stack elements.
    $               Pop and discard top stack element.
    .               Pop a value and output it as an integer. Whitespace not included.
    ,               Pop a value and output the corresponding ASCII character.
    #               Jump over the next instruction.
    g               Pop y, pop x, push the character at coordinate (x,y).
    p               Pop y, pop x, pop v, set character at coordinate (x,y) to v.
    &               Read an integer from STDIN and push it.
    ~               Read a character from STDIN and push it ASCII value.
    @               End program.

คุณอาจถือว่าคุณสมบัติต่อไปนี้ของคอมไพเลอร์ / ล่าม Befunge-93:

• จำนวนเต็มมีความแม่นยำไม่ จำกัด
• จะช่วยให้กริดทุกขนาด
• พิกัดกริด (สำหรับgและp) เป็นแบบ 0

เกณฑ์การให้คะแนน

เพื่อป้องกันการส่งที่สร้าง Prelude interpreter ใน Befunge และ hardcode ของ Prelude source เข้าไปเป้าหมายจะลดขนาดของซอร์สโค้ด Befunge ที่เกิดขึ้นให้น้อยที่สุด

ด้านล่างมีโปรแกรม Prelude ให้เลือกมากมาย นักแปลของคุณจะทำงานกับสิ่งเหล่านี้ทั้งหมด คะแนนของคุณคือผลรวมของขนาดของโปรแกรม Befunge โดยที่รายการทั้งหมดนั้นถูกต้อง

นักแปลของคุณไม่ควรปรับให้เหมาะกับกรณีทดสอบเหล่านี้โดยเฉพาะ (เช่นโดยโปรแกรม hardcoding ที่เขียนด้วยลายมือ Befunge สำหรับพวกเขา) หากฉันสงสัยว่ามีคำตอบใด ๆ ฉันขอสงวนสิทธิ์ในการเปลี่ยนแปลงอินพุตหรือสร้างรายการเพิ่มเติม

อินพุตตัวอย่าง

พิมพ์n-1ลงไปที่0:

?(1-^!)

ตรรกะและ:

?  (0)  
 ?(0  ) 
    1  !

ตรรกะหรือ:

 ?   (0) 
? (0)    
   1  1 !

ตรวจสอบพาริตีของอินพุต (เช่นโมดูโล 2) ของหมายเลขที่ไม่ติดลบ:

?(1-)   
 ^  v   
 v1-^^-!

กำหนดค่าอินพุต:

 ^    
  ^+ !
?(1-) 

พิมพ์หมายเลข Fibonacci ลำดับที่nที่n = 0ตรงกับ 0 และn = 1สอดคล้องกับ 1:

0 v+v!
1   ^ 
?(1-) 

Signum:

  1) v #  - !
 vv (##^v^+) 
?(#   ^   ## 

การหารสำหรับอินพุตที่ไม่เป็นลบ:

1 (#  1) v #  - 1+)   
     vv (##^v^+)      
?  v-(0 # ^   #       
 ?                    
   1+              1-!

แน่นอนว่าโปรแกรมของคุณจะต้องแสดงพฤติกรรมเดียวกันทุกกรณีแม้ว่าจะไม่ได้ระบุพฤติกรรมของโปรแกรมตัวอย่างสำหรับจำนวนลบ

สุดท้ายนักแปลของคุณไม่ควรยาวเกินเหตุผล:

• จะต้องมีอยู่ในโพสต์แลกเปลี่ยนกอง
• ควรประมวลผลอินพุตตัวอย่างภายใน 10 นาทีบนคอมพิวเตอร์เดสก์ท็อปทั่วไป

โปรดทราบว่าการป้อนตัวเลขสำหรับ Prelude หรือ Befunge นั้นจะได้รับเป็นเครื่องหมายลบตัวเลือกตามด้วยตัวเลขทศนิยมหนึ่งหลักขึ้นไปตามด้วยการขึ้นบรรทัดใหม่ อินพุตอื่นคือพฤติกรรมที่ไม่ได้กำหนด

คุณสามารถเขียนนักแปลเป็นภาษาใดก็ได้ รหัส Befunge ที่แปลสั้นที่สุดชนะ

ลีดเดอร์บอร์ด

• Sp3000 : 16430 ไบต์

Python 3 จะทำคะแนนในภายหลัง

from collections import defaultdict
from functools import lru_cache
import sys

NUMERIC_OUTPUT = True

@lru_cache(maxsize=1024)
def to_befunge_num(n):
    # Convert number to Befunge number, using base 9 encoding (non-optimal,
    # but something simple is good for now)

    assert isinstance(n, int) and n >= 0

    if n == 0:
        return "0"

    digits = []

    while n:
        digits.append(n%9)
        n //= 9

    output = [str(digits.pop())]

    while digits:
        output.append("9*")
        d = digits.pop()

        if d:
            output.append(str(d))
            output.append("+")

    output = "".join(output)

    if output.startswith("19*"):
        return "9" + output[3:]

    return output

def translate(program_str):
    if program_str.count("(") != program_str.count(")"):
        exit("Error: number of opening and closing parentheses do not match")

    program = program_str.splitlines()
    row_len = max(len(row) for row in program)
    program = [row.ljust(row_len) for row in program]
    num_stacks = len(program)


    loop_offset = 3
    stack_len_offset = program_str.count("(")*2 + loop_offset
    stack_offset = stack_len_offset + 1
    output = [[1, ["v"]], [1, [">"]]] # (len, [strings]) for each row
    max_len = 1 # Maximum row length so far

    HEADER_ROW = 0
    MAIN_ROW = 1
    FOOTER_ROW = 2
    # Then stack lengths, then loop rows, then stacks

    # Match closing parens with opening parens
    loop_map = {} # {column: (loop num, stack number to check, is_start)}
    loop_stack = []
    loop_num = 0

    for col in range(row_len):
        col_str = "".join(program[stack][col] for stack in range(num_stacks))

        if col_str.count("(") + col_str.count(")") >= 2:
            exit("Error: more than one parenthesis in a column")

        if "(" in col_str:
            stack_num = col_str.index("(")

            loop_map[col] = (loop_num, stack_num, True)
            loop_stack.append((loop_num, stack_num, False))
            loop_num += 1

        elif ")" in col_str:
            if loop_stack:
                loop_map[col] = loop_stack.pop()

            else:
                exit("Error: mismatched parentheses")


    def pad_max(row):
        nonlocal max_len, output

        while len(output) - 1 < row:
            output.append([0, []])

        if output[row][0] < max_len:
            output[row][1].append(" "*(max_len - output[row][0]))
            output[row][0] = max_len


    def write(string, row):
        nonlocal max_len, output

        output[row][1].append(string)
        output[row][0] += len(string)

        max_len = max(output[row][0], max_len)


    def stack_len(stack, put=False):
        return (to_befunge_num(stack) + # x
                str(stack_len_offset) + # y
                "gp"[put])


    def get(stack, offset=0):
        assert offset in [0, 1] # 1 needed for 2-arity ops

        # Check stack length
        write(stack_len(stack) + "1-"*(offset == 1) + ":0`", MAIN_ROW)

        pad_max(HEADER_ROW)
        pad_max(MAIN_ROW)
        pad_max(FOOTER_ROW)

        write(">" + to_befunge_num(stack + stack_offset) + "g", HEADER_ROW)
        write("|", MAIN_ROW)
        write(">$0", FOOTER_ROW)

        pad_max(HEADER_ROW)
        pad_max(MAIN_ROW)
        pad_max(FOOTER_ROW)

        write("v", HEADER_ROW)
        write(">", MAIN_ROW)
        write("^", FOOTER_ROW)


    def put(stack, value=""):
        put_inst = (value +
                    stack_len(stack) +
                    to_befunge_num(stack + stack_offset) +
                    "p")

        post_insts.append(put_inst)


    def pop(stack):
        put(stack, "0")


    def inc_stack_len(stack):
        post_insts.append(stack_len(stack) + "1+")
        post_insts.append(stack_len(stack, put=True))


    def dec_stack_len(stack):
        post_insts.append(stack_len(stack) + ":0`-") # Ensure nonnegativity
        post_insts.append(stack_len(stack, put=True))


    # Technically not necessary to initialise stack lengths per spec, but it makes it
    # more portable and easier to test against other Befunge interpreters

    for stack in range(num_stacks):
        write("0" + stack_len(stack, put=True), MAIN_ROW)

    for col in range(row_len):
        post_insts_all = []

        loop_start = False
        loop_end = False

        if col in loop_map:
            if loop_map[col][2]:
                loop_start = True
            else:
                loop_end = True

        if loop_start:
            loop_row = loop_offset + 2*loop_map[col][0]
            get(loop_map[col][1])

        elif loop_end:
            get(loop_map[col][1])
            write("!", MAIN_ROW)


        for stack in range(num_stacks-1, -1, -1):
            char = program[stack][col]
            post_insts = [] # Executed after the gets in reverse order, i.e. last added first

            if char in " ()":
                continue

            # Pre-inc, post-dec
            elif char.isdigit():
                inc_stack_len(stack)
                put(stack, char)

            elif char == "?":
                inc_stack_len(stack)
                put(stack, "&")

            elif char == "!":
                get(stack)
                post_insts.append(".91+," if NUMERIC_OUTPUT else ",")
                pop(stack)
                dec_stack_len(stack)

            elif char == "#":
                pop(stack)
                dec_stack_len(stack)

            elif char in "+-":
                get(stack, 1)
                get(stack)
                post_insts.append(char)
                pop(stack) # This one first in case of ! or 1!
                post_insts.append(stack_len(stack) + ":1`-:1\\`+") # Ensure >= 1
                post_insts.append(stack_len(stack, put=True))
                put(stack)                

            elif char in "^v":
                offset = -1 if char == "^" else 1

                get((stack + offset) % num_stacks)
                inc_stack_len(stack)
                put(stack)

            else:
                exit("Error: invalid character " + char)

            post_insts_all.append(post_insts)


        while post_insts_all:
            write("".join(post_insts_all.pop()), MAIN_ROW)

        if loop_start or loop_end:
            loop_row = loop_offset + 2*loop_map[col][0]

            pad_max(HEADER_ROW)
            pad_max(MAIN_ROW)
            pad_max(loop_row)
            pad_max(loop_row + 1)

            write(">v", HEADER_ROW)
            write("|>", MAIN_ROW)

            if loop_start:
                write(" ^", loop_row)
                write(">", loop_row + 1)

            else:
                write("<", loop_row)
                write(" ^", loop_row + 1)


    write("@", MAIN_ROW)
    return "\n".join("".join(row) for row_len, row in output)

if __name__ == '__main__':
    if len(sys.argv) < 3:
        exit("Usage: py -3 prefunge.py <input filename> <output filename>")

    with open(sys.argv[1]) as infile:
        with open(sys.argv[2], "w") as outfile:
            outfile.write(translate(infile.read()))

py -3 prefunge.py <input filename> <output filename>ทำงานเหมือน

เป็นสัปดาห์ที่ช้าสำหรับฉันดังนั้นในที่สุดฉันก็เบื่อพอที่จะตอบคำถามเก่าหกเดือนนี้ ฉันถามว่าทำไมไม่มีใครลองอีกแล้ว แต่ฉันยังรู้สึกถึงความเจ็บปวดจากการดีบั๊ก (และอาจมีข้อบกพร่องเหลืออยู่สำหรับทุกอย่างที่ฉันรู้)

คำถามไม่ได้ให้ล่าม Befunge-93 ดังนั้นฉันจึงใช้อันนี้ซึ่งแตกต่างจากสเป็คเล็กน้อย ความแตกต่างที่สำคัญสองประการคือ:

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

• เซลล์กริดไม่ได้กำหนดค่าเริ่มต้นเป็นศูนย์ - เพื่อความสะดวกฉันได้รวมการกำหนดค่าเริ่มต้นบางอย่างไว้ในผลลัพธ์ของ Befunge แต่เนื่องจากมันไม่จำเป็นฉันอาจนำมันออกไปเมื่อฉันเริ่มให้คะแนน

โครงร่างหลักของโปรแกรมเอาต์พุตคือ:

v [header row]
> [main row]
  [footer row]
  ---
   |
   | rows for loops (2 per loop)
   |
  ---
  [stack length row]
  ---
   |
   | rows for stack space (1 per voice)
   |
  ---

พื้นที่สแต็คอยู่นอกโปรแกรมดังนั้นการขึ้นบรรทัดใหม่ใส่ความคิดเห็นจากสแปมก่อนหน้านี้

แนวคิดหลักคือการกำหนดแต่ละแถวเสียงที่ทำหน้าที่เป็นสแต็กของมัน เพื่อรักษาสแต็คเหล่านี้เรายังมีแถวความยาวสแต็กพิเศษที่ความยาวของแต่ละสแต็กจะถูกบันทึกในเซลล์ตามแถว โปรแกรมนี้มีgets และputs จำนวนมากเช่นสำหรับการพิมพ์กระบวนการคือ:

• รับเซลล์ที่ y = stack_row[stack], x = stack_length[stack]
• ดำเนินการ.91+,เช่นพิมพ์เป็นจำนวนเต็มจากนั้นพิมพ์บรรทัดใหม่
• แทนที่เซลล์ที่ coords ด้านบนด้วย 0 (เพื่อจำลองการ popping)
• การพร่อง stack_length[stack]

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

`ซึ่งมีค่ามากกว่าใช้เพื่อให้แน่ใจว่าความยาวของสแต็กจะไม่เป็นลบและสำหรับการกด 0s เมื่อสแต็กว่างเปล่า นี่คือที่มาของการแตกแขนงที่มองเห็นได้อย่างชัดเจน แต่ฉันมีความคิดที่จะลบการแยกซึ่งควรจะลบช่องว่างออกจากแถวแรกและแถวที่สาม

สำหรับลูปเนื่องจากลูปพรีลูดสามารถกระโดดได้ทั้งสองวิธีเราใช้สองแถวต่อลูปในการกำหนดค่าดังนี้:

       >v                     >v
(cond) |>  (program)  (cond) !|>

        ^                     <
       >                       ^

ปัจจุบันวงวนเหล่านี้ประกอบไปด้วยไบต์ส่วนใหญ่ แต่สามารถลงเล่นได้อย่างง่ายดายโดยวางลงในกล่องรหัสด้วยpซึ่งฉันวางแผนที่จะทำหลังจากที่ฉันมีความสุขที่นักแปลทำงานได้อย่างถูกต้อง

นี่คือตัวอย่างผลลัพธ์สำหรับ?(1-^!)เช่นพิมพ์n-1ลงไปที่0:

v                        >6gv>v                      >6gv      >6gv                                 >6gv                   >6gv                           >6gv >v
>005p05g1+05p&05g6p05g:0`|  >|>05g1+05p105g6p05g1-:0`|  >05g:0`|  >-005g6p05g:1`-:1\`+05p05g6p05g:0`|  >05g1+05p05g6p05g:0`|  >.91+,005g6p05g:0`-05p05g:0`|  >!|>@
                         >$0^                        >$0^      >$0^                                 >$0^                   >$0^                           >$0^
                              ^                                                                                                                                <
                             >                                                                                                                                  ^

สแควร์ที่ป้อนข้อมูล:

v                                >8gv      >8gv             >v      >6gv                                   >8gv      >8gv        >7gv      >7gv                                                            >8gv >v      >7gv
>005p015p025p25g1+25p&25g8p25g:0`|  >25g:0`|  >05g1+05p05g6p|>05g:0`|  >15g1+15p15g7p25g1+25p125g8p25g1-:0`|  >25g:0`|  >15g1-:0`|  >15g:0`|  >+015g7p15g:1`-:1\`+15p15g7p-025g8p25g:1`-:1\`+25p25g8p25g:0`|  >!|>15g:0`|  >.91+,015g7p15g:0`-15p@
                                 >$0^      >$0^                     >$0^                                   >$0^      >$0^        >$0^      >$0^                                                            >$0^         >$0^
                                                             ^                                                                                                                                                  <
                                                            >                                                                                                                                                    ^

การหาร (แนะนำให้ป้อนข้อมูลเล็ก ๆ ):

v                                                                          >91+gv>v      >94+gv                                                         >95+gv      >95+gv        >93+gv      >93+gv                                                                    >93+gv      >93+gv               >v      >93+gv                                                     >93+gv >v      >92+gv                  >v      >92+gv                                       >92+gv                                       >91+gv                                       >93+gv                     >91+gv                       >92+gv      >92+gv        >91+gv      >91+gv                                                                                      >92+gv >v                        >91+gv      >91+gv                                     >91+gv >v                        >95+gv      >95+gv                                     >95+gv
>009p019p029p039p049p09g1+09p109g91+p29g1+29p&29g93+p39g1+39p&39g94+p09g:0`|    >|>39g:0`|    >009g91+p09g:0`-09p29g1+29p29g93+p49g1+49p149g95+p49g1-:0`|    >49g:0`|    >29g1-:0`|    >29g:0`|    >-029g93+p29g:1`-:1\`+29p29g93+p+049g95+p49g:1`-:1\`+49p49g95+p29g:0`|    >29g:0`|    >19g1+19p19g92+p|>29g:0`|    >09g1+09p109g91+p19g1+19p19g92+p29g1+29p029g93+p29g:0`|    >!|>19g:0`|    >029g93+p29g:0`-29p|>19g:0`|    >09g1+09p09g91+p019g92+p19g:0`-19p19g:0`|    >019g92+p19g:0`-19p29g1+29p29g93+p09g:0`|    >009g91+p09g:0`-09p19g1+19p19g92+p29g:0`|    >19g1+19p19g92+p09g:0`|    >19g1+19p19g92+p19g1-:0`|    >19g:0`|    >09g1-:0`|    >09g:0`|    >-009g91+p09g:1`-:1\`+09p09g91+p+019g92+p19g:1`-:1\`+19p19g92+p029g93+p29g:0`-29p19g:0`|    >!|>09g1+09p109g91+p09g1-:0`|    >09g:0`|    >+009g91+p09g:1`-:1\`+09p09g91+p09g:0`|    >!|>49g1+49p149g95+p49g1-:0`|    >49g:0`|    >-049g95+p49g:1`-:1\`+49p49g95+p49g:0`|    >.91+,049g95+p49g:0`-49p@
                                                                           >$0  ^        >$0  ^                                                         >$0  ^      >$0  ^        >$0  ^      >$0  ^                                                                    >$0  ^      >$0  ^                       >$0  ^                                                     >$0  ^         >$0  ^                          >$0  ^                                       >$0  ^                                       >$0  ^                                       >$0  ^                     >$0  ^                       >$0  ^      >$0  ^        >$0  ^      >$0  ^                                                                                      >$0  ^                           >$0  ^      >$0  ^                                     >$0  ^                           >$0  ^      >$0  ^                                     >$0  ^
                                                                                  ^                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <
                                                                                 >                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ^
                                                                                                                                                                                                                                                                                                          ^                                                                        <
                                                                                                                                                                                                                                                                                                         >                                                                          ^
                                                                                                                                                                                                                                                                                                                                                                                                                    ^                                                                                                                                                                                                                                                                                                                                              <
                                                                                                                                                                                                                                                                                                                                                                                                                   >                                                                                                                                                                                                                                                                                                                                                ^

นอกจากนี้ยังมีการเพิ่มประสิทธิภาพเล็ก ๆ น้อย ๆ อื่น ๆ ที่นึกถึงเช่นแทนที่07p07gด้วย:07pแต่ตอนนี้ฉันทำทีละขั้นตอน :)