Bu çok basit: Bir ASCII Gantt şeması yazdırın .

Verilen görev aralıkları (başlangıç ​​zamanı - bitiş zamanı Tuples), -her görev süresi için karakter biçiminde bir Gantt zaman çizelgesi yazdırın - her görev yeni bir satırda.

Örnek

Diyelim ki görevlerimin aralığı 28->35, 34->40, 39->44, Gantt şöyle görünecek:

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

Özellikler

• Tam bir program, adlandırılmış bir işlev veya adsız bir işlev yazabilirsiniz.
• Programınız / fonksiyonunuz, görevleri STDIN yoluyla veya argüman olarak kabul etmelidir .
• Her görev bir dizi olarak temsil edilmelidir ve vardır tamsayı . Görevler boşluk veya virgülle ayrılır. Alternatif olarak , bir Tam Sayı Dizisi olarak veya 2 Tam Sayı Dizisi / Dizisi olarak alabilirsiniz. (Örneğin, JavaScript’te bunu şu şekilde alabilirsiniz - buna izin verilir).start->endstartend[start,end]
• Olumsuz sayıda görev (argüman) desteklenmelidir.
• Açıklığa kavuşturmak için, görevler toplama tek bir argüman izin verilmez. Tek bir dize bağımsız değişkenini ayrıştırabilir veya sıfır veya daha fazla görev bağımsız değişkenini destekleyebilirsiniz. Görev, bir demet veya 2 büyüklüğünde bir koleksiyon.
• Sadece geçerli girdi verileceğini varsayabilirsiniz. Bu, her görevin olumlu bir süresi olduğu anlamına gelir.
• Dönüş değeri önemli değil, kodunuz STDOUT'da zaman çizelgesini yazdırmalı.
• Çıktı: Görev başına, startboşlukları ardından (end-start)tire ve a \n.
• Söylemeye gerek yok, çıkış hatları giriş (görevler) sırasına göre sıralanmalıdır.
• \nSize yardımcı olursa, önce boşluklara izin verilir.

Test durumları

Input:
(empty)

Output:
(empty)


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

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


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

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

Kazanan

• Bu kod-golf olduğundan en az kod uzunluğu (bayt cinsinden) kazanır.
• Geleneksel olarak, kravat kırıcı daha erken direk olarak bulunur.
• "Standart boşluklar artık komik değil".

-----

DÜZENLE

Birçoğunuzun, tek bir görev toplama argümanına sahip olduğuna izin verildiğini anladığınız gibi, ve bununla orijinal varargs gereksinimi arasında pek bir fark olmadığı için, şimdi kullanmak istemiyorsanız, şimdi tek bir toplama argümanına sahip olmasına izin verilir. varargs seçeneği veya dilinizin varargs özelliğini desteklememesi durumunda.

CJam, 16 14 bayt

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

Bu girdi olarak bir liste listesi bekliyor. Örneğin:

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

verir:

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

Nasıl çalışır

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

Burada çevrimiçi deneyin

Python 2, 39 Bayt

String çarpma kullanarak basit çözüm :)

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

Bu şekilde biçimlendirilmiş girişi kabul eder:

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

Buradan kontrol edin.

Brainfuck, 120 115 111 bayt

En azından Java'dan daha kısa :) Giriş, her bir çiftin gantt'ta tek bir satır olduğu bir bayt listesidir.

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

Denemek

http://copy.sh/brainfuck/

Giriş sonu chardeğerini değere ayarlayın \0. Örnek giriş: \5\20\5\20\2\10\15\19.

\0Girdi sıfırı içerdiğinde, giriş sonu değerinin ayarlanmasının, hiçbir girişin okunmayacağına (ve böylece programı durdurmayacağına) ilişkin yan etkiye sahip olacağını unutmayın. BF'de girişin ne zaman tükendiğini bilmenin başka bir yolu yoktur.

Açıklama *

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

_{* (Yorumlar nedeniyle bunu derleyemezsiniz / çalıştıramazsınız)}

