Это просто: распечатайте диаграмму Гантта ASCII .

Для заданных диапазонов задач (время начала - время окончания), выведите временную шкалу Ганта в виде -символов для каждой продолжительности задачи - каждая задача в новой строке.

пример

Скажем, мои задачи находятся в диапазоне 28->35, 34->40, 39->44, Гантт будет выглядеть так:

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

Характеристики

• Вы можете написать полную программу, именованную функцию или анонимную функцию.
• Ваша программа / функция должна принимать задачи через STDIN или в качестве аргументов .
• Каждая задача должна быть представлена ​​в виде строки, start->endгде startи endявляются целыми числами . Задачи разделяются пробелами или запятыми. Кроме того , вы можете получить его как кортеж целых чисел или как массив / набор из 2 целых чисел. (Например, в JavaScript вы можете получить это как [start,end]- это разрешено).
• Любое неотрицательное количество задач (аргументов) должно поддерживаться.
• Чтобы было понятно, один аргумент набора задач не допускается. Вы можете анализировать один строковый аргумент или поддерживать ноль или более аргументов задач. Где задача - это кортеж или коллекция размером 2.
• Вы можете предполагать, что будет дан только верный ввод. Это означает, что каждая задача имеет положительную продолжительность.
• Возвращаемое значение не имеет значения, ваш код должен печатать временную шкалу на STDOUT.
• Вывод: за задачу, startпробелы, за которыми следуют (end-start)тире и a \n.
• Нет необходимости говорить, что выходные строки должны быть упорядочены в соответствии с порядком ввода (задач).
• Замыкающие пробелы перед \nразрешены, если это вам помогает.

Контрольные примеры

Input:
(empty)

Output:
(empty)


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

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


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

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

выигрыш

• Это код-гольф, поэтому выигрывает наименьшая длина кода (в байтах).
• Традиционно прерыватель связи - это более ранний пост.
• «Стандартные лазейки больше не смешны».

-----

РЕДАКТИРОВАТЬ

Как многие из вас поняли, что разрешено иметь один аргумент коллекции задач, и, поскольку между этим и исходным требованием varargs нет особых различий , теперь разрешено иметь один аргумент коллекции, если вы не хотите использовать опция varargs, или если ваш язык не поддерживает varargs.

CJam, 16 14 байтов

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

Это ожидает список списков в качестве входных данных. Например:

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

дает:

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

Как это работает

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

Попробуйте онлайн здесь

Python 2, 39 байт

Простое решение с использованием умножения строк :)

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

Принимает входные данные, отформатированные так:

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

Проверьте это здесь.

Brainfuck, 120 115 111 байтов

По крайней мере, это короче, чем Java :) Входные данные представляют собой список байтов, где каждая пара представляет собой одну строку в Гантте.

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

Проверять

http://copy.sh/brainfuck/

Установите конец ввода в charзначение \0. Пример входных данных: \5\20\5\20\2\10\15\19.

Обратите внимание, что установка значения конца ввода \0будет иметь побочный эффект, заключающийся в том, что больше входной сигнал не будет считываться (и, следовательно, останавливается программа), когда вход содержит нулевое число. В BF нет другого способа узнать, когда ввод исчерпан.

Объяснение *

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

_{* (Вы не сможете скомпилировать / запустить это из-за комментариев)}

Pyth, 36 22 19 14 байтов

Это моя первая программа Pyth. Якуб помог вытащить 5 байтов!

FNQ<s*V" -"NeN

Ожидает ввода в форме [[5,20], [5,20], [2,10], [15,19]].

Вы можете попробовать это онлайн .

C ++ 14, 69 байт

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

В первый раз, играя в гольф, это была хорошая проблема для начала!

К, 18 байт

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

Ожидается список пар в качестве входных данных:

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

Я распаковываю каждый 'кортеж ( ) с помощью dot-apply ( .), чтобы внутри лямбды я имел доступ к начальному и конечному значению как xи y, соответственно. Затем я собираю их в кортеж (начало, длина) ( x,y-x) и применяю «где» ( &). Это дает мне вывод примерно так:

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

Затем мне просто нужно проиндексировать 2-символьный массив с помощью этой рваной матрицы ( " -"@) и отправить все это в stdout ( 0:).

JavaScript ( ES6 ), 63

Редактировать сохраненные 3 байта thx @apsillers
63 байта, не считая присваивание F как анонимной функции.

Функция с переменным количеством параметров в соответствии с запросом.
Функция со списком задач в качестве одного параметра.

