介绍

编写一个程序，按照给定的规则输出著名的八卦的输出螺旋。

挑战

一个全字母短句是使用给定的字母的每一个字母至少一次的句子。最著名的语言之一是在Windows字体查看器中广泛使用的语言，即“ 快速的棕色狐狸跳过懒狗 ”。挑战在于根据此文本输出螺旋形。

您的任务将输出以下确切文本：

heeeeellllllllllllazzzzzzzzzzz
hummmmmmmmmmmmmppppppppppppppy
hubrrrrrrrrrrrrrrrrrrooooooosy
hukyddddoooooooooooooooggggwsy
hukyveeeeerrrrrrrrrrrrrrrrtwsy
hukyvxjjjjjjjjjjuuuuuuuuuttwsy
hukyvxkbbrrrrrrrrrrrrrrrmttwsy
hukyvxkogggggggttttttttomttwsy
tukyvokoellllllllllllahomttwsy
tukyvokoeovvvvvvvvvvvzhomttwsy
tukyvocoeoummmmmmmmmezhomttwsy
tukyvocoeoufooooooopezhomttwsy
tukyvocohoufroooooxpezhomttwsy
tukyvoiohoufrquuuwxpezhomttwsy
tucyvoiohoufbqttiwxpezhomttwsy
tucyvoiohoufbeehiwxprzhomttwsy
tucyvoiohoufkccciwxprzeomttwsy
tjiyvoidhounnnnnnwxprzeomttwsy
tjiyvoidhojjjjjjjjxprzeomttwsy
tjiyvoidhssssssssssprzeopttwsy
tjiyvoidttttttttttttrzeopttwsy
tjiyvoiyyyyyyyyyyyyyyzqopttwoy
tjiyvouuuuuuuuuuuuuuuuqwpttwoy
tjiyvffffnnnnnnnnnnnnnnwpttwoy
tjiyossssssssssssssssssspthwoy
tjizzzzalllllllllllleeeeehhwoy
tjuuqqqqqqqqqqqqqqqqqeeeeehnod
txxxxxoooooooooooooooffffffnod
reeeeevvvvvvvvvvvvvvvvvvvvvvod
       gggggggoooooooooooooood

它是这样产生的，

• 有一只热心的狐狸喜欢八卦，“敏捷的棕色狐狸跳过了懒狗”。一天，他在向外螺旋的中心，决定跳进去并画画。
• 他想从头到尾遍历全能图，如果一个字母是字母表中的第n个字母，他想把它画n次。
• 但是，狐狸不太擅长在拐角处转弯，因此在到达每个拐角处时，他还必须停下来切换到下一个字母。
• 他还决定重复三次全字母短句强调，他是在敏捷的棕色狐狸。
• 您的工作是显示在狐狸涂完所有这些字母后的螺旋状。

（普通版，不讲故事）

• 重复三次著名的字母“快速的棕色狐狸越过懒狗”，去掉空格，所有字母都小写，生成

  thequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydog
  

• 螺旋从中心开始，以字母“ t”开始，从右向开始，然后顺时针向外延伸。如果当前字符是字母表中的第n个字母，则无论何时只要切换到下一个字符

  • 螺旋到达一个角，或
  • 当前字母正好打印n次。

为了更好地说明这一点，我将解释如何生成与前三个单词“ thequickbrown”相关的螺旋。

 rooooo
 rquuuw
 bqttiw
 beehiw
 kccciw
nnnnnnw

狐狸从“ t”开始，向右走，到达第一个角，用“ t”绘画，然后切换到“ h”，然后下降，到达第二个角，切换到“ e”，向左走，到达第3个角，切换到“ q”并上升，到达第4个角，切换到“ u”并右拐，到达一个角并切换到“ i”，下降，到达一个角并切换到“ c”，然后上升左，在到达下一个角之前成功绘制3个“ c”，切换到“ k”并继续向左，立即到达一个角，切换到“ b”并上升，在到达前绘制2个“ b”下一个角落，切换到“ r”然后继续往上走，到一个拐角处，然后切换为“ o”，向右走，然后依次为“ w”，向下，“ n”，左侧。

眼镜

• 您可以采用包含任何标准形式的字符串的可选输入

  thequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydog
  

• 您的输出必须格式化为字符串，并且必须转到STDOUT而不是文件或STDERR，并正确放置换行符。标题行和尾随的空行无关紧要。每行中的标题和尾部空格是允许的，但必须保持一致。因此，如果在给定文本的一行之前添加5个空格，则需要在每行之前恰好添加5个空格，以使螺旋看起来相同。

• 这是代码高尔夫球，赢得的最低字节数。

• 像往常一样，此处存在默认漏洞。

_{欢迎解释，尽管没有必要。}

_{标题由caird coinheringaahing编辑，使其对每个评论都非常有用。}

_{懒狗太懒了，无法出现在故事​​中。}

_{我的目标是创建一个字符串挑战，其中要输出的字母不能通过简单的坐标函数来计算。}

