23

तारीखों का प्रतिनिधित्व करने वाले पूर्णांकों की सूची के इनपुट को देखते हुए, निम्न की तरह ASCII कला समयरेखा का उत्पादन करें:

<----------------------------->
  A     B  C           D    E

उपरोक्त समयरेखा इनपुट के लिए आउटपुट है [1990, 1996, 1999, 2011, 2016]। समयरेखा के बारे में कई बातें नोट करें:

आउटपुट की पहली पंक्ति साइन की तुलना में कम है ( <), बराबर डैश की संख्या dateOfLastEvent - dateOfFirstEvent + 3(क्योंकि अंतिम तिथि को शामिल करने के लिए एक को जोड़ा जाना चाहिए, और फिर पैडिंग के लिए दो और), और फिर साइन ( >) से बड़ा है ।
आउटपुट की दूसरी पंक्ति में, प्रत्येक घटना को स्थिति dateOfEvent - dateOfFirstEvent + 2(शून्य-अनुक्रमण मानते हुए) पर रखा गया है । इसलिए, पहली घटना को स्थिति में रखा जाता है 2, दो वर्णों को दाईं ओर <और अंतिम घटना को दो वर्णों को बाईं ओर स्थित किया जाता है >।
प्रत्येक घटना को एक पत्र द्वारा दर्शाया जाता है। ईवेंट 1 है A, ईवेंट 2 है B, आदि 26 से अधिक ईवेंट नहीं होंगे। यदि आप चाहें तो आप लोअरकेस अक्षरों का उपयोग कर सकते हैं।
कोई अनुगामी व्हॉट्सएप नहीं है। केवल अतिरिक्त व्हाट्सएप की अनुमति कार्यक्रम के अंत में एक अनुगामी न्यूलाइन है।

इसके अलावा,

जरूरी नहीं कि घटनाओं को क्रम में दिया जाए। दिनांक अभी भी सरणी में उनकी स्थिति के अनुसार लेबल किए गए हैं, हालांकि। उदाहरण के लिए, [2, 3, 1, 5, 4]आउटपुट का एक इनपुट होना चाहिए
```
<------->
  CABED
```
आपको इनपुट के रूप में एक या अधिक इवेंट दिए जा सकते हैं। उदाहरण के लिए, [12345]आउटपुट का एक इनपुट होना चाहिए
```
<--->
  A
```
आप मान सकते हैं कि इनपुट में कभी भी डुप्लिकेट दिनांक नहीं होंगे।

इनपुट को किसी भी गैर-संख्यात्मक चरित्र द्वारा अलग किए गए पूर्णांक / स्ट्रिंग्स की एक सरणी / सूची या एक स्ट्रिंग के रूप में दिया जा सकता है। तारीखों की स्वीकार्य सीमा जो इनपुट के रूप में प्रदान की जाएगी 1 ≤ x ≤ 32767।

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीत जाएगा।

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

32767 32715 32716 32750 32730 32729 32722 32766 32740 32762
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA
2015 2014
<---->
  BA
1990 1996 1999 2011 2016
<----------------------------->
  A     B  C           D    E
2 3 1 5 4
<------->
  CABED
12345
<--->
  A

code-golf ascii-art

— Doorknob
स्रोत

5

पायथ, 37 36 35 34 बाइट्स

:*dlp++\<*\-+3-eJSQhJ">
"mhh-dhJQG

स्पष्टीकरण: (इसके लिए नई लाइन को \nसरलता से बदल दिया जाएगा )

:*dlp++\<*\-+3-eJSQhJ">\n"mhh-dhJQG

                                    - autoassign Q = eval(input())
                                    - G = "abcdefghijklmnopqrstuvwxyz"

    p++\<*\-+3-eJSQhJ">\n"          -    print out the first line

            +3-eJSQhJ               -        Get the number of dashes
                 SQ                 -            sorted(Q)
                J                   -           autoassign J = ^
               e                    -          ^[-1]
              -                     -         ^-V
                   hJ               -          J[0]
            +3                      -        ^+3

         *\-                        -       ^*"-"
      +\<                           -      "<"+^
     +               ">\n"          -     ^+"-->\n"
    p                               -    print(^)

 *dl                                -  work out the number of spaces to print
   l                                -   len(^)
 *d                                 -  ^*" "
:                                 G - For i in V: ^[i] = G[i]
                          mhh-dhJQ  -  Work out the positions of the characters
                          m      Q  -  [V for d in Q]
                               hJ   -     J[0]
                             -d     -    d-^
                           hh       -   ^+2

यहाँ यह कोशिश करो!

— नीला
स्रोत

5

पॉवरशेल, 120 108 बाइट्स

param($a)$n,$m=($a|sort)[0,-1];"<$('-'*($b=$m-$n+3))>";$o=,' '*$b;$i=97;$a|%{$o[$_-$n+2]=[char]$i++};-join$o

