C'est simple: imprimez un diagramme de Gantt ASCII .

En fonction des plages de tâches (tuples de début et de fin), imprimez une chronologie de Gantt sous forme de -caractères pour chaque durée de tâche - chaque tâche dans une nouvelle ligne.

Exemple

Disons que mes plages de tâches sont 28->35, 34->40, 39->44, le Gantt ressemblera à ceci:

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

Caractéristiques

• Vous pouvez écrire un programme complet, une fonction nommée ou une fonction anonyme.
• Votre programme / fonction doit accepter les tâches via STDIN ou comme arguments .
• Chaque tâche doit être représentée comme une chaîne de start->endoù startet endsont des entiers . Les tâches sont séparées par des espaces ou des virgules. Alternativement , vous pouvez l'obtenir en tant que Tuple de nombres entiers, ou en tant que tableau / collection de 2 nombres entiers. (Par exemple, en JavaScript, vous pouvez l'obtenir sous la forme [start,end]- cela est autorisé).
• Tout nombre non négatif de tâches (arguments) doit être pris en charge.
• Pour être clair, un seul argument de la collecte des tâches n'est pas autorisé. Vous pouvez soit analyser un seul argument de chaîne, soit prendre en charge zéro ou plusieurs arguments de tâches. Où la tâche est un tuple ou une collection de taille 2.
• Vous pouvez supposer que seule une entrée valide sera donnée. Cela signifie que chaque tâche a une durée positive.
• La valeur de retour n'a pas d'importance, votre code doit imprimer la chronologie sur STDOUT.
• Sortie: par tâche, startespaces suivis de (end-start)tirets et a \n.
• Inutile de dire que les lignes de sortie doivent être ordonnées en conséquence avec l'ordre d'entrée (tâches).
• Les espaces de fin avant le \nsont autorisés, si cela vous aide.

Cas de test

Input:
(empty)

Output:
(empty)


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

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


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

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

Gagnant

• Il s'agit de code-golf, donc la plus petite longueur de code (en octets) l'emporte.
• Traditionnellement, le bris d'égalité est un post antérieur.
• "Les failles standard ne sont plus drôles".

-----

MODIFIER

Comme beaucoup d'entre vous ont compris qu'il est autorisé d'avoir un seul argument de collection de tâches, et comme il n'y a pas beaucoup de différence entre cela et l' exigence varargs d' origine , il est désormais autorisé d'avoir un seul argument de collection, si vous ne souhaitez pas utiliser l'option varargs, ou dans le cas où votre langue ne prend pas en charge varargs.

CJam, 16 14 octets

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

Cela attend une liste de listes en entrée. Par exemple:

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

donne:

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

Comment ça marche

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

Essayez-le en ligne ici

Python 2, 39 octets

Solution simple utilisant la multiplication de chaînes :)

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

Accepte une entrée formatée comme suit:

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

Vérifiez le ici.

Brainfuck, 120 115 111 octets

Au moins, c'est plus court que Java :) L'entrée est une liste d'octets, où chaque paire est une seule ligne dans le gantt.

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

Essaie

http://copy.sh/brainfuck/

Définissez la fin de l'entrée sur charavec une valeur \0. Exemple de saisie \5\20\5\20\2\10\15\19.

Notez que la définition de la valeur de fin d'entrée \0aura pour effet secondaire qu'aucune autre entrée ne sera lue (et donc arrêtera le programme) lorsque l'entrée contient le numéro zéro. Dans BF, il n'y a pas d'autre moyen de savoir quand l'entrée est épuisée.

Explication*

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

_{* (Vous ne pourrez pas compiler / exécuter cela à cause des commentaires)}

Pyth, 36 22 19 14 octets

Ceci est mon premier programme Pyth. Jakube a aidé à jouer au golf sur 5 octets!

FNQ<s*V" -"NeN

Il attend une entrée dans le formulaire [[5,20], [5,20], [2,10], [15,19]].

Vous pouvez l' essayer en ligne .

C ++ 14, 69 octets

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

Pour la première fois au golf, c'était un bon problème pour commencer!

K, 18 octets

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

Attend une liste de paires en entrée:

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

