Prosty Gantt ASCII

31

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

Jakub
źródło
1
Punkt 3 wydaje się jasny. Ale piint 5 ( To make it clear...) nie jest wcale jasne.
edc65
Dobra, pozwólcie, że sformułuję: Nie można napisać funkcji, która akceptuje dokładnie jeden argument, chyba że jest to ciąg znaków. Jeśli mówimy o krotkach, mogą zostać przesłane do Twojej funkcji jako argumenty, a nie zawinięte w kolekcję. Na przykład w JavaScript: możesz iterować argumentsw obrębie funkcji, ale nie możesz zakładać, że arguments[0]jest to tablica zadań.
Jacob
8
Dlaczego po prostu nie zezwolić na wprowadzanie danych jako tablicy / listy / wektora / itd. Dla wszystkich języków? Osobiste preferencje wydają się dość słabym powodem.
Klamka
1
Varargs kontra lista argumentów jest czysto syntaktycznym rozróżnieniem i, moim zdaniem, reguły tego pytania pozostawiają niepotrzebny i arbitralny stopień interpretacji.
JohnE
2
@Jacob Ma sens. W przypadku przyszłych wyzwań zalecałbym jak najmniej luźną specyfikację danych wejściowych: zmiana danych wejściowych nie powinna być częścią wyzwania.
Adám

Odpowiedzi:

14

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

Optymalizator
źródło
20

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.

Kade
źródło
11

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)

Rolf ツ
źródło
6
Brainfuck krótszy niż Java => świat wkrótce się skończy.
Alex A.
1
Wyjaśnienie powinno właściwie działać poprawnie. Jedynymi dostępnymi komendami BF są <i >, i są idealnie zrównoważone.
undergroundmonorail
@undergroundmonorail Fajny haczyk, nawet nie próbowałem sprawdzić, czy są zrównoważone;)
Rolf ツ
8

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 .

Alex A.
źródło
5

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!

sweerpotato
źródło
2
Nie trzeba std::na cini cout?
Alex A.,
3

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:).

JohnE
źródło
3

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>

edc65
źródło
Zapisz jeden bajt, przypisując t[0]go do globalnego (lub możesz go bezpiecznie przypisać, ljeśli nie chcesz tworzyć globalnego). Ponadto specyfikacja zezwala na „nazwaną funkcję lub funkcję anonimową”, więc myślę, że można pominąć F=liczbę bajtów.
apsillers
@apillers Brakowało mi tej anonymousmyśli. Dzięki
edc65
3

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!

Jakub
źródło
2

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

człowiek w pracy
źródło
2

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)))
zura
źródło
1

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

     ---------------
     ---------------
  --------
               ----
Fatalizować
źródło
Przykro mi, ale format wejściowy w tej odpowiedzi nie spełnia specyfikacji - każde zadanie powinno być reprezentowane w jednym argumencie, a nie w dwóch. (Chyba że coś mi umknęło w składni SWI-Prolog, z którym nie jestem zaznajomiony ...)
Jacob
@Jacob Tak, czytając swój post, pomyślałem o tym i już zmieniłem kod, aby to uwzględnić.
Fatalize
1

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.

nimi
źródło
1

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([])
Alex A.
źródło
Pewnie. Przepraszam za niedogodności.
Jacob
@Jacob: Bez niedogodności. Niezłe wyzwanie. :)
Alex A.,
1

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}
lodowisko. dozorca 6
źródło
Jeśli to ES6, to dlaczego nie String.repeat()?
manatwork
@manatwork Dzięki za pokazanie mi czegoś nowego !! Na nieszczęście w przypadku golfa kodowego, w rzeczywistości jest to dłuższe
rink.attendant.6
Rzeczywiście, ten dwuwymiarowy atak naprawdę nie pomaga. Miałem na myśli coś takiego ()=>{for(i=0,s='';a=arguments[i++];)s+='_'.repeat(a[0])+'-'.repeat(a[1]-a[0])+"\n";return s}.
manatwork
r = „powtórzyć”? ... 2 razy? nie! a=>a.reduce((p,v)=>p+=' '.repeat(z=v[0])+'-'.repeat(v[1]-z)+"\n",'')
edc65
1
Brak wyników. Return value does not matter, your code must print the timeline on STDOUT.(i byłby też krótszy)
edc65
1

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.

Functino
źródło
1
Ustaw c jako statyczny - możesz upuścić jego typ (będzie to int) i inicjować (będzie zero). *l>=0jest taki sam jak ten, *l+1który jest krótszy. c&&putcharjest krótszy niż trójskładnikowy. W przypadku wymiany c=!cz c^=13(+1 bajt) można zmienić c?45:32na 32+c(-3 bajtów). Przesunąć cklapki ze forna końcu pętli: (c^=13)||putchar(10);. c;void g(int*l){for(;*l+1;l++){l[1]-=c?0:*l;while(l[0]--)putchar(32+c);(c^=13)||putchar(10);}}- 94 bajty.
aragaer
1

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'
-------
     -
   ---
