이것은 간단한 것입니다 : ASCII Gantt 차트를 인쇄하십시오 .

주어진 작업 범위 (시작 시간-종료 시간 튜플)에서 -각 작업 기간 (새 작업의 각 작업)에 대해 문자 형태로 Gantt 타임 라인을 인쇄합니다 .

예

내 작업 범위가 있다고 가정 28->35, 34->40, 39->44하면 Gantt는 다음과 같습니다.

                            -------
                                  ------
                                       -----

명세서

• 전체 프로그램, 명명 된 함수 또는 익명 함수를 작성할 수 있습니다.
• 프로그램 / 기능은 STDIN을 통해 또는 인수로 작업을 수락해야합니다 .
• 각 작업은 start->endwhere start및 endare Integer 문자열로 표시되어야합니다 . 작업은 공백이나 쉼표로 구분됩니다. 또는 Tuple of Integer 또는 Array / Collection of 2 Integer로 얻을 수 있습니다. (예를 들어, JavaScript에서는 다음과 같이 얻을 수 있습니다 [start,end]-이것이 허용됩니다).
• 음수가 아닌 수의 작업 (인수)이 지원되어야합니다.
• 명확하게하기 위해, 태스크 콜렉션의 단일 인수는 허용되지 않습니다. 단일 문자열 인수를 구문 분석하거나 0 개 이상의 작업 인수를 지원할 수 있습니다. 여기서 작업은 튜플 또는 크기 2의 모음입니다.
• 유효한 입력 만 제공한다고 가정 할 수 있습니다. 즉, 각 작업에는 긍정적 기간이 있습니다.
• 반환 값은 중요하지 않습니다. 코드는 STDOUT에 타임 라인을 인쇄해야합니다.
• 출력 : 작업 당, start공백 다음에 (end-start)대시와 a가 표시 \n됩니다.
• 말할 것도없이, 출력 라인은 입력 (작업) 순서에 따라 정렬되어야합니다.
• \n도움이된다면 앞에 공백 이 허용됩니다.

테스트 사례

Input:
(empty)

Output:
(empty)


Input:
0->7,5->6,3->6

Output:
-------
     -
   ---


Input:
5->20,5->20,2->10,15->19

Output:
     ---------------
     ---------------
  --------
               ----

승리

• 이것은 코드 골프 이므로 최소 코드 길이 (바이트)가 이깁니다.
• 전통적으로 타이 브레이커는 이전 포스트입니다.
• "표준 허점은 더 이상 재미 없다".

-----

편집하다

많은 사람들이 단일 작업 수집 인수를 가질 수 있으며 그와 원래 varargs 요구 사항 사이에 큰 차이 가 없으므로 사용하지 않으려는 경우 단일 수집 인수를 가질 수 있습니다. varargs 옵션 또는 언어가 varargs를 지원하지 않는 경우

CJam, 16 14 바이트

q~{S.*~'-e]N}/

이것은 목록의 목록을 입력으로 예상합니다. 예를 들면 다음과 같습니다.

[[5 20] [5 20] [2 10] [5 19]]

제공합니다 :

     ---------------
     ---------------
  --------
     --------------

작동 원리

q~                      e# Read the input and parse it as a list of list
  {         }/          e# Go over each item in the list in a for loop
   S                    e# S is basically this string - " "
    .*                  e# Multiply each item of the first list with the corresponding index
                        e# item of the second list. This basically repeats the space
                        e# X times where X is the first number of the tuple. The second
                        e# number remains untouched as the second list was only 1 char long
      ~                 e# Unwrap the space string and second number containing list
       '-               e# Put character '-' on stack
         e]             e# Make sure that the space is filled with - to its right so as to
                        e# make the total length of the string equal to the second number
           N            e# Put a newline. After all iterations, the result is printed
                        e# automatically to STDOUT

여기에서 온라인으로 사용해보십시오

파이썬 2, 39 바이트

문자열 곱셈을 사용하는 간단한 솔루션 :)

for x,y in input():print' '*x+'-'*(y-x)

다음과 같은 형식의 입력을 허용합니다.

((5,20),(5,20),(2,10),(15,19))

여기서 확인하십시오.

브레인 퍽, 120 (115) 111 바이트

적어도 Java보다 짧습니다 :) 입력은 바이트 목록이며, 각 쌍은 간트에서 한 줄입니다.

