É simples: imprima um gráfico ASCII Gantt .

Dado o intervalo das tarefas (horário de início - Tuplas no horário de término), imprima uma linha do tempo de Gantt na forma de -caracteres para cada duração de tarefa - cada tarefa em uma nova linha.

Exemplo

Digamos que meus intervalos de tarefas sejam 28->35, 34->40, 39->44, o Gantt ficará assim:

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

Especificações

• Você pode escrever um programa completo, uma função nomeada ou uma função anônima.
• Seu programa / função deve aceitar as tarefas via STDIN ou como argumentos .
• Cada tarefa deve ser representada como uma sequência de start->endonde starte endsão Inteiros . As tarefas são separadas por espaços ou vírgulas. Como alternativa , você pode obtê-lo como uma tupla de números inteiros ou como uma matriz / coleção de 2 números inteiros. (Por exemplo, em JavaScript, você pode obtê-lo como [start,end]- isso é permitido).
• Qualquer número não negativo de tarefas (argumentos) deve ser suportado.
• Para deixar claro, não é permitido um único argumento de coleta de tarefas. Você pode analisar um argumento de cadeia única ou oferecer suporte a zero ou mais argumentos de tarefas. Onde tarefa é uma tupla ou uma coleção de tamanho 2.
• Você pode assumir que apenas dados válidos serão fornecidos. Isso significa que cada tarefa tem uma duração positiva.
• O valor de retorno não importa, seu código deve imprimir a linha do tempo em STDOUT.
• Saída: por tarefa, startespaços seguidos por (end-start)traços e a \n.
• Desnecessário dizer que as linhas de saída devem ser ordenadas de acordo com a ordem de entrada (tarefas).
• Os espaços à direita antes do \npermitido são permitidos, se isso o ajudar.

Casos de teste

Input:
(empty)

Output:
(empty)


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

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


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

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

Ganhando

• Isso é código-golfe, então o menor comprimento de código (em bytes) vence.
• Tradicionalmente, o desempate é um post anterior.
• "As brechas padrão não são mais engraçadas".

-----

EDITAR

Como muitos de vocês entendem que é permitido ter um único argumento de coleção de tarefas, e como não há muito diferente entre isso e o requisito de varargs original , agora é permitido ter um único argumento de coleção, se você não quiser usar a opção varargs ou caso seu idioma não suporte varargs.

CJam, 16 14 bytes

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

Isso espera uma lista de listas como entrada. Por exemplo:

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

dá:

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

Como 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

Experimente online aqui

Python 2, 39 bytes

Solução simples usando multiplicação de cadeias :)

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

Aceita entrada formatada da seguinte forma:

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

Confira aqui.

BrainFuck, 120 115 111 bytes

Pelo menos é mais curto que Java :) A entrada é uma lista de bytes, em que cada par é uma única linha no Gantt.

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

Tente

http://copy.sh/brainfuck/

Defina o final da entrada como charcom valor \0. Exemplo de entrada: \5\20\5\20\2\10\15\19.

Observe que definir o valor de final de entrada como \0terá o efeito colateral de que nenhuma entrada será mais lida (e, portanto, interrompendo o programa) quando a entrada contiver o número zero. Em BF não há outra maneira de saber quando a entrada está esgotada.

Explicação*

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

_{* (Você não poderá compilar / executar isso devido aos comentários)}

Pitão, 36 22 19 14 bytes

Este é o meu primeiro programa Pyth. Jakube ajudou a obter 5 bytes de golfe!

FNQ<s*V" -"NeN

Espera entrada no formulário [[5,20], [5,20], [2,10], [15,19]].

Você pode experimentá-lo online .

C ++ 14, 69 bytes

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

Golfe pela primeira vez, este foi um bom problema para começar!

K, 18 bytes

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

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

Descompacto cada 'tupla ( ) usando dot-apply ( .) para que dentro do lambda eu tenha acesso ao valor inicial e final como xe y, respectivamente. Em seguida, remontei-as em uma tupla (início, comprimento) ( x,y-x) e apliquei "where" ( &). Isso me dá uma saída assim:

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

Então, eu simplesmente tenho que indexar em uma matriz de 2 caracteres usando essa matriz irregular ( " -"@) e enviar tudo para stdout ( 0:).

JavaScript ( ES6 ), 63

Edite 3 bytes salvos thx @apsillers
63 bytes sem contar a atribuição para F, pois é permitida uma função anônima.

