Đây là một cách đơn giản: in biểu đồ Gantt ASCII .

Phạm vi của các nhiệm vụ (thời gian bắt đầu - thời gian kết thúc), in dòng thời gian Gantt dưới dạng -ký tự cho mỗi thời lượng tác vụ - mỗi tác vụ trong một dòng mới.

Thí dụ

Giả sử phạm vi nhiệm vụ của tôi là 28->35, 34->40, 39->44, Gantt sẽ trông như thế này:

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

Thông số kỹ thuật

• Bạn có thể viết một chương trình đầy đủ, một chức năng được đặt tên hoặc một chức năng ẩn danh.
• Chương trình / chức năng của bạn sẽ chấp nhận các tác vụ thông qua STDIN hoặc làm đối số .
• Mỗi tác vụ nên được biểu diễn dưới dạng một chuỗi các start->endvị trí startvà endlà số nguyên . Nhiệm vụ được phân tách bằng dấu cách hoặc dấu phẩy. Ngoài ra , bạn có thể lấy nó dưới dạng Tuple of Integers hoặc dưới dạng Mảng / Bộ sưu tập 2 số nguyên. (Ví dụ: trong JavaScript, bạn có thể lấy nó dưới dạng [start,end]- điều này được cho phép).
• Bất kỳ số lượng tác vụ (đối số) không âm nào cũng cần được hỗ trợ.
• Để làm cho nó rõ ràng, một đối số duy nhất của bộ sưu tập nhiệm vụ không được phép. Bạn có thể phân tích một đối số chuỗi đơn hoặc hỗ trợ các đối số tác vụ không hoặc nhiều hơn. Trong đó nhiệm vụ là một bộ hoặc một bộ sưu tập kích thước 2.
• Bạn chỉ có thể giả sử đầu vào hợp lệ sẽ được đưa ra. Điều đó có nghĩa là, mỗi nhiệm vụ có một thời gian tích cực.
• Giá trị trả về không quan trọng, mã của bạn phải in dòng thời gian trên STDOUT.
• Đầu ra: mỗi tác vụ, startkhoảng trắng theo sau (end-start)dấu gạch ngang và a \n.
• Không cần phải nói, các dòng đầu ra nên được sắp xếp tương ứng với thứ tự đầu vào (tác vụ).
• Trailing space trước khi \nđược phép, nếu điều đó giúp bạn.

Các trường hợp thử nghiệm

Input:
(empty)

Output:
(empty)


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

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


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

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

Chiến thắng

• Đây là môn đánh gôn để độ dài mã ít nhất (tính bằng byte) sẽ thắng.
• Theo truyền thống, tie breaker là bài trước.
• "Sơ hở tiêu chuẩn không còn buồn cười".

-----

CHỈNH SỬA

Như nhiều bạn hiểu rằng nó được phép có một đối số bộ sưu tập nhiệm vụ duy nhất và vì không có nhiều khác biệt giữa yêu cầu varargs ban đầu , nên giờ đây được phép có một đối số bộ sưu tập, nếu bạn không muốn sử dụng tùy chọn varargs hoặc trong trường hợp ngôn ngữ của bạn không hỗ trợ varargs.

CJam, 16 14 byte

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

Điều này mong đợi một danh sách các danh sách như đầu vào. Ví dụ:

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

cho:

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

Làm thế nào nó hoạt động

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

Dùng thử trực tuyến tại đây

Python 2, 39 byte

Giải pháp đơn giản sử dụng phép nhân chuỗi :)

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

Chấp nhận đầu vào được định dạng như vậy:

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

Kiểm tra nó ở đây.

Brainfuck, 120 115 111 byte

Ít nhất nó ngắn hơn Java :) Đầu vào là một danh sách các byte, trong đó mỗi cặp là một dòng trong gantt.

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

Hãy thử

http://copy.sh/brainfuck/

Đặt đầu cuối thành chargiá trị \0. Ví dụ đầu vào : \5\20\5\20\2\10\15\19.

Lưu ý rằng việc đặt giá trị cuối của đầu vào thành \0sẽ có tác dụng phụ là không đọc thêm đầu vào (và do đó dừng chương trình) khi đầu vào chứa số 0. Trong BF không có cách nào khác để biết khi nào đầu vào cạn kiệt.

Giải trình*

++++[->++++++++<]>  #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

_{* (Bạn sẽ không thể biên dịch / chạy phần này do các bình luận)}

Pyth, 36 22 19 14 byte

Đây là chương trình Pyth đầu tiên của tôi. Jakube đã giúp chơi golf hết 5 byte!

FNQ<s*V" -"NeN

Nó mong đợi đầu vào trong mẫu [[5,20], [5,20], [2,10], [15,19]].

Bạn có thể thử nó trực tuyến .

C ++ 14, 69 byte

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

Lần đầu tiên chơi golf, đây là một vấn đề tốt để bắt đầu!

K, 18 byte

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

