यह एक सरल है: एक ASCII गैंट चार्ट प्रिंट करें ।

दिए गए कार्यों की रेंज (स्टार्ट-टाइम - एंड-टाइम ट्यूपल), -प्रत्येक कार्य अवधि के लिए वर्णों के रूप में एक गंट्ट टाइमलाइन प्रिंट करें - प्रत्येक कार्य एक नई पंक्ति में।

उदाहरण

कहो मेरे कार्य रेंज हैं 28->35, 34->40, 39->44, गैंट इस तरह दिखेगा:

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

विशेष विवरण

आप एक पूर्ण कार्यक्रम, एक नामित फ़ंक्शन या एक अनाम फ़ंक्शन लिख सकते हैं।
आपके कार्यक्रम / समारोह को STDIN या तर्कों के माध्यम से कार्यों को स्वीकार करना चाहिए ।
प्रत्येक कार्य के एक स्ट्रिंग के रूप में प्रतिनिधित्व किया जाना चाहिए start->endजहां startऔर endकर रहे हैं पूर्णांकों । कार्य रिक्त स्थान या अल्पविराम द्वारा अलग किए जाते हैं। वैकल्पिक रूप से , आप इसे टुपल ऑफ इंटेगर के रूप में, या 2 इंटेगर के एरे / संग्रह के रूप में प्राप्त कर सकते हैं। (उदाहरण के लिए, जावास्क्रिप्ट में आप इसे प्राप्त कर सकते हैं [start,end]- यह अनुमति है)।
किसी भी गैर-नकारात्मक कार्यों (तर्कों) का समर्थन किया जाना चाहिए।
इसे स्पष्ट करने के लिए, कार्य संग्रह के एक भी तर्क की अनुमति नहीं है। आप या तो एकल स्ट्रिंग तर्क को पार्स कर सकते हैं, या शून्य या अधिक कार्य तर्क का समर्थन कर सकते हैं। जहां कार्य एक टपल या आकार 2 का संग्रह है।
आप मान सकते हैं कि केवल वैध इनपुट दिया जाएगा। इसका मतलब है, प्रत्येक कार्य की एक सकारात्मक अवधि है।
रिटर्न वैल्यू मायने नहीं रखती, आपके कोड को STDOUT पर टाइमलाइन को प्रिंट करना होगा।
आउटपुट: कार्य प्रति, startरिक्त स्थान के द्वारा पीछा किया (end-start)डैश और एक \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 का समर्थन नहीं करती है।

code-golf ascii-art

— याकूब
स्रोत

1

बिंदु 3 स्पष्ट लगता है। लेकिन पिंट 5 ( To make it clear...) बिल्कुल स्पष्ट नहीं है।

— edc65

ठीक है, मुझे यह बताने की अनुमति दें कि: आप एक फ़ंक्शन नहीं लिख सकते हैं जो बिल्कुल एक तर्क को स्वीकार करता है जब तक कि यह एक स्ट्रिंग नहीं है। यदि यह टुपल्स का एक समूह है, जिसके बारे में हम बात कर रहे हैं, तो उन्हें आपके फ़ंक्शन में तर्क के रूप में भेजा जा सकता है, न कि किसी संग्रह में लिपटा हुआ। उदाहरण के लिए, जावास्क्रिप्ट में: आप argumentsफ़ंक्शन के भीतर पुनरावृति कर सकते हैं, लेकिन आप यह नहीं मान सकते हैं कि arguments[0]यह एक कार्य है।

— जैकब

8

सभी भाषाओं के लिए केवल एक सरणी / सूची / वेक्टर / आदि के रूप में इनपुट की अनुमति क्यों नहीं दी जाती है? व्यक्तिगत पसंद एक बहुत कमजोर कारण की तरह लगता है।

— दरवाज़े

1

वर्गास बनाम एक तर्क सूची एक विशुद्ध रूप से वाक्यविन्यास अंतर है और इस प्रश्न के नियमों को मेरी राय में एक अनावश्यक और मनमानी व्याख्या तक छोड़ देता है।

