Este es simple: imprima un diagrama de Gantt ASCII .

Dados los rangos de las tareas (tiempo de inicio - Tuplas de tiempo de finalización), imprima una línea de tiempo de Gantt en forma de -caracteres para la duración de cada tarea, cada tarea en una nueva línea.

Ejemplo

Digamos que mis rangos de tareas son 28->35, 34->40, 39->44, el Gantt se verá así:

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

Presupuesto

• Puede escribir un programa completo, una función con nombre o una función anónima.
• Su programa / función debe aceptar las tareas a través de STDIN o como argumentos .
• Cada tarea debe representarse como una cadena de start->enddónde starty endson enteros . Las tareas están separadas por espacios o comas. Alternativamente , puede obtenerlo como una Tupla de enteros, o como una matriz / colección de 2 enteros. (Por ejemplo, en JavaScript puede obtenerlo como [start,end]: esto está permitido).
• Se debe admitir cualquier número no negativo de tareas (argumentos).
• Para que quede claro, no se permite un único argumento de recopilación de tareas. Puede analizar un solo argumento de cadena o admitir argumentos de cero o más tareas. Donde la tarea es una tupla o una colección de tamaño 2.
• Puede suponer que solo se proporcionarán datos válidos. Eso significa que cada tarea tiene una duración positiva.
• El valor de retorno no importa, su código debe imprimir la línea de tiempo en STDOUT.
• Salida: por tarea, startespacios seguidos de (end-start)guiones y a \n.
• No es necesario decir que las líneas de salida deben ordenarse en correspondencia con el orden de entrada (tareas).
• Los espacios finales antes del \nestán permitidos, si eso te ayuda.

Casos de prueba

Input:
(empty)

Output:
(empty)


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

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


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

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

Victorioso

• Este es el código de golf, por lo que gana la menor longitud de código (en bytes).
• Tradicionalmente, el desempate es la publicación anterior.
• "Las lagunas estándar ya no son divertidas".

-----

EDITAR

Como muchos de ustedes entendieron que está permitido tener un único argumento de recopilación de tareas, y dado que no hay mucha diferencia entre eso y el requisito original de varargs , ahora está permitido tener un único argumento de recopilación, si no desea usar la opción varargs, o en caso de que su idioma no sea compatible con varargs.

CJam, 16 14 bytes

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

Esto espera una lista de listas como entrada. Por ejemplo:

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

da:

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

Cómo funciona

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

Pruébalo en línea aquí

Python 2, 39 bytes

Solución directa usando multiplicación de cuerdas :)

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

Acepta entradas formateadas así:

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

Compruébalo aquí.

Brainfuck, 120 115 111 bytes

Al menos es más corto que Java :) La entrada es una lista de bytes, donde cada par es una sola línea en el gantt.

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

Probar

http://copy.sh/brainfuck/

Establezca el fin de la entrada a charcon valor \0. Ejemplo de entrada: \5\20\5\20\2\10\15\19.

Tenga en cuenta que establecer el valor de fin de entrada \0tendrá el efecto secundario de que no se leerán más entradas (y, por lo tanto, se detendrá el programa) cuando la entrada contenga el número cero. En BF no hay otra forma de saber cuándo se agota la entrada.

Explicación*

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

_{* (No podrá compilar / ejecutar esto debido a los comentarios)}

Pyth, 36 22 19 14 bytes

Este es mi primer programa Pyth. ¡Jakube ayudó a jugar golf 5 bytes!

FNQ<s*V" -"NeN

Espera entrada en el formulario [[5,20], [5,20], [2,10], [15,19]].

Puedes probarlo en línea .

C ++ 14, 69 bytes

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

Primera vez jugando al golf, ¡este fue un buen problema para empezar!

K, 18 bytes

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

Espera una lista de pares como entrada:

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

Descomprimo cada 'tupla ( ) usando dot-apply ( .) para que dentro de la lambda tenga acceso al valor inicial y final como xy y, respectivamente. Luego los vuelvo a ensamblar en una tupla (inicio, longitud) ( x,y-x) y aplico "where" ( &). Esto me da salida de esta manera:

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

Luego, simplemente tengo que indexar en una matriz de 2 caracteres usando esta matriz desigual ( " -"@) y enviarla a stdout ( 0:).

JavaScript ( ES6 ), 63

Editar 3 bytes guardados thx @apsillers
63 bytes sin contar la asignación a F como una función anónima está permitida.

Una función con un número variable de parámetros, según lo solicitado.
Una función con una lista de tareas como un solo parámetro.