इनपुट लेता $aसेट तो $nऔर $mक्रमश: कम से कम और अधिक से अधिक मूल्यों के लिए,। हम $(...)उचित -वर्ण उत्पन्न करने के लिए स्ट्रिंग के अंदर एक कोड ब्लॉक निष्पादित करके, अगले खंड के साथ समयरेखा का उत्पादन करते हैं । हम तब केवल रिक्त स्थान वाले एक ही लंबाई का एक सरणी उत्पन्न करते हैं, और हमारे आउटपुट चरित्र को सेट करते हैं $i।

फिर, हम इनपुट के माध्यम से लूप $aकरते हैं |%{...}। प्रत्येक लूप हम उचित $oमूल्य निर्धारित करते हैं । अंत में, हम -join $oएक साथ मिलकर एक स्ट्रिंग बनाते हैं। चूँकि पाइप लाइन पर छोड़ दिया गया है, आउटपुट निहित है।

.TrimEnd()कमांड को हटाने के लिए संपादित किया जाता है , क्योंकि $oहमेशा एक अक्षर होने की गारंटी दी जाती है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\draw-a-timeline.ps1 2015,2014,2000
<------------------>
  c             ba

— AdmBorkBork
स्रोत

4

सी - 294 287 220 191 184 178 174 बाइट्स

कुछ पागल कोड के साथ बाहर घूरने के बाद मैंने कम से कम इसे थोड़ा नीचे पा लिया है ...

नोट: सबसे पहले लूप आवश्यकता है कि द्विआधारी के निष्पादन से परिणाम के रूप में 0 देता है atoi()पर argv[0]। यदि नहीं, तो इसका परिणाम बाइनरी (नाम) को एक घटना के रूप में शामिल किया जाएगा। अमान्य होने वाले उदाहरण:

$ 42/program 1 2 3
# 42/program gives 42 from argv[0], fail.

$ 1program 3 2 9
# 1program gives 1 from argv[0], fail.

$ 842 3 2 9
# 842 gives 842 from argv[0], fail.

यकीन नहीं होता कि यह एक वैध आवश्यकता है।

char y[32769];n,m;main(i,a)char**a;{for(;n=atoi(a[--i]);y[n>m?m=n:n]=64+i);for(;!y[++i];);printf("<");for(n=i;i<=m;i+=printf("-"))!y[i]?y[i]=' ':0;printf("-->\n  %s\n",y+n);}

चलाएँ:

./cabed 32767 32715 32716 32750 32730 32729 32722 32766 32740 32762
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA

./cabed 2 1 3 5 4
<------->
  BACED

./cabed 2016
<--->
  A

./cabed 130 155 133 142 139 149 148 121 124 127 136
<------------------------------------->
  H  I  J  A  C  K  E  D     GF     B

Ungolfed:

#include <stdio.h>
#include <stdlib.h>

char y[32769]; /* Zero filled as it is in global scope. */
int n, m;

int main(i, a) 
    char**a; 
{
    /* Loop argv and set y[argv[i] as int] = Letter, (Event name).
     * Set m = Max value and thus last data element in y. */
    for ( ; n = atoi(a[--i]); y[n > m ? m = n : n] = 64 + i)
        ;

    /* i = 0. Find first element in y that has a value. (Min value.) */
    for (; !y[++i]; )
        ;

    printf("<");

    /* Save min value / y-index where data starts to n.
     * Print dashes until y-index = max 
     * Build rest of event string by filling in spaces where no letters.*/
    for (n = i; i <= m; i += printf("-"))
        !y[i] ? y[i] = ' ' : 0;

    printf("-->\n  %s\n", y + n);

    return 0;
}

— Runium
स्रोत

3

MATL , 40 41 बाइट्स