— जॉनी

2

@ जेकब समझ में आता है। भविष्य की चुनौतियों के लिए, मैं जितना संभव हो सके एक इनपुट युक्ति को ढीला करने की सलाह दूंगा: मंगलिंग इनपुट चुनौती का हिस्सा नहीं होना चाहिए।

— आदम

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

पायथन 2, 39 बाइट्स

स्ट्रिंग गुणन का उपयोग करके सीधा समाधान :)

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

इनपुट को इस तरह स्वरूपित किया गया:

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

यहां इसकी जांच कीजिए।

— Kade
स्रोत

11

ब्रेनफक, 120 115 111 बाइट्स

कम से कम यह जावा से छोटा है :) इनपुट बाइट्स की एक सूची है, जहां प्रत्येक जोड़ी गैंट में एक पंक्ति है।

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

कोशिश करें

http://copy.sh/brainfuck/

charमूल्य के साथ अंत-इनपुट सेट करें \0। उदाहरण इनपुट: \5\20\5\20\2\10\15\19।

ध्यान दें कि एंड-ऑफ-इनपुट वैल्यू सेट करने \0का साइड इफेक्ट होगा कि कोई और इनपुट नहीं पढ़ा जाएगा (और इस तरह प्रोग्राम को रोकना) जब इनपुट में नंबर शून्य होता है। बीएफ में यह जानने का कोई दूसरा तरीका नहीं है कि इनपुट कब समाप्त होगा।

स्पष्टीकरण *

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

जावा => दुनिया की तुलना में ब्रेनफक जल्द ही समाप्त हो जाएगा।

— एलेक्स ए।

1

स्पष्टीकरण वास्तव में ठीक चलना चाहिए। केवल bf कमांड वहाँ हैं <और >, और वे पूरी तरह से संतुलित हैं।

— अंडरग्राउंडोरेल

@undergroundmonorail अच्छा कैच, मैंने यह देखने की कोशिश भी नहीं की कि क्या वे संतुलित थे?)

— रॉल्फ

8

पायथ, 36 22 19 14 बाइट्स

यह मेरा पहला पायथ कार्यक्रम है। Jakube ने गोल्फ को 5 बाइट्स में मदद की!

FNQ<s*V" -"NeN

यह प्रपत्र में इनपुट की अपेक्षा करता है [[5,20], [5,20], [2,10], [15,19]]।

आप इसे ऑनलाइन आज़मा सकते हैं ।

— एलेक्स ए।
स्रोत

5

सी ++ 14, 69 बाइट्स

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

पहली बार गोल्फ, यह एक अच्छी समस्या थी!

— sweerpotato
स्रोत

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

मैं प्रत्येक (खोल 'डॉट लागू (का प्रयोग करके) टपल .कि लैम्ब्डा के अंदर मैं के रूप में आरंभ और अंत मूल्य की पहुंच है) तो 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)

फिर मुझे बस इस ragged मैट्रिक्स ( " -"@) का उपयोग करके 2-वर्ण सरणी में अनुक्रमित करना है और इसे सभी को stdout ( 0:) में भेजना है ।

— JohnE
स्रोत

3

जावास्क्रिप्ट ( ईएस 6 ), 63

संपादित करें 3 बाइट बचाया thx @apsillers
63 बाइट्स एफ को असाइनमेंट की गिनती नहीं करता है क्योंकि अनाम फ़ंक्शन की अनुमति है।

~~अनुरोध के रूप में मापदंडों की एक चर संख्या के साथ एक समारोह।~~
एकल पैरामीटर के रूप में कार्यों की सूची के साथ एक फ़ंक्शन।

नीचे स्निपेट का परीक्षण करना (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>

स्निपेट का विस्तार करें

— edc65
स्रोत

t[0]एक ग्लोबल को असाइन करके एक बाइट बचाएं (या आप सुरक्षित रूप से इसे असाइन कर सकते हैं lयदि आप वैश्विक नहीं बनाना चाहते हैं)। इसके अलावा, कल्पना "एक नामित फ़ंक्शन या एक अनाम फ़ंक्शन" की अनुमति देती है, इसलिए मुझे लगता है कि आप F=अपनी बाइट गिनती में छोड़ सकते हैं ।

— अप्सलर

@apsillers मुझे anonymousलगता है कि याद किया । धन्यवाद

— edc65

3

स्काला, 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

जावास्क्रिप्ट (ईएस 6), 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)))