Pyth, 36 22 19 14 bayt

Bu benim ilk Pyth programım. Jakube 5 bayta golf attı!

FNQ<s*V" -"NeN

Formdaki girişi bekliyor [[5,20], [5,20], [2,10], [15,19]].

Şunları yapabilirsiniz çevrimiçi denemek .

C ++ 14, 69 bayt

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

İlk kez golf oynamak, başlamak için iyi bir problemdi!

K, 18 bayt

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

Giriş olarak bir çift listesi bekler:

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

Her (paketten '(nokta-uygulamak kullanarak) tuple .lambda içimde başlangıç ve bitiş olarak değere erişibileceğinizden) xve ysırasıyla. Sonra bunları bir (başlangıç, uzunluk) tuple ( x,y-x) içine yeniden monte ettim ve "where" ( &) uyguladım . Bu bana böyle çıktı verir:

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

O zaman bu düzensiz matrisi ( " -"@) kullanarak 2 karakterli bir dizine indekslemem ve hepsini stdout ( 0:) 'a göndermem gerekiyor .

JavaScript ( ES6 ), 63

3 bayt düzenle kaydedildi thx @apsillers
63 bayt, isimsiz bir fonksiyona izin verildiğinden F olarak sayılmayacaktır.

İstenildiği gibi değişken sayıda parametre içeren bir işlev.
Tek bir parametre olarak görev listesini içeren bir işlev.

Aşağıdaki pasajı çalıştırma testi (yalnızca EcmaScript 6, Firefox olmak)

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 bayt

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

Kullanım: res0()veya res0(Seq(28->35, 34->40, 39->44))vb

Bir for ifade kullanarak 4 bayt tıraş için gilad!

Yakut: 35 karakter

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

Örnek çalışma:

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

Her iki görev için bir tane olmak üzere iki eleman dizisini kabul edecek şekilde güncellendi. (Güncellenen gereksinimin beklediği şeyin bu olduğunu düşünüyorum.)

Javascript (ES6), 61/66 karakter

Cevabım neredeyse @ edc65 tarafından gönderilene benzer, ancak bazı iyileştirmeler yapıldı. Tek dizideki görevlere izin verilmediğinden (bu şekilde işlev şöyle çağrılır:) a([3,4], [7,15], [0,14], [10, 15]), doğru olan şudur ( isim ataması olmadan 66 karakter ):

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

Ve eğer bir dizi argümanına izin verilirse (fn bu şekilde çağırır:) a([[3,4], [7,15], [0,14], [10, 15]]), öyleyse olur ( atanmadan 61 karakter ):

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

SWI-Prolog, 55 bayt

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

Örnek: a([[5,20],[5,20],[2,10],[15,19]]).çıktılar

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

Haskell, 76 bayt

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

Giriş formatı virgülle ayrılmış tuples dizisidir, örn "(1,2),(3,4)".

Kullanım örnekleri:

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

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

Nasıl çalışır: giriş ayrıştırma için giriş dizesini içine alın [ve tamsayılı tuples listeleri için ]Haskell'in native readişlevini kullandım . Gerisi kolaydır: her demet (s,e)için sboşluk e-sbıraktıktan sonra kısa çizgiler takip eder, ardından yeni satır izler ve hepsini tek bir dizge halinde birleştirir. Yazdırın.

Haskell, 59 bayt

rahat giriş formatı ile:

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

Şimdi, örneğin bir listesini alır f [(0,7),(5,6),(3,6)].

Yukarıda açıklandığı gibi çalışır ancak giriş ayrıştırması olmadan.

Julia, 44 bayt

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

Bu, bir dizi tezi giriş olarak kabul eden ve STDOUT'a basan anonim bir işlev oluşturur.

Ungolfed + açıklama:

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

Örnekler:

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 bayt

Güncellenen gereksinimlere göre, artık bir görev listesi kabul edilebilir

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

Sıfır veya daha fazla argüman alır: 80 bayt

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

Orijinal deneme, 106 bayt:

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

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

Parametre olarak sonlandırılan tam sayıların bir listesini alır -1. Örneğin:

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

Bu kullanır cyazı alanları ve çizgiler arasında geçiş yapmak için.

Perl: 42 41 karakter

Sadece dize ayrıştırma ile en az bir çözüm olması için.

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

Örnek çalışma:

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 bayt

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

Virgülle ayrılmış bir giriş dizesi alan ve elde edilen ascii Gantt Grafiğini stdout'a basan bir yöntem.

10 byte tasarruf etmeme yardımcı olan durron597 ve masterX244'e teşekkürler

Java, 187 181 197 183 101 bayt

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 (tür):

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

Girdiyi 2d dizisi olarak kabul eder int. SayesindeMasterX244'e , kurallara izin verildiğini gösterdiği için .

Jöle , 13 9 bayt

ạ\⁾ -xµ€Y

Çevrimiçi deneyin!

Girişi alır [[5, 20], [5, 20], [2, 10], [15, 19]] .

Erik sayesinde -4 bayt

APL (Dyalog Klasik) , 12 bayt

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

Çevrimiçi deneyin!

APL'de varargs yoktur, bu nedenle buradaki argüman tek bir Nx2 matrisidir.

JavaScript (ES8), 54 bayt

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

Çevrimiçi deneyin

PowerShell 3.0, 4836 Bayt

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

Listeyi geçmek için daha iyi bir yolla 12 tasarruf için Mazzy sayesinde

Eski kod ve açıklama:

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

Bir liste halinde tartışmalar yapar; örneğin (5,20), (5,20), (2,10), (15,19). Boş dizgeye bakmak için bir değere varsayılan b $ koymak zorunda kaldı çünkü bir şekilde hiçbir giriş olmadan çağrılan foreach bloğuna girdi.

R , 117 90 75 bayt

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

Çevrimiçi deneyin!

Giuseppe orjinal cevabımdan en az 29 byte golf attı!

Fikir açıktır: " "gerektiği kadar yazdırın ve ardından gerektiği kadar yazdırın "-". Girdi, 2*Lçift ​​sayısının L olduğu bir matristir. Vectorized işlevi diff"-" sayısını almak için kullanılır.

VBA (Excel), 99 90 bayt

Acil Pencereyi ve [A1]örneğin girişini kullanma .0-1,2-5

Bazı baytları kesmek için @TaylorSott'a teşekkürler.

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 bayt

Görev listesi (ES6): 65 bayt

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

Görevlerin listesi (ES5 değişkeni): 82 bayt

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

Sıfır veya daha fazla bağımsız değişken: 104 bayt

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

PHP, 94 91 bayt

Görevlerin bir listesini alır (örneğin [[5,20],[5,20],[2,10],[15,19]]). Değişken işlev adlarının hatırlatılması için @IsmaelMiguel 'e teşekkürler.

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

Orijinal deneme: 94 bayt

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

PHP, 89 karakter (fonksiyon gövdesi)

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

Dizeleri okumak için gidecektim, ama girişlerin birçoğu tamsayı çiftleri dizisini alıyordu, ben de kısalık uğruna takım elbise izleyeceğimi düşündüm.

Her bir demet için $adizideki $xI tekrarlı çizgi bir dizi yankı $a[1] - $a[0]daha büyük bir sayıya kadar yastıklı kez $a[1]boşluklarla. Sonra zorunlu newline.

Gema : 47 karakter

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

Örnek çalışma:

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;

Örnek çalışma:

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 bayt

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

ungolfed

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

Bu aslında sadece J'nin kopya fiildir #, ama onun biz liste boşluk karakteri kafasını kopyalıyorsun {.kaç kez ve kaç kez tire karakteri "2 liste öğesi eksi 1 liste öğesi" Numarası: -~/. Ne yazık ki bu bizi "1açıkça rütbeyi belirtmek zorunda bırakıyor ve Adverse kullanmamız gerekiyor:: boş vakayı ele almak için .

Çevrimiçi deneyin!