Yêu cầu một danh sách các cặp làm đầu vào:

  `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}.'()

Tôi giải nén mỗi ( ') tuple sử dụng dot-áp ( .) để bên trong lambda tôi được tiếp cận với sự khởi đầu và kết thúc giá trị như xvà y, tương ứng. Sau đó, tôi tập hợp lại những thứ này thành một tuple (bắt đầu, chiều dài x,y-x) và áp dụng "where" ( &). Điều này mang lại cho tôi đầu ra như vậy:

  {&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)

Sau đó, tôi chỉ cần lập chỉ mục vào một mảng 2 ký tự bằng cách sử dụng ma trận rách rưới ( " -"@) này và gửi tất cả cho stdout ( 0:).

JavaScript ( ES6 ), 63

Chỉnh sửa 3 byte đã lưu thx @apsillers
63 byte không tính việc gán cho F là một hàm ẩn danh được cho phép.

Một hàm với số lượng tham số thay đổi, theo yêu cầu.
Một chức năng với một danh sách các nhiệm vụ như là một tham số duy nhất.

Kiểm tra chạy đoạn mã bên dưới (chỉ là EcmaScript 6, chỉ dành cho 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>

Scala, 67 63 59 bytes

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

Usage: res0() or res0(Seq(28->35, 34->40, 39->44)) etc.

Thanks gilad for shaving 4 bytes using a for expression!

Ruby: 35 characters

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

Sample run:

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

Updated to accept multiple two-element arrays, one for each task to display. (I think that is what the updated requirement expects.)

Javascript(ES6), 61/66 chars

My answer is almost similar to the one posted by @edc65 , but with some improvements. As tasks in single array are not allowed(so function would be called like this: a([3,4], [7,15], [0,14], [10, 15])), correct one would be this(66 chars without name assignment):

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

And if one array argument is allowed(so fn call like this: a([[3,4], [7,15], [0,14], [10, 15]])), then it would be(61 char without assignment):

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

SWI-Prolog, 55 bytes

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

Example: a([[5,20],[5,20],[2,10],[15,19]]). outputs

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

Haskell, 76 bytes

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

Input format is a string of comma separated tuples, e.g. "(1,2),(3,4)".

Usage examples:

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

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

How it works: for input parsing I enclose the input string in [ and ] and use Haskell's native read function for lists of integer tuples. The rest is easy: for each tuple (s,e) take s spaces followed by e-s dashes followed by a newline and concatenate all into a single string. Print.

Haskell, 59 bytes

with relaxed input format:

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

Now it takes a list of tuples, e.g f [(0,7),(5,6),(3,6)].

Works as described above, but without input parsing.

Julia, 44 bytes

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

This creates an anonymous function that accepts an array of tuples as input and prints to STDOUT.

Ungolfed + explanation:

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

Examples:

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

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

julia> f([])

JavaScript (ES6), 106 85 80 68 bytes

As per the updated requirements, a list of tasks is now acceptable

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

Takes zero or more arguments: 80 bytes

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

Original attempt, 106 bytes:

(...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 bytes

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

Ungolfed:

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

Takes as a parameter a list of integers terminated by -1. For example:

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

It uses c to toggle between writing spaces and dashes.

Perl: 42 41 characters

Just to have at least one solution with string parsing too.

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

Sample run:

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

Java 8, 280 275 246 204 195 185 180 bytes

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

A method that takes a comma-seperated input string and prints the resulting ascii Gantt Chart to stdout.

Thanks to durron597 and masterX244 for helping me save 10 bytes

Java, 187 181 197 183 101 bytes

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

Ungolfed (sort of):

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

Accepts input as 2d array of ints. Thanks to masterX244 for pointing out that this is allowed by the rules.

Jelly, 13 9 bytes

ạ\⁾ -xµ€Y

Try it online!

Takes input as [[5, 20], [5, 20], [2, 10], [15, 19]].

-4 bytes thanks to Erik

APL (Dyalog Classic), 12 bytes

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

Try it online!

APL has no varargs, so the arg here is a single Nx2 matrix.

JavaScript (ES8), 54 bytes

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

Try it online

PowerShell 3.0, 4836 Bytes

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

Thanks to Mazzy for saving 12 with a better way to pass in the list

Old code and explanation:

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

Takes arguments as a list of tuples, e.g. (5,20),(5,20),(2,10),(15,19). Had to default $b to a value to take care of the empty string because it somehow entered the foreach block when called with no input.

R, 117 90 75 bytes

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

Try it online!

Giuseppe golfed at least 29 bytes off my original answer!

The idea is straightforward: print as many " " as necessary followed by as many "-" as required. Input is a 2*L matrix with L the number of pairs. The vectorized function diff is used to get the number of "-".

VBA (Excel), 99 90 bytes

Using Immediate Window and [A1] as input eg.0-1,2-5

Thanks to @TaylorSott for cutting some bytes.

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 bytes

List of tasks (ES6): 65 bytes

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

List of tasks (ES5 variant): 82 bytes

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

Zero or more arguments: 104 bytes

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

Unminified:

() -> [].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 bytes

Takes a list of tasks (e.g. [[5,20],[5,20],[2,10],[15,19]]). Thanks @IsmaelMiguel for the reminder of variable function names.

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

Original attempt: 94 bytes

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

PHP, 89 characters (function body)

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

I was going to go for reading strings, but as a lot of the entries were taking arrays of integer pairs, I figured I would follow suit for the sake of brevity.

For each tuple $a in array $x I echo a string of dashes repeated $a[1] - $a[0] times, padded up to the larger number $a[1] with spaces. Then the obligatory newline.

Gema: 47 characters

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

Sample run:

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

PostgreSQL: 160 characters

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;

Sample run:

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 bytes

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

ungolfed

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

This is essentially just J's copy verb #, but its we're copying the space character head of list {. number of times, and the hyphen character "2nd list element minus 1st list element" number of times: -~/. Sadly this forces us to have to specify the rank "1 explictly, and we need to use Adverse :: to handle the empty case.

Try it online!