您将打印此确切文本：

A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A

眼镜

• 在输出末尾允许多余的尾随换行符。
• 每行的末尾都允许使用多余的尾随空格（U + 0020），包括多余的尾随换行符。
• 您可以使用所有小写字母，而不是全部大写字母，但是您不能打印部分小写字母和部分大写字母。
• 您可以将文本作为函数输出返回，而不是在完整程序中打印。

计分

由于这是一个三角形，并且三角形具有3个边，而3是一个小数，因此代码的字节数应该较小。

Vim，37个字节

:h<_↵↵↵YZZPP$xqqxYpGP√2G$A♥-€k$q24@qJ

传说

↵ = Return
√ = Ctrl+V
♥ = Ctrl+R
€ = Escape

标志，232个207 196 190字节

有人说三角形吗？

拿出指南针和量角器，让我们以图形方式进行操作。几何图形使用等边三角形对齐结果。我以前有一个等腰三角形，但是它包含太多的小数位。此更改还压缩了输出，减少了我必须要做的屏幕准备和字体更改量。

我使用Calormen在线解释器充实了这一内容。如果您没有足够的屏幕空间，它会被包装，但是您也可以摆弄一些数字来解决这个问题。我在浏览器上使用了“ F11”全屏模式。

ht
pu
to r:n:b:l repeat:n[rt:b label char 90-:n lt:b fd:l] end
to t:s
fd 12 rt 120 bk 6
repeat 2[r:s 90 12]
repeat 2[rt 120 r:s 90-heading 24]
end
rt 90 label "Z lt 210
repeat 25[t repcount]

该r过程绘制了一行n字符。该字符是根据被告知要使用的段数自动确定的。该b参数告诉它暂时旋转多少，以使字母指向正确的方向。该l参数确定字母之间的线性距离。

该t过程将移至下一个位置，并r四次调用该函数以创建一个三角形，并在适当时旋转。我在垂直方向两次调用它，因为与经过特殊处理的一次调用相比，它占用的字节更少。该过程的结束将乌龟定位到下一个三角形的上方（上一步）。

Z是一种特殊情况，因此我们直接将其打印并旋转，就好像刚完成一个三角形一样。最后t被称为25次。

Haskell，58个字节

f x=init x++reverse x
t=unlines$f[f['A'..c]|c<-['A'..'Z']]

定义一个t将输出作为字符串返回的函数。

f x=               define a helper function
init x             take the argument minus its last element
++                 and concatenate it with
reverse x          the argument reversed, producing ex. [a,b,c,b,a] from [a,b,c]

t=                                    define the main function
           [         |c<-['A'..'Z']]  for every char c from 'A' to 'Z'...
             ['A'..c]                 generate the range from 'A' to c
            f                         call the helper function to "reflect" it
          f                           call the helper function on the entire list
  unlines$                            join on newlines

果冻，16 13 字节

Ṗ;Ṛ
ØAḣJÇ€Çj⁷

感谢@LeakyNun打高尔夫球3个字节！

在线尝试！

这个怎么运作

Ṗ;Ṛ        Helper link. Argument: A (array)

Ṗ          Pop; yield A without its last element.
  Ṛ        Reversed; yield A with inverted order.
 ;         Concatenate the results to both sides.


ØAḣJÇ€Çj⁷  Main link. No arguments.

ØA         Alphabet; set link argument and return value to "A...Z".
   J       Indices; yield [1, ..., 26].
  ḣ        Head; take the first, the first two, etc. elements of the alphabet.
           This yields ["A", AB", ..., "A...Z"].
    ǀ     Apply the helper link to each string.
      Ç    Apply the helper link to the array itself.
       j⁷  Join, separating by linefeeds.

Python，74个字节

def f(x=66,s='A'):
 t=s+s[-2::-1];print t
 if x<91:f(x+1,s+chr(x));print t

一个Python 2函数，可打印且不带参数。关键思想是通过递归生成三角形的来回图案。首先考虑这个更简单的功能，该功能将字母“ A”打印到“ Z”，再打印回“ A”：

def f(x=65):
 t=chr(x);print t
 if x<90:f(x+1);print t 

该功能首先打印“ A”（字符代码65），然后递归打印“ B”（66），依此类推打印到“ Z”（90）。从那里开始，它停止递归。在递归向下递归堆栈的方式上，它将打印t在同一层上打印的任何字符，从“ Y”回到“ A”。

主要代码执行相同的操作，只是s到目前为止，它已累积到字母字符串中并打印上下字符串s+s[-2::-1]。

感谢xsot 2个字节。

在Python 3中，通过将所有内容放在一行上，相同的事情是短了一个字节（73字节）。

def f(x=66,s='A'):t=s+s[-2::-1];print(t);x>90or[f(x+1,s+chr(x)),print(t)]

brainfuck，1733 121 119字节

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

可读性更高的版本：

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

解释可能会到来。

05AB1E，20 13 12 6个字节

感谢Adnan，节省了2个字节。
借助Magic Octopus Urn和一些新的语言功能，节省了6个字节。

Aη€ûû»

在线尝试！

说明

Aη       # push prefixes of alphabet
  €û     # palendromize each prefix
    û    # palendromize the whole list
     »   # join on newlines

J，26 23 22字节

f(f=:,1}.|.)\u:65+i.26

