Простой ASCII Гантт


31

Это просто: распечатайте диаграмму Гантта 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.


1
Пункт 3 кажется ясным. Но piint 5 ( To make it clear...) не совсем понятно.
edc65

Хорошо, позвольте мне перефразировать это: вы не можете написать функцию, которая принимает ровно один аргумент, если это не строка. Если речь идет о группе кортежей, они могут быть отправлены в вашу функцию в качестве аргументов, а не помещены в коллекцию. Например, в JavaScript: вы можете выполнять итерации argumentsвнутри функции, но можете не предполагать, что arguments[0]это массив задач.
Джейкоб

8
Почему бы просто не разрешить ввод в виде массива / списка / вектора / и т. Д. Для всех языков? Личные предпочтения кажутся довольно слабой причиной.
Дверная ручка

1
Varargs против списка аргументов является чисто синтаксическим различием и оставляет правила этого вопроса до ненужной и произвольной степени интерпретации, по моему мнению.
JohnE

2
@Jacob имеет смысл. Для будущих задач я бы порекомендовал как можно более слабую спецификацию ввода: искажение ввода не должно быть частью проблемы.
Адам

Ответы:


14

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

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


20

Python 2, 39 байт

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

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

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

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

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


11

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

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


6
Brainfuck короче Java => мир скоро кончится.
Алекс А.

1
Объяснение должно работать нормально. Единственные команды БФА в есть <и >, и они прекрасно сбалансированы.
подземный

@undergroundmonorail Хороший улов, я даже не пытался увидеть, были ли они сбалансированы;)
Рольф ツ


5

C ++ 14, 69 байт

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

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


2
Вам не нужно std::на cinи cout?
Алекс А.

3

К, 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:).


3

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>


Сохраните один байт, назначив t[0]глобальный (или вы можете безопасно назначить его, lесли вы не хотите создавать глобальный). Кроме того, спецификация допускает «именованную функцию или анонимную функцию», так что я думаю, что вы можете опустить F=счетчик байтов.
Апсиллеры

@apsillers Я пропустил anonymousмысль. Спасибо
edc65

3

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 байта, используя для выражения!


2

Рубин: 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]
-------
     -
   ---

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


2

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

1

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]]).выходы

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

Извините, но формат ввода в этом ответе не соответствует спецификациям - каждая задача должна быть представлена ​​одним аргументом, а не двумя. (Если я не пропустил что-то в синтаксисе SWI-Prolog, с которым я не знаком ...)
Джейкоб

@Jacob Да, перечитывая твой пост, я понял это и уже изменил свой код, чтобы учесть это.
Fatalize

1

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

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


1

Юлия, 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([])

Конечно. Приносим извинения за неудобства.
Джейкоб

@Jacob: никаких неудобств. Хороший вызов. :)
Алекс А.

1

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}

Если это ES6, то почему бы и нет String.repeat()?
Манатворк

@manatwork Спасибо, что показали мне что-то новое! К сожалению, для кода гольф это на самом деле больше использовать
rink.attendant.6

Действительно, это двухмерное aне очень помогает. Я имел в виду нечто подобное ()=>{for(i=0,s='';a=arguments[i++];)s+='_'.repeat(a[0])+'-'.repeat(a[1]-a[0])+"\n";return s}.
Манатворк

г = «повторить»? ... в 2 раза? Неа! a=>a.reduce((p,v)=>p+=' '.repeat(z=v[0])+'-'.repeat(v[1]-z)+"\n",'')
edc65

1
Нет выхода. Return value does not matter, your code must print the timeline on STDOUT.(и тоже будет короче)
edc65

1

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для переключения между написанием пробелов и тире.


1
Сделайте c статическим - вы можете удалить его тип (это будет int) и инициализацию (это будет ноль). *l>=0такой же, *l+1какой короче. c&&putcharкороче троичного. Если вы замените c=!cна c^=13(+1 байт), вы можете изменить его c?45:32на 32+c(-3 байта). Перемещение cфлип от forконца цикла: (c^=13)||putchar(10);. c;void g(int*l){for(;*l+1;l++){l[1]-=c?0:*l;while(l[0]--)putchar(32+c);(c^=13)||putchar(10);}}- 94 байта.
aragaer

1

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, который разбирает строку :) В любом случае, спасибо и за этот!
Джейкоб

