Dies ist ganz einfach: Drucken Sie ein ASCII- Gantt-Diagramm .

Geben Sie für die angegebenen Aufgabenbereiche (Startzeit - Endzeit-Tupel) eine Gantt-Zeitleiste in Form von -Zeichen für jede Aufgabendauer aus - jede Aufgabe in einer neuen Zeile.

Beispiel

Angenommen, meine Aufgabenbereiche sind 28->35, 34->40, 39->44, sieht der Gantt folgendermaßen aus:

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

Spezifikationen

• Sie können ein vollständiges Programm, eine benannte Funktion oder eine anonyme Funktion schreiben.
• Ihr Programm / Ihre Funktion sollte die Aufgaben über STDIN oder als Argumente annehmen .
• Jede Aufgabe sollte als eine Zeichenfolge von start->endwhere startund endare Integers dargestellt werden . Aufgaben werden durch Leerzeichen oder Kommas getrennt. Alternativ können Sie es als Tupel von Ganzzahlen oder als Array / Sammlung von 2 Ganzzahlen erhalten. (Zum Beispiel können Sie es in JavaScript wie [start,end]folgt abrufen - dies ist zulässig).
• Jede nicht negative Anzahl von Aufgaben (Argumenten) sollte unterstützt werden.
• Zur Verdeutlichung ist ein einzelnes Argument der Auflistung von Aufgaben nicht zulässig. Sie können entweder ein einzelnes Zeichenfolgenargument analysieren oder null oder mehr Aufgabenargumente unterstützen. Wo Aufgabe ist ein Tupel oder eine Sammlung von Größe 2.
• Sie können davon ausgehen, dass nur gültige Eingaben gemacht werden. Das heißt, jede Aufgabe hat eine positive Dauer.
• Rückgabewert spielt keine Rolle, Ihr Code muss die Timeline auf STDOUT drucken.
• Ausgabe: pro Aufgabe startLeerzeichen, gefolgt von (end-start)Bindestrichen und a \n.
• Es ist unnötig zu erwähnen, dass die Ausgabezeilen entsprechend der Reihenfolge der Eingabe (Aufgaben) angeordnet werden sollten.
• Leerzeichen vor dem \nsind erlaubt, wenn das hilft.

Testfälle

Input:
(empty)

Output:
(empty)


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

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


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

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

Gewinnen

• Dies ist Code-Golf, so dass die geringste Codelänge (in Bytes) gewinnt.
• Traditionell ist Tie Breaker ein früherer Posten.
• "Standardlücken sind nicht mehr lustig".

-----

BEARBEITEN

Wie viele von Ihnen verstanden haben, ist es zulässig, ein einziges Argument für die Auflistung von Tasks zu verwenden, und da es keinen großen Unterschied zur ursprünglichen Varg- Anforderung gibt, ist es jetzt zulässig, ein einziges Argument für die Auflistung zu verwenden, wenn Sie es nicht verwenden möchten die varargs Option, oder falls Ihre Sprache varargs nicht unterstützt.

CJam, 16 bis 14 Bytes

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

Dies erwartet eine Liste von Listen als Eingabe. Beispielsweise:

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

gibt:

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

Wie es funktioniert

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

Probieren Sie es hier online aus

Python 2, 39 Bytes

Einfache Lösung mit String-Multiplikation :)

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

Akzeptiert wie folgt formatierte Eingaben:

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

Schau es dir hier an.

Brainfuck, 120 115 111 Bytes

Zumindest ist es kürzer als Java :) Die Eingabe ist eine Liste von Bytes, wobei jedes Paar eine einzelne Zeile im Gantt ist.

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

Ausprobieren

http://copy.sh/brainfuck/

Setzen Sie das Eingabeende auf charmit Wert \0. Beispiel Eingabe: \5\20\5\20\2\10\15\19.

Beachten Sie, dass das Setzen des Eingabeende-Werts auf \0den Nebeneffekt hat, dass keine Eingabe mehr gelesen wird (und somit das Programm beendet wird), wenn die Eingabe die Zahl Null enthält. In BF gibt es keine andere Möglichkeit zu wissen, wann die Eingabe erschöpft ist.

