( Terinspirasi oleh tantangan ini .)

Katakanlah kita punya string ABBCBA. Kita dapat mengatakan bahwa ada kenaikan antara Adan B, untuk Bmengikuti A; kita dapat mengatakan bahwa ada jalan antara Bdan B, untuk tidak ada perubahan; dan akhirnya kita bisa mengatakan ada perbedaan antara Cdan B. Kita dapat menggambar grafik seperti ini:

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

Tanpa label, dan meminimalkan spasi putih:

o o
 o
   oo

Ini adalah output yang diharapkan untuk input ABBCBA.

Anda dapat menggunakan karakter non-spasi putih untuk menggantikan odalam output. Selanjutnya, setiap kolom secara opsional memiliki ruang tambahan di antara mereka, seperti:

o   o
  o 
      o o

Input akan terdiri dari setidaknya tiga karakter. String seluruhnya terdiri dari huruf besar, tetapi Anda bisa menggunakan huruf kecil.

Uji kasus

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

Jelly , 11 byte

OIṠ“ o ”ṙZY

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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 byte

(menggunakan 0, bukan O)

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

Penjelasan

LetterNumber@#

Mendapat posisi dalam alfabet setiap karakter input.

Sign@Differences@

Mengambil perbedaan antara setiap elemen berturut-turut, dan mengambil tanda ( -1untuk negatif / jatuh, 0untuk 0 / terus, 1untuk positif / naik)

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

Menyisipkan a 0dalam daftar dua Nulls, di posisi pertama jika naik, tengah jika terus, dan posisi ketiga jika jatuh.

Row[Column@ ... ]

Memformat output.

Jika output bisa terlihat berbeda dari yang ada di pertanyaan, kode di atas dapat disingkat menjadi 41 byte:

ListPlot@*Sign@*Differences@*LetterNumber

... yang menciptakan sesuatu seperti ini (untuk "ABBCBA"):

MATL , 15 , 14 byte

dZSqtQtQv~79*c

Cobalah online!

Penjelasan:

Mereka mengatakan gambar bernilai ribuan kata, jadi di sini ada penerjemah online beta yang menunjukkan kepada Anda nilai di atas tumpukan secara langsung saat diperbarui. Perhatikan bahwa ini masih dalam versi beta, jadi Anda mungkin perlu menjalankan beberapa kali.

Jadi pertama-tama, kita panggil dZS. dmemberi kita perbedaan antara setiap elemen berurutan, dan ZSmemberi kita tanda (-1, 0, atau 1) dari setiap elemen. Jadi dengan 'HELLOWORLD' sebagai input, setelah langkah pertama kita akan memiliki:

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

Sekarang, kita gunakan quntuk mengurangi ini dan mendapatkan:

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

Dan kemudian dua kali kita menduplikasi bagian atas tumpukan dan menambah array ( tQ) Setelah ini kita akan punya

-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

Sekarang semua '0 adalah di mana kita ingin menampilkan karakter. Jadi, kami menggabungkan ketiga array ini ke dalam matriks ( v), dan meniadakannya secara logis ( ~). Kemudian kita mengalikan setiap nilai dalam matriks dengan nilai ASCII dari 'O', ( 79*) dan menampilkannya sebagai string dengan c.

Haskell, 63 byte

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

Mengembalikan daftar tiga string, mewakili garis output. Tidak mengandung pesan subliminal.

dianne menyimpan tiga byte dengan menggunakan donotasi dan maxbukannya pemahaman daftar dan last.

CJam , 19 byte

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

Gunakan 0bukan o.

Cobalah online!

Penjelasan

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]

Terima kasih kepada @xnor karena memberi tahu saya bahwa mengembalikan daftar string diperbolehkan.

Uji di Ideone .

JavaScript (ES6), 96 95 89 87 82 byte

2 byte disimpan dengan menggunakan 0bukan o, seperti yang disarankan oleh Conor O'Brien
2 6 byte disimpan berkat 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

Termasuk +1 untuk -p

Berikan masukan pada 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

Cobalah online!

Ini tumbuh dari diskusi tentang jawaban DJMCMahem . Meskipun jawaban ini 2 karakter lebih panjang dengan panjang yang sama, metode ini agak berbeda sehingga mungkin menjadi minat independen.

Terima kasih kepada Luis Mendo untuk saran menghemat 2 byte (lihat komentar)

Penjelasan:

'dZS' mendapatkan vektor di mana setiap entri adalah tanda perbedaan antara karakter sukses, lalu 'qq_' mengurangi setiap entri dengan dua dan membalik tanda, jadi sekarang jika karakter meningkat itu adalah 1, jika tetap sama 2, dan jika berkurang 3. Misalnya,

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