— Zura
स्रोत

1

एसडब्ल्यूआई-प्रोलॉग, 55 बाइट्स

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

उदाहरण: a([[5,20],[5,20],[2,10],[15,19]]).आउटपुट

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

— Fatalize
स्रोत

मुझे खेद है लेकिन इस उत्तर में इनपुट प्रारूप विनिर्देशों को पूरा नहीं करता है - प्रत्येक कार्य को एक तर्क में दर्शाया जाना चाहिए, दो में नहीं। (जब तक मैं SWI- प्रोलॉग सिंटैक्स में कुछ याद नहीं कर रहा हूँ, जिससे मैं परिचित नहीं हूँ ...)

— याकूब

@Jacob हाँ जब आपके पोस्ट को री-मेयर किया गया तो मुझे लगा कि और पहले से ही इसके लिए मेरे कोड को बदल दिया है।

— घातक

1

हास्केल, 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पूर्णांक tuples की सूची के लिए कार्य करते हैं। बाकी आसान है: प्रत्येक टपल (s,e)ले sरिक्त स्थान के बाद e-sडैश के बाद एक नई रेखा और सभी को एक स्ट्रिंग में समेटना। प्रिंट।

हास्केल, 59 बाइट्स

आराम इनपुट प्रारूप के साथ:

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

अब यह tuples की सूची लेता है, उदा f [(0,7),(5,6),(3,6)]।

ऊपर वर्णित के रूप में काम करता है, लेकिन इनपुट पार्सिंग के बिना।

— nimi
स्रोत

1

जूलिया, 44 बाइट्स

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

यह एक अनाम फ़ंक्शन बनाता है जो इनपुट के रूप में ट्यूपल्स की एक सरणी को स्वीकार करता है और STDOUT को प्रिंट करता है।

असंगठित + स्पष्टीकरण:

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

— एलेक्स ए।
स्रोत

ज़रूर। असुविधा के लिए खेद है।

— याकूब

@ जैकब: कोई असुविधा नहीं। अच्छी चुनौती है। :)

— एलेक्स ए।

1

जावास्क्रिप्ट (ईएस 6), 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}

— rink.attendant.6
स्रोत

अगर यह ES6 है, तो क्यों नहीं String.repeat()?

— मैनटवर्क

@manatwork मुझे कुछ नया दिखाने के लिए धन्यवाद !! दुर्भाग्य से कोड गोल्फ के लिए यह वास्तव में अब उपयोग करने के लिए लंबा है

— rink.attenders.6

वास्तव में, यह दो आयामी aवास्तव में मदद नहीं करता है। मेरे मन में कुछ ऐसा था ()=>{for(i=0,s='';a=arguments[i++];)s+='_'.repeat(a[0])+'-'.repeat(a[1]-a[0])+"\n";return s}।

— मैनटवर्क

r = 'दोहराना'? ... 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रिक्त स्थान और डैश लिखने के बीच टॉगल का उपयोग करता है।

— Functino
स्रोत

1

सी स्टैटिक बनाएं - आप इसके प्रकार (यह इंट) और आरंभीकरण (यह शून्य होगा) छोड़ सकते हैं। *l>=0वही है *l+1जो छोटा है। c&&putcharटर्निरी से कम है। आप की जगह तो c=!cसाथ c^=13(+1 बाइट) आप बदल सकते हैं c?45:32करने के लिए 32+c(-3 बाइट्स)। लूप के अंत cसे फ्लिप हटो :। - 94 बाइट्स। 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);}}