0lY2in:)GtX<-I+(t~32w(ctn45lbX"60hP62hcw

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

0          % array initiallized to 0
lY2        % string 'ABC...Z'
in:)       % input array. Take as many letters as its length
GtX<-I+    % push input again. Duplicate, subtract minimum and add 3
(          % assign selected letter to those positions. Rest entries are 0
t~32w(     % replace 0 by 32 (space)
c          % convert to char
tn45lbX"   % duplicate, get length. Generate array of 45 ('-') repeated that many times
60hP62h    % prepend 60 ('<'), postpend 62 ('>')
c          % convert to char
w          % swap. Implicit display

— लुइस मेंडो
स्रोत

2

रूबी, 83 वर्ण

->a{n,m=a.minmax
s=' '*(d=m-n+3)
l=?@
a.map{|i|s[i-n+2]=l.next!}
puts ?<+?-*d+?>,s}

नमूना रन:

irb(main):001:0> ->a{n,m=a.minmax;s=' '*(d=m-n+3);l=?@;a.map{|i|s[i-n+2]=l.next!};puts ?<+?-*d+?>,s}[[32767,32715,32716,32750,32730,32729,32722,32766,32740,32762]]
<------------------------------------------------------->
  BC     G      FE         I         D           J   HA

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

2

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

l=>(l.map(v=>r[v-Math.min(...l)]=(++i).toString(36),r=[],i=9),`<-${'-'.repeat(r.length)}->
  `+[...r].map(x=>x||' ').join``)

परीक्षा

F=
l=>(l.map(v=>r[v-Math.min(...l)]=(++i).toString(36),r=[],i=9),`<-${'-'.repeat(r.length)}->
  `+[...r].map(x=>x||' ').join``)

console.log=x=>O.textContent+=x+'\n'

test= [[32767,32715,32716,32750,32730,32729,32722,32766,32740,32762],
[2015,2014],[1990,1996,1999,2011,2016],[2,3,1,5,4],[12345]]

test.forEach(x=>console.log(x+'\n'+F(x)+'\n'))

<pre id=O></pre>

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

— edc65
स्रोत

2

PHP, 129 126 125 121 117 115 बाइट्स

आईएसओ 8859-1 एन्कोडिंग का उपयोग करता है।

$l=min([$h=max($z=$argv)]+$z)-3;echo~str_pad(Ã,$h-$l,Ò).~ÒÁõ;for(;$l<$h;)echo chr((array_search(++$l,$z)-1^32)+65);

इस तरह से चलाएं ( -dकेवल सौंदर्यशास्त्र के लिए जोड़ा गया):

php -r '$l=min([$h=max($z=$argv)]+$z)-3;echo~str_pad(Ã,$h-$l,Ò).~ÒÁõ;for(;$l<$h;)echo chr((array_search(++$l,$z)-1^32)+65);' 1990 1996 1999 2016 2011 2>/dev/null;echo

Ungolfed संस्करण:

// Get the highest input value.
$h = max($z = $argv);

// Get the lowest value, setting the first argument (script name) to the highest
// so it is ignored.
$l = min([$h] + $z);

// Output the first line.
echo "<".str_repeat("-",$h - $l + 3).">\n  ";

// Iterate from $l to $h.
for(;$l <= $h;)
    // Find the index of the current iteration. If found, convert the numeric
    // index to a char. If not found, print a space.
    echo ($s = array_search($l++, $z)) ? chr($s+64) : " ";

लूप से प्रमुख स्थानों को मुद्रित <=करने और बदलने के लिए 3 बाइट्स सहेजे गए <।
के str_padबजाय का उपयोग करके एक बाइट बचाया str_repeat।
बिटविज लॉजिक का उपयोग करके 4 बाइट्स को 0 ( false) को 32 में परिवर्तित किया , और 0 से 97 के ऊपर की सभी चीजों को सहेजा । फिर उस नंबर को char में कन्वर्ट करें।
उपज के लिए नकार दिया एक्स्टेंडेड ASCII का उपयोग करके 4 बाइट सहेजा <, -, >और न्यू लाइन
पहले के बजाय पैडिंग के बाद स्ट्रिंग की उपेक्षा करके 2 बाइट्स बचाए

— aross
स्रोत

1

पर्ल, 109 बाइट्स

के लिए +1 शामिल है -p

$l=A;s/\d+/$h{$&}=$l++/ge;($a,$z)=(sort keys%h)[0,-1];$o.=$h{$_}//$"for$a..$z;$_='<'.'-'x($z-$a+3).">$/  $o"

स्टड पर इनपुट की उम्मीद: अंतरिक्ष अलग संख्या। उदाहरण:

$ echo 2016 2012 2013 | perl -p file.pl
<------->
  BC  A

कुछ पठनीय:

$l=A;                                   # Intialize $l with the letter A
s/\d+/$h{$&}=$l++/ge;                   # construct %h hash with number->letter
($a,$z) = (sort keys %h)[0,-1];         # grab min/max numbers
$o .= $h{$_} // $" for $a..$z;          # construct 2nd line: letter or space
$_= '<' . '-' x ($z-$a+3) . ">$/  $o"   # construct 1st line, merge both lines to $_ output

— केनी
स्रोत

1

अजगर 2, 173 172 182 बाइट्स

चूंकि पायथन अभी तक लापता है, यहाँ मेरी पहली पोस्ट है:

import sys
d=dict([(int(v),chr(65+i))for(i,v)in enumerate(sys.argv[1:])])
k=sorted(d.keys())
f=k[0]
s=k[-1]-f+3
o=list(" "*s)
for i in k:o[i-f+2]=d[i]
print "<"+"-"*s+">\n"+"".join(o)

मूल दिखता निम्नलिखित है:

import sys

dates = dict([(int(v), chr(65+i)) for (i,v) in enumerate(sys.argv[1:])])
keys = sorted(dates.keys())
first = keys[0]
out_size = keys[-1] - first + 3
out = list(" " * out_size)
for date in keys: out[date - first + 2] = dates[date]
print "<" + "-" * out_size + ">\n" + "".join(out)

— BloodyD
स्रोत

1

आप import sysअपने गोल्फ संस्करण में की जरूरत है।

— Mego

ठीक है, मैं करूंगा, लेकिन मैंने गोल्फ के संस्करणों में कभी कोई आयात नहीं देखा है, इसलिए मैंने अभी इसे छोड़ दिया है

— BloodyD

0

ग्रूवी, 106 99 वर्ण

{n=it.min()
o=[l="A"]
it.each{o[it-n]=l++}
"<${"-"*(it.max()-n+3)}>\n  "+o.collect{it?:" "}.join()}