Questo è semplice: stampare un diagramma di Gantt ASCII .

Dati gli intervalli delle attività (ora di inizio - tuple dell'ora di fine), stampa una sequenza temporale di Gantt sotto forma di -caratteri per ogni durata dell'attività - ogni attività in una nuova riga.

Esempio

Supponiamo che i miei intervalli di attività siano 28->35, 34->40, 39->44, il Gantt sarà simile a questo:

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

specificazioni

• È possibile scrivere un programma completo, una funzione con nome o una funzione anonima.
• Il tuo programma / funzione dovrebbe accettare le attività tramite STDIN o come argomenti .
• Ogni attività dovrebbe essere rappresentata come una stringa di start->enddove starte endsono numeri interi . Le attività sono separate da spazi o virgole. In alternativa , puoi ottenerlo come Tupla di numeri interi o come matrice / raccolta di 2 numeri interi. (Ad esempio, in JavaScript puoi ottenerlo come [start,end]- questo è permesso).
• Qualsiasi numero non negativo di attività (argomenti) dovrebbe essere supportato.
• Per chiarire, un singolo argomento della raccolta di attività non è consentito. È possibile analizzare un singolo argomento stringa o supportare argomenti zero o più attività. Dove task è una tupla o una raccolta di dimensioni 2.
• Si può presumere che verrà fornito solo un input valido. Ciò significa che ogni attività ha una durata positiva.
• Il valore restituito non ha importanza, il codice deve stampare la sequenza temporale su STDOUT.
• Output: per attività, startspazi seguiti da (end-start)trattini e a \n.
• Inutile dire che le righe di output devono essere ordinate in modo corrispondente all'ordine di input (attività).
• Gli spazi finali prima di \nsono consentiti, se ciò ti aiuta.

Casi test

Input:
(empty)

Output:
(empty)


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

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


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

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

vincente

• Questo è code-golf quindi vince la lunghezza minima del codice (in byte).
• Tradizionalmente, il tie breaker è post precedente.
• "Le scappatoie standard non sono più divertenti".

-----

MODIFICARE

Come molti di voi hanno capito che è consentito avere un singolo argomento di raccolta di attività, e poiché non c'è molta differenza tra questo e il requisito varargs originale , ora è permesso avere un singolo argomento di raccolta, se non si desidera utilizzare l'opzione varargs, o nel caso in cui la tua lingua non supporti varargs.

CJam, 16 14 byte

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

Ciò prevede un elenco di elenchi come input. Per esempio:

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

dà:

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

Come funziona

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

Provalo online qui

Python 2, 39 byte

Soluzione semplice usando la moltiplicazione di stringhe :)

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

Accetta input formattati in questo modo:

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

Controllalo qui.

Brainfuck, 120 115 111 byte

Almeno è più breve di Java :) L'input è un elenco di byte, in cui ogni coppia è una singola riga nel gantt.

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

Provalo

http://copy.sh/brainfuck/

Impostare end-of-input su charcon valore \0. Esempio di input: \5\20\5\20\2\10\15\19 .

Si noti che l'impostazione del valore di fine input su \0avrà l'effetto collaterale che non verrà più letto alcun input (e quindi arrestando il programma) quando l'ingresso contiene il numero zero. In BF non c'è altro modo di sapere quando l'input è esaurito.

Spiegazione*

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

_{* (Non sarai in grado di compilare / eseguire questo a causa dei commenti)}

Pyth, 36 22 19 14 byte

Questo è il mio primo programma Pyth. Jakube ha aiutato il golf a 5 byte!

FNQ<s*V" -"NeN

Si aspetta input nel modulo [[5,20], [5,20], [2,10], [15,19]] .

Puoi provarlo online .

C ++ 14, 69 byte

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

La prima volta che giocavo a golf, questo è stato un buon problema per cominciare!

K, 18 byte

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

Si aspetta un elenco di coppie come input:

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