— अर्गनेर

1

पर्ल: 42 ४१ अक्षर

बस स्ट्रिंग पार्सिंग के साथ कम से कम एक समाधान करने के लिए।

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

— आदमी काम पर है
स्रोत

वास्तव में हमारे पास पहले से ही सीधा जावा उत्तर है कि एक स्ट्रिंग पार्स :) वैसे भी, इस के लिए भी धन्यवाद!

— जैकब

हां, लेकिन जैसा कि मैं समझता हूं कि कॉमा से अलग किए गए नंबरों की अपेक्षा है, न कि प्रश्न में निर्दिष्ट प्रारूप।

— मैनटवर्क

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 गैंट चार्ट को स्टडआउट में प्रिंट करती है।

10 बाइट बचाने में मेरी मदद करने के लिए ड्यूर्रोन 597 और मास्टरएक्स 244 का धन्यवाद

— SuperJedi224
स्रोत

मुझे लगता है कि आपको इसके बजाय एक विधि का उपयोग करने की अनुमति है।

— lirtosiast

यह अनुमति दी जाती है यदि यह Java8 में एक अनाम फ़ंक्शन बनाने का एक (या) तरीका है। क्या यह?

— जैकब

इस तरह की सुविधा के लिए जावा 8 सबसे करीबी चीज है।

— SuperJedi224

यदि आप करते Integer i=0;हैं for(;i<i.parseInt;, तो आप 8 वर्णों को बचा सकते हैं ।

— डुर्रोन 597

मैं इसे Ideone पर संकलित करने के लिए नहीं मिल सका, लेकिन ऐसा प्रतीत होता है कि यह खाली इनपुट को स्वीकार नहीं करेगा, क्योंकि नियमों के लिए ( t.split(",")अपवाद को फेंकना होगा)।

— नटोमामी

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

अघोषित (प्रकार):

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

इनपुट को 2 डी सरणी के रूप में स्वीकार करता है int। यह इंगित करने के लिए कि यह नियमों द्वारा अनुमत है, मास्टरएक्स 244 के लिए धन्यवाद ।

— Nateowami
स्रोत

यदि आप इनपुट के लिए वर्तमान प्रश्न संस्करण और varargs के तीसरे बुलेटपॉइंट का उपयोग करते हैं, तो लूप को छोटा कर सकते हैं

— MasterX244

@ masterX244 धन्यवाद, मुझे वह याद आया। लगता है मुझे धोखा देने की तरह है कि यह पहले से तैयार है, लेकिन अगर धोखा दिया जाता है ... जो भी हो। समय होने पर मैं इसे अपडेट करूंगा।

— नाटेओमी

1

जेली , 13 9 बाइट्स

ạ\⁾ -xµ€Y

इसे ऑनलाइन आज़माएं!

के रूप में इनपुट लेता है [[5, 20], [5, 20], [2, 10], [15, 19]]।

-4 बाइट्स एरिक के लिए धन्यवाद

— ऐली
स्रोत

9 बाइट्स

— द एग्जोलर आउट

1

APL (Dyalog Classic) , 12 बाइट्स

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

इसे ऑनलाइन आज़माएं!

APL का कोई भी वैरैग नहीं है, इसलिए यहाँ arg एक एकल Nx2 मैट्रिक्स है।

— NGN
स्रोत

यदि आप दो तर्क (शुरू और समाप्त) ले सकते हैं↑'-'\⍨¨≤∘⍳¨

— Adám

चुनौती लेखक कहते हैं कि नहीं

— ngn

1

जावास्क्रिप्ट (ईएस 8), 54 बाइट्स

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

इसे ऑनलाइन आज़माएं

— झबरा
स्रोत

1

पावरशेल 3.0, 4836 बाइट्स

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

सूची में पास होने के लिए बेहतर तरीके से 12 को बचाने के लिए Mazzy का धन्यवाद

पुराना कोड और स्पष्टीकरण:

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

ट्यूपल्स की सूची के रूप में तर्क देता है, उदाहरण के लिए (5,20), (5,20), (2,10), (15,19)। खाली स्ट्रिंग की देखभाल के लिए $ b को एक मूल्य के लिए डिफ़ॉल्ट करना पड़ा क्योंकि यह किसी भी तरह से बिना इनपुट के कॉल किए जाने पर फॉर्च्यूनिक ब्लॉक में प्रवेश करता है।

— Veskah
स्रोत

36 बाइट्स $args|%{" "*$_[0]+"-"*($_[1]-$_[0])}:। के रूप में सहेजें get-asciiGantt.ps1। टेस्ट स्क्रिप्ट.\get-asciiGantt.ps1 (5,20) (5,20) (2,10) (15,19)

— माज़ी

1

आर , 117 90 75 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Giuseppe ने मेरे मूल उत्तर को कम से कम 29 बाइट्स से उड़ा दिया!

विचार सीधा है: " "जितना आवश्यक हो उतना प्रिंट करें "-"। इनपुट 2*Lएल के साथ एक मैट्रिक्स है जो जोड़े की संख्या है। वेक्टर किए गए फ़ंक्शन diffका उपयोग "-" की संख्या प्राप्त करने के लिए किया जाता है।

— Jayce
स्रोत

1

@Giuseppe यह वही है जो मुझे matrixएक forलूप का उपयोग करते समय अपने मूल विचार से चिपके रहने की कोशिश करने के लिए मिलता है ... ty!

— JayCe

86 बाइट्स

— Giuseppe

@Giuseppe स्थानांतरित yकुछ और :) को बचाने के लिए

