( Zainspirowany tym wyzwaniem .)

Powiedzmy, że mamy ciąg ABBCBA. Możemy powiedzieć, że istnieje wzrost pomiędzy Ai B, dla Bnastępujących A; możemy powiedzieć, że istnieje bieg pomiędzy Bi B, ponieważ nic się nie zmienia; i na koniec możemy powiedzieć, że jest spadek między Ca B. Możemy narysować taki wykres:

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

Bez etykiet i minimalizowanie białych znaków:

o o
 o
   oo

Jest to oczekiwany wynik dla danych wejściowych ABBCBA.

Możesz użyć dowolnego znaku spacji, aby zastąpić owynik. Co więcej, każda kolumna może opcjonalnie mieć między sobą dodatkową przestrzeń, na przykład:

o   o
  o 
      o o

Dane wejściowe będą się składały z co najmniej trzech znaków. Ciąg będzie składał się wyłącznie z wielkich liter, ale zamiast tego możesz użyć małych liter.

Przypadki testowe

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

Galaretka , 11 bajtów

OIṠ“ o ”ṙZY

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

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 bajtów

(używa 0, nie O)

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

Wyjaśnienie

LetterNumber@#

Pobiera pozycję w alfabecie każdego znaku wejścia.

Sign@Differences@

Pobiera różnicę między każdym kolejnym elementem i przyjmuje znak ( -1dla negatywu / spadku, 0dla 0 / kontynuacji, 1dla pozytywu / wzrostu)

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

Wstawia a 0na liście dwóch Nulls, w pierwszej pozycji, gdy rośnie, środkowej, jeśli kontynuuje, i trzeciej pozycji, jeśli spada.

Row[Column@ ... ]

Formatuje dane wyjściowe.

Jeśli dane wyjściowe mogą wyglądać inaczej niż w pytaniu, powyższy kod można skrócić do 41 bajtów:

ListPlot@*Sign@*Differences@*LetterNumber

... który tworzy coś takiego (dla „ABBCBA”):

MATL , 15 , 14 bajtów

dZSqtQtQv~79*c

Wypróbuj online!

Wyjaśnienie:

Mówią, że obraz jest wart tysiąca słów, więc tutaj jest internetowy tłumacz w wersji beta, który pokazuje wartość na szczycie stosu na żywo podczas aktualizacji. Pamiętaj, że wciąż jest w fazie beta, więc może być konieczne kilkukrotne naciśnięcie przycisku Uruchom.

Najpierw dzwonimy dZS. ddaje nam różnicę między każdym kolejnym elementem i ZSdaje nam znak (-1, 0 lub 1) każdego elementu. Więc z 'HELLOWORLD' jako wejściem, po pierwszym kroku będziemy mieli:

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

Teraz po prostu qzmniejszamy to i otrzymujemy:

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

A następnie dwa razy duplikujemy górę stosu i zwiększamy tablicę ( tQ) Po tym będziemy mieli

-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

Teraz wszystkie „0” są tam, gdzie chcemy wypisać znak. Łączymy te trzy tablice w macierz ( v) i logicznie negujemy ( ~). Następnie mnożymy każdą wartość w macierzy przez wartość ASCII „O”, ( 79*) i wyświetlamy ją jako ciąg znaków c.

Haskell, 63 bajty

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

Zwraca listę trzech ciągów znaków reprezentujących linie wyjściowe. Nie zawiera żadnych podprogowych wiadomości.

dianne zapisał trzy bajty, używając donotacji i maxzamiast rozumienia listy i last.

CJam , 19 bajtów

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

Używa 0zamiast o.

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Dzięki @xnor za powiadomienie mnie, że dozwolone jest zwracanie listy ciągów.

Przetestuj na Ideone .

JavaScript (ES6), 96 95 89 87 82 bajtów

2 bajty zapisane przy użyciu 0zamiast o, jak sugeruje Conor O'Brien
2 6 bajtów zaoszczędzonych dzięki produktom ETH

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 bajtów

Obejmuje +1 dla -p

Podaj dane wejściowe STDIN:

bumpy.pl <<< ABBCBA

bumpy.pl:

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

MATL, 16 14 bajtów

dZSqq_tn:79Z?c

Wypróbuj online!

Wynikało to z dyskusji na temat odpowiedzi DJMCMahem . Mimo że ta odpowiedź ma 2 znaki dłuższe o tej samej długości, metoda jest nieco inna, więc może być niezależna.

Podziękowania dla Luisa Mendo za sugestię oszczędzającą 2 bajty (patrz komentarze)

Wyjaśnienie:

„dZS” otrzymuje wektor, w którym każdy wpis jest znakiem różnic między kolejnymi znakami, a następnie „qq_” zmniejsza każdy wpis o dwa i odwraca znak, więc teraz, jeśli znak się zwiększy, wynosi 1, jeśli pozostaje taki sam 2, a jeśli spadnie 3. Na przykład

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

