Gantt ASCII simple

31

Este es simple: imprima un diagrama de Gantt ASCII .

Dados los rangos de las tareas (tiempo de inicio - Tuplas de tiempo de finalización), imprima una línea de tiempo de Gantt en forma de -caracteres para la duración de cada tarea, cada tarea en una nueva línea.

Ejemplo

Digamos que mis rangos de tareas son 28->35, 34->40, 39->44, el Gantt se verá así:

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

Presupuesto

  • Puede escribir un programa completo, una función con nombre o una función anónima.
  • Su programa / función debe aceptar las tareas a través de STDIN o como argumentos .
  • Cada tarea debe representarse como una cadena de start->enddónde starty endson enteros . Las tareas están separadas por espacios o comas. Alternativamente , puede obtenerlo como una Tupla de enteros, o como una matriz / colección de 2 enteros. (Por ejemplo, en JavaScript puede obtenerlo como [start,end]: esto está permitido).
  • Se debe admitir cualquier número no negativo de tareas (argumentos).
  • Para que quede claro, no se permite un único argumento de recopilación de tareas. Puede analizar un solo argumento de cadena o admitir argumentos de cero o más tareas. Donde la tarea es una tupla o una colección de tamaño 2.
  • Puede suponer que solo se proporcionarán datos válidos. Eso significa que cada tarea tiene una duración positiva.
  • El valor de retorno no importa, su código debe imprimir la línea de tiempo en STDOUT.
  • Salida: por tarea, startespacios seguidos de (end-start)guiones y a \n.
  • No es necesario decir que las líneas de salida deben ordenarse en correspondencia con el orden de entrada (tareas).
  • Los espacios finales antes del \nestán permitidos, si eso te ayuda.

Casos de prueba

Input:
(empty)

Output:
(empty)


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

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


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

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

Victorioso

  • Este es el por lo que gana la menor longitud de código (en bytes).
  • Tradicionalmente, el desempate es la publicación anterior.
  • "Las lagunas estándar ya no son divertidas".

-----

EDITAR

Como muchos de ustedes entendieron que está permitido tener un único argumento de recopilación de tareas, y dado que no hay mucha diferencia entre eso y el requisito original de varargs , ahora está permitido tener un único argumento de recopilación, si no desea usar la opción varargs, o en caso de que su idioma no sea compatible con varargs.

Jacob
fuente
1
El punto 3 parece claro. Pero piint 5 ( To make it clear...) no está claro en absoluto.
edc65
Muy bien, permítanme reformular eso: no puede escribir una función que acepte exactamente un argumento a menos que sea una cadena. Si estamos hablando de un montón de tuplas, pueden enviarse a su función como argumentos, no envueltos en una colección. Por ejemplo, en JavaScript: puede iterar argumentsdentro de la función, pero no puede suponer que se arguments[0]trata de una serie de tareas.
Jacob
8
¿Por qué no simplemente permitir la entrada como una matriz / lista / vector / etc. para todos los idiomas? La preferencia personal parece una razón bastante débil.
Pomo de la puerta
1
Varargs versus una lista de argumentos es una distinción puramente sintáctica y deja las reglas de esta pregunta en un grado de interpretación innecesario y arbitrario, en mi opinión.
JohnE
2
@Jacob tiene sentido. Para futuros desafíos, recomendaría una especificación de entrada lo más laxa posible: la entrada de manipulación no debería ser parte del desafío.
Adám

Respuestas:

14

CJam, 16 14 bytes

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

Esto espera una lista de listas como entrada. Por ejemplo:

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

da:

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

Cómo 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

Pruébalo en línea aquí

Optimizador
fuente
20

Python 2, 39 bytes

Solución directa usando multiplicación de cuerdas :)

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

Acepta entradas formateadas así:

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

Compruébalo aquí.

Kade
fuente
11

Brainfuck, 120 115 111 bytes