Тестовый запуск фрагмента ниже (будь то 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 байт

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

Использование: res0()или res0(Seq(28->35, 34->40, 39->44))др.

Спасибо Гиладу за бритье 4 байта, используя для выражения!

Рубин: 35 символов

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

Образец прогона:

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

Обновлен, чтобы принимать несколько двухэлементных массивов, по одному для каждой задачи для отображения. (Я думаю, что именно этого ожидает обновленное требование.)

Javascript (ES6), 61/66 символов

Мой ответ почти аналогичен тому, который опубликовал @ edc65, но с некоторыми улучшениями. Поскольку задачи в одном массиве недопустимы (поэтому функция будет вызываться так:) a([3,4], [7,15], [0,14], [10, 15]), правильной будет следующая ( 66 символов без присвоения имени):

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

И если разрешен один аргумент массива (поэтому вызовите fn так:) a([[3,4], [7,15], [0,14], [10, 15]]), то это будет ( 61 символ без присваивания):

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

SWI-Пролог, 55 байт

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

Пример: a([[5,20],[5,20],[2,10],[15,19]]).выходы

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

Haskell, 76 байт

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

Формат ввода - это строка кортежей, разделенных запятыми, например "(1,2),(3,4)".

Примеры использования:

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

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

Как это работает: для разбора ввода я заключаю входную строку в [и ]и использую встроенную readфункцию Haskell для списков целочисленных кортежей. Остальное легко: для каждого кортежа (s,e)взять sпробелы, за которыми e-sследуют тире, за которым следует новая строка, и объединить все в одну строку. Распечатать.

Haskell, 59 байт

с расслабленным форматом ввода:

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

Теперь он принимает список кортежей, например f [(0,7),(5,6),(3,6)].

Работает, как описано выше, но без разбора ввода.

Юлия, 44 байта

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

Это создает анонимную функцию, которая принимает массив кортежей в качестве входных данных и печатает в STDOUT.

Ungolfed + объяснение:

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

Примеры:

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 байт

Согласно обновленным требованиям, список задач теперь приемлем

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

Принимает ноль или более аргументов: 80 байт

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

Исходная попытка, 106 байт:

(...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 байтов

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

Принимает в качестве параметра список целых чисел, оканчивающихся на -1. Например:

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

Используется cдля переключения между написанием пробелов и тире.

Perl: 42 41 символов

Просто иметь хотя бы одно решение с разбором строк тоже.

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

Образец прогона:

bash-4.3$ perl -pe 's!(\d+)->(\d+),?!$"x$1."-"x($2-$1).$/!ge' <<< '0->7,5->6,3->6'
-------
     -
   ---

Ява 8, 280 275 246 204 195 185 180 байт

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

Метод, который принимает разделенную запятыми входную строку и печатает результирующую диаграмму Ганта ascii в стандартный вывод.

Спасибо durron597 и masterX244 за помощь в экономии 10 байт

Ява, 187 181 197 183 101 байт

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 (вроде):

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

Принимает ввод как 2d массив ints. Спасибо masterX244 за указание, что это разрешено правилами.

Желе , 13 9 байт

ạ\⁾ -xµ€Y

Попробуйте онлайн!

Принимает вход как [[5, 20], [5, 20], [2, 10], [15, 19]].

-4 байта благодаря Эрику

APL (Dyalog Classic) , 12 байт

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

Попробуйте онлайн!

У APL нет переменных, поэтому аргумент здесь представляет собой одну матрицу Nx2.

JavaScript (ES8), 54 байта

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

Попробуйте онлайн

PowerShell 3.0, 4836 байт

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

Спасибо Mazzy за сохранение 12 с лучшим способом пройти в списке

Старый код и объяснение:

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

Принимает аргументы в виде списка кортежей, например (5,20), (5,20), (2,10), (15,19). Пришлось по умолчанию $ b к значению, чтобы позаботиться о пустой строке, потому что он каким-то образом вошел в блок foreach при вызове без ввода.

R , 117 90 75 байт

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

Попробуйте онлайн!

Джузеппе проиграл не менее 29 байтов от моего первоначального ответа!

Идея проста: напечатать столько, " "сколько необходимо, а затем столько, "-"сколько требуется. Вход представляет собой 2*Lматрицу с L количеством пар. Векторизованная функция diffиспользуется для получения числа «-».

VBA (Excel), 99 90 байт

Использование немедленного окна и в [A1]качестве ввода, например.0-1,2-5

Спасибо @TaylorSott за сокращение байтов.

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 байт

Список задач (ES6): 65 байт

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

Список задач (вариант ES5): 82 байта

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

Ноль или более аргументов: 104 байта

()->[].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 байт

Принимает список задач (например [[5,20],[5,20],[2,10],[15,19]]). Спасибо @IsmaelMiguel за напоминание имен переменных функций.

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

Исходная попытка: 94 байта

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

PHP, 89 символов (тело функции)

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

Я собирался пойти на чтение строк, но так как многие записи принимали массивы целочисленных пар, я решил, что для краткости последую примеру.

Для каждого кортежа $aв массиве $xя повторяю строку из повторяющихся черточек $a[1] - $a[0], дополняемых до большего числа $a[1]пробелами. Тогда обязательный перевод строки.

Гема : 47 символов

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

Образец прогона:

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

PostgreSQL: 160 символов

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;

Образец прогона:

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 байт

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

ungolfed

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

Это, по существу , просто копия глагол Джея #, но его мы копирование пространства символов голову списка {.количества раз, и дефис «второй элемент списка минус первого элемент списка» количество раз: -~/. К сожалению, это заставляет нас "1явно указывать ранг , и нам нужно использовать Adverse ::для обработки пустого регистра.

Попробуйте онлайн!