— Jayce

अब 1- अनुक्रमित 4

— JayCe

अच्छा है, के <बजाय का उपयोग करें *और आप इसे 81 बाइट्स

— Giuseppe

1

VBA (एक्सेल), 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

— remoel
स्रोत

1

यदि आप इनपुट प्रारूप को कॉमा सीमांकित होने के बजाय अंतरिक्ष सीमांकित होने के लिए बदलते हैं, तो आप पहले दो खंडों से पीछा a=[A1]:b=Split(a,",")कर सकते हैं b=Split([A1])। इसके अलावा, आप से पहले अंतरिक्ष ड्रॉप कर सकते हैं Toमें For पाश घोषणा।

— टेलर स्कॉट

धन्यवाद और नोट किया! : डी

— रेमोएल

0

कॉफीस्क्रिप्ट, 104 82, 65 बाइट्स

कार्यों की सूची (ईएस 6): 65 बाइट्स

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

कार्यों की सूची (ईएस 5 संस्करण): 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
)

— rink.attendant.6
स्रोत

यह सुनिश्चित नहीं है कि आपके उत्तरों में जावास्क्रिप्ट, कॉफीस्क्रिप्ट और ईसीएमस्क्रिप्ट कहां से कहां है, लेकिन ईसीएमएस्क्रिप्ट में आप Array.from(arguments)इसके बजाय उपयोग कर सकते हैं [].slice.call(arguments)।

— मैनटवर्क

@manatwork जैसा कि आप मेरे जवाब में देख सकते हैं (दोनों ES5 और ES6, कॉफीस्क्रिप्ट में) कार्य की सूची की अनुमति देते हुए परिवर्तित आवश्यकता को संबोधित करते हुए, मुझे argumentsकिसी और संदर्भ की आवश्यकता नहीं है ।

— रिंक.टेंटडेंट .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";}}

— rink.attendant.6
स्रोत

73 बाइट्स, PHP4: $R=str_repeat;foreach($G as$v)echo$R(' ',$v[0]),$R('-',$v[1]-$v[0]),'\n';( \nएक वास्तविक न्यूलाइन के साथ बदलें )। इस काम के लिए, आपको $GPOST / GET / SESSION / COOKIE पर कुंजी पर एक सरणी भेजने की आवश्यकता है ...