Al menos es más corto que Java :) La entrada es una lista de bytes, donde cada par es una sola línea en el gantt.

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

Probar

http://copy.sh/brainfuck/

Establezca el fin de la entrada a charcon valor \0. Ejemplo de entrada: \5\20\5\20\2\10\15\19.

Tenga en cuenta que establecer el valor de fin de entrada \0tendrá el efecto secundario de que no se leerán más entradas (y, por lo tanto, se detendrá el programa) cuando la entrada contenga el número cero. En BF no hay otra forma de saber cuándo se agota la entrada.

Explicación*

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

* (No podrá compilar / ejecutar esto debido a los comentarios)

Rolf ツ
fuente
66
Brainfuck más corto que Java => el mundo pronto terminará.
Alex A.
1
La explicación debería funcionar bien. Los únicos comandos bf que existen son <y >, y están perfectamente equilibrados.
undergroundmonorail
@undergroundmonorail Buena captura, ni siquiera intenté ver si estaban equilibrados;)
Rolf ツ
8

Pyth, 36 22 19 14 bytes

Este es mi primer programa Pyth. ¡Jakube ayudó a jugar golf 5 bytes!

FNQ<s*V" -"NeN

Espera entrada en el formulario [[5,20], [5,20], [2,10], [15,19]].

Puedes probarlo en línea .

Alex A.
fuente
5

C ++ 14, 69 bytes

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

Primera vez jugando al golf, ¡este fue un buen problema para empezar!

patata dulce
fuente
2
¿No necesitas std::sobre ciny cout?
Alex A.
3

K, 18 bytes

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

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

Descomprimo cada 'tupla ( ) usando dot-apply ( .) para que dentro de la lambda tenga acceso al valor inicial y final como xy y, respectivamente. Luego los vuelvo a ensamblar en una tupla (inicio, longitud) ( x,y-x) y aplico "where" ( &). Esto me da salida de esta manera:

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

Luego, simplemente tengo que indexar en una matriz de 2 caracteres usando esta matriz desigual ( " -"@) y enviarla a stdout ( 0:).

JohnE
fuente
3

JavaScript ( ES6 ), 63

Editar 3 bytes guardados thx @apsillers
63 bytes sin contar la asignación a F como una función anónima está permitida.

Una función con un número variable de parámetros, según lo solicitado.
Una función con una lista de tareas como un solo parámetro.

