Це просте: роздрукувати діаграму ASCII Ганта .

З огляду на діапазони завдань (час початку - кортежі кінця часу), надрукуйте шкалу Ганта у вигляді -символів для кожної тривалості завдання - кожне завдання у новому рядку.

Приклад

Скажіть, мої діапазони завдань є 28->35, 34->40, 39->44 , Гант виглядатиме так:

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

Технічні умови

• Ви можете написати повну програму, названу функцію або анонімну функцію.
• Ваша програма / функція повинна приймати завдання через STDIN або як аргументи .
• Кожне завдання повинно бути представлене у вигляді рядка, start->endде startі endє Цілі особи . Завдання розділені пробілами або комами. Крім того , ви можете отримати його як набір цілих чисел, або як масив / колекція з 2 цілих чисел. (Наприклад, в JavaScript ви можете отримати його як[start,end] - це дозволено).
• Будь-яка негативна кількість завдань (аргументів) повинна підтримуватися.
• Щоб було зрозуміло, не допускається єдиний аргумент збору завдань. Ви можете або проаналізувати один аргумент рядка, або підтримати аргументи з нульовим або більше завданням. Де завдання - кортеж або колекція розміром 2.
• Ви можете припустити, що буде надано лише дійсне введення. Це означає, що кожне завдання має позитивну тривалість.
• Повернене значення не має значення, ваш код повинен надрукувати часову шкалу на STDOUT.
• Вихідні дані: на завдання, startпробіли, за якими (end-start)пробірки й а\n .
• Зайве говорити, що вихідні рядки слід упорядковувати відповідно до порядку введення (завдання).
• Пробіли перед \nдозволеними, якщо це допоможе вам.

Тестові справи

Input:
(empty)

Output:
(empty)


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

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


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

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

Перемога

• Це код-гольф тому виграє найменша довжина коду (у байтах).
• Традиційно розрив краватки - це раніше повідомлення.
• "Стандартні лазівки вже не смішні".

-----

EDIT

Оскільки багато хто з вас зрозуміли, що дозволено мати один аргумент збору задач, і оскільки між цим та початковою вимогою 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

Спробуйте його онлайн тут

Пітон 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

_{* (Ви не зможете компілювати / запустити це через коментарі)}

Піта, 36 22 19 14 байт

Це моя перша програма Pyth. Jakube допоміг гольфу на 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)

Тоді мені просто потрібно проіндексувати масив з двома символами, використовуючи цю розірвану матрицю ( " -"@), і надіслати все до 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)) ін.

Дякуємо gilad за гоління 4-х байт, використовуючи для виразу!

Ruby: 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 call так:) a([[3,4], [7,15], [0,14], [10, 15]]), то це було б ( 61 char без призначення):

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

SWI-Prolog, 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функцію для списків цілочисельних кортежів. Решта просто: для кожного кортежу (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.

Недоліковані + пояснення:

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

Безголовки:

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

Java 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 Gantt в stdout.

Завдяки durron597 та masterX244 за те, що допомогли мені зберегти 10 байт

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

Безголів (вид):

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 не має varargs, тому arg тут є єдиною матрицею 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)

Без обмежень:

() -> [].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]пробілами. Потім обов’язковий новий рядок.

Gema : 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 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!