( Inspirado por este desafío ).

Digamos que tenemos una cadena ABBCBA. Podemos decir que hay un aumento entre Ay B, para lo Bsiguiente A; podemos decir que hay una carrera entre By B, porque nada cambia; y finalmente podemos decir que hay una caída entre Cy B. Podemos dibujar un gráfico como este:

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

Sin las etiquetas y minimizando los espacios en blanco:

o o
 o
   oo

Esta es la salida esperada para la entrada ABBCBA.

Puede usar cualquier carácter que no sea un espacio en blanco para reemplazar oen la salida. Además, cada columna puede tener opcionalmente un espacio adicional entre ellas, de esta manera:

o   o
  o 
      o o

La entrada constará de al menos tres caracteres. La cadena consistirá completamente en letras mayúsculas, pero en su lugar puede usar letras minúsculas.

Casos de prueba

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

Jalea , 11 bytes

OIṠ“ o ”ṙZY

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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 bytes

(usos 0, no O)

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

Explicación

LetterNumber@#

Obtiene la posición en el alfabeto de cada carácter de la entrada.

Sign@Differences@

Toma la diferencia entre cada elemento consecutivo y toma el signo ( -1para negativo / descendente, 0para 0 / continuo, 1para positivo / ascendente)

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

Inserta a 0en una lista de dos Nulls, en la primera posición si sube, en el medio si continúa, y en la tercera posición si cae.

Row[Column@ ... ]

Formatea la salida.

Si la salida pudiera verse diferente de la de la pregunta, el código anterior podría acortarse a 41 bytes:

ListPlot@*Sign@*Differences@*LetterNumber

... que crea algo como esto (para "ABBCBA"):

MATL , 15 , 14 bytes

dZSqtQtQv~79*c

Pruébalo en línea!

Explicación:

Dicen que una imagen vale más que mil palabras, así que aquí hay un intérprete beta en línea que le muestra el valor en la parte superior de la pila en vivo a medida que se actualiza. Tenga en cuenta que todavía está en beta, por lo que es posible que deba ejecutar varias veces.

Entonces, primero, llamamos dZS. dnos da la diferencia entre cada elemento consecutivo y ZSnos da el signo (-1, 0 o 1) de cada elemento. Entonces, con 'HELLOWORLD' como entrada, después del primer paso tendremos:

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

Ahora, solo usamos qpara disminuir esto y obtener:

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

Y luego dos veces duplicamos la parte superior de la pila e incrementamos la matriz ( 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

Ahora todos los '0' son donde queremos generar un carácter. Entonces, unimos estas tres matrices en una matriz ( v), y lo negamos lógicamente ( ~). Luego multiplicamos cada valor en la matriz por el valor ASCII de 'O', ( 79*) y lo mostramos como una cadena con c.

Haskell, 63 bytes

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

Devuelve una lista de tres cadenas, que representan las líneas de salida. No contiene mensajes subliminales.

dianne ahorró tres bytes usando donotación y en maxlugar de una lista de comprensión y last.

CJam , 19 bytes

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

Usos en 0lugar de o.

Pruébalo en línea!

Explicación

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 bytes

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

Gracias a @xnor por notificarme que está permitido devolver una lista de cadenas.

Pruébalo en Ideone .

JavaScript (ES6), 96 95 89 87 82 bytes

2 bytes guardados usando en 0lugar de o, como lo sugiere Conor O'Brien
2 6 bytes guardados gracias a 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 bytes

Incluye +1 para -p

Dar entrada en STDIN:

bumpy.pl <<< ABBCBA

bumpy.pl:

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

MATL, 16 14 Bytes

dZSqq_tn:79Z?c

Pruébalo en línea!

Esto surgió de una discusión sobre la respuesta de DJMCMahem . Aunque esta respuesta tiene 2 caracteres más de la misma longitud, el método es algo diferente por lo que puede ser de interés independiente.

Gracias a Luis Mendo por su sugerencia de guardar 2 bytes (ver comentarios)

Explicación:

'dZS' obtiene un vector donde cada entrada es el signo de las diferencias entre los caracteres sucesivos, luego 'qq_' disminuye cada entrada en dos y voltea el signo, por lo que ahora si el carácter aumenta es 1, si permanece igual 2, y si disminuye 3. Por ejemplo,

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

Luego, 't' hace una copia del vector anterior en la pila, luego 'n:' coloca el vector [1,2,3,4, ...] también en la pila. Entonces '79' coloca el valor 79 en la pila. El valor 79 se elige porque es el número para el carácter unicode 'o', que será nuestro resultado más adelante. (Gracias a Luis Mendo por la idea de poner el valor 79 aquí en lugar de más tarde)

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

En este punto, tenemos precisamente los índices de fila, los índices de columna y el valor distinto de cero de una matriz dispersa que tiene el valor 79 donde queramos el carácter de salida, y 0 donde queramos espacios en blanco. Quitamos estos tres elementos de la pila y creamos esta matriz dispersa con el comando 'Z?' De matriz dispersa de MATL. Es decir,

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]