说明

,1}.|.  Monad f: Input: A
    |.  Reverse the items in A
 1}.    Drop the first item in the reversed A
,       Join A and the previous

f(f=:,1}.|.)\u:65+i.26
                  i.26  Create the range [0, 1, ..., 25]
               65+      Add 65 to each
             u:         Convert to characters to get 'A..Z'
  f=:,1}.|.             Define a verb f
 (         )\           Call f monadically on each prefix of 'A..Z'
f                       Call f again on that result

Python 3，97个字节

s="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
a=[s[:x]+s[x::-1]for x in range(26)]
print('\n'.join(a+a[24::-1]))

伊迪恩！

Ruby，71个字节

在repl.it上尝试

s=*?A..?Y
s+=[?Z]+s.reverse
puts s.map{|e|k=[*?A...e]*'';k+e+k.reverse}

> <>，60字节

1"AA"1[v
?v:1-:}>:5d*=
o>l  ?!v
{$-}:1[\ao]{:}+::"@Z"@=?;=2*

在线尝试！

C，272个 247 234 230 144 137字节：

（由于昔加洛尔提供了出色的高尔夫技巧和技巧，我以前的方法节省了许多字节（272 -> 230）！）

（通过切换到更好的方法，节省了近100个字节（230 -> 144）。）

main(q,i,e,x){for(q=0;q<51;q++){i=q>25 ? 25-(q-25):q;for(e=65;e<66+i;e++)printf("%c",e);for(x=64+i;x>64;x--)printf("%c",x);printf("\n");}}

我的第一个回答是C。我是最近才开始自学的，所以让我们看看它的进展。

行动吧！（爱迪生）

JavaScript（ES6），81个字节

[...'ZYXWVUTSRQPONMLKJIHGFEDCBA'].reduce((p,c)=>c+`
`+p.replace(/^|$/gm,c)+`
`+c)

Mathematica 59字节