— Ismael Miguel

@IsmaelMiguel प्रश्न के अनुसार, इनपुट को एक तर्क के रूप में या एसटीडीआईएन से आने की आवश्यकता है।

— रिंक.टेंडेंट .6

क्या GETपैरामीटर की गिनती होती है? और मुझे लगता है कि GETSTDIN का उपयोग करता है।

— इस्माइल मिगुएल

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सरणी में प्रत्येक tuple के लिए $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);}(कोड में ␊ शाब्दिक न्यूलाइन के लिए है: बस अपना कोड वहां लपेटें।)

— मैनटवर्क

1

वास्तव में एक अच्छा पुराना foreachबेहतर है: function g($x){foreach($x as$a)printf("%$a[1]s␊",str_repeat('-',$a[1]-$a[0]));}और यह सब कुछ सहित 79 वर्ण है।

— मैनटवर्क

@AlexA। आह, मैंने उन गोल्फों को देखा है जहां लोग फ़ंक्शन हेडर की गिनती या छूट करते हैं। मुझे यकीन नहीं था कि मुझे क्या करना है, इसलिए मैंने निर्दिष्ट किया कि क्या गिनती थी।

— जेपीएमसी

0

Gema : 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

जे, 21 बाइट्स

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

ungolfed

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

यह अनिवार्य रूप से सिर्फ J की कॉपी क्रिया है #, लेकिन इसकी हम सूची {.नंबर के स्पेस कैरेक्टर हेड को कई बार कॉपी कर रहे हैं , और हाइफन कैरेक्टर "2nd लिस्ट एलिमेंट माइनस फर्स्ट लिस्ट एलिमेंट" नंबर ऑफ टाइम्स -~/:। अफसोस की बात यह है कि हमें रैंक को स्पष्ट रूप से निर्दिष्ट करने के लिए मजबूर करना पड़ता है "1, और हमें ::खाली मामले को संभालने के लिए प्रतिकूल का उपयोग करने की आवश्यकता होती है ।

इसे ऑनलाइन आज़माएं!

— जोनाह
स्रोत

सरल ASCII गैंट

उदाहरण

विशेष विवरण

परीक्षण के मामलों

जीतना

-----

संपादित करें

CJam, 16 14 बाइट्स

पायथन 2, 39 बाइट्स

ब्रेनफक, 120 115 111 बाइट्स

पायथ, 36 22 19 14 बाइट्स

सी ++ 14, 69 बाइट्स

के, 18 बाइट्स

जावास्क्रिप्ट ( ईएस 6 ), 63

स्काला, 67 63 59 बाइट्स

रूबी: 35 अक्षर

एसडब्ल्यूआई-प्रोलॉग, 55 बाइट्स

हास्केल, 76 बाइट्स

हास्केल, 59 बाइट्स

जूलिया, 44 बाइट्स

जावास्क्रिप्ट (ईएस 6), 106 85 80 68 बाइट्स

C: 108 बाइट्स

पर्ल: 42 ४१ अक्षर

जावा 8, 280 275 246 204 195 185 180 बाइट्स

जावा, 187 181 197 183 101 बाइट्स

जेली , 13 9 बाइट्स

APL (Dyalog Classic) , 12 बाइट्स

जावास्क्रिप्ट (ईएस 8), 54 बाइट्स

पावरशेल 3.0, 4836 बाइट्स

आर , 117 90 75 बाइट्स

VBA (एक्सेल), 99 90 बाइट्स

कॉफीस्क्रिप्ट, 104 82, 65 बाइट्स

PHP, 94 91 बाइट्स

PHP, 89 वर्ण (फ़ंक्शन बॉडी)

Gema : 47 वर्ण

PostgreSQL: 160 अक्षर

जे, 21 बाइट्स

ungolfed