( ได้รับแรงบันดาลใจจากการท้าทายนี้)

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สำหรับค่าลบ / ลดลง0สำหรับ 0 / ต่อเนื่อง1สำหรับค่าบวก / ค่าเพิ่มขึ้น)

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

แทรก a 0ในรายการของสองNulls ในตำแหน่งแรกถ้าสูงขึ้นกลางถ้าดำเนินการต่อและตำแหน่งที่สามถ้าล้ม

Row[Column@ ... ]

จัดรูปแบบเอาต์พุต

หากผลลัพธ์อาจดูแตกต่างจากที่อยู่ในคำถามรหัสข้างต้นอาจสั้นลงถึง 41 ไบต์:

ListPlot@*Sign@*Differences@*LetterNumber

... ซึ่งสร้างบางสิ่งเช่นนี้ (สำหรับ "ABBCBA"):

MATL , 15 , 14 ไบต์

dZSqtQtQv~79*c

ลองออนไลน์!

คำอธิบาย:

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

ก่อนอื่นเราเรียก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สัญกรณ์และแทนที่จะเข้าใจรายการและmaxlast

CJam , 19 ไบต์

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

ใช้แทน0o

ลองออนไลน์!

คำอธิบาย

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 ไบต์

บันทึก 2 ไบต์โดยใช้0แทนoตามที่ Conor O'Brien แนะนำ
2 6 ไบต์บันทึกด้วย 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 ไบต์

รวม +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_' ลดแต่ละรายการด้วยสองและพลิกสัญญาณดังนั้นตอนนี้ถ้าอักขระเพิ่มขึ้นเป็น 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]

สิ่งที่เหลืออยู่คือการแปลงเมทริกซ์จากตัวเลขเป็นตัวอักษรยูนิโค้ดซึ่งทำโดยคำสั่ง '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`
`

เขียนตั้งแต่เริ่มต้นถึงแม้ว่ามันจะเป็นแรงบันดาลใจอย่างมากจาก@ คำตอบ ใช้การเรียกซ้ำเพื่อคำนวณเนื้อหาของแต่ละแถว

ทับทิม, 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;}

2 ไบต์บันทึกขอบคุณที่@Frozn

กรณีที่ไม่ได้รับการทดสอบ &:

ลองที่นี่

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

ตรวจสอบถ้าใส่ถ่านปัจจุบันIมีขนาดเล็กกว่าถ่านถัดไป< Nบันทึกผลลัพธ์ในการตั้งค่าสถานะส่วนกลาง ตรวจสอบผลการตั้งค่าสถานะ?และถ้าเป็นจริงเอาท์พุท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 และพิมพ์ผลลัพธ์

สิ่งนี้ใช้แนวคิดคล้ายกับคำตอบ CJamของ @ MartinEnderคำตอบ

ลองออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมดตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

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

คำอธิบาย

iterates ผ่านสาย (เลข1, 0, -1) จากนั้นวนซ้ำสตริงการป้อนข้อมูลสำหรับทุกบรรทัด เมื่อผลลัพธ์ของการเปรียบเทียบยานอวกาศเท่ากับจำนวนบรรทัดเอาท์พุทหรือoมิฉะนั้นส่งออกช่องว่าง หลังจากทุกบรรทัดพิมพ์บรรทัดใหม่

การปรับแต่ง

• หยุดการวนซ้ำเมื่อ$xมีอยู่-1ซึ่งเราสามารถหาได้ด้วยการปฏิเสธไบนารี (ผลลัพธ์0) บันทึกไบต์เปรียบเทียบกับการเพิ่ม1(หรือ 2 ด้วยการเพิ่มล่วงหน้า)
• บันทึก 3 ไบต์โดยใช้ $argn

Lua 326 303 bytes tl = 0 s = io.read () o1, o2, o3 = "", "", "" t = {} สำหรับ i = 1, # s ทำ t [i] = s: sub (i , i) tl = tl + 1 จุดสิ้นสุดสำหรับ v = 1, tl-1 ทำอย่างไรถ้า t [v] t [v + 1] จากนั้น o1 = o1 .. "" o2 = o2 .. "" o3 = o3 .. " o "end end print (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. รับความแตกต่างที่ 1 และสร้างเวกเตอร์ 3x ยาวเท่ากันด้วยช่องว่างสีขาว
3. จากนั้นให้เปลี่ยนเวกเตอร์พื้นที่สีขาวด้วย#ถ้าความแตกต่าง>0, หรือ==0<0
4. บีบบังคับเวกเตอร์และพิมพ์โดยคั่นด้วยบรรทัดใหม่