Stax，35 34 33 32 字节

é╛îá%ⁿ┌○iê}→Ug=╩◙╘Ç⌐)QX↑L╓₧╗▌╧▬q

在线运行和调试

Stax是我一直致力于大约6个月的一种语言。这是第一次公开高尔夫。让我们转到工作上。

Stax通常以可打印的ASCII字符集编写。这34个字节的提交被打包到CP437字符集的变体中。相应的ascii表示为

't],{]_96-*~cHT,+nh%^(XUs&xH{rM}MF|<mr

Stax是一种基于堆栈的语言，但是它具有两个数据堆栈，即“ main”和“ input”。大多数操作使用主堆栈，但是输入从输入堆栈开始。Stax指令主要是一两个字符的ASCII序列。它们中的大多数都过载，这意味着它们的行为由堆栈上的前几个值确定。

在较高的层次上，该程序通过将字符串重复添加到最后一行来构建网格。当最后一行填满时，它将顺时针旋转网格。最后，它水平镜像网格。更详细地讲，该程序的工作方式如下。

't],{]_96-*~cHT,+nh%^(XUs&xH{rM}MF|<mr
't]                                         ["t"]
   ,                                        Pop from input, push to main ("thequick...")
    {                            F          For each character in input, execute block...
     ]_96-*                                 Produce string using character appropriate
                                                number of times (a=1, b=2, etc)
           ~                                Pop from main, push to input for use later
            cH                              Copy last row from grid.
              T                             Right-trim whitespace
               ,+                           Pop from input stack and append
                 nh%                        Get the width of the first row of the grid
                    ^                       Add 1
                     (                      Right-pad/truncate string to this length
                      X                     Store in the x register
                       Us&                  Overwrite last row of the grid with new value.
                          xH                Get the last element from x.
                                                Basically, the lower right corner.
                             {  }M         Conditionally execute block.  This will happen 
                                                when the bottom right corner isn't a space.
                              rM            Reverse and transpose (aka rotate clockwise)
                                  |<        Left-justify grid; give all rows equal size.
                                     m      For each row, execute the rest of the program
                                               and then print the result to output
                                      r     Reverse the row

木炭，66 40 36字节

≔²ηＦＳ«Ｆ¬η«¶↷⊞υη≔⊕÷Ｌυ²η¶»Ｆ⊕⌕βι¿η«≦⊖ηι

在线尝试！链接是详细版本的代码。编辑：通过将文本作为输入保存了16个字节。说明：

≔²η

t由于某种原因，请从2 秒开始。

ＦＳ«

循环显示字母中的所有字母。

Ｆ¬η«

我们到了一个角落吗？

¶

向下（或下一个方向将会是）向下移动一行。

↷

将打印方向顺时针旋转90°。

⊞υη≔⊕÷Ｌυ²η

计算下边的长度。

¶»

完成固定光标位置。（木炭本来希望该边在拐角处之前结束，以便您在拐角处自己旋转。）

Ｆ⊕⌕βι

循环播放当前字母在字母表中的位置次数。

¿η«

如果还没到角落，

≦⊖ηι

减少计数并打印当前字母。

红宝石，217个 212 209 208字节

->s{s+=' '*8
x=0
a=[""]*30
i=14
a[i]=?t
l=->{a[i]=s[x]+a[i]}
r=->{a[i]+=s[x]}
(0..58).map{|g|c=0
(0..g/2).map{c>s[x].ord-97&&(x+=1;c=0)
c+=1
eval %w{r i+=1;r l i-=1;l}[g%4]+"[]"}
x+=1}
a[-1].slice!0
$><<a*$/}

在线尝试！

花大量时间管理指针，因此可能会有更多打高尔夫球的空间。

-5个字节：输入前将三倍的pangram 。感谢周伟军。

-3个字节：填充输入字符串并修剪最后一条腿，而不是从头开始生成最后一条腿。

-1个字节：&&代替具有抛弃值的三元运算符。

说明：

->s{
  s += " " * 8                             # These spaces will show on the bottom row
  x = 0                                    # x is a pointer into s
  a = [""] * 30                            # a is an array of row strings
  i = 14                                   # i is a pointer into a
  a[i] = ?t                                # "Starts with two t's for some reason"
  l = ->{ a[i] = s[x]+a[i] }               # lambda to prepend char x to row i
  r = ->{ a[i] += s[x] }                   # lambda to append char x to row i
  (0..57).map{|g|                          # There are 58 "legs" to the spiral
    c = 0                                  # c is the print count of s[x]
    (0..g/2).map{                          # Leg g has g/2+1 characters
      c > s[x].ord-97 && (x+=1;c=0)        # Possibly switch to next letter
      c += 1
      eval %w{r i+=1;r l i-=1;l}[g%4]+"[]" # Call the appropriate lambda
    }
    x += 1                                 # Definitely switch to next letter
  }
  a[-1].slice!0                            # Remove the first char from the bottom row
  $> << a*$/                               # Join with newlines and print
}