( Натхненний цим викликом .)

Скажімо, у нас є рядок 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.

Математика, 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позначення та 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 байт

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 байти (див. Коментарі)

Пояснення:

'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', яке ми отримаємо згодом. (Дякую Луїсу Мендо за ідею поставити значення 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, куди ми хочемо виділити пробіл. Ми знімаємо ці три елементи зі стека і створюємо цю розріджену матрицю за допомогою команди "Z?" З розрідженою матрицею MATL. Це є,

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`
`

Написано з нуля, хоча воно було сильно натхнене відповіддю @ Арнальда . Використовує рекурсію для обчислення вмісту кожного рядка.

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

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

Клора (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 і друкує результат.

Це використовує подібну ідею @ 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, в іншому випадку, виведіть пробіл. Після кожного рядка надрукуйте новий рядок.

Налаштування

• Зупиніть ітерацію, коли $xє -1, що ми можемо знайти за допомогою бінарного заперечення (результату 0). Зберігає байт порівняно з додаванням 1(або 2 з попереднім збільшенням).
• Збережено 3 байти за допомогою $argn

Луа 326 303 байт tl = 0 s = io.read () o1, o2, o3 = "", "", "" t = {} для i = 1, # s do 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 "кінцевий друк (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. Візьміть першу різницю і створіть 3х вектори однакової довжини з пробілами
3. Потім замініть білі простори вектора на, #якщо відмінності є >0, ==0або <0.
4. Примушуйте вектори і друкуйте їх розділеними новими рядками