Następnie „t” tworzy kopię poprzedniego wektora na stosie, a następnie „n:” umieszcza również wektor [1,2,3,4, ...] na stosie. Następnie „79” umieszcza wartość 79 na stosie. Wartość 79 została wybrana, ponieważ jest to liczba znaku Unicode „o”, który zostanie później otrzymany. (Podziękowania dla Luisa Mendo za pomysł umieszczenia tutaj wartości 79 zamiast później)

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

W tym momencie mamy dokładnie indeksy wierszy, indeksy kolumn i niezerową wartość macierzy rzadkiej, która ma wartość 79 wszędzie tam, gdzie chcemy znaku wyjściowego, i 0 wszędzie tam, gdzie chcemy wyprowadzać białe spacje. Zdejmujemy te trzy elementy ze stosu i tworzymy tę rzadką macierz za pomocą polecenia MATL rzadkiej macierzy „Z?”. To jest,

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]

Pozostaje tylko przekonwertować macierz z liczb na znaki Unicode, co odbywa się za pomocą polecenia „c”. 79 to „o”, a 0 to spacje:

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

Wynikowa macierz znaków jest następnie domyślnie wyświetlana.

PHP, 95 bajtów

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

1. Utwórz tablicę ciągów z indeksem od -1 do 1 alternatywy $b=array_fill(-1,3," ");

2. Wypełnij ciągi zależne od operatora statku kosmicznego i pozycji wejścia

3. Wyjście dołącz do tablicy z nową linią

Pierwszy sposób 111 bajtów

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

Użyj operatora <=> statku kosmicznego

JavaScript (ES6), 81 bajtów

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

Napisany od zera, choć w dużej mierze zainspirowany odpowiedzią @ Arnauld . Wykorzystuje rekurencję do obliczania zawartości każdego wiersza.

Rubin, 66 64 bajtów

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

Zobacz na eval.in: https://eval.in/649503

Java 7, 158 156 bajtów

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 bajty zapisane dzięki @Frozn .

Przypadki bez golfa i testy:

Wypróbuj tutaj.

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

Wydajność:

 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 bajtów)

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

Wyjaśnienie:

Istnieją 3 programy Clora, po jednym dla każdej linii wyjściowej.

Pierwszy program, <IN?o

Sprawdź, czy obecny znak wejściowy Ijest mniejszy <niż następny znak N. Zapisz wynik w globalnej fladze. Sprawdź wynik flagi ?i jeśli jest prawdą, wypisz o, w przeciwnym razie puste miejsce (tak, jest tam puste miejsce).

Wszystkie inne programy działają zgodnie z tą samą regułą i są oddzielone ;, każdy program jest wykonywany i otrzymuje dane wejściowe jako argument.

Możesz go przetestować samodzielnie, w tym clora.js i wykonać go

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

Pyth, 21 bajtów

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

Program, który pobiera niecytowany ciąg znaków na STDIN i wypisuje wynik.

Wykorzystuje to podobny pomysł do odpowiedzi CJam @ MartinEnder .

Wypróbuj online lub Zweryfikuj wszystkie przypadki testowe .

Jak to działa

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 bajtów

Uwaga: używa kodowania Windows-1252

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

Uruchom tak:

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

Wyjaśnienie

Iteracje nad liniami (numerowane 1, 0, -1). Następnie iteruje ciąg wejściowy dla każdej linii. Kiedy wynik porównania statku kosmicznego jest równy numerowi linii, wypisz lub o, w przeciwnym razie, wypuść spację. Po każdej linii wydrukuj nowy wiersz.

Poprawki

• Przestań iterować, kiedy $xjest -1, co możemy znaleźć poprzez negację binarną (wynik 0). Zapisuje bajt w porównaniu do dodawania 1(lub 2 z przyrostem wstępnym).
• Zaoszczędzono 3 bajty $argn

Lua 326 303 bajtów tl = 0 s = io.read () o1, o2, o3 = "", "", "" t = {} dla i = 1, # s do t [i] = s: sub (i , i) tl = tl + 1 koniec dla v = 1, tl-1 zrobić, jeśli t [v] t [v + 1], to o1 = o1 .. "" o2 = o2 .. "" o3 = o3 .. " o "koniec końca wydruku (o1 .." \ n ".. o2 .." \ n ".. o3)

Wersja bez golfa

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 bajtów

Niekonkurencyjna odpowiedź 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="")

Wyjaśnienie

1. Odczytaj dane wejściowe z wiersza poleceń i przekonwertuj na wektor dziesiętny ascii
2. Weź pierwszą różnicę i utwórz 3x wektory o tej samej długości z białymi spacjami
3. Następnie zamień wektory białych znaków na, #jeśli różnice są >0, ==0lub <0.
4. Wymuś wektory i wydrukuj je oddzielone znakami nowej linii