Selanjutnya, 't' membuat salinan dari vektor sebelumnya pada stack, kemudian 'n:' menempatkan vektor [1,2,3,4, ...] pada stack juga. Kemudian '79' menempatkan nilai 79 di tumpukan. Nilai 79 dipilih karena ini adalah angka untuk karakter unicode 'o', yang akan menjadi output kita nanti. (Terima kasih kepada Luis Mendo untuk gagasan untuk meletakkan nilai 79 di sini daripada nanti)

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

Pada titik ini kita memiliki indeks baris, indeks kolom, dan nilai bukan nol dari matriks jarang yang memiliki nilai 79 di mana pun kita menginginkan karakter output, dan 0 di mana pun kita ingin menampilkan spasi kosong. Kami mengambil tiga item ini dari tumpukan dan membuat matriks jarang ini dengan perintah matriks jarang MATL 'Z?'. Itu adalah,

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]

Yang tersisa hanyalah mengubah matriks dari angka menjadi karakter unicode, yang dilakukan oleh perintah 'c'. 79 menjadi 'o', dan 0 menjadi spasi:

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

Matriks karakter yang dihasilkan kemudian ditampilkan secara implisit.

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. Buat array string dengan indeks -1 hingga 1 alternatif $b=array_fill(-1,3," ");

2. Isi string yang tergantung oleh operator pesawat ruang angkasa dan posisi input

3.Output bergabung dengan array dengan baris baru

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

Gunakan operator pesawat ruang angkasa operator <=> pesawat ruang angkasa

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

Ditulis dari awal, meskipun sangat terinspirasi oleh jawaban @ Arnauld . Menggunakan rekursi untuk menghitung konten setiap baris.

Ruby, 66 64 byte

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

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

2 byte disimpan berkat @Frozn .

Kasus yang tidak disatukan & uji:

Coba di sini.

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

Keluaran:

 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

Penjelasan:

Ada 3 program Clora, satu untuk setiap jalur output.

Program pertama, <IN?o

Periksa apakah char input saat Iini lebih kecil <dari char berikutnya N. Simpan hasilnya dalam bendera global. Periksa hasil flag ?dan jika benar, output o, jika tidak ada ruang kosong (ya, ada ruang kosong di sana.

Semua program lain, ikuti aturan yang sama dan dipisahkan oleh ;, setiap program dijalankan dan menerima input sebagai argumen.

Anda dapat mengujinya sendiri termasuk clora.js dan mengeksekusi dengan

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

Pyth, 21 byte

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

Program yang mengambil input dari string yang tidak dikutip pada STDIN dan mencetak hasilnya.

Ini menggunakan ide yang mirip dengan jawaban CJam @ MartinEnder .

Cobalah secara online atau Verifikasi semua uji .

Bagaimana itu bekerja

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

Catatan: menggunakan pengkodean Windows-1252

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

Jalankan seperti ini:

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

Penjelasan

Iterates atas garis (nomor 1, 0,-1 ). Kemudian beralih ke string input untuk setiap baris. Ketika hasil perbandingan pesawat ruang angkasa sama dengan nomor baris, output sebuah o, jika tidak, output spasi. Setelah setiap baris, cetak baris baru.

Tweaks

• Hentikan iterasi saat $xini -1, yang bisa kita temukan dengan negasi biner (hasil0 ). Menyimpan byte dibandingkan dengan menambahkan 1(atau 2 dengan pra-kenaikan).
• Disimpan 3 byte dengan menggunakan $argn

Lua 326 303 byte tl = 0 s = io.read () o1, o2, o3 = "", "", "" t = {} untuk i = 1, # s lakukan t [i] = s: sub (i ( , i) tl = tl + 1 untuk v = 1, tl-1 lakukan jika t [v] t [v + 1] maka o1 = o1 .. "" o2 = o2 .. "" o3 = o3 .. " o "akhir cetak (o1 .." \ n ".. o2 .." \ n ".. o3)

Versi ungolfed

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

Jawaban R yang tidak bersaing.

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

Penjelasan

1. Baca input dari baris perintah dan konversikan ke dalam ascii desimal vector
2. Ambil perbedaan pertama dan buat vektor 3x dengan panjang yang sama dengan spasi putih
3. Kemudian ganti vektor spasi putih dengan #jika perbedaannya adalah >0, ==0atau <0.
4. Paksa vektor dan cetak dipisahkan oleh baris baru