To jest proste: wydrukuj wykres Gantta ASCII .

Biorąc pod uwagę zakresy zadań (czas rozpoczęcia - krotki czasu zakończenia), wydrukuj oś czasu Gantta w postaci -znaków dla każdego czasu trwania zadania - każde zadanie w nowej linii.

Przykład

Powiedzmy, że moje zakresy zadań są następujące 28->35, 34->40, 39->44, Gantt będzie wyglądał następująco:

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

Dane techniczne

• Możesz napisać pełny program, funkcję o nazwie lub funkcję anonimową.
• Twój program / funkcja powinna zaakceptować zadania przez STDIN lub jako argumenty .
• Każde zadanie powinno być reprezentowane jako ciąg liczb całkowitychstart->end gdzie starti endsą . Zadania są oddzielone spacjami lub przecinkami. Alternatywnie , możesz otrzymać go jako krotkę liczb całkowitych lub jako tablicę / kolekcję 2 liczb całkowitych. (Na przykład w JavaScript można go pobrać jako - jest to dozwolone).[start,end]
• Każda nieujemna liczba zadań (argumentów) powinna być obsługiwana.
• Aby to wyjaśnić, pojedynczy argument kolekcji zadań jest niedozwolony. Możesz parsować pojedynczy argument ciągu lub obsługiwać argumenty zadań o zerowej lub większej liczbie zadań. Gdzie zadaniem jest krotka lub kolekcja wielkości 2.
• Możesz założyć, że podane zostaną tylko prawidłowe dane wejściowe. Oznacza to, że każde zadanie ma pozytywny czas trwania.
• Zwracana wartość nie ma znaczenia, kod musi wydrukować oś czasu na STDOUT.
• Dane wyjściowe: na zadanie, startspacje (end-start)i myślniki oraz a \n.
• Nie trzeba dodawać, że linie wyjściowe należy porządkować odpowiednio do kolejności wprowadzania (zadań).
• Końcowe spacje przed nimi \nsą dozwolone, jeśli to ci pomoże.

Przypadki testowe

Input:
(empty)

Output:
(empty)


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

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


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

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

Zwycięski

• To jest golf golfowy, więc wygrywa najmniejsza długość kodu (w bajtach).
• Tradycyjnie remis jest wcześniejszy.
• „Standardowe luki nie są już śmieszne”.

-----

EDYTOWAĆ

Ponieważ wielu z was zrozumiało, że może istnieć pojedynczy argument kolekcji zadań, a ponieważ nie ma wiele różnic między tym a oryginalnym wymaganiem varargs , teraz można mieć pojedynczy argument kolekcji, jeśli nie chce się używać opcja varargs lub w przypadku, gdy Twój język nie obsługuje varargs.

CJam, 16 14 bajtów

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

Oczekuje to listy list jako danych wejściowych. Na przykład:

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

daje:

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

Jak to działa

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

Wypróbuj online tutaj

Python 2, 39 bajtów

Proste rozwiązanie wykorzystujące mnożenie ciągów :)

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

Akceptuje dane wejściowe sformatowane w następujący sposób:

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

Sprawdź to tutaj.

Brainfuck, 120 115 111 bajtów

Przynajmniej jest krótszy niż Java :) Dane wejściowe to lista bajtów, gdzie każda para jest pojedynczą linią w gantcie.

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

Spróbować

http://copy.sh/brainfuck/

Ustaw koniec wejścia na charwartość \0. Przykład wkład: \5\20\5\20\2\10\15\19.

Zauważ, że ustawienie wartości końca wejścia na \0spowoduje efekt uboczny polegający na tym, że nie będzie już czytany żaden sygnał wejściowy (a tym samym zatrzymanie programu), gdy na wejściu będzie liczba zero. W BF nie ma innej możliwości sprawdzenia, kiedy dane wejściowe są wyczerpane.

Wyjaśnienie*

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

_{* (Nie będziesz mógł tego skompilować / uruchomić z powodu komentarzy)}

Pyth, 36 22 19 14 bajtów

To jest mój pierwszy program w języku Pyth. Jakube pomógł rozegrać 5 bajtów!

FNQ<s*V" -"NeN

Oczekuje danych wejściowych w formularzu [[5,20], [5,20], [2,10], [15,19]].

Możesz spróbować online .

C ++ 14, 69 bajtów

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

Po raz pierwszy w golfa był to dobry problem na początek!

K, 18 bajtów

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

Oczekuje listy par jako danych wejściowych:

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

