Ini sederhana: cetak grafik ASCII Gantt .

Rentang tugas yang diberikan (waktu mulai - Tupel waktu akhir), cetak garis waktu Gantt dalam bentuk -karakter untuk setiap durasi tugas - setiap tugas di baris baru.

Contoh

Katakanlah rentang tugas saya adalah 28->35, 34->40, 39->44, Gantt akan terlihat seperti ini:

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

Spesifikasi

• Anda dapat menulis program lengkap, fungsi bernama atau fungsi anonim.
• Program / fungsi Anda harus menerima tugas melalui STDIN atau sebagai argumen .
• Setiap tugas harus direpresentasikan sebagai string dari start->endmana startdan endyang Integer . Tugas dipisahkan oleh spasi atau koma. Atau , Anda bisa mendapatkannya sebagai Tuple of Integer, atau sebagai Array / Collection of 2 Integer. (Misalnya, dalam JavaScript Anda dapat memperolehnya [start,end]- ini diizinkan).
• Sejumlah tugas (argumen) non-negatif harus didukung.
• Untuk membuatnya lebih jelas, argumen tunggal pengumpulan tugas tidak diperbolehkan. Anda dapat menguraikan argumen string tunggal, atau mendukung argumen tugas nol atau lebih. Di mana tugas adalah tupel atau kumpulan ukuran 2.
• Anda dapat mengasumsikan hanya input yang valid yang akan diberikan. Itu artinya, setiap tugas memiliki durasi positif.
• Nilai pengembalian tidak masalah, kode Anda harus mencetak timeline pada STDOUT.
• Output: per tugas, startspasi diikuti (end-start)tanda hubung dan a \n.
• Tidak perlu dikatakan, jalur output harus dipesan sesuai dengan urutan input (tugas).
• Membuntuti spasi sebelum \ndiizinkan, jika itu membantu Anda.

Uji kasus

Input:
(empty)

Output:
(empty)


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

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


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

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

Kemenangan

• Ini adalah kode-golf sehingga panjang kode paling sedikit (dalam byte) menang.
• Secara tradisional, tie breaker adalah posting sebelumnya.
• "Lubang standar tidak lagi lucu".

-----

EDIT

Seperti banyak dari Anda mengerti bahwa diperbolehkan untuk memiliki argumen pengumpulan tugas tunggal, dan karena tidak ada banyak perbedaan antara itu dan persyaratan vararg asli , sekarang diperbolehkan untuk memiliki argumen pengumpulan tunggal, jika Anda tidak ingin menggunakan opsi varargs, atau jika bahasa Anda tidak mendukung varargs.

CJam, 16 14 byte

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

Ini mengharapkan daftar daftar sebagai input. Sebagai contoh:

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

memberi:

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

Bagaimana itu bekerja

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

Cobalah online di sini

Python 2, 39 Bytes

Solusi mudah menggunakan perkalian string :)

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

Menerima input yang diformat seperti ini:

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

Lihat disini.

Brainfuck, 120 115 111 byte

Setidaknya lebih pendek dari Java :) Inputnya adalah daftar byte, di mana setiap pasangan adalah satu baris di gantt.

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

Mencoba

http://copy.sh/brainfuck/

Tetapkan end-of-input chardengan nilai \0. Contoh masukan: \5\20\5\20\2\10\15\19.

Perhatikan bahwa pengaturan nilai input akhir \0akan memiliki efek samping sehingga tidak ada lagi input yang akan dibaca (dan dengan demikian menghentikan program) ketika input berisi angka nol. Dalam BF tidak ada cara lain untuk mengetahui kapan input habis.

Penjelasan*

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

_{* (Anda tidak dapat mengkompilasi / menjalankan ini karena komentar)}

Pyth, 36 22 19 14 byte

Ini adalah program Pyth pertama saya. Jakube membantu golf 5 byte!

FNQ<s*V" -"NeN

Ia mengharapkan input dalam formulir [[5,20], [5,20], [2,10], [15,19]].

Anda dapat mencobanya secara online .

C ++ 14, 69 byte

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

Pertama kali bermain golf, ini adalah masalah yang bagus untuk memulai!

K, 18 byte

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

Mengharapkan daftar pasangan sebagai masukan:

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

