（受此挑战启发。）

假设我们有一个字符串ABBCBA。我们可以说，之间存在上升A和B，为B如下A; 我们可以说B和之间有一个过渡B，没有任何变化；最后我们可以说C和之间有一个落差B。我们可以这样画一个图：

             A   B   B   C   B   A
Rising:        o       o
Continuing:        o
Falling:                   o   o

没有标签，并最小化空白：

o o
 o
   oo

这是输入的预期输出ABBCBA。

您可以使用任何非空白字符替换o输出中的字符。此外，每列之间可以选择有一个额外的空间，如下所示：

o   o
  o 
      o o

输入内容将至少包含三个字符。该字符串将完全由大写字母组成，但是您可以改用小写字母。

测试用例

TEST CASE
LINE 1
LINE 2
LINE 3

HELLOWORLD
 o oo o
  o
o    o oo

TESTCASE
 oo  o

o  oo o

EXAMINATION
o o o o o

 o o o o o

ZSILENTYOUTH
  o ooo o

oo o   o oo

ABC
oo



ABCBA
oo

  oo

果冻，11 字节

OIṠ“ o ”ṙZY

在线尝试！或验证所有测试用例。

怎么运行的

OIṠ“ o ”ṙZY  Main link. Argument: s (string)

O            Ordinal; replace all characters with their code points.
 I           Increments; compute the differences of consecutive code points.
  Ṡ          Sign function.
   “ o ”ṙ    Rotate that string -1, 0, or 1 unit(s) to the left.
         Z   Zip; transpose rows and columns.
          Y  Join, separating by linefeeds.

Mathematica，93 83 68 64字节

（使用0，不是O）