Decomprimo ogni 'tupla ( ) usando dot-apply ( .) in modo che all'interno della lambda abbia accesso al valore iniziale e finale come xe y, rispettivamente. Quindi li riassemblo in una tupla (inizio, lunghezza) ( x,y-x) e applico "dove" ( &). Questo mi dà l'output in questo modo:

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

Quindi devo semplicemente indicizzare un array di 2 caratteri usando questa matrice irregolare ( " -"@) e inviarlo tutto a stdout ( 0:).

JavaScript ( ES6 ), 63

Modifica 3 byte salvati thaps @apsillers
63 byte che non contano l'assegnazione a F come funzione anonima sono consentiti.

Una funzione con un numero variabile di parametri, come richiesto.
Una funzione con un elenco di attività come singolo parametro.

Prova a eseguire lo snippet di seguito (essendo EcmaScript 6, solo 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 byte

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

Uso: res0()o res0(Seq(28->35, 34->40, 39->44))ecc.

Grazie Gilad per la rasatura di 4 byte usando un per espressione!

Rubino: 35 caratteri

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

Esecuzione di esempio:

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

Aggiornato per accettare più array a due elementi, uno per ogni attività da visualizzare. (Penso che sia quello che si aspetta il requisito aggiornato.)

Javascript (ES6), 61/66 caratteri

La mia risposta è quasi simile a quella pubblicata da @ edc65, ma con alcuni miglioramenti. Poiché le attività in un singolo array non sono consentite (quindi la funzione sarebbe chiamata in questo modo a([3,4], [7,15], [0,14], [10, 15]):), uno corretto sarebbe questo ( 66 caratteri senza assegnazione di nomi):

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

E se è consentito un argomento array (quindi chiama così:) a([[3,4], [7,15], [0,14], [10, 15]]), allora sarebbe ( 61 caratteri senza assegnazione):

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

SWI-Prolog, 55 byte

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

Esempio: a([[5,20],[5,20],[2,10],[15,19]]).uscite

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

Haskell, 76 byte

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

Il formato di input è una stringa di tuple separate da virgola, ad es "(1,2),(3,4)".

Esempi di utilizzo:

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

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

Come funziona: per l'analisi dell'input allego la stringa di input [ e ]ed utilizzo nativo di Haskell readfunzione per le liste di tuple interi. Il resto è facile: per ogni tupla (s,e)prendi gli sspazi seguiti da e-strattini seguiti da una nuova riga e concatena tutto in una singola stringa. Stampare.

Haskell, 59 byte

con formato di input rilassato:

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

Ora ci vuole un elenco di tuple, ad es f [(0,7),(5,6),(3,6)].

Funziona come descritto sopra, ma senza analisi dell'input.

Julia, 44 byte

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

Questo crea una funzione anonima che accetta una matrice di tuple come input e stampa su STDOUT.

Ungolfed + spiegazione:

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

Esempi:

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

In base ai requisiti aggiornati, un elenco di attività è ora accettabile

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

Accetta zero o più argomenti: 80 byte

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

Tentativo originale, 106 byte:

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

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

Prende come parametro un elenco di numeri interi terminati da -1. Per esempio:

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

Usa cper alternare tra spazi di scrittura e trattini.

Perl: 42 41 caratteri

Solo per avere almeno una soluzione con l'analisi delle stringhe.

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

Esecuzione di esempio:

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 byte

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

Un metodo che accetta una stringa di input separata da virgola e stampa il diagramma di Gantt ascii risultante su stdout.

Grazie a durron597 e masterX244 per avermi aiutato a salvare 10 byte

Java, 187 181 197 183 101 byte

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 (sorta di):

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

Accetta input come 2d array di ints. Grazie a masterX244 per aver sottolineato che ciò è consentito dalle regole.

Gelatina , 13 9 byte

ạ\⁾ -xµ€Y

Provalo online!

Accetta input come [[5, 20], [5, 20], [2, 10], [15, 19]] .

-4 byte grazie a Erik

APL (Dyalog Classic) , 12 byte

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

Provalo 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!