Saya membongkar setiap ( ') tuple menggunakan dot-apply ( .) sehingga di dalam lambda saya memiliki akses ke nilai awal dan akhir sebagai xdan y, masing-masing. Lalu saya pasang kembali ini menjadi (mulai, panjang) tuple ( x,y-x) dan menerapkan "di mana" ( &). Ini memberi saya output seperti:

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

Maka saya hanya perlu mengindeks ke array 2-karakter menggunakan matriks kasar ini ( " -"@) dan mengirim semuanya ke stdout ( 0:).

JavaScript ( ES6 ), 63

Edit 3 byte disimpan thx @apsillers
63 byte tidak termasuk tugas ke F sebagai fungsi anonim diperbolehkan.

Fungsi dengan jumlah parameter variabel, seperti yang diminta.
Fungsi dengan daftar tugas sebagai parameter tunggal.

Tes menjalankan cuplikan di bawah ini (menjadi EcmaScript 6, hanya 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 byte

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

Penggunaan: res0()atau res0(Seq(28->35, 34->40, 39->44))dll.

Terima kasih gilad untuk mencukur 4 byte menggunakan untuk ekspresi!

Ruby: 35 karakter

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

Contoh dijalankan:

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

Diperbarui untuk menerima beberapa array dua elemen, satu untuk setiap tugas untuk ditampilkan. (Saya pikir itulah yang diharapkan dari persyaratan yang diperbarui.)

Javascript (ES6), 61/66 karakter

Jawaban saya hampir mirip dengan yang diposting oleh @ edc65, tetapi dengan beberapa perbaikan. Karena tugas-tugas dalam array tunggal tidak diperbolehkan (jadi fungsi akan dipanggil seperti ini a([3,4], [7,15], [0,14], [10, 15]):), yang benar adalah ini ( 66 karakter tanpa penugasan nama):

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

Dan jika satu argumen array diperbolehkan (jadi fn panggil seperti ini:) a([[3,4], [7,15], [0,14], [10, 15]]), maka itu akan menjadi ( 61 char tanpa penugasan):

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

SWI-Prolog, 55 byte

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

Contoh: a([[5,20],[5,20],[2,10],[15,19]]).keluaran

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

Haskell, 76 byte

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

Format input adalah serangkaian tupel yang dipisahkan koma, mis "(1,2),(3,4)".

Contoh penggunaan:

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

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

Cara kerjanya: untuk penguraian input Saya lampirkan string input [dan ]dan gunakan readfungsi asli Haskell untuk daftar tupel integer. Sisanya mudah: untuk setiap tupel, (s,e)ambil sspasi diikuti e-standa hubung diikuti oleh baris baru dan gabungkan semuanya menjadi satu string tunggal. Mencetak.

Haskell, 59 byte

dengan format input santai:

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

Sekarang dibutuhkan daftar tupel, mis f [(0,7),(5,6),(3,6)].

Bekerja seperti yang dijelaskan di atas, tetapi tanpa parsing input.

Julia, 44 byte

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

Ini menciptakan fungsi anonim yang menerima larik tupel sebagai input dan mencetak ke STDOUT.

Penjelasan + tidak dikumpulkan:

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

Contoh:

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 byte

Sesuai persyaratan yang diperbarui, daftar tugas kini dapat diterima

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

Membawa nol atau lebih argumen: 80 byte

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

Upaya asli, 106 byte:

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

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

Tidak Disatukan:

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

Mengambil sebagai parameter daftar bilangan diakhiri oleh -1. Sebagai contoh:

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

Ini digunakan cuntuk beralih antara ruang penulisan dan tanda hubung.

Perl: 42 41 karakter

Hanya untuk memiliki setidaknya satu solusi dengan penguraian string juga.

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

Contoh dijalankan:

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 byte

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

Metode yang mengambil string input yang dipisah koma dan mencetak Ascii Gantt Chart yang dihasilkan ke stdout.

Terima kasih kepada durron597 dan masterX244 karena membantu saya menghemat 10 byte

Java, 187 181 197 183 101 byte

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

Tidak disatukan (semacam):

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

Menerima input sebagai array 2d dari ints. Terima kasih kepada masterX244 untuk menunjukkan bahwa ini diizinkan oleh aturan.

Jelly , 13 9 byte

ạ\⁾ -xµ€Y

Cobalah online!

Mengambil input sebagai [[5, 20], [5, 20], [2, 10], [15, 19]].

-4 byte terima kasih kepada Erik

APL (Dyalog Classic) , 12 byte

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

Cobalah online!

APL tidak memiliki varargs, jadi arg di sini adalah matriks Nx2 tunggal.

JavaScript (ES8), 54 byte

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

Cobalah online

PowerShell 3.0, 4836 Bytes

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

Terima kasih kepada Mazzy karena telah menyimpan 12 dengan cara yang lebih baik untuk lulus dalam daftar

Kode lama dan penjelasan:

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

Membawa argumen sebagai daftar tupel, misalnya (5,20), (5,20), (2,10), (15,19). Harus default $ b ke nilai untuk menjaga string kosong karena entah bagaimana memasuki blok foreach ketika dipanggil tanpa input.

R , 117 90 75 byte

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

Cobalah online!

Giuseppe bermain golf setidaknya 29 byte dari jawaban asli saya!

Idenya langsung: cetak sebanyak yang " "diperlukan diikuti oleh sebanyak yang "-"diperlukan. Input adalah 2*Lmatriks dengan L jumlah pasangan. Fungsi vektor diffdigunakan untuk mendapatkan jumlah "-".

VBA (Excel), 99 90 byte

Menggunakan Window Segera dan [A1]sebagai input misalnya.0-1,2-5

Terima kasih kepada @TaylorSott untuk memotong beberapa byte.

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 byte

Daftar tugas (ES6): 65 byte

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

Daftar tugas (varian ES5): 82 byte

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

Nol atau lebih argumen: 104 byte

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

Tidak dijinakkan:

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

Mengambil daftar tugas (mis [[5,20],[5,20],[2,10],[15,19]].). Terima kasih @IsmaelMiguel untuk pengingat nama fungsi variabel.

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

Upaya asli: 94 byte

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

PHP, 89 karakter (badan fungsi)

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

Saya akan pergi untuk membaca string, tetapi karena banyak entri mengambil array pasangan integer, saya pikir saya akan mengikuti untuk kepentingan singkatnya.

Untuk setiap tuple $adalam array, $xsaya mengulangi deretan tanda hubung berkali- $a[1] - $a[0]kali, diisi hingga lebih banyak $a[1]dengan spasi. Maka baris baru wajib.

Gema : 47 karakter

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

Contoh dijalankan:

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

PostgreSQL: 160 karakter

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;

Contoh dijalankan:

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 byte

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

ungolfed

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

Ini pada dasarnya hanya J copy kata kerja #, tapi kita menyalin kepala karakter spasi daftar {.beberapa kali, dan karakter tanda hubung "2 daftar elemen dikurangi 1 elemen daftar" beberapa kali: -~/. Sayangnya ini memaksa kita untuk harus menentukan peringkat "1secara eksplisit, dan kita perlu menggunakan Adverse ::untuk menangani kasing kosong.

Cobalah online!