Uma função com um número variável de parâmetros, conforme solicitado.
Uma função com uma lista de tarefas como um único parâmetro.

Teste a execução do snippet abaixo (sendo EcmaScript 6, apenas 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() ou res0(Seq(28->35, 34->40, 39->44))etc.

Obrigado gilad por barbear 4 bytes usando a para expressão!

Ruby: 35 caracteres

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

Exemplo de execução:

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

Atualizado para aceitar várias matrizes de dois elementos, uma para cada tarefa a ser exibida. (Acho que é isso que o requisito atualizado espera).

Javascript (ES6), 61/66 caracteres

Minha resposta é quase semelhante à postada por @ edc65, mas com algumas melhorias. Como tarefas em matriz única não são permitidas (a função seria chamada assim a([3,4], [7,15], [0,14], [10, 15]):), a correta seria essa ( 66 caracteres sem atribuição de nome):

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

E se um argumento de matriz for permitido (então fn chame assim:) a([[3,4], [7,15], [0,14], [10, 15]]), seria ( 61 char sem atribuição):

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

Exemplo: a([[5,20],[5,20],[2,10],[15,19]]).saídas

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

Haskell, 76 bytes

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

O formato de entrada é uma sequência de tuplas separadas por vírgula, por exemplo "(1,2),(3,4)".

Exemplos de uso:

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

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

Como funciona: para entrada de analisar Estou anexando a cadeia de entrada em [e ]e usar natal de Haskell readfunção para listas de tuplas inteiros. O resto é fácil: para cada tupla (s,e)ocupe sespaços seguidos dee-s traços seguidos por uma nova linha e concatene tudo em uma única sequência. Impressão.

Haskell, 59 bytes

com formato de entrada relaxado:

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

Agora é preciso uma lista de tuplas, por exemplo f [(0,7),(5,6),(3,6)] .

Funciona como descrito acima, mas sem análise de entrada.

Julia, 44 bytes

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

Isso cria uma função anônima que aceita uma matriz de tuplas como entrada e imprime em STDOUT.

Ungolfed + explicação:

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

Exemplos:

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

De acordo com os requisitos atualizados, uma lista de tarefas agora é aceitável

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

Leva zero ou mais argumentos: 80 bytes

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

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

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

Toma como parâmetro uma lista de números inteiros terminados por -1. Por exemplo:

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

Ele usa cpara alternar entre escrever espaços e traços.

Perl: 42 41 caracteres

Apenas para ter pelo menos uma solução com análise de string também.

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

Exemplo de execução:

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

Um método que pega uma sequência de entrada separada por vírgula e imprime o gráfico de Gantt ascii resultante em stdout.

Obrigado a durron597 e masterX244 por me ajudarem a economizar 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":"-"));}

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

Aceita entrada como 2d array de ints. Agradecemos a masterX244 por apontar que isso é permitido pelas regras.

Geléia , 13 9 bytes

ạ\⁾ -xµ€Y

Experimente online!

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

-4 bytes graças a Erik

APL (Dyalog Classic) , 12 bytes

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

Experimente online!

O APL não possui varargs, portanto, o argumento aqui é uma única matriz Nx2.

JavaScript (ES8), 54 bytes

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

Experimente online

PowerShell 3.0, 48.36 bytes

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

Agradecemos a Mazzy por salvar 12 com uma maneira melhor de passar na lista

Código antigo e explicação:

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

Toma argumentos como uma lista de tuplas, por exemplo, (5,20), (5,20), (2,10), (15,19). Teve que usar como padrão $ b em um valor para cuidar da cadeia vazia, porque de alguma forma entrou no bloco foreach quando chamado sem entrada.

R , 117 90 75 bytes

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

Experimente online!

Giuseppe jogou pelo menos 29 bytes na minha resposta original!

A idéia é direta: imprima quantas forem " "necessárias, seguidas de quantas forem "-"necessárias. Entrada é uma 2*Lmatriz com L o número de pares. A função vetorizada diffé usada para obter o número de "-".

VBA (Excel), 99 90 bytes

Usando Janela Imediata e [A1]como entrada, por exemplo.0-1,2-5

Obrigado a @TaylorSott por cortar alguns 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 tarefas (ES6): 65 bytes

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

Lista de tarefas (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

Zero ou mais 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)

Desminificado:

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