++++[->++++++++<]>[->+>+<<]++++++++++>>+++++++++++++>+[,[->+>+<<]>>[-<<+>>],<[->-<<<<.>>>]>[-<<<.>>>]<<<<<.>>>]

사용해보십시오

http://copy.sh/brainfuck/

입력 끝 char을 value로 설정하십시오 \0. 입력 예 : \5\20\5\20\2\10\15\19.

입력 끝 값을 설정하면 \0입력에 숫자 0이 포함 된 경우 더 이상 입력을 읽지 않아 (프로그램을 중지) 부작용이 발생합니다. BF에서는 입력이 소진 된 시점을 알 수있는 다른 방법이 없습니다.

설명*

++++[->++++++++<]>  #Store <space> at index 1                   
[->+>+<<]           #Move index 1 to index 2 and 3
++++++++++          #Increment index 1 to <newline>
>>                  #Move to index 3
+++++++++++++       #Increment index 3 to <dash>    
>                   #Move to (empty) index 4
+                   #Increment to start the main loop
[                   #Main loop
,                   #Read first number to index 4
[->+>+<<]>>[-<<+>>] #Copy index 4 to index 5 (index 5 can now be altered)
,                   #Read second number (the number pair is now stored at index 5 and 6)
<                   #Move to first number (index 5)
[->-<<<<.>>>]       #Decrement index 5 and 6 and print <space> until index 5 equals zero
>                   #move to second input (index 6)
[-<<<.>>>]          #Decrement index 6 and print <dash> until index 6 equals zero
<<<<<.>>>           #Print <newline> and move to index 4 (original first number)
]                   #End of main loop

_{* (댓글로 인해 컴파일 / 실행할 수 없습니다)}

Pyth, 36 22 19 14 바이트

이것은 나의 첫 번째 Pyth 프로그램입니다. Jakube는 5 바이트의 골프 아웃을 도왔습니다.

FNQ<s*V" -"NeN

형식의 입력이 필요합니다 [[5,20], [5,20], [2,10], [15,19]].

당신은 할 수 있습니다 온라인으로보십시오 .

C ++ 14, 69 바이트

[]{int a,b;for(;cin>>a>>b;){cout<<setw(b)<<string(b-a,'-')+'\n';}}();

처음으로 골프를 타는 것은 시작하기에 좋은 문제였습니다!

K, 18 바이트

`0:" -"@{&x,y-x}.'

입력으로 쌍 목록을 예상합니다.

  `0:" -"@{&x,y-x}.'(0 7;5 6;3 6)
-------
     -
   ---
  `0:" -"@{&x,y-x}.'(5 20;5 20;2 10; 15 19)
     ---------------
     ---------------
  --------
               ----
  `0:" -"@{&x,y-x}.'()

'도트 적용 ( .)을 사용하여 각 ( ) 튜플의 압축을 풀고 람다 내부에서 각각 시작 및 종료 값 에 각각 x및 로 액세스 할 수 y있습니다. 그런 다음 이것을 (시작, 길이) 튜플 ( x,y-x) 로 다시 조립 하고 "where"( &)를 적용 합니다. 이것은 나에게 이렇게 출력을 준다 :

  {&x,y-x}.'(0 7;5 6;3 6)
(1 1 1 1 1 1 1
 0 0 0 0 0 1
 0 0 0 1 1 1)

그런 다음이 비정형 행렬 ( " -"@)을 사용하여 2 자 배열로 색인을 작성하고 stdout ( 0:)으로 모두 보내야합니다 .

자바 스크립트 ( ES6 ), 63

익명 함수로 F에 대한 할당을 계산하지 않는 63 바이트는 3 바이트 저장된 thx @apsillers 편집 63 바이트입니다.

요청한대로 다양한 수의 매개 변수가있는 함수입니다.
작업 목록을 단일 매개 변수로 사용하는 기능입니다.

아래 스 니펫 실행 테스트 (EcmaScript 6, Firefox 만 해당)

F=l=>l.map(t=>console.log(' '.repeat(l=t[0])+'-'.repeat(t[1]-l)))

// TEST

// for this test, redefine console.log to have output inside the snippet
console.log = (...x) => O.innerHTML += x + '\n';

console.log('* Empty'); F([]);
console.log('\n* [0,7],[5,6],[3,6]'); F([[0,7],[5,6],[3,6]])
console.log('\n* [5,20],[5,20],[2,10],[15,19]');F([[5,20],[5,20],[2,10],[15,19]]);

