( Bu zorluktan ilham aldık .)

Diyelim ki bir ipimiz var ABBCBA. Biz arasında bir artış olduğunu söyleyebiliriz Ave Biçin, Başağıda A; Hiçbir şey değişmediği için Bve arasında bir koşu olduğunu söyleyebiliriz B; ve nihayet arasında bir düşüş olduğunu söyleyebiliriz Cve B. Bunun gibi bir grafik çizebiliriz:

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

Etiketler olmadan ve beyaz alanın en aza indirilmesi:

o o
 o
   oo

Bu girdi için beklenen çıktı ABBCBA.

oÇıktıdaki yerine herhangi bir boşluk olmayan karakter kullanabilirsiniz . Ayrıca, her sütun isteğe bağlı olarak, aralarında aşağıdakiler gibi fazladan bir boşluk olabilir:

o   o
  o 
      o o

Giriş en az üç karakterden oluşacaktır. Dize tamamen büyük harflerden oluşacaktır, ancak bunun yerine küçük harf kullanabilirsiniz.

Test durumları

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

Jöle , 11 bayt

OIṠ“ o ”ṙZY

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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 bayt

(kullanır 0, kullanmaz O)

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

açıklama

LetterNumber@#

Girişin her karakterinin alfabesindeki konumunu alır.

Sign@Differences@

Her ardışık eleman arasındaki farkı alır ve işareti alır ( -1negatif / düşme, 00 / devam etme, 1pozitif / yükselme için)

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

Artan 0iki Nullise, yükselen ilk durumda, devam ederse orta, düşerken üçüncü konumda bir a ekler .

Row[Column@ ... ]

Çıkışı formatlar.

Çıktı söz konusu olandan farklı görünebilirse, yukarıdaki kod 41 bayta kısaltılabilir:

ListPlot@*Sign@*Differences@*LetterNumber

... böyle bir şey yaratan ("ABBCBA" için)

MATL , 15 , 14 bayt

dZSqtQtQv~79*c

Çevrimiçi deneyin!

Açıklama:

Bir resmin bin kelimeye bedel olduğunu söylüyorlar, bu yüzden burada güncelledikçe canlı yığının en üstündeki değeri gösteren bir beta çevrimiçi tercüman var. Hala beta sürümünde olduğunu unutmayın, bu nedenle birkaç kez koşmaya başlamanız gerekebilir.

İlk önce arayacağız dZS. dbize her ardışık eleman arasındaki farkı verir ve bize her elemanın ZSişaretini (-1, 0 veya 1) verir. Yani 'HELLOWORLD' ile giriş olarak, ilk adımdan sonra biz:

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

Şimdi, sadece qbunu azaltmak ve almak için kullanıyoruz:

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

Ve sonra iki kez yığının tepesini çoğaltırız ve diziyi arttırırız ( tQ) Bundan sonra

-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

Şimdi '0'ların tümü bir karakter çıkarmak istediğimiz yerde. Bu yüzden, bu üç diziyi bir matrise ( v) dahil ediyoruz ve mantıksal olarak onu ( ~) reddediyoruz . Sonra matristeki her bir değeri ASCII 'O', ( 79*) değeri ile çarpıyoruz ve onu bir dize olarak gösteriyoruz c.

Haskell, 63 bayt

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

Çıktı çizgilerini temsil eden üç dizenin bir listesini döndürür. Hiçbir bilinçaltı mesajı içermez.

dianne, donotasyon kullanarak ve maxliste anlama yerine üç bayt kaydetti last.

CJam , 19 bayt

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

Kullanımları 0yerine o.

Çevrimiçi deneyin!

açıklama

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 bayt

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

@Xnor, bana bir dizeler listesi döndürmenin izin verildiğini bildirdiği için teşekkür ederiz.

İdeone üzerinde test et .

JavaScript (ES6), 96 95 89 87 82 bayt

Kullanılarak kaydedilmiş 2 byte 0yerine oConor O'Brien tarafından önerildiği gibi,
2 6 bayt ETHproductions sayesinde kurtardı

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 bayt

İçin +1 içerir -p

STDIN'e giriş verin:

bumpy.pl <<< ABBCBA

bumpy.pl:

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

MATL, 16 14 Bayt

dZSqq_tn:79Z?c

Çevrimiçi deneyin!

Bu, DJMCMahem'in cevabının tartışmasından kaynaklandı . Bu cevap, aynı uzunlukta 2 karakter daha uzun olsa da , yöntem biraz farklıdır, bu nedenle bağımsız ilgi çekici olabilir.

Luis Mendo'ya 2 bayt tasarruf eden bir öneri için teşekkürler (Yorumlara bakın)

Açıklama:

'dZS', her girişin başarılı karakterler arasındaki farkların işareti olduğu bir vektör alır, ardından 'qq_' her girişi iki azaltır ve işaretini çevirir, böylece karakter artarsa, aynı 2 kalırsa, ve eğer azalırsa 3. Örneğin,

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