Column@FromCharacterCode[#@#@26+64]&[#-Abs@Range[1-#,#-1]&]

Dyalog APL，18个字节

↑(⊣,⌽)(⊣,1↓⌽)¨,\⎕a

R，63 61 59字节

for(i in c(1:26,25:1))cat(LETTERS[c(1:i,i:1-1)],"
",sep="")

有用的LETTTERS[0]是不返回任何字符。

编辑：由于@leakynun失去了一个

编辑：多两个感谢@plannapus

TSQL，159个字节

DECLARE @ varchar(52)='ABCDEFGHIJKLMNOPQRSTUVWXY',@o varchar(max)SELECT @+='Z'+REVERSE(@)+'
',@o=@
WHILE''<@
SELECT @=STUFF(@,LEN(@)/2,2,''),@o=@+@o+@
PRINT @o

小提琴

Javascript（使用外部库可枚举），135个字节

_.Range(1,51).WriteLine(x=>(g=_.Range(65,x>25?52-x:x)).Write("",y=>(w=String.fromCharCode)(y))+(g.Reverse().Skip(1).Write("",y=>w(y))))

链接到库：https : //github.com/mvegh1/Enumerable

代码说明：创建一个从1开始的整数范围，计数为51。对于每个整数，请根据复数pred编写一行。用全局变量和缓存做一些JS向导...瞧瞧。对于WriteLine中的每个int，我们将创建int的左手范围，并将其存储到全局“ g”中，并使用""定界符将其与String Joining（写入）并将每个int映射到String并映射到int char代码。然后，我们通过反转该顺序（并跳过第一个元素，因为它将与原始顺序的最后一个元素相匹配...）来连接右侧，并使用相同的逻辑进行编写。编辑：更新了库中写入的内部。一个空序列将写入一个空字符串，而不是null。这也使答案减少了15个字节

Powershell，61 52字节

感谢TimmyD节省了9个字节！

65..90+89..65|%{-join[char[]]((65..$_-ne$_)+$_..65)}

循环浏览ASCII值，以使大写字母向前，然后向后。对于每个数字，这将创建一个由前X个数字组成的数组，删除X-1st个数字，然后添加与前X个数字相反的数字，然后将其全部转换为char并加入字符串。

切达（Cheddar），102 96 79 69 67字节

感谢Downgoat提供了17个字节，另外还有10个字节的灵感。

"A"+(2@"27+@"(25|>1)).bytes.map(i->65@"(64+i)+@"((64+i)|>65)).vfuse

字符串可以串联而不是数组的事实意味着我必须将两个范围转换为字符串，然后再将其转换回数组。

同样，vfuse产生领先的newliens 的事实意味着我需要手动生成第一行，然后再与其余行连接。

@" 因为一个dyad（两个参数的函数）可以直接转换为字符串，但不适用于反向范围（如果第一个参数大于第二个参数）。

范围是一半。错误修复后，它变得具有包容性。

用法

cheddar> "A"+(2@"27+@"(25|>1)).bytes.map(i->(65@"(64+i)+@"((64+i)|>65))).vfuse
"A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYZYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNONMLKJIHGFEDCBA
ABCDEFGHIJKLMNMLKJIHGFEDCBA
ABCDEFGHIJKLMLKJIHGFEDCBA
ABCDEFGHIJKLKJIHGFEDCBA
ABCDEFGHIJKJIHGFEDCBA
ABCDEFGHIJIHGFEDCBA
ABCDEFGHIHGFEDCBA
ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A"

Cheddar，55个字节（非竞争）

在具有所有修复程序的最新版本中，答案是：

(|>25+24|>0).map(i->65@"(65+i)+(i?(64+i)@"65:"")).vfuse

但它是在挑战之后制成的。

C，93字节

f()不带参数的呼叫。

g(l,n){putchar(l);n?g(l+1,--n),putchar(l):0;}f(n){for(n=-26;++n<26;puts(""))g(65,25-abs(n));}

在ideone上尝试一下。

VBA，94个字节

Function T:For j=-25To 25:k=25-Abs(j):For i=-k To k:T=T &Chr(65+k-Abs(i)):Next:T=T &vbLf:Next

用？T在立即窗口中调用

只是为了解释发生了什么：我两次使用Abs函数，以反映字母遍历和行长。由于在两种情况下都具有单个极值，因此非常适合该任务，这对应于pre-Abs变量的零交叉。

作为VBA立即窗口中的一组简单命令，而不是程序或函数，以下命令将需要72个字节：

For j=-25To 25:k=25-Abs(j):For i=-k To k:?Chr(65+k-Abs(i));:Next:?:Next

（感谢@GuitarPicker）

Python，73 71字节

感谢@xnor的递归

f=lambda x=66,s='A',t='':x/92*t or t+f(x+1,s+chr(x),s+s[-2::-1]+"\n")+t

说明

• 参数：
  • x 是字母表中下一个字母的ascii值
  • s 是字母的累加器
  • t是三角形中的一条线（即s+ s backwards）
• 返回值：t如果字母完成（即我们位于中间）
• 其他：t+f(...)+t具有：
  • x 增加的
  • s 附有下一个字母
  • t重置为s+ s backwards+\n

更新资料

• -2 [16-08-05]移除导致\n（1）和缩短的条件（-3）所有由于@xnor

HTML + CSS，884个字符

（763个字符的HTML + 121个字符的CSS）

只是扩大漏嫩的评论上MonkeyZeus s'的答案。（尽管我可能会误读评论...）

p{margin:0}p:before{content:"ABCDEFGH"}p:after{content:"HGFEDCBA"}a:before{content:"IJKLMNOP"}a:after{content:"PONMLKJI"}

<pre>A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
ABCDEFEDCBA
ABCDEFGFEDCBA
ABCDEFGHGFEDCBA
<p>I</p><p>IJI</p><p>IJKJI</p><p>IJKLKJI</p><p>IJKLMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNOPONMLKJI</p><p><a>Q</p><p><a>QRQ</p><p><a>QRSRQ</p><p><a>QRSTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXYZYXWVUTSRQ</p><p><a>QRSTUVWXYXWVUTSRQ</p><p><a>QRSTUVWXWVUTSRQ</p><p><a>QRSTUVWVUTSRQ</p><p><a>QRSTUVUTSRQ</p><p><a>QRSTUTSRQ</p><p><a>QRSTSRQ</p><p><a>QRSRQ</p><p><a>QRQ</p><p><a>Q</a></p><p>IJKLMNOPONMLKJI</p><p>IJKLMNONMLKJI</p><p>IJKLMNMLKJI</p><p>IJKLMLKJI</p><p>IJKLKJI</p><p>IJKJI</p><p>IJI</p><p>I</p>ABCDEFGHGFEDCBA
ABCDEFGFEDCBA
ABCDEFEDCBA
ABCDEDCBA
ABCDCBA
ABCBA
ABA
A

Brachylog，37 29字节

感谢Fatalize在整个过程中的协助。

4个字节归功于Fatalize，另外还有4个字节的灵感。

@A:1&e:"a"yr:1&cw@Nw\
:Lc.r.!

在线尝试！

谓词0（主谓词）

@A:1&e:"a"yr:1&cw@Nw\
@A:1&                  Apply predicate 1 to @A, which is
                       basically "abcdefghijklmnopqrstuvwxyz"
     e                 Choose one element from the result (choice point)
      :"a"yr               generate substring from element to "a"
            :1&            apply predicate 1
               c           concatenate
                w          write to STDOUT
                 @Nw       write "\n" to STDOUT
                    \  Backtrack to last choice point to choose
                       another element until there is no more
                       choice left, then halt.

谓词1（辅助谓词）

这基本上从给定的字符串构建回文。

:Lc.r.!
:Lc.     output is [input:L]
   .r.   output reversed is still output
      !  stop searching after the first output

R，127125字节

k=cat;L=LETTERS;for(i in 1:26)k(c(L[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))

对这个解决方案不完全满意，尤其是两个for循环，但是不能提供更好的东西！
LETTERS包含大写字母。

松散

for(i in 1:26){
  cat(c(LETTERS[1:i],LETTERS[(i-1):0],"\n"))
               }

for(i in 1:26){
  cat(c(LETTERS[0:(26-i)],LETTERS[ifelse((25-i)>=0,25-i,0):0],"\n"))
               }

ifelse是取消唱歌的一种较短方法，其if... else...工作方式如下：ifelse(condition,action if TRUE, action if FALSE)

另一种125字节的解决方案：

for(i in 1:26)(k=cat)(c((L=LETTERS)[1:i],L[(i-1):0],"\n"));for(i in 1:26)k(c(L[0:(26-i)],L[ifelse((25-i)>=0,25-i,0):0],"\n"))

Java 131字节

不使用字符串（131字节）

public static void main(String[] args) {
    for(int i = 0 ,k=1; i>-1; i+=k){
        for(int c= 65, d = 1; c>64;){
            d = d>-1 & c < 65+i?1:-1;
            System.out.print((char)c+((c+=d)<65?"\n":""));
        }
        k = k>-1 & i < 25?1:-1;
    }
}

代号

for(int i=0,k=1;i>-1;k=k>-1&i<25?1:-1,i+=k)for(int c=65,d=1;c>64;d=d>-1&c<65+i?1:-1,System.out.print((char)c+((c+=d)<65?"\n":"")));

带字符串（173字节）

String a="abcdefghijklmnopqrstuvwxyz";
for(int i = 1 ,k=1; i>0; i+=k==1?1:-1){
    System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i));
    k = k>-1 & i < 26?1:-1;
}