Erläuterung*

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

_{* (Sie können dies aufgrund der Kommentare nicht kompilieren / ausführen)}

Pyth, 36 22 19 14 Bytes

Dies ist mein erstes Pyth-Programm. Jakube hat 5 Bytes beim Golfen geholfen!

FNQ<s*V" -"NeN

Es erwartet Eingaben in das Formular [[5,20], [5,20], [2,10], [15,19]].

Sie können es online ausprobieren .

C ++ 14, 69 Bytes

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

Zum ersten Mal Golf spielen, das war ein gutes Problem für den Anfang!

K, 18 Bytes

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

Erwartet eine Liste von Paaren als Eingabe:

  `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 Entpacke jedes ( ') unter Verwendung von Dot-Tupel gelten ( .) , so dass innerhalb der Lambda - I Zugriff auf den Anfangs- und Endwert haben , wie xund y, respectively. Dann setze ich diese zu einem (Anfang, Länge) Tupel ( x,y-x) zusammen und wende "where" ( &) an. Das gibt mir eine Ausgabe wie folgt:

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

Dann muss ich einfach mit dieser unregelmäßigen Matrix ( " -"@) ein Array mit 2 Zeichen indizieren und alles an stdout ( 0:) senden .

JavaScript ( ES6 ), 63

Bearbeite 3 Bytes gespeichert dank @apsillers
63 Bytes nicht die Zuordnung zu F als anonyme Zählfunktion ist erlaubt.

Eine Funktion mit einer variablen Anzahl von Parametern, wie angefordert.
Eine Funktion mit einer Liste von Aufgaben als einem einzigen Parameter.

Teste das folgende Snippet (nur in 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>

Scala, 67 63 59 Bytes

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

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

Vielen Dank, Gilad, für das Rasieren von 4 Bytes mit einem for-Ausdruck!

Ruby: 35 Zeichen

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

Probelauf:

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

Aktualisiert, um mehrere Arrays mit zwei Elementen zu akzeptieren, eines für jede anzuzeigende Aufgabe. (Ich denke, das ist, was die aktualisierte Anforderung erwartet.)

Javascript (ES6), 61/66 Zeichen

Meine Antwort ist fast ähnlich der von @ edc65, aber mit einigen Verbesserungen. Da Aufgaben in einem einzelnen Array nicht zulässig sind (so würde die Funktion folgendermaßen aufgerufen werden:), ist dies a([3,4], [7,15], [0,14], [10, 15])korrekt ( 66 Zeichen ohne Namenszuweisung):

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

Und wenn ein Array-Argument erlaubt ist (also fn wie folgt aufrufen:) a([[3,4], [7,15], [0,14], [10, 15]]), dann wäre es ( 61 Zeichen ohne Zuweisung):

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

Beispiel: a([[5,20],[5,20],[2,10],[15,19]]).Ausgänge

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

Haskell, 76 Bytes

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

Das Eingabeformat ist eine Folge von durch Kommas getrennten Tupeln, z "(1,2),(3,4)" .

Anwendungsbeispiele:

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

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

So funktioniert es: Zum Parsen von Eingaben füge ich die Eingabezeichenfolge in [und ein ]und verwende die native readFunktion von Haskell für Listen von Integer-Tupeln. Der Rest ist einfach: für jedes Tupel (s,e)nehmen sLeerzeichen gefolgt vone-s Bindestrichen und einer neuen Zeile, und verketten Sie alles zu einer einzigen Zeichenfolge. Drucken.

Haskell, 59 Bytes

mit entspanntem Eingabeformat:

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

Nun braucht es eine Liste von Tupeln, z f [(0,7),(5,6),(3,6)] .

Funktioniert wie oben beschrieben, jedoch ohne Eingabe-Parsing.

Julia, 44 Bytes

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

Dadurch wird eine anonyme Funktion erstellt, die ein Array von Tupeln als Eingabe akzeptiert und an STDOUT ausgibt.

Ungolfed + Erklärung:

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

Beispiele:

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 Byte

Gemäß den aktualisierten Anforderungen ist jetzt eine Liste von Aufgaben zulässig

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

Nimmt keine oder mehr Argumente an: 80 Bytes

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

Ursprünglicher Versuch, 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;
    }
}

Nimmt als Parameter eine Liste von Ganzzahlen, die mit abgeschlossen sind -1. Beispielsweise:

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

Es verwendet czwischen Beschriftungsfeldern und Striche zu wechseln.

Perl: 42 41 Zeichen

Nur um mindestens eine Lösung mit String-Parsing zu haben.

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

Probelauf:

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

Eine Methode, die eine durch Kommas getrennte Eingabezeichenfolge verwendet und das resultierende ASCII-Gantt-Diagramm an stdout ausgibt.

Vielen Dank an durron597 und masterX244, die mir geholfen haben, 10 Bytes zu sparen

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 (Art):

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

Akzeptiert Eingaben als 2D-Array von ints. Vielen Dank an masterX244 für den Hinweis, dass dies nach den Regeln zulässig ist.

Jelly , 13 9 Bytes

ạ\⁾ -xµ€Y

Probieren Sie es online!

Übernimmt die Eingabe als [[5, 20], [5, 20], [2, 10], [15, 19]] .

-4 Bytes danke an Erik

APL (Dyalog Classic) , 12 Byte

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

Probieren Sie es online!

APL hat keine Varargs, daher ist das Argument hier eine einzelne Nx2-Matrix.

JavaScript (ES8), 54 Byte

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

Probieren Sie es online aus

PowerShell 3.0, 4836 Bytes

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

Vielen Dank an Mazzy für das Speichern von 12 mit einer besseren Möglichkeit, die Liste weiterzugeben

Alter Code und Erklärung:

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

Nimmt Argumente als Liste von Tupeln, zB (5,20), (5,20), (2,10), (15,19). Wir mussten $ b auf einen Wert zurücksetzen, um die leere Zeichenfolge zu pflegen, da sie beim Aufruf ohne Eingabe irgendwie in den foreach-Block einging.

R , 117 90 75 Bytes

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

Probieren Sie es online!

Giuseppe hat mindestens 29 Bytes von meiner ursprünglichen Antwort entfernt!

Die Idee ist einfach: Drucken Sie so viele " "wie nötig, gefolgt von so vielen "-"wie nötig. Die Eingabe ist eine 2*LMatrix mit L der Anzahl der Paare. Die vektorisierte Funktion diffwird verwendet, um die Anzahl von "-" zu erhalten.

VBA (Excel), 99 bis 90 Byte

Mit Sofortfenster und [A1]als Eingabe zB.0-1,2-5

Vielen Dank an @TaylorSott für das Schneiden einiger 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

Aufgabenliste (ES6): 65 Byte

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

Aufgabenliste (ES5-Variante): 82 Byte

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

Null oder mehr Argumente: 104 Byte

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

Nicht abgeschlossen:

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

Nimmt eine Liste von Aufgaben auf (zB [[5,20],[5,20],[2,10],[15,19]]). Vielen Dank an @IsmaelMiguel für die Erinnerung an variable Funktionsnamen.

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

Ursprünglicher Versuch: 94 Bytes

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

PHP, 89 Zeichen (Funktionskörper)

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

Ich wollte Strings lesen, aber da viele der Einträge Arrays aus ganzzahligen Paaren enthielten, nahm ich an, dass ich der Kürze halber dem Beispiel folgen würde.

Für jedes Tupel $aim Array gebe $xich eine Folge von Strichen wieder $a[1] - $a[0], die $a[1]mit Leerzeichen auf die größere Zahl aufgefüllt sind. Dann die obligatorische Newline.

Gema : 47 Zeichen

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

Probelauf:

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

PostgreSQL: 160 Zeichen

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;

Probelauf:

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 ::''

Dies ist im Wesentlichen nur Kopie Verbs J #, aber die wir kopieren das Leerzeichen Kopf der Liste {.Anzahl der Male, und der Bindestrich - Zeichen „2. Listenelement minus 1. Listenelement“ Mal: -~/. Leider müssen wir deshalb den Rang "1explizit angeben , und wir müssen Adverse verwenden ::, um mit dem leeren Fall umzugehen .

Probieren Sie es online!