Daha sonra, 't' önceki vektörün bir kopyasını yığına yapar, daha sonra 'n:' vektörü [1,2,3,4, ...] yığına da yerleştirir. Sonra '79', 79 değerini yığına yerleştirir. 79 değeri, daha sonra çıktımız olacak olan unicode karakteri 'o' için sayı olduğundan seçilir. (Daha sonra değil, 79 değerini buraya koyma fikri için Luis Mendo'ya teşekkürler)

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

Bu noktada tam olarak satır karakterlerini, sütun indekslerini ve çıktı karakterini istediğimiz yerde 79 değerine sahip seyrek bir matrisin sıfır değerine ve 0 karakterini de boşluk beyazına çıkarmak istediğimiz yerde elde ederiz. Bu üç maddeyi yığından alıyoruz ve bu seyrek matrisi MATL'ın seyrek matris komutu 'Z?' İle oluşturuyoruz. Yani,

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]

Geriye kalan tek şey, matrisi sayılardan 'c' komutu ile yapılan unicode karakterlere dönüştürmektir. 79'lar 'o' ve 0'lar boşluklar haline geldi:

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

Sonuçta ortaya çıkan karakter matrisi dolaylı olarak gösterilir.

PHP, 95 Bayt

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 ile 1 alternatifine sahip bir dizge dizisi oluşturun. $b=array_fill(-1,3," ");

2. Uzay gemisi operatörüne ve girişin konumuna bağlı olarak dizeleri doldurun.

3.Çıkış, diziye yeni bir satırla katılın

İlk yol 111 bayt

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

Uzay gemisi operatörü kullanın Uzay <=> gemisi operatörü

JavaScript (ES6), 81 bayt

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

Sıfırdan yazılmış, @ Arnauld'un cevabından esinlenilmiş olsa da . Her satırın içeriğini hesaplamak için özyineleme kullanır.

Ruby, 66 64 bayt

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

Eval.in üzerinde görün: https://eval.in/649503

Java 7, 158 156 bayt

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

@Frozn sayesinde 2 bayt kurtarıldı .

Ungolfed ve test durumları:

Burada dene.

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

Çıktı:

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

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

Açıklama:

Her çıktı satırı için bir tane olmak üzere 3 Clora programı vardır.

İlk program <IN?o

Geçerli giriş karakterinin bir sonraki karakterden Iküçük olup olmadığını kontrol edin . Sonucu global bayrağa kaydedin. Bayrak sonucunu kontrol edin ve eğer doğru ise çıktı , başka bir boşluk bırakın (evet, orada bir boşluk var.<N?o

Diğer tüm programlar aynı kuralı izler ve birbirinden ayrılır ;, her program yürütülür ve girdiyi argüman olarak alır.

Clora.js de dahil olmak üzere kendiniz test edebilirsiniz ve

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

Pyth, 21 bayt

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

STDIN'de tırnaksız bir dizgenin girişini alan ve sonucu basan bir program.

Bu @ MartinEnder'in CJam cevabına benzer bir fikir kullanıyor .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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 bayt

Not: Windows-1252 kodlamasını kullanır

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

Bu şekilde koş:

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

açıklama

Hatlar üzerinden dolaşır (numaralı 1, 0, -1). Sonra her satır için giriş dizgisini tekrar eder. Uzay gemisi karşılaştırmasının sonucu satır numarasına eşit olduğunda,o , aksi halde bir boşluk çıkarır. Her satırdan sonra yeni bir satır yazdırın.

Düzenlemeler

• Ne zaman Dur yineleme $xolduğunu -1biz ikili olumsuzlama (sonuç ile bulabileceğiniz, 0). Eklemeye kıyasla 1(veya önceden artışla 2) bir bayt kaydeder .
• Kullanarak 3 bayt kaydedildi $argn

Lua 326 303 bayt tl = 0 s = io.read () o1, o2, o3 = "", "", "" t = {} için i = 1, # s t [i] = s: sub (i , i) tl = tl + 1 sonu v = 1, tl-1 eğer t [v] t [v + 1] sonra o1 = o1 .. "" o2 = o2 .. "" o3 = o3 .. " o "bitiş sonu yazdır (o1 .." \ n ".. o2 .." \ n ".. o3)

Ungolfed versiyonu

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 bayt

Rekabet etmeyen bir R cevabı.

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

açıklama

1. Komut satırından girişi okuyun ve ascii ondalık vektörüne dönüştürün
2. 1. farkı alın ve beyaz boşluklarla aynı uzunlukta 3x vektörler oluşturun
3. Sonra beyaz boşluk vektörleri yerine #farklar ise >0, ==0ya <0.
4. Vektörleri zorla ve onları yeni satırlarla ayırarak yazdır