Pruebe a ejecutar el fragmento a continuación (siendo 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 bytes

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

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

¡Gracias gilad por afeitar 4 bytes usando una expresión for!

Rubí: 35 caracteres.

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

Ejecución de muestra:

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

Actualizado para aceptar múltiples matrices de dos elementos, una para cada tarea a mostrar. (Creo que eso es lo que espera el requisito actualizado).

Javascript (ES6), 61/66 caracteres

Mi respuesta es casi similar a la publicada por @ edc65, pero con algunas mejoras. Como las tareas en una sola matriz no están permitidas (la función se llamaría así:) a([3,4], [7,15], [0,14], [10, 15]), la correcta sería esta ( 66 caracteres sin asignación de nombre):

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

Y si se permite un argumento de matriz (entonces llame así:) a([[3,4], [7,15], [0,14], [10, 15]]), entonces sería ( 61 caracteres sin asignación):

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

Ejemplo: a([[5,20],[5,20],[2,10],[15,19]]).salidas

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

Haskell, 76 bytes

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

El formato de entrada es una cadena de tuplas separadas por comas, por ejemplo "(1,2),(3,4)".

Ejemplos de uso:

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

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

Cómo funciona: análisis sintáctico para la entrada Adjunto la cadena de entrada en [y ]y uso nativo de Haskell readfunción de listas de tuplas de números enteros. El resto es fácil: para cada tupla, (s,e)tome sespacios seguidos de e-sguiones seguidos de una nueva línea y concatene todo en una sola cadena. Impresión.

Haskell, 59 bytes

con formato de entrada relajado:

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

Ahora se necesita una lista de tuplas, por ejemplo f [(0,7),(5,6),(3,6)].

Funciona como se describió anteriormente, pero sin análisis de entrada.

Julia, 44 bytes

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

Esto crea una función anónima que acepta una matriz de tuplas como entrada e imprime en STDOUT.

Ungolfed + explicación:

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

Ejemplos:

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

Según los requisitos actualizados, ahora se acepta una lista de tareas

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

Toma cero o más argumentos: 80 bytes

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

Intento original, 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;}}

Sin golf:

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

Toma como parámetro una lista de enteros terminados por -1. Por ejemplo:

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

Se usa cpara alternar entre espacios de escritura y guiones.

Perl: 42 41 caracteres

Solo para tener al menos una solución con análisis de cadenas también.

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

Ejecución de muestra:

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

Un método que toma una cadena de entrada separada por comas e imprime el diagrama de Gantt ascii resultante en stdout.

Gracias a durron597 y masterX244 por ayudarme a ahorrar 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":"-"));}

Sin golf (tipo de):

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

Acepta la entrada como una matriz 2D de ints. Gracias a masterX244 por señalar que esto está permitido por las reglas.

Jalea , 13 9 bytes

ạ\⁾ -xµ€Y

Pruébalo en línea!

Toma entrada como [[5, 20], [5, 20], [2, 10], [15, 19]].

-4 bytes gracias a Erik

APL (Dyalog Classic) , 12 bytes

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

Pruébalo en línea!

APL no tiene varargs, por lo que el argumento aquí es una única matriz Nx2.

JavaScript (ES8), 54 bytes

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

Pruébalo en línea

PowerShell 3.0, 4836 bytes

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

Gracias a Mazzy por salvar 12 con una mejor manera de pasar en la lista

Código antiguo y explicación:

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

Toma argumentos como una lista de tuplas, por ejemplo (5,20), (5,20), (2,10), (15,19). Tuve que predeterminar $ b a un valor para cuidar la cadena vacía porque de alguna manera ingresó al bloque foreach cuando se llamó sin entrada.

R , 117 90 75 bytes

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

Pruébalo en línea!

¡Giuseppe jugó al menos 29 bytes de mi respuesta original!

La idea es sencilla: imprima tantas " "como sea necesario y luego tantas "-"como sea necesario. La entrada es una 2*Lmatriz con L el número de pares. La función vectorizada diffse usa para obtener el número de "-".

VBA (Excel), 99 90 bytes

Usando la ventana Inmediato y [A1]como entrada ej.0-1,2-5

Gracias a @TaylorSott por cortar algunos 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

Lista de tareas (ES6): 65 bytes

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

Lista de tareas (variante ES5): 82 bytes

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

Cero o más argumentos: 104 bytes

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

No minificado:

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

Toma una lista de tareas (por ejemplo [[5,20],[5,20],[2,10],[15,19]]). Gracias @IsmaelMiguel por el recordatorio de los nombres de las funciones variables.

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

Intento original: 94 bytes

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

PHP, 89 caracteres (cuerpo de la función)

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

Iba a ir a leer cadenas, pero como muchas de las entradas tomaban conjuntos de pares enteros, pensé que seguiría el ejemplo por razones de brevedad.

Para cada tupla $aen la matriz, $xhago eco de una serie de guiones repetidos $a[1] - $a[0], rellenados hasta el número más grande $a[1]con espacios. Luego la nueva línea obligatoria.

Gema : 47 caracteres

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

Ejecución de muestra:

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

PostgreSQL: 160 caracteres

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;

Ejecución de muestra:

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

sin golf

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

Esto es esencialmente lo mismo verbo copia de J #, pero su estamos copiando la cabeza carácter de espacio de la lista {.número de veces, y el carácter de guión "segundo elemento de la lista menos el primero elemento de la lista de" número de veces: -~/. Lamentablemente, esto nos obliga a tener que especificar el rango "1explícitamente, y necesitamos usar Adverse ::para manejar el caso vacío.

Pruébalo en línea!