Je déballe chaque ( ') en utilisant tuple dot-appliquer ( .) de sorte que l' intérieur de la lambda je accès au début et à la fin comme valeur xet y, respectivement. Ensuite, je les rassemble dans un tuple (début, longueur) ( x,y-x) et applique "où" ( &). Cela me donne une sortie comme ça:

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

Ensuite, je dois simplement indexer dans un tableau à 2 caractères en utilisant cette matrice irrégulière ( " -"@) et envoyer tout cela à stdout ( 0:).

JavaScript ( ES6 ), 63

Modifier 3 octets enregistrés thx @apsillers
63 octets sans compter l'affectation à F comme fonction anonyme est autorisé.

Une fonction avec un nombre variable de paramètres, comme demandé.
Une fonction avec une liste de tâches en tant que paramètre unique.

Testez l'exécution de l'extrait ci-dessous (étant EcmaScript 6, Firefox uniquement)

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 octets

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

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

Merci gilad d'avoir rasé 4 octets en utilisant une expression!

Ruby: 35 caractères

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

Échantillon échantillon:

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

Mis à jour pour accepter plusieurs tableaux à deux éléments, un pour chaque tâche à afficher. (Je pense que c'est ce que l'exigence mise à jour attend.)

Javascript (ES6), 61/66 caractères

Ma réponse est presque similaire à celle publiée par @ edc65, mais avec quelques améliorations. Comme les tâches dans un seul tableau ne sont pas autorisées (donc la fonction serait appelée comme ceci a([3,4], [7,15], [0,14], [10, 15]):), la bonne serait la suivante ( 66 caractères sans attribution de nom):

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

Et si un argument de tableau est autorisé (donc appel fn comme ceci:) a([[3,4], [7,15], [0,14], [10, 15]]), alors ce serait ( 61 caractères sans affectation):

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

SWI-Prolog, 55 octets

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

Exemple: a([[5,20],[5,20],[2,10],[15,19]]).sorties

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

Haskell, 76 octets

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

Le format d'entrée est une chaîne de tuples séparés par des virgules, par exemple "(1,2),(3,4)".

Exemples d'utilisation:

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

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

Comment ça marche: Je joins pour analyser la chaîne d' entrée d'entrée [et ]et utiliser natif de Haskell readfonction pour les listes de tuples entières. Le reste est simple: pour chaque tuple, (s,e)prenez des sespaces suivis de e-stirets suivis d'une nouvelle ligne et concaténez le tout en une seule chaîne. Impression.

Haskell, 59 octets

avec un format d'entrée détendu:

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

Maintenant, il faut une liste de tuples, par exemple f [(0,7),(5,6),(3,6)].

Fonctionne comme décrit ci-dessus, mais sans analyse d'entrée.

Julia, 44 octets

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

Cela crée une fonction anonyme qui accepte un tableau de tuples en entrée et imprime sur STDOUT.

Ungolfed + explication:

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

Exemples:

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 octets

Conformément aux exigences mises à jour, une liste de tâches est désormais acceptable

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

Prend zéro ou plusieurs arguments: 80 octets

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

Tentative d'origine, 106 octets:

(...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 octets

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

Prend comme paramètre une liste d'entiers se terminant par -1. Par exemple:

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

Il permet cde basculer entre les espaces d'écriture et les tirets.

Perl: 42 41 caractères

Juste pour avoir au moins une solution avec l'analyse des chaînes aussi.

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

Échantillon échantillon:

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 octets

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

Une méthode qui prend une chaîne d'entrée séparée par des virgules et imprime le diagramme de Gantt ascii résultant sur stdout.

Merci à durron597 et masterX244 pour m'avoir aidé à économiser 10 octets

Java, 187 181 197 183 101 octets

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

Non golfé (en quelque sorte):

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

Accepte l'entrée comme un tableau 2D de ints. Merci à masterX244 d' avoir souligné que cela est autorisé par les règles.

Gelée , 13 9 octets

ạ\⁾ -xµ€Y

Essayez-le en ligne!

Prend les entrées en tant que [[5, 20], [5, 20], [2, 10], [15, 19]].

-4 octets grâce à Erik

APL (Dyalog Classic) , 12 octets

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

Essayez-le en ligne!

APL n'a pas de varargs, donc l'argument ici est une seule matrice Nx2.

JavaScript (ES8), 54 octets

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

Essayez-le en ligne

PowerShell 3.0, 4836 octets

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

Merci à Mazzy d'avoir économisé 12 avec une meilleure façon de passer dans la liste

Ancien code et explication:

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

Prend les arguments comme une liste de tuples, par exemple (5,20), (5,20), (2,10), (15,19). J'ai dû par défaut $ b sur une valeur pour prendre soin de la chaîne vide, car il est entré en quelque sorte dans le bloc foreach lorsqu'il a été appelé sans entrée.

R , 117 90 75 octets

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

Essayez-le en ligne!

Giuseppe a joué au moins 29 octets sur ma réponse d'origine!

L'idée est simple: imprimer autant " " que nécessaire, puis autant "-"que nécessaire. L'entrée est une 2*Lmatrice avec L le nombre de paires. La fonction vectorisée diffest utilisée pour obtenir le nombre de "-".

VBA (Excel), 99 90 octets

Utilisation de la fenêtre immédiate et [A1]comme entrée, par exemple.0-1,2-5

Merci à @TaylorSott d'avoir coupé quelques octets.

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 octets

Liste des tâches (ES6): 65 octets

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

Liste des tâches (variante ES5): 82 octets

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

Zéro ou plusieurs arguments: 104 octets

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

Non minée:

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

Prend une liste de tâches (par exemple [[5,20],[5,20],[2,10],[15,19]]). Merci @IsmaelMiguel pour le rappel des noms de fonctions variables.

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

Tentative d'origine: 94 octets

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

PHP, 89 caractères (corps de fonction)

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

J'allais aller lire des chaînes, mais comme beaucoup d'entrées prenaient des tableaux de paires entières, j'ai pensé que je ferais de même pour des raisons de concision.

Pour chaque tuple $adans le tableau, $xje fais écho à une chaîne de tirets répétée $a[1] - $a[0], complétée au plus grand nombre $a[1]avec des espaces. Puis la nouvelle ligne obligatoire.

Gema : 47 caractères

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

Échantillon échantillon:

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

PostgreSQL: 160 caractères

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;

Échantillon échantillon:

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 octets

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

non golfé

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

Ceci est essentiellement juste verbe copie de J #, mais son nous copient la tête de caractère d'espace de liste {.nombre de fois, et le caractère de trait d' union « 2ème élément de la liste moins 1er élément de la liste » nombre de fois: -~/. Malheureusement, cela nous oblige à spécifier explicitement le rang "1, et nous devons utiliser Adverse ::pour gérer le cas vide.

Essayez-le en ligne!