człowiek w pracy
źródło
Właściwie mamy już prostą odpowiedź Java, która parsuje ciąg :) W każdym razie dziękuję również za to!
Jacob
Tak, ale jak rozumiem, że oczekuje liczb oddzielonych przecinkami, a nie formatu określonego w pytaniu.
manatwork
1

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

SuperJedi224
źródło
Myślę, że zamiast tego możesz użyć metody.
lirtosiast
Dozwolone jest, jeśli jest to (lub a) sposób na utworzenie anonimowej funkcji w Javie8. Czy to jest
Jacob
Java 8 jest najbliższą taką funkcją.
SuperJedi224
Jeśli możesz, Integer i=0;możesz to zrobić for(;i<i.parseInt;, oszczędzając 8 znaków.
durron597
Nie mogłem zmusić go do kompilacji na Ideone, ale wygląda na to, że nie zaakceptuje pustych danych wejściowych, ponieważ wymagają tego reguły (wygeneruje t.split(",")wyjątek).
Nateowami,
1

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.

Nateowami
źródło
możesz skrócić pętle, jeśli użyjesz trzeciego punktu w bieżącej wersji pytania i varargs dla danych wejściowych
masterX244
@ masterX244 Dzięki, tęskniłem za tym. Wydaje mi się, że oszustwo wymaga wcześniejszej analizy, ale jeśli oszustwo jest dozwolone ... cokolwiek. Zaktualizuję go, kiedy będę miał czas.
Nateowami,
1

APL (Dyalog Classic) , 12 bajtów

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

Wypróbuj online!

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

ngn
źródło
Jeśli możesz wziąć dwa argumenty (początek i koniec), to↑'-'\⍨¨≤∘⍳¨
Adám
autor wyzwań mówi no
ngn
1

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.

Veskah
źródło
36 bajtów: $args|%{" "*$_[0]+"-"*($_[1]-$_[0])}. Zapisz jako get-asciiGantt.ps1. Skrypt testowy.\get-asciiGantt.ps1 (5,20) (5,20) (2,10) (15,19)
mazzy
1

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 "-".

JayCe
źródło
1
@Giuseppe this is what I get for trying to trying to stick to my original matrix idea while using a for loop... ty!
JayCe
86 bytes
Giuseppe
@Giuseppe Transposed y to save a few more :)
JayCe
Now 1- indexed would save 4
JayCe
Nice, use < instead of * and you can get this to 81 bytes
Giuseppe
1

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
remoel
źródło
1
If you change the input format to being space delimited rather than being comma delimited, you cang chage the first two clauses from a=[A1]:b=Split(a,",") to b=Split([A1]). Also, you can drop the space before the To in the For loop declaration.
Taylor Scott
Thanks and noted! :D
remoel
0

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
)
rink.attendant.6
źródło
Not sure from where to where is the JavaScript, CoffeeScript and ECMAScript in your answers, but in ECMAScript you can use Array.from(arguments) instead of [].slice.call(arguments).
manatwork
@manatwork As you can see in my answers (both ES5 and ES6, in CoffeeScript) addressing the changed requirement allowing a list of tasks, I don't need to reference arguments any more.
rink.attendant.6
0

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";}}
rink.attendant.6
źródło
73 bytes, PHP4: $R=str_repeat;foreach($G as$v)echo$R(' ',$v[0]),$R('-',$v[1]-$v[0]),'\n'; (replace the \n with a real newline). For this to work, you need to send an array on the key $G, over POST/GET/SESSION/COOKIE...
Ismael Miguel
@IsmaelMiguel According to the question, the input needs to come as an argument or from STDIN.
rink.attendant.6
Does GET parameters count? And I think that GETuses STDIN.
Ismael Miguel
0

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.

JPMC
źródło
You can make your function name just a single letter to save a few bytes. or better yet, if PHP supports anonymous functions, just omit a function name altogether.
Alex A.
1
Oh I see now what you mean by "function body." You have to count the entire function definition in your score, not just the innards.
Alex A.
1
printf() seems shorter than echo+str_pad(): function gantt($x){array_map(function($a){printf("%$a[1]s␊",str_repeat('-',$a[1]-$a[0]));},$x);} (The ␊ in the code is for a literal newline: just wrap your code there.)
manatwork
1
Actually a good old foreach is better: function g($x){foreach($x as$a)printf("%$a[1]s␊",str_repeat('-',$a[1]-$a[0]));} And this is 79 characters including everything.
manatwork
@AlexA. ah, I've seen golfs where people count or discount function headers. I wasn't sure what to go for, hence why I specified what count was what.
JPMC
0

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'
-------
     -
   ---
manatwork
źródło
0

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]]);
-------
     -
   ---
manatwork
źródło
0

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!

Jonah
źródło