Да, но, насколько я понимаю, ожидается, что числа, разделенные запятыми, а не формат, указанный в вопросе.
Манатворк

1

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


Я думаю, что вы можете использовать метод вместо этого.
lirtosiast

Это разрешено, если это (или) способ создания анонимной функции в Java8. Это?
Джейкоб

Java 8 ближе всего к такой возможности.
SuperJedi224

Если вы Integer i=0;можете сделать for(;i<i.parseInt;, сохраняя 8 символов.
durron597

Я не смог заставить его скомпилировать на Ideone, но похоже, что он не будет принимать пустой ввод, как того требуют правила ( t.split(",")будет выдано исключение).
Nateowami

1

Ява, 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 за указание, что это разрешено правилами.


Вы можете сократить циклы, если вы используете третью точку в текущей версии вопроса и переменные для ввода
masterX244

@ masterX244 Спасибо, я пропустил это. Мне кажется, что это измена для предварительного анализа, но если обман разрешен ... что угодно. Я обновлю его, когда у меня будет время.
Nateowami




1

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 при вызове без ввода.


36 байт: $args|%{" "*$_[0]+"-"*($_[1]-$_[0])}. Сохранить как get-asciiGantt.ps1. Тестовый сценарий.\get-asciiGantt.ps1 (5,20) (5,20) (2,10) (15,19)
mazzy

1

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используется для получения числа «-».


1
@Giuseppe это то, что я получаю, пытаясь придерживаться своей оригинальной matrixидеи, используя forцикл ... ты!
JayCe


@Giuseppe Транспонировано, yчтобы сохранить еще несколько :)
JayCe

Теперь 1 - проиндексированный спасет 4
JayCe

Хорошо, используйте <вместо, *и вы можете получить это до 81 байта
Джузеппе

1

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

1
Если вы измените формат ввода на разделенный пробелами, а не через запятую, вы можете изменить первые два предложения с a=[A1]:b=Split(a,",")на b=Split([A1]). Кроме того , вы можете оставить пространство перед Toв For объявлении цикла.
Тейлор Скотт

Спасибо и отметил! : D
перебрать

0

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
)

Не уверен, откуда и где в ваших ответах JavaScript, CoffeeScript и ECMAScript, но в ECMAScript вы можете использовать Array.from(arguments)вместо [].slice.call(arguments).
manatwork

@manatwork Как вы можете видеть в моих ответах (как ES5, так и ES6 в CoffeeScript) об изменении измененного требования, разрешающего список задач, мне больше не нужно ссылаться arguments.
rink.attendant.6

0

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

73 байт, PHP4: $R=str_repeat;foreach($G as$v)echo$R(' ',$v[0]),$R('-',$v[1]-$v[0]),'\n';(замените \nс реальной новой строки). Чтобы это работало, вам нужно отправить массив с ключом $Gчерез POST / GET / SESSION / COOKIE ...
Исмаэль Мигель

@IsmaelMiguel В зависимости от вопроса, входные данные должны поступать в качестве аргумента или из STDIN.
rink.attendant.6

Учитываются ли GETпараметры? И я думаю, что GETиспользует STDIN.
Исмаэль Мигель

0

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]пробелами. Тогда обязательный перевод строки.


Вы можете сделать имя вашей функции всего одной буквой, чтобы сохранить несколько байтов. или, что еще лучше, если PHP поддерживает анонимные функции, просто полностью опустите имя функции.
Алекс А.

1
О, теперь я понимаю, что вы подразумеваете под «функциональным телом». Вы должны посчитать все определение функции в вашем счете, а не только внутренности.
Алекс А.

1
printf()кажется короче echo+ str_pad(): function gantt($x){array_map(function($a){printf("%$a[1]s␊",str_repeat('-',$a[1]-$a[0]));},$x);}(␊ в коде для буквального перехода на новую строку: просто оберните ваш код там.)
manatwork

1
На самом деле старый добрый foreachлучше: function g($x){foreach($x as$a)printf("%$a[1]s␊",str_repeat('-',$a[1]-$a[0]));}и это 79 символов, включая все.
Манатворк

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

0

Гема : 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'
-------
     -
   ---

0

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

0

J, 21 байт

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

ungolfed

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

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

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

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.