( Lấy cảm hứng từ thử thách này .)

Hãy nói rằng chúng ta có một chuỗi ABBCBA. Chúng ta có thể nói rằng có một sự gia tăng giữa Avà B, cho Bsau A; chúng ta có thể nói rằng có một sự chạy giữa Bvà B, không có gì thay đổi; và cuối cùng chúng ta có thể nói có một mùa thu giữa Cvà B. Chúng ta có thể vẽ một biểu đồ như thế này:

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

Không có nhãn và giảm thiểu khoảng trắng:

o o
 o
   oo

Đây là đầu ra dự kiến ​​cho đầu vào ABBCBA.

Bạn có thể sử dụng bất kỳ ký tự không phải khoảng trắng nào để thay thế otrong đầu ra. Hơn nữa, mỗi cột tùy ý có thể có thêm một khoảng trắng giữa chúng, như vậy:

o   o
  o 
      o o

Đầu vào sẽ bao gồm ít nhất ba ký tự. Chuỗi sẽ bao gồm hoàn toàn các chữ cái viết hoa, nhưng thay vào đó bạn có thể sử dụng các chữ cái viết thường.

Các trường hợp thử nghiệm

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

Thạch , 11 byte

OIṠ“ o ”ṙZY

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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.

Toán học, 93 83 68 64 byte

(sử dụng 0, không O)

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

Giải trình

LetterNumber@#

Có được vị trí trong bảng chữ cái của mỗi ký tự của đầu vào.

Sign@Differences@

Lấy sự khác biệt giữa từng yếu tố liên tiếp và lấy dấu ( -1cho âm / giảm, 0cho 0 / tiếp tục, 1cho dương / tăng)

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

Chèn a 0vào danh sách hai Nulls, ở vị trí đầu tiên nếu tăng, giữa nếu tiếp tục và vị trí thứ ba nếu rơi.

Row[Column@ ... ]

Định dạng đầu ra.

Nếu đầu ra có thể trông khác với câu hỏi trong đoạn mã, đoạn mã trên có thể được rút ngắn xuống còn 41 byte:

ListPlot@*Sign@*Differences@*LetterNumber

... tạo ra thứ gì đó như thế này (cho "ABBCBA"):

MATL , 15 , 14 byte

dZSqtQtQv~79*c

Hãy thử trực tuyến!

Giải trình:

Họ nói rằng một bức tranh đáng giá cả ngàn từ, vì vậy đây là một trình thông dịch trực tuyến beta cho bạn thấy giá trị trên đầu trang trực tiếp khi nó cập nhật. Lưu ý rằng nó vẫn đang trong giai đoạn thử nghiệm, vì vậy bạn có thể cần phải chạy nhiều lần.

Vì vậy, đầu tiên, chúng tôi gọi dZS. dcung cấp cho chúng tôi sự khác biệt giữa từng yếu tố liên tiếp và ZScung cấp cho chúng tôi dấu (-1, 0 hoặc 1) của mỗi yếu tố. Vì vậy, với 'HELLOWORLD' làm đầu vào, sau bước đầu tiên chúng ta sẽ có:

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

Bây giờ, chúng tôi chỉ sử dụng qđể giảm giá này và nhận được:

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

Và sau đó hai lần chúng ta nhân đôi đỉnh của ngăn xếp và tăng mảng ( tQ) Sau này chúng ta sẽ có

-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

Bây giờ tất cả các số 0 là nơi chúng ta muốn xuất ký tự. Vì vậy, chúng ta nối ba mảng này thành một ma trận ( v) và phủ nhận một cách hợp lý nó ( ~). Sau đó, chúng tôi nhân mọi giá trị trong ma trận với giá trị ASCII của 'O', ( 79*) và hiển thị nó dưới dạng một chuỗi với c.

Haskell, 63 byte

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

Trả về danh sách ba chuỗi, biểu thị các dòng đầu ra. Không chứa thông điệp thăng hoa.

dianne đã lưu ba byte bằng cách sử dụng doký hiệu và maxthay vì hiểu danh sách và last.

CJam , 19 byte

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

Sử dụng 0thay vì o.

Hãy thử trực tuyến!

Giải trình

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 byte

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

Cảm ơn @xnor đã thông báo cho tôi rằng việc trả lại danh sách các chuỗi được cho phép.

Kiểm tra nó trên Ideone .

JavaScript (ES6), 96 95 89 87 82 byte

2 byte được lưu bằng cách sử dụng 0thay vì o, như được đề xuất bởi Conor O'Brien
2 6 byte được lưu nhờ vào ETHproductions

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 byte

Bao gồm +1 cho -p

Cung cấp đầu vào trên STDIN:

bumpy.pl <<< ABBCBA

bumpy.pl:

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

MATL, 16 14 byte

dZSqq_tn:79Z?c

Hãy thử trực tuyến!

Điều này phát triển từ một cuộc thảo luận về câu trả lời của DJMCMahem . Mặc dù câu trả lời này dài hơn 2 ký tự , nhưng phương thức này có phần khác nhau nên có thể được quan tâm độc lập.

Cảm ơn Luis Mendo vì đã gợi ý tiết kiệm 2 byte (xem bình luận)

Giải trình:

'dZS' nhận được một vectơ trong đó mỗi mục nhập là dấu hiệu của sự khác biệt giữa các ký tự thành công, sau đó 'qq_' giảm mỗi mục nhập hai lần và lật ký hiệu, vì vậy bây giờ nếu ký tự tăng nó là 1, nếu nó giữ nguyên 2, và nếu nó giảm 3. Ví dụ:

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

Tiếp theo, 't' tạo một bản sao của vectơ trước đó trên ngăn xếp, sau đó 'n:' đặt vectơ [1,2,3,4, ...] lên ngăn xếp. Sau đó, '79' đặt giá trị 79 trên ngăn xếp. Giá trị 79 được chọn vì đó là số cho ký tự unicode 'o', sẽ là đầu ra của chúng ta sau này. (Cảm ơn Luis Mendo vì ý tưởng đặt giá trị 79 ở đây thay vì sau này)

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

Tại thời điểm này, chúng ta có chính xác các chỉ số hàng, chỉ số cột và giá trị khác không của một ma trận thưa thớt có giá trị 79 bất cứ nơi nào chúng ta muốn ký tự đầu ra và 0 bất cứ nơi nào chúng ta muốn xuất khoảng trắng. Chúng tôi lấy ba mục này ra khỏi ngăn xếp và tạo ma trận thưa thớt này bằng lệnh ma trận thưa thớt của MATL 'Z?'. Đó là,

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]

Tất cả những gì còn lại là chuyển đổi ma trận từ các số thành các ký tự unicode, được thực hiện bằng lệnh 'c'. 79 trở thành 'o' và 0 trở thành khoảng trắng:

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

Ma trận kết quả của ký tự sau đó được hiển thị ngầm.

PHP, 95 byte

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

1. Tạo một chuỗi các chuỗi có chỉ số -1 đến 1 thay thế $b=array_fill(-1,3," ");

2. Điền các chuỗi phụ thuộc bởi toán tử tàu vũ trụ và vị trí của đầu vào

3.Output tham gia mảng với một dòng mới

Cách thứ nhất 111 byte

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));

Sử dụng toán tử <=> tàu vũ trụ toán tử

JavaScript (ES6), 81 byte

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

Được viết từ đầu, mặc dù nó được truyền cảm hứng rất nhiều từ câu trả lời của @ Arnauld . Sử dụng đệ quy để tính toán nội dung của từng hàng.

Ruby, 66 64 byte

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

Xem nó trên eval.in: https://eval.in/649503

Java 7, 158 156 byte

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;}

Lưu 2 byte nhờ @Frozn .

Các trường hợp bất ngờ & thử nghiệm:

Hãy thử nó ở đây.

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("-------------------------");
  }
}

Đầu ra:

 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 byte)

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

Giải trình:

Có 3 chương trình Clora, một cho mỗi dòng đầu ra.

Chương trình đầu tiên, <IN?o

Kiểm tra xem char đầu vào hiện tại Icó nhỏ <hơn char tiếp theo không N. Lưu kết quả trong một lá cờ toàn cầu. Kiểm tra kết quả cờ ?và nếu đúng, đầu ra o, nếu không thì một khoảng trắng (vâng, có một khoảng trống ở đó.

Tất cả các chương trình khác, tuân theo cùng một quy tắc và được phân tách bằng ;, mọi chương trình được thực thi và nhận đầu vào dưới dạng đối số.

Bạn có thể tự kiểm tra nó bao gồm clora.js và thực hiện nó với

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

Bình thường, 21 byte

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

Một chương trình lấy đầu vào của một chuỗi không trích dẫn trên STDIN và in kết quả.

Điều này sử dụng một ý tưởng tương tự như câu trả lời CJam của @ MartinEnder .

Hãy thử trực tuyến hoặc Xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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 byte

Lưu ý: sử dụng mã hóa Windows-1252

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

Chạy như thế này:

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

Giải trình

Lặp trên dòng (đánh số 1, 0, -1). Sau đó lặp lại qua chuỗi đầu vào cho mỗi dòng. Khi kết quả so sánh tàu vũ trụ bằng số dòng, xuất ra mộto khác, xuất ra một khoảng trắng. Sau mỗi dòng, in một dòng mới.

Tinh chỉnh

• Dừng lặp khi $xlà -1, mà chúng ta có thể tìm thấy bằng cách phủ định nhị phân (kết quả 0). Lưu một byte so với việc thêm 1(hoặc 2 với mức tăng trước).
• Đã lưu 3 byte bằng cách sử dụng $argn

Lua 326 303 byte tl = 0 s = io.read () o1, o2, o3 = "", "", "" t = {} cho i = 1, # s do t [i] = s: sub (i , i) tl = tl + 1 kết thúc cho v = 1, tl-1 làm nếu t [v] t [v + 1] thì o1 = o1 .. "" o2 = o2 .. "" o3 = o3 .. " o "kết thúc in (o1 .." \ n ".. o2 .." \ n ".. o3)

Một phiên bản vô văn hóa

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 byte

Một câu trả lời R không cạnh tranh.

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="")

Giải trình

1. Đọc đầu vào từ dòng lệnh và chuyển đổi thành vector thập phân ascii
2. Lấy điểm khác biệt thứ 1 và tạo một vectơ 3x có cùng độ dài với khoảng trắng
3. Sau đó thay thế các vectơ khoảng trắng bằng #nếu sự khác biệt là >0, ==0hoặc <0.
4. Ép buộc các vectơ và in chúng cách nhau bởi dòng mới