<pre id=O></pre>

스칼라, 67 63 59 바이트

(r:Seq[(Int,Int)])⇒for((s,e)←r)(println(" "*s+"-"*(e-s)))

사용법 : res0()또는 res0(Seq(28->35, 34->40, 39->44))등

for 표현식을 사용하여 4 바이트를 면도 해 주셔서 감사합니다!

루비 : 35 자

->*t{t.map{|s,e|puts' '*s+?-*(e-s)}

샘플 실행 :

irb(main):001:0> ->*t{t.map{|s,e|puts' '*s+?-*(e-s)}}.call [0,7], [5,6], [3,6]
-------
     -
   ---

표시 할 각 작업마다 하나씩 여러 개의 요소를 두 개씩 배열하도록 업데이트되었습니다. (그것이 업데이트 된 요구 사항이 기대하는 것입니다.)

자바 스크립트 (ES6), 61/66 자

내 대답은 @ edc65 게시 한 것과 거의 비슷하지만 약간 개선되었습니다. 단일 배열의 작업은 허용되지 않으므로 (따라서 함수는 다음과 같이 호출됩니다. a([3,4], [7,15], [0,14], [10, 15])) 올바른 것은 다음과 같습니다 ( 이름을 지정하지 않은 66 자 ).

a=(...x)=>x.map(([c,d])=>console.log(' '.repeat(c)+'-'.repeat(d-c)))

그리고 하나의 배열 인수가 허용되면 (따라서 fn 호출은 다음과 같습니다 a([[3,4], [7,15], [0,14], [10, 15]])), 할당되지 않은 61 문자입니다 .

a=x=>x.map(([c,d])=>console.log(' '.repeat(c)+'-'.repeat(d-c)))

SWI- 프롤로그, 55 바이트

a([[A,B]|C]):-tab(A),writef("%r",[-,B-A]),nl,C=[];a(C).

예 : a([[5,20],[5,20],[2,10],[15,19]]).출력

     ---------------
     ---------------
  --------
               ----

하스켈, 76 바이트

(#)=replicate
f i=putStr$g=<<(read$'[':i++"]")
g(s,e)=s#' '++(e-s)#'-'++"\n"

입력 형식은 쉼표로 구분 된 튜플 문자열입니다 (예 :) "(1,2),(3,4)".

사용 예 :

*Main> f "(1,2),(3,4)" 
  -
    -

*Main> f "(0,7),(5,6),(3,6)" 
-------
     -
   ---

작동 원리 : 구문 분석 입력 난에 입력 문자열을 둘러싸 [과 ]와 하스켈의 기본 사용 read정수 튜플의 목록에 대한 기능을. 나머지는 간단합니다 : 각 튜플에 대한 (s,e)포획 s다음에 공백을 e-s대시는 개행 문자 다음에 단일 문자열로 모두를 연결할. 인쇄.

하스켈, 59 바이트

편안한 입력 형식으로 :

(#)=replicate
f=putStr.(g=<<)
g(s,e)=s#' '++(e-s)#'-'++"\n"

이제 튜플 목록이 필요합니다 (예 :) f [(0,7),(5,6),(3,6)].

위에서 설명한대로 작동하지만 입력 구문 분석이 없습니다.

줄리아, 44 바이트

x->for t=x a,b=t;println(" "^a*"-"^(b-a))end

이것은 튜플 배열을 입력으로 받아들이고 STDOUT에 인쇄하는 익명 함수를 작성합니다.

언 골프 + 설명 :

function f(x)
    # Loop over the tasks (tuples) in x
    for t in x
        # Assign a and b to the two elements of t
        a,b = t

        # Print a spaces followed by b-a dashes on a line
        println(" "^a * "-"^(b-a))
    end
end

예 :

julia> f([(5,20), (5,20), (2,10), (15,19)])
     ---------------
     ---------------
  --------
               ----

julia> f([(0,7), (5,6), (3,6)])
-------
     -
   ---

julia> f([])

자바 스크립트 (ES6), 106 85 80 68 바이트

업데이트 된 요구 사항에 따라 이제 작업 목록이 허용됩니다.

a=>a.reduce((p,v)=>p+=' '.repeat(z=v[0])+'-'.repeat(v[1]-z)+"\n",'')

0 개 이상의 인수를받습니다 : 80 바이트

(...a)=>{s='';a.map(v=>s+=' '[r='repeat'](z=v[0])+'-'[r](v[1]-z)+"\n");return s}

원래 시도, 106 바이트 :

(...a)=>{for(i=-1,s='',r='repeat';a.length>++i;){s+=' '[r](a[i][0])+'-'[r](a[i][1]-a[i][0])+"\n"}return s}

C : 108 바이트

void g(int*l){for(int c=0;*l>=0;c=!c,l++){if(!c)l[1]-=*l;while(l[0]-->0)putchar(c?45:32);c?putchar(10):0;}}

언 골프 드 :

void gantt(int*l) {
    for (int c = 0; *l >= 0; c = !c, l++) {
        if (!c) l[1] -= *l;
        while (l[0]-- > 0) putchar(c? 45 : 32);
        c? putchar(10) : 0;
    }
}

로 끝나는 정수 목록을 매개 변수로 사용합니다 -1. 예를 들면 다음과 같습니다.

int list[] = {
    28, 35,
    34, 40,
    39, 44,
    -1
};
gantt(list);

c쓰기 공간과 대시 사이를 전환 하는 데 사용 됩니다.

펄 : 42 41 자

문자열 구문 분석이있는 솔루션을 하나 이상 갖기 만하면됩니다.

s!(\d+)->(\d+),?!$"x$1."-"x($2-$1).$/!ge

샘플 실행 :

bash-4.3$ perl -pe 's!(\d+)->(\d+),?!$"x$1."-"x($2-$1).$/!ge' <<< '0->7,5->6,3->6'
-------
     -
   ---

자바 (8) 280 275 246 204 195 185 180 바이트

void g(String t){for(String s:t.split(",")){String[]a=s.split("->");s="";Integer i;for(i=0;i<i.valueOf(a[0]);i++)s+=" ";for(;i<i.valueOf(a[1]);i++)s+="-";System.out.println(s);};};

쉼표로 구분 된 입력 문자열을 가져와 결과 ASCII Gantt Chart를 stdout에 인쇄하는 방법입니다.

10 바이트 절약에 도움을 준 durron597 및 masterX244 덕분에

자바, 187 (181) 197 (183) 101 바이트

void g(int[][]g){for(int[]i:g)for(int j=0;j<i[1];System.out.print(j++<i[0]?" ":j==i[1]?"-\n":"-"));}

언 골프 (정렬) :

void g(int[][] g){
    for(int[] i : g)
        for(int j = 0; j < i[1]; System.out.print(j++ < i[0] ? " " : j == i[1] ? "-\n" : "-"));
}

입력을 ints의 2 차원 배열로 허용합니다 . 이것이 규칙에 의해 허용된다는 것을 지적한 masterX244 에게 감사합니다 .

젤리 , 13 9 바이트

ạ\⁾ -xµ€Y

온라인으로 사용해보십시오!

로 입력을 [[5, 20], [5, 20], [2, 10], [15, 19]]받습니다.

Erik 덕분에 -4 바이트

APL (Dyalog Classic) , 12 바이트

↑('-'\⍨≤∘⍳)/

온라인으로 사용해보십시오!

APL에는 varargs가 없으므로 여기서 arg는 단일 Nx2 행렬입니다.

자바 스크립트 (ES8), 54 바이트

a=>a.map(([x,y])=>"-".repeat(y-x).padStart(y)).join`
`

온라인으로 사용해보십시오

PowerShell 3.0, 4836 바이트

$args|%{" "*$_[0]+"-"*($_[1]-$_[0])}

목록을 통과하는 더 좋은 방법으로 12를 절약 한 Mazzy에게 감사드립니다.

이전 코드 및 설명 :

&{param($b="")$b|%{" "*$_[0]+"-"*($_[1]-$_[0])}}

튜플 목록으로 인수를 취합니다 (예 : (5,20), (5,20), (2,10), (15,19)). 빈 문자열을 입력하지 않고 호출 할 때 foreach 블록에 입력했기 때문에 빈 문자열을 처리하기 위해 기본값으로 $ b를 설정해야했습니다.

R , 117 90 75 바이트

function(y)for(i in 1:ncol(y))cat(" "<y[1,i],"-"<diff(y)[i],"
")
"<"=strrep

온라인으로 사용해보십시오!

주세페는 원래 답변에서 최소 29 바이트를 골랐습니다!

아이디어는 간단합니다. " "필요한만큼 인쇄 하고 필요한만큼 인쇄하십시오 "-". 입력은 2*LL의 쌍 수를 가진 행렬입니다. 벡터화 된 함수 diff는 "-"의 수를 얻는 데 사용됩니다.

VBA (엑셀), 99 90 바이트

즉시 창 사용 [A1] 입력 예 :0-1,2-5

바이트를 자르는 @TaylorSott에게 감사드립니다.

b=Split([A1]):For x=0To Ubound(b):c=Split(b(x),"-"):?Spc(c(0)-0)String(c(1)-c(0),"-"):Next

CoffeeScript, 104 82, 65 바이트

작업 목록 (ES6) : 65 바이트

(a)->a.map (v)->console.log ' '.repeat(v[0])+'-'.repeat v[1]-v[0]

작업 목록 (ES5 변형) : 82 바이트

(a)->a.map (v)->j=-1;s='';s+=(if j<v[0]then' 'else'-') while++j<v[1];console.log s

0 개 이상의 인수 : 104 바이트

()->[].slice.call(arguments).map((v)->j=-1;s='';s+=(if j<v[0]then' 'else'-')while++j<v[1];console.log s)

미완성 :

() -> [].slice.call(arguments).map( # convert to array-like arguments to array and loop
 (v) ->
  j = -1 # counter
  s = '' # initialize string
  s += (if j < v[0] then ' ' else '-') while ++j < v[1]
  console.log s # print to STDOUT
)

PHP, 94 91 바이트

작업 목록을 가져옵니다 (예 :) [[5,20],[5,20],[2,10],[15,19]]. 변수 함수 이름을 상기시켜 준 @IsmaelMiguel에게 감사드립니다.

function x($a){$r=str_repeat;foreach($a as$v){echo$r(' ',$v[0]).$r('-',$v[1]-$v[0])."\n";}}

원래 시도 : 94 바이트

function x($a){foreach($a as$v){echo str_repeat(' ',$v[0]).str_repeat('-',$v[1]-$v[0])."\n";}}

PHP, 89 자 (기능 본문)

function gantt($x){array_walk($x,function($a){echo str_pad(str_repeat('-',$a[1]-$a[0]),$a[1],' ',0)."\n";});}

나는 문자열을 읽기 위해 갔지만 많은 항목이 정수 쌍의 배열을 취함에 따라 간결성을 위해 적합하다고 생각했습니다.

$a배열의 각 튜플 에 대해 $x반복 된 대시 문자열을 반복 $a[1] - $a[0]하여 더 큰 숫자 $a[1]를 공백으로 채 웁니다. 그런 다음 의무적 인 개행.

Gema : 47 자

<D>-\><D><y>=@left{$1;}@repeat{@sub{$2;$1};-}\n

샘플 실행 :

bash-4.3$ gema '<D>-\><D><y>=@left{$1;}@repeat{@sub{$2;$1};-}\n' <<< '0->7,5->6,3->6'
-------
     -
   ---

PostgreSQL : 160 자

create function g(int[])returns text as
$$select string_agg(lpad(repeat('-',$1[x][2]-$1[x][1]),$1[x][2]),chr(10))from generate_subscripts($1,1)x$$
language sql;

샘플 실행 :

manatwork=# create function g(int[])returns text as
manatwork-# $$select string_agg(lpad(repeat('-',$1[x][2]-$1[x][1]),$1[x][2]),chr(10))from generate_subscripts($1,1)x$$
manatwork-# language sql;
CREATE FUNCTION

manatwork=# select g(array[[0,7],[5,6],[3,6]]);
-------
     -
   ---

J, 21 바이트

(' -'#~{.,-~/)"1 ::''

언 골프

(' -' #~ {. , -~/)"1 ::''

이것은 본질적으로 J의 copy verb #이지만 공백 문자 머리글을 {.여러 번 복사 하고 하이픈 문자 "2 번째 목록 요소-1 번째 목록 요소"를 여러 번 복사합니다 -~/. 안타깝게도 이로 인해 순위를 "1명시 적으로 지정 해야하며 불리한 점을 사용해야합니다:: 하며 빈 사례를 처리 를 합니다.

온라인으로 사용해보십시오!