Pruebe a ejecutar el fragmento a continuación (siendo EcmaScript 6, solo 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>

edc65
fuente
Ahorre un byte asignándolo t[0]a un global (o puede asignarlo de manera segura lsi no desea hacer un global). Además, la especificación permite "una función con nombre o una función anónima", por lo que creo que podría omitirla F=en su recuento de bytes.
apsillers
@apsillers Eché de menos la idea anonymous. Gracias
edc65
3

Scala, 67 63 59 bytes

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

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

¡Gracias gilad por afeitar 4 bytes usando una expresión for!

Jacob
fuente
2

Rubí: 35 caracteres.

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

Ejecución de muestra:

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

Actualizado para aceptar múltiples matrices de dos elementos, una para cada tarea a mostrar. (Creo que eso es lo que espera el requisito actualizado).

hombre trabajando
fuente
2

Javascript (ES6), 61/66 caracteres

Mi respuesta es casi similar a la publicada por @ edc65, pero con algunas mejoras. Como las tareas en una sola matriz no están permitidas (la función se llamaría así:) a([3,4], [7,15], [0,14], [10, 15]), la correcta sería esta ( 66 caracteres sin asignación de nombre):

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

Y si se permite un argumento de matriz (entonces llame así:) a([[3,4], [7,15], [0,14], [10, 15]]), entonces sería ( 61 caracteres sin asignación):

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

SWI-Prolog, 55 bytes

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

Ejemplo: a([[5,20],[5,20],[2,10],[15,19]]).salidas

     ---------------
     ---------------
  --------
               ----
Fatalizar
fuente
Lo siento, pero el formato de entrada en esta respuesta no cumple con las especificaciones: cada tarea debe representarse en un argumento, no en dos. (A menos que me haya perdido algo en la sintaxis SWI-Prolog con la que no estoy familiarizado ...)
Jacob
@Jacob Sí, cuando volví a leer tu publicación, me di cuenta de eso y ya cambié mi código para tenerlo en cuenta.
Fatalize
1

Haskell, 76 bytes

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

El formato de entrada es una cadena de tuplas separadas por comas, por ejemplo "(1,2),(3,4)".

Ejemplos de uso:

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

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

Cómo funciona: análisis sintáctico para la entrada Adjunto la cadena de entrada en [y ]y uso nativo de Haskell readfunción de listas de tuplas de números enteros. El resto es fácil: para cada tupla, (s,e)tome sespacios seguidos de e-sguiones seguidos de una nueva línea y concatene todo en una sola cadena. Impresión.

Haskell, 59 bytes

con formato de entrada relajado:

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

Ahora se necesita una lista de tuplas, por ejemplo f [(0,7),(5,6),(3,6)].

Funciona como se describió anteriormente, pero sin análisis de entrada.

nimi
fuente
1

Julia, 44 bytes

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

Esto crea una función anónima que acepta una matriz de tuplas como entrada e imprime en STDOUT.

Ungolfed + explicación:

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

Ejemplos:

julia> f([(5,20), (5,20), (2,10), (15,19)])
     ---------------
     ---------------
  --------
               ----

julia> f([(0,7), (5,6), (3,6)])
-------
     -
   ---

julia> f([])
Alex A.
fuente
Seguro. Lo siento por los inconvenientes ocasionados.
Jacob
@Jacob: Sin inconvenientes. Buen desafío :)
Alex A.
1

JavaScript (ES6), 106 85 80 68 bytes

Según los requisitos actualizados, ahora se acepta una lista de tareas

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

Toma cero o más argumentos: 80 bytes

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

Intento 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}
rink.attendant.6
fuente
Si es ES6, ¿por qué no String.repeat()?
manatwork
@manatwork Gracias por mostrarme algo nuevo !! Desafortunadamente para el golf de código, en realidad es más largo usar eso
rink.attendant.6
De hecho, esa bidimensional arealmente no ayuda. Tenía en mente algo así ()=>{for(i=0,s='';a=arguments[i++];)s+='_'.repeat(a[0])+'-'.repeat(a[1]-a[0])+"\n";return s}.
manatwork
r = 'repetir'? ... por 2 veces? nah! a=>a.reduce((p,v)=>p+=' '.repeat(z=v[0])+'-'.repeat(v[1]-z)+"\n",'')
edc65
1
No hay salida. Return value does not matter, your code must print the timeline on STDOUT.(y también sería más corto)
edc65
1

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

Sin golf:

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 una lista de enteros terminados por -1. Por ejemplo:

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

Se usa cpara alternar entre espacios de escritura y guiones.

Functino
fuente
1
Haga que c static: puede eliminar su tipo (será int) y la inicialización (será cero). *l>=0es lo mismo *l+1que es más corto. c&&putcharEs más corto que el ternario. Si reemplaza c=!ccon c^=13(+1 byte) puede cambiar c?45:32a 32+c(-3 bytes). Mover cflip desde forel final del bucle: (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 bytes.
aragaer
1

Perl: 42 41 caracteres

Solo para tener al menos una solución con análisis de cadenas también.

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

Ejecución de muestra:

bash-4.3$ perl -pe 's!(\d+)->(\d+),?!$"x$1."-"x($2-$1).$/!ge' <<< '0->7,5->6,3->6'
-------
     -
   ---
hombre trabajando
fuente
En realidad, ya tenemos la respuesta directa de Java que analiza una cadena :) De todos modos, ¡gracias por esta también!
Jacob
Sí, pero entiendo que espera números separados por comas, no el formato especificado en la pregunta.
manatwork
1

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

