( 이 도전에서 영감을 얻었습니다 .)

string이 있다고 가정 해 봅시다 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

입력은 3 자 이상으로 구성됩니다. 문자열은 모두 대문자로 구성되지만 대신 소문자를 사용할 수 있습니다.

테스트 사례

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음수 / 하강, 00 / 계속, 1양수 / 상승)

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

상승하는 경우 첫 번째 위치, 계속 진행중인 경우 중간, 떨어지는 경우 세 번째 위치 0에 2 Nulls 목록에 a를 삽입합니다 .

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.

하스켈, 63 바이트

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

출력 라인을 나타내는 세 개의 문자열 목록을 리턴합니다. 잠재 메시지가 없습니다.

dianne 은 목록 이해와 do및 max대신 표기법 을 사용하여 3 바이트를 절약했습니다 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.

파이썬 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에서 테스트하십시오 .

자바 스크립트 (ES6), 96 95 89 87 82 바이트

Conor O'Brien이 제안한대로 2 0대신에 o
2 바이트를 절약했습니다. ETHproduction 덕분에 6 바이트가 절약되었습니다.

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

펄, 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 자 더 길지만 방법이 약간 다르므로 독립적으로 관심을 가질 수 있습니다.

2 바이트 절약 제안에 대한 Luis Mendo에게 감사드립니다 (주석 참조)

설명:

'dZS'는 각 항목이 성공적인 문자 사이의 차이의 부호 인 벡터를 얻은 다음 'qq_'는 각 항목을 2 씩 줄이고 부호를 뒤집습니다. 따라서 문자가 증가하면 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는 유니 코드 문자 'o'의 숫자이므로 나중에 출력됩니다. (Luis Mendo에게 나중에 79이 아닌 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을 갖는 희소 행렬의 행 인덱스, 열 인덱스 및 0이 아닌 값을가집니다. 이 세 항목을 스택에서 꺼내고 MATL의 희소 행렬 명령 'Z?'를 사용하여이 희소 행렬을 만듭니다. 그건,

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]

남은 것은 매트릭스를 숫자에서 유니 코드 문자로 변환하는 것인데,이 명령은 '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));

우주선 연산자 사용 <=> 우주선 연산자

자바 스크립트 (ES6), 81 바이트

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

@Arnauld의 답변 에서 많은 영감을 얻었지만 처음부터 작성되었습니다 . 재귀를 사용하여 각 행의 내용을 계산합니다.

루비, 66 64 바이트

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

eval.in에서 참조하십시오 : https://eval.in/649503

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

@Frozn 덕분에 2 바이트가 절약 되었습니다 .

언 골프 및 테스트 사례 :

여기에서 시도하십시오.

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. 결과를 전역 플래그로 저장하십시오. 플래그 결과를 확인하고 ?true이면 output 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 answer 과 비슷한 아이디어를 사용합니다 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

작동 원리

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그렇지 않으면 공백을 출력합니다. 모든 줄마다 줄 바꿈을 인쇄하십시오.

조정

• 이진 부정 (result )으로 찾을 수있는 $xis 반복을 중지 합니다. 추가와 비교하여 바이트를 저장합니다 (또는 사전 증가시 2).-101
• 를 사용하여 3 바이트를 절약했습니다 $argn

루아 326 303 바이트 TL = 0 S = io.read () O1, O2, O3 = "", "", ""t = i가 1 = 들어 #들 t [I] = S 할 {} 부 (Ⅰ , 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 10 진수 벡터로 변환
2. 첫 번째 차이를 취하고 공백으로 같은 길이의 3x 벡터를 만듭니다.
3. 그런 다음 #차이가 있으면 공백 벡터를으로 바꿉니다.>0 , ==0또는 <0.
4. 벡터를 강제 변환하고 개행으로 분리하여 인쇄