I rozpakować każda ( ') krotki stosując dot-apply ( .), dzięki czemu wewnątrz lambda mam dostęp do wartości początkowej i końcowej, jak xi y, odpowiednio. Następnie składam je w krotkę (początek, długość) ( x,y-x) i stosuję „gdzie” ( &). Daje mi to wynik:

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

Następnie muszę po prostu zaindeksować tablicę 2-znakową za pomocą tej nierównej matrycy ( " -"@) i wysłać wszystko do stdout ( 0:).

JavaScript ( ES6 ), 63

Edytuj 3 bajty zapisane thx @apsillers
63 bajty nie licząc przypisania do F jako dozwolona funkcja anonimowa.

Funkcja o zmiennej liczbie parametrów, zgodnie z żądaniem.
Funkcja z listą zadań jako pojedynczym parametrem.

Przetestuj poniższy fragment kodu (tylko EcmaScript 6, tylko 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 bajtów

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

Zastosowanie: res0()lub res0(Seq(28->35, 34->40, 39->44))itp.

Dzięki gilad za golenie 4 bajtów za pomocą wyrażenia!

Rubin: 35 znaków

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

Przykładowy przebieg:

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

Zaktualizowano, aby akceptować wiele tablic dwuelementowych, po jednym dla każdego zadania do wyświetlenia. (Myślę, że tego właśnie oczekuje zaktualizowany wymóg).

JavaScript (ES6), znaki 61/66

Moja odpowiedź jest prawie podobna do tej opublikowanej przez @ edc65, ale z pewnymi poprawkami. Ponieważ zadania w pojedynczej tablicy nie są dozwolone (więc funkcja będzie wywoływana w ten sposób a([3,4], [7,15], [0,14], [10, 15]):), poprawne byłoby to ( 66 znaków bez przypisania nazwy):

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

A jeśli dozwolony jest jeden argument tablicowy (więc wywołanie fn w ten sposób:) a([[3,4], [7,15], [0,14], [10, 15]]), to byłoby ( 61 znaków bez przypisania):

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

SWI-Prolog, 55 bajtów

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

Przykład: a([[5,20],[5,20],[2,10],[15,19]]).wyjścia

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

Haskell, 76 bajtów

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

Format wejściowy to ciąg krotek oddzielonych przecinkami, np "(1,2),(3,4)".

Przykłady użycia:

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

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

Jak to działa: na wejściu parsowania Załączam ciąg wejściowy w [i ]i używać ojczystego Haskell za readfunkcję list krotki całkowitych. Reszta jest łatwa: dla każdej krotki (s,e)bierz sspacje, a następnie e-smyślniki, a następnie nowy wiersz i łącz wszystkie w jeden ciąg. Wydrukować.

Haskell, 59 bajtów

z łagodnym formatem wejściowym:

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

Teraz zajmuje listę krotek, np f [(0,7),(5,6),(3,6)].

Działa jak opisano powyżej, ale bez parsowania danych wejściowych.

Julia, 44 bajty

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

Tworzy to anonimową funkcję, która przyjmuje tablicę krotek jako dane wejściowe i drukuje do STDOUT.

Niegolfowane + wyjaśnienie:

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

Przykłady:

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 bajtów

Zgodnie ze zaktualizowanymi wymaganiami, lista zadań jest teraz akceptowalna

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

Przyjmuje zero lub więcej argumentów: 80 bajtów

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

Oryginalna próba, 106 bajtów:

(...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 bajtów

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

Nie golfowany:

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

Jako parametr przyjmuje listę liczb całkowitych zakończonych przez -1. Na przykład:

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

Służy cdo przełączania między spacjami i myślnikami.

Perl: 42 41 znaków

Wystarczy mieć co najmniej jedno rozwiązanie z analizowaniem łańcuchów.

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

Przykładowy przebieg:

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 180 bajtów

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

Metoda, która pobiera rozdzielony przecinkami ciąg wejściowy i drukuje wynikowy wykres Gantta ascii na standardowe wyjście.

Dzięki durron597 i masterX244 za pomoc w oszczędzaniu 10 bajtów

Java, 187 181 197 183 101 bajtów

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

Niegolfowany (w pewnym sensie):

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

Akceptuje dane wejściowe jako tablicę 2d ints. Dzięki masterX244 za wskazanie, że jest to dozwolone przez reguły.

Galaretka , 13 9 bajtów

ạ\⁾ -xµ€Y

Wypróbuj online!

Pobiera dane wejściowe jako [[5, 20], [5, 20], [2, 10], [15, 19]] .

-4 bajty dzięki Erikowi

APL (Dyalog Classic) , 12 bajtów

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

Wypróbuj online!

APL nie ma varargs, więc tutaj arg jest pojedynczą macierzą Nx2.

JavaScript (ES8), 54 bajty

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

Wypróbuj online

PowerShell 3.0, 4836 bajtów

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

Dzięki Mazzy za uratowanie 12 z lepszym sposobem na przejście na listę

Stary kod i objaśnienie:

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

Traktuje argumenty jako listę krotek, np. (5,20), (5,20), (2,10), (15,19). Musiałem ustawić $ b na wartość, aby zająć się pustym łańcuchem, ponieważ jakoś wszedł do bloku foreach, gdy został wywołany bez danych wejściowych.

R , 117 90 75 bajtów

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

Wypróbuj online!

Giuseppe grał w golfa co najmniej 29 bajtów od mojej oryginalnej odpowiedzi!

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!