代号

String a="abcdefghijklmnopqrstuvwxyz";for(int i=1,k=1;i>0;k=k>-1&i<26?1:-1,System.out.println(a.substring(0,i)+new StringBuilder(a).reverse().substring(27-i)),i+=k==1?1:-1);

感谢manatwork和Kevin Cruijssen

Brainfuck，79个字节

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

格式：

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

在线尝试

Sesos，27个字节

0000000: a85ab9 ac5daa f8b1c7 785f9b b961f7 665c1b 73ccfc  .Z..]....x_..a.f\.s..
0000015: c01ecb 987303                                     ....s.

在线尝试！选中调试以查看生成的SBIN代码。

Sesos组装

上面的二进制文件是通过组合以下SASM代码生成的。

add 65, rwd 1, add 10, rwd 2, add 25
jmp
    fwd 3
    jmp
        put, fwd 1
    jnz
    rwd 1
    jmp
        fwd 1, add 1, fwd 1, add 1, rwd 2, sub 1
    jnz
    fwd 2
    jmp
        rwd 2, add 1, fwd 2, sub 1
    jnz
    rwd 1, add 1, rwd 2
    jmp
        put, rwd 1
    jnz
    rwd 1, sub 1
jnz
fwd 3
jmp
    jmp
        put, fwd 1
    jnz
    rwd 1, get, rwd 1
    jmp
        put, rwd 1
    jnz
    fwd 2
; jnz (implicit)

/// 208字节

/'/\/\///+/BA
AB'-/DC+CD'&/FE-EF')/HG&GH'=/JI)IJ'|/LK=KL'7/NM|MN'1/PO7OP'q/RQ1QR'p/TSqST'6/VUpUV'[/XW6WX/A
A+C+C-E-E&G&G)I)I=K=K|M|M7O7O1Q1QqSqSpUpU6W6W[Y[YZY[Y[W6W6UpUpSqSqQ1Q1O7O7M|M|K=K=I)I)G&G&E-E-C+C+A
A

当然没有赢，但是在这里，早于马丁·恩德...