Row[Column@Insert[{,},0,2-#]&/@Sign@Differences@LetterNumber@#]&

说明

LetterNumber@#

获取输入的每个字符在字母表中的位置。

Sign@Differences@

取每个连续元素之间的差，并取符号（-1负/下降，00 /连续，1正/上升）

Insert[{,},0,2-#]&

0在两个Nulls 的列表中插入a ，如果上升则插入第一个位置，如果继续则插入中间，如果下降则插入第三个位置。

Row[Column@ ... ]

格式化输出。

如果输出看起来与问题中的输出不同，则上述代码可以缩短为41个字节：

ListPlot@*Sign@*Differences@*LetterNumber

...会创建以下内容（对于“ ABBCBA”）：

MATL，15，14个字节

dZSqtQtQv~79*c

在线尝试！

说明：

他们说一张图片值一千个单词，所以这里是一个beta在线解释器，它向您显示更新时实时显示的堆栈顶部的价值。请注意，它仍处于测试阶段，因此您可能需要多次运行。

所以首先，我们致电dZS。d给我们每个连续元素之间的差，并ZS给我们每个元素的符号（-1、0或1）。因此，以“ HELLOWORLD”作为输入，第一步之后，我们将获得：

-1  1  0  1  1 -1  1 -1 -1

现在，我们只是使用q减量来获得：

-2  0 -1  0  0 -2  0 -2 -2

然后两次，我们复制堆栈的顶部并递增数组（tQ），之后我们将得到

-2  0 -1  0  0 -2  0 -2 -2
-1  1  0  1  1 -1  1 -1 -1
0   2  1  2  2  0  2  0  0

现在所有的“ 0”都是我们要输出字符的地方。因此，我们将这三个数组合并为一个矩阵（v），并在逻辑上取反（~）。然后，将矩阵中的每个值乘以ASCII值'O'（79*），然后将其显示为字符串c。

Haskell，63个字节

f w=[do(e,y)<-zip w$tail w;max" "['o'|b e y]|b<-[(<),(==),(>)]]

返回三个字符串的列表，代表输出的行。不包含任何潜意识信息。

戴安娜（Dianne）使用do表示法而max不是列表理解和节省了三个字节last。

CJam，19个字节

l2ew{:-g)S3*0t}%zN*

用0代替o。

在线尝试！

说明

l      e# Read input.
2ew    e# Get all pairs of consecutive letters.
{      e# Map this block over the pairs...
  :-   e#   Compute the difference between the two letters.
  g    e#   Signum. Gives -1 for rises, 1 for falls, 0 otherwise.
  )    e#   Increment. Gives 0 for rises, 2 for falls, 1 otherwise. Call this i.
  S3*  e#   Push a string with three spaces.
  0t   e#   Replace the i'th space (zero-based) with a zero.
}%
z      e# Transpose.
N*     e# Join with linefeeds.

Python 2，76 71字节

lambda s:[''.join(' o'[cmp(*x)==n]for x in zip(s,s[1:]))for n in-1,0,1]

感谢@xnor通知我，允许返回字符串列表。

在Ideone上进行测试。

JavaScript（ES6），96 95 89 87 82字节

根据Conor O'Brien的建议，使用0代替节省了o
2个字节2 ETHproductions节省了6个字节

let f =

s=>[1,0,-1].map(k=>s.replace(/./g,(c,i)=>i--?(c>s[i])-(c<s[i])-k&&' ':'')).join`
`

console.log(f("HELLOWORLD"));
console.log(f("EXAMINATION"));

Perl，47个字节

包括+1的 -p

在STDIN上输入：

bumpy.pl <<< ABBCBA

bumpy.pl：

#!/usr/bin/perl -p
$_ x=3;s%.%/\G(.)(.)/?$2cmp$1^$.&&$":--$.>0%eg

MATL，16 14字节

dZSqq_tn:79Z?c

在线尝试！

这源于对DJMCMahem答案的讨论。即使此答案在相同长度下长了2个字符，但方法还是有些不同，因此可能会引起人们的关注。

感谢Luis Mendo的建议，它节省了2个字节（请参阅注释）

说明：

'dZS'得到一个向量，其中每个条目都是连续字符之间差异的符号，然后'qq_'将每个条目减2并翻转符号，所以现在如果字符增加，则为1，如果保持不变，则为2，并减少3。例如，

dZSqq_ applied to 'HELLOWORLD' creates the vector [3 1 2 1 1 3 1 3 3]

接下来，“ t”在堆栈上复制前一个向量，然后“ n：”将向量[1,2,3,4，...]也放置在堆栈上。然后'79'将值79放置在堆栈上。选择值79是因为它是Unicode字符'o'的数字，稍后将作为输出。（感谢路易斯·门多（Luis Mendo）提出将值79放在此处而不是稍后的想法）

tn:79 applied to [3 1 2 1 1 3 1 3 3] creates the following items:
[3 1 2 1 1 3 1 3 3]   <-- first item on the stack
[1 2 3 4 5 6 7 8 9]   <-- second item on the stack
79                    <-- third item on the stack

在这一点上，我们正好有一个稀疏矩阵的行索引，列索引和非零值，无论何时需要输出字符，其值都为79；而要输出空白的位置，其值为0。我们将这三个项目从堆栈中取出，并使用MATL的稀疏矩阵命令'Z？'创建此稀疏矩阵。那是，

dZSqq_tn:79 Z? applied to 'HELLOWORLD' outputs the following:
[0  79 0  79 79 0  79 0  0 ]
[0  0  79 0  0  0  0  0  0 ]   <-- 3-by-n sparse matrix
[79 0  0  0  0  79 0  79 79]

剩下的就是将矩阵从数字转换为Unicode字符，这是通过命令“ c”完成的。79变成'o'，0变成空格：

dZSqq_tn:79Z?c applied to 'HELLOWORLD' outputs:
[  o   o o   o    ]
[    o            ]   <-- 3-by-n sparse matrix of characters.
[o         o   o o]

然后隐式显示所得的字符矩阵。

PHP，95字节

for($b[1]=$b[0]=$b[-1]=" ";($s=$argv[1])[++$i];)$b[$s[$i-1]<=>$s[$i]][$i]=8;echo join("\n",$b);

1，创建索引为-1到1的字符串数组 $b=array_fill(-1,3," ");

2.填写由飞船操作员和输入位置所依赖的字符串

3.输出用新行连接数组

第一路111字节

for($o=" ";$i<$l=strlen($s=$argv[1])-1;)$o[$l*(1+($s[$i]<=>$s[$i+1]))+$i++]=8;echo join("\n",str_split($o,$l));

使用飞船操作员<=> 飞船操作员

JavaScript（ES6），81个字节

s=>[s,s,s].map(f=([c,...s],n)=>(p=s[0])?((c<p)-(c>p)+n-1&&" ")+f(s,n):"").join`
`

从头开始编写，尽管它在很大程度上受到@Arnauld的回答的启发。使用递归计算每行的内容。

Ruby，66 64字节

->s{(-1..1).map{|n|s.gsub(/.(?=(.))/){"o  "[n+($1<=>$&)]}.chop}}

在eval.in上查看：https：//eval.in/649503

Java 7中，158个 156字节

String c(char[]z){String a,b,c=a=b="";for(char i=1,q=z[0],o=79,s=32,x;i<z.length;a+=(x=z[i])>q?o:s,b+=x==q?o:s,c+=x<q?o:s,q=z[i++]);return a+"\n"+b+"\n"+c;}

@Frozn节省了2个字节。

非高尔夫球和测试用例：

在这里尝试。

class M{
  static String c(char[] z){
    String a,
           b,
           c = a = b = "";
    for(char i = 1,
             q = z[0],
             o = 79,
             s = 32,
             x; i < z.length; a += (x = z[i]) > q
                                     ? o
                                     : s,
                              b += x == q
                                     ? o
                                     : s,
                              c += x < q
                                     ? o
                                     : s,
                              q = z[i++]);
    return a + "\n" + b + "\n" + c;
  }

  public static void main(String[] a){
    print("HELLOWORLD");
    print("TESTCASE");
    print("EXAMINATION");
    print("ZSILENTYOUTH");
    print("ABC");
    print("ABCBA");
    print("ABBCBA");
    print("UVVWVVUVVWVVUVVW");
  }

  static void print(String s){
    System.out.println(c(s.toCharArray()));
    System.out.println("-------------------------");
  }
}

输出：

 O OO O  
  O      
O    O OO
-------------------------
 OO  O 

O  OO O
-------------------------
O O O O O 

 O O O O O
-------------------------
  O OOO O  

OO O   O OO
-------------------------
OO


-------------------------
OO  

  OO
-------------------------
O O  
 O   
   OO
-------------------------
O O   O O   O O
 O  O  O  O  O 
   O O   O O   
-------------------------

Clora（20字节）

<IN?o ;=IN?o ;>IN?o

说明：

有3个Clora程序，每条输出线一个。

第一个程序 <IN?o

检查当前输入的char I是否小于<下一个char N。将结果保存在全局标志中。检查标志结果?，如果为true，则输出output o，否则为空格（是的，那里有一个空格。

所有其他程序，遵循相同的规则，并由分隔;，每个程序都将执行并接收输入作为参数。

您可以自己测试它，包括clora.js并执行

(function() {
  var x = new Clora('<IN?o ;=IN?o ;>IN?o ');
  x.execute('EXAMINATION', function(r) {
    console.log(r)
  })
})();

Pyth，21个字节

jCmX*3\ h._d0-M.:CMz2

一个程序，该程序在STDIN上输入未加引号的字符串并打印结果。

这使用了类似于@MartinEnder的CJam答案的想法。

在线尝试或验证所有测试用例。

怎么运行的

jCmX*3\ h._d0-M.:CMz2  Program. Input: z
                 CMz   Map ordinal over z, yielding the code-points of the characters
               .:   2  Yield all length-2 sublists of that
             -M        Map subtraction over that
  m                    Map the following over that with variable d:
         ._d            Yield the sign of d
        h               Increment that (i)
    *3\                 Yield string literal of 3 spaces, "   "
   X        0           Replace the space at index i with 0
 C                     Transpose that
j                      Join that on newlines
                       Implicitly print

PHP 7，81 80 77字节

注意：使用Windows-1252编码

for($x=2;~$x--;print~õ)for($a=$argn;$c=$a[$$x+1];)echo$c<=>$a[$$x++]^$x?~ß:o;

像这样运行：

echo HELLOWORLD | php -nR 'for($x=2;~$x--;print"\n")for($a=$argn;$c=$a[$$x+1];)echo$c<=>$a[$$x++]^$x?" ":o;';echo

说明

通过线迭代（编号1，0，-1）。然后遍历每行的输入字符串。当飞船比较的结果等于行号时，输出o，否则输出一个空格。每行之后，打印换行符。

调整

• 停止对$xis进行迭代-1，可以通过二进制取反（结果0）找到。与添加相比节省一个字节1（或2个带预增量的字节）。
• 通过使用节省了3个字节 $argn

LUA 326 303字节TL = 0 S = io.read（）O1，O2，O3 = “”， “” “” T = {}，对于i = 1，＃就做T [1] = S：子（ⅰ ，i）v = 1，tl-1的tl = tl + 1结尾，如果t [v] t [v + 1]则o1 = o1 ..“” o2 = o2 ..“” o3 = o3 ..“ o“结束打印（o1 ..” \ n“ .. o2 ..” \ n“ .. o3）

非高尔夫版本

tl = 0 --set the tables length to 0
s = io.read() --Get the string from input
o1,o2,o3="","","" --Set the 3 output rows to empty strings
t = {} --Make a table for the string to be sent into
for i = 1, #s do --Loop from 1 to the length of the string
    t[i] = s:sub(i, i) --Set the I-th term in the table to the I-th character in the string
    tl = tl+1 --Add 1 to the table length
end --End the loop
for v=1,tl-1, 1 do --Loop from 1 to the tables length - 1, incrementing by 1
    if t[v] < t[v+1] then --Lua supports greater than less than and equals to with charactes, so this if statement detects if the string is rising
        o1=o1.."o" --Adds an o to the end of the first line of output
        o2=o2.." " --Adds a space to the second line
        o3=o3.." " --Adds a space to the third line
    elseif t[v] == t[v+1] then --Detects if the string is continuing
        o1=o1.." " --Adds a space to the first line
        o2=o2.."o" --Adds an o to the second line
        o3=o3.." " --Adds a space to the third line
    elseif t[v] > t[v+1] then --Detects if string is falling
        o1=o1.." " --Adds a space to the first line
        o2=o2.." " --Adds a space to the second line
        o3=o3.."o" --Adds an o to the third line
    end --Ends the if statement
end --Ends the loop
print(o1.."\n"..o2.."\n"..o3) --Prints the output

R，114字节

非竞争性的R答案。

v=y=z=rep(" ",length(x<-diff(utf8ToInt(scan(,"")))));v[x>0]="#";y[x==0]="#";z[x<0]="#";cat(v,"\n",y,"\n",z,sep="")

说明

1. 从命令行读取输入并转换为ASCII十进制向量
2. 求第一差，并用空格创建相同长度的3x向量
3. 然后用更换的白色空间矢量#，如果差异>0，==0或<0。
4. 强制矢量并用换行符分隔打印