Todo lo que queda es convertir la matriz de números a caracteres unicode, que se realiza mediante el comando 'c'. Los 79 se convierten en 'o', y los 0 se convierten en espacios:

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

La matriz de caracteres resultante se muestra implícitamente.

PHP, 95 bytes

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

1.Cree una matriz de cadenas con la alternativa de índice -1 a 1 $b=array_fill(-1,3," ");

2.Rellenar las cadenas que dependen del operador de la nave espacial y la posición de la entrada.

3.Salida únete a la matriz con una nueva línea

First Way 111 Bytes

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

Usar el operador de nave espacial operador de <=> nave espacial

JavaScript (ES6), 81 bytes

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

Escrito desde cero, aunque fue fuertemente inspirado por la respuesta de @ Arnauld . Utiliza la recursividad para calcular el contenido de cada fila.

Ruby, 66 64 bytes

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

Véalo en eval.in: https://eval.in/649503

Java 7, 158156 bytes

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 bytes guardados gracias a @Frozn .

Sin golf y casos de prueba:

Pruébalo aquí

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

Salida:

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

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

Explicación:

Hay 3 programas Clora, uno para cada línea de salida.

Primer programa, <IN?o

Verifique si el carácter de entrada actual Ies más pequeño <que el siguiente carácter N. Guarde el resultado en una bandera global. Verifique el resultado del indicador ?y, si es verdadero, la salida o, de lo contrario, un espacio en blanco (sí, hay un espacio en blanco allí.

Todos los demás programas, siguen la misma regla y están separados por ;, cada programa se ejecuta y recibe la entrada como argumento.

Puede probarlo usted mismo, incluido clora.js y ejecutarlo con

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

Pyth, 21 bytes

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

Un programa que toma la entrada de una cadena sin comillas en STDIN e imprime el resultado.

Esto usa una idea similar a la respuesta CJam de @ MartinEnder .

Pruébelo en línea o verifique todos los casos de prueba .

Cómo funciona

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 bytes

Nota: utiliza la codificación de Windows-1252

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

Corre así:

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

Explicación

Itera sobre líneas (numeradas 1, 0, -1). Luego itera sobre la cadena de entrada para cada línea. Cuando el resultado de la comparación de la nave espacial es igual al número de línea, genera un o, de lo contrario, genera un espacio. Después de cada línea, imprima una nueva línea.

Ajustes

• Deje de iterar cuando $xsea -1, lo que podemos encontrar por negación binaria (resultado 0). Guarda un byte en comparación con la suma 1(o 2 con pre-incremento).
• Guardado 3 bytes usando $argn

Lua 326 303 bytes tl = 0 s = io.read () o1, o2, o3 = "", "", "" t = {} para i = 1, # s hacen t [i] = s: sub (i , i) tl = tl + 1 final para v = 1, tl-1 si t [v] t [v + 1] entonces o1 = o1 .. "" o2 = o2 .. "" o3 = o3 .. " o "end end print (o1 .." \ n ".. o2 .." \ n ".. o3)

Una versión sin golf

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 bytes

Una respuesta R no competitiva.

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

Explicación

1. Lea la entrada de la línea de comando y conviértala en un vector decimal ascii
2. Tome la primera diferencia y cree 3x vectores de la misma longitud con espacios en blanco
3. Luego reemplace los vectores de espacio en blanco con #si las diferencias son >0, ==0o <0.
4. Coaccionar los vectores e imprimirlos separados por nuevas líneas