Un método que toma una cadena de entrada separada por comas e imprime el diagrama de Gantt ascii resultante en stdout.

Gracias a durron597 y masterX244 por ayudarme a ahorrar 10 bytes

SuperJedi224
fuente
Creo que puedes usar un método en su lugar.
lirtosiast
Está permitido si esta es la (o una) forma de crear una función anónima en Java8. ¿Lo es?
Jacob
Es lo más parecido que tiene Java 8 a dicha característica.
SuperJedi224
Si lo haces Integer i=0;puedes hacerlo for(;i<i.parseInt;, guardando 8 caracteres.
durron597
No pude hacer que se compilara en Ideone, pero parece que no aceptaría entradas vacías, como lo requieren las reglas ( t.split(",")arrojaría una excepción).
Nateowami
1

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

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

Acepta la entrada como una matriz 2D de ints. Gracias a masterX244 por señalar que esto está permitido por las reglas.

Nateowami
fuente
puede acortar los bucles si usa el tercer punto de viñeta de la versión actual de la pregunta y varargs para la entrada
masterX244
@ masterX244 Gracias, me perdí eso. Me parece como hacer trampa para que se analice previamente, pero si se permite hacer trampa ... lo que sea. Lo actualizaré cuando tenga tiempo.
Nateowami
1

APL (Dyalog Classic) , 12 bytes

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

Pruébalo en línea!

APL no tiene varargs, por lo que el argumento aquí es una única matriz Nx2.

ngn
fuente
Si puede tomar dos argumentos (comienza y termina) entonces↑'-'\⍨¨≤∘⍳¨
Adám
el autor del desafío dice que no
ngn
1

PowerShell 3.0, 4836 bytes

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

Gracias a Mazzy por salvar 12 con una mejor manera de pasar en la lista

Código antiguo y explicación:

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

Toma argumentos como una lista de tuplas, por ejemplo (5,20), (5,20), (2,10), (15,19). Tuve que predeterminar $ b a un valor para cuidar la cadena vacía porque de alguna manera ingresó al bloque foreach cuando se llamó sin entrada.

Veskah
fuente
36 Bytes: $args|%{" "*$_[0]+"-"*($_[1]-$_[0])}. Guardar como get-asciiGantt.ps1. Script de prueba.\get-asciiGantt.ps1 (5,20) (5,20) (2,10) (15,19)
mazzy
1

R , 117 90 75 bytes

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

Pruébalo en línea!

¡Giuseppe jugó al menos 29 bytes de mi respuesta original!

La idea es sencilla: imprima tantas " "como sea necesario y luego tantas "-"como sea necesario. La entrada es una 2*Lmatriz con L el número de pares. La función vectorizada diffse usa para obtener el número de "-".

JayCe
fuente
1
@Giuseppe esto es lo que obtengo por tratar de mantener mi matrixidea original mientras uso un forbucle ... ¡ty!
JayCe
86 bytes
Giuseppe
@Giuseppe transpuso ypara ahorrar unos cuantos más :)
JayCe
Ahora 1- indexado ahorraría 4
JayCe
Agradable, use en <lugar de *y puede llevar esto a 81 bytes
Giuseppe
1

VBA (Excel), 99 90 bytes

Usando la ventana Inmediato y [A1]como entrada ej.0-1,2-5

Gracias a @TaylorSott por cortar algunos bytes.

b=Split([A1]):For x=0To Ubound(b):c=Split(b(x),"-"):?Spc(c(0)-0)String(c(1)-c(0),"-"):Next
remodelar
fuente
1
Si cambia el formato de entrada a delimitado por espacios en lugar de delimitado por comas, puede cambiar las dos primeras cláusulas de a=[A1]:b=Split(a,",")a b=Split([A1]). Además, puede soltar el espacio antes Tode la For declaración en el bucle.
Taylor Scott,
Gracias y notado! : D
remoel
0

CoffeeScript, 104 82, 65 bytes

Lista de tareas (ES6): 65 bytes

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

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

Cero o más 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)

No minificado:

() -> [].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
)
rink.attendant.6
fuente
No estoy seguro de dónde está JavaScript, CoffeeScript y ECMAScript en sus respuestas, pero puede usar ECMAScript en Array.from(arguments)lugar de [].slice.call(arguments).
manatwork
@manatwork Como puede ver en mis respuestas (tanto ES5 como ES6, en CoffeeScript) que abordan el requisito modificado que permite una lista de tareas, ya no necesito hacer referencia arguments.
rink.attendant.6
0

PHP, 94 91 bytes

Toma una lista de tareas (por ejemplo [[5,20],[5,20],[2,10],[15,19]]). Gracias @IsmaelMiguel por el recordatorio de los nombres de las funciones variables.

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

Intento original: 94 bytes

function x($a){foreach($a as$v){echo str_repeat(' ',$v[0]).str_repeat('-',$v[1]-$v[0])."\n";}}
rink.attendant.6
fuente
73 bytes, PHP4: $R=str_repeat;foreach($G as$v)echo$R(' ',$v[0]),$R('-',$v[1]-$v[0]),'\n';(reemplace el \ncon una nueva línea real ). Para que esto funcione, debe enviar una matriz en la clave $G, a través de POST / GET / SESSION / COOKIE ...
Ismael Miguel
@IsmaelMiguel Según la pregunta, la entrada debe venir como argumento o desde STDIN.
rink.attendant.6
¿ GETCuentan los parámetros? Y creo que eso GETusa STDIN.
Ismael Miguel
0

PHP, 89 caracteres (cuerpo de la función)

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

Iba a ir a leer cadenas, pero como muchas de las entradas tomaban conjuntos de pares enteros, pensé que seguiría el ejemplo por razones de brevedad.

Para cada tupla $aen la matriz, $xhago eco de una serie de guiones repetidos $a[1] - $a[0], rellenados hasta el número más grande $a[1]con espacios. Luego la nueva línea obligatoria.

JPMC
fuente
Puede hacer que el nombre de su función sea solo una letra para guardar unos pocos bytes. o mejor aún, si PHP admite funciones anónimas, simplemente omita un nombre de función por completo.
Alex A.
1
Oh, ahora veo lo que quieres decir con "cuerpo funcional". Debe contar la definición de la función completa en su puntaje, no solo las entrañas.
Alex A.
1
printf()parece más corto que echo+ str_pad(): function gantt($x){array_map(function($a){printf("%$a[1]s␊",str_repeat('-',$a[1]-$a[0]));},$x);}(La ␊ en el código es para una nueva línea literal: simplemente envuelva su código allí.)
manatwork
1
En realidad, un buen viejo foreaches mejor: function g($x){foreach($x as$a)printf("%$a[1]s␊",str_repeat('-',$a[1]-$a[0]));}y son 79 caracteres, incluido todo.
manatwork
@AlexA. Ah, he visto campos de golf donde las personas cuentan o descartan encabezados de funciones. No estaba seguro de a qué ir, de ahí que especificara qué conteo era qué.
JPMC
0

Gema : 47 caracteres

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

Ejecución de muestra:

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

PostgreSQL: 160 caracteres

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;

Ejecución de muestra:

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]]);
-------
     -
   ---
hombre trabajando
fuente
0

J, 21 bytes

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

sin golf

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

Esto es esencialmente lo mismo verbo copia de J #, pero su estamos copiando la cabeza carácter de espacio de la lista {.número de veces, y el carácter de guión "segundo elemento de la lista menos el primero elemento de la lista de" número de veces: -~/. Lamentablemente, esto nos obliga a tener que especificar el rango "1explícitamente, y necesitamos usar Adverse ::para manejar el caso vacío.

Pruébalo en línea!

Jonás
fuente