49

आईएसओ 8601 मानक तिथि प्रारूप के बारे में अपने एक्सकेडीएन में रान्डेल ने उत्सुक वैकल्पिक संकेतन में झपकी ली:

बड़ी संख्या वे सभी अंक हैं जो वर्तमान तिथि में अपने सामान्य क्रम में दिखाई देते हैं, और छोटी संख्याएं उस अंक की घटनाओं के 1-आधारित सूचक हैं। तो उपरोक्त उदाहरण का प्रतिनिधित्व करता है 2013-02-27।

आइए ऐसी तारीख के लिए ASCII प्रतिनिधित्व को परिभाषित करें। पहली पंक्ति में 1 से 4 के सूचकांक होते हैं। दूसरी पंक्ति में "बड़े" अंक होते हैं। तीसरी पंक्ति में सूचकांकों 5 से 8 हैं। यदि एकल स्लॉट में कई सूचकांक हैं, तो वे एक-दूसरे के बगल में सबसे छोटे से सबसे बड़े तक सूचीबद्ध हैं। यदि mएक ही स्लॉट (यानी एक ही पंक्ति में) पर अधिकांश सूचकांकों में हैं, तो प्रत्येक कॉलम में m+1वर्ण चौड़े और बाएं-संरेखित होने चाहिए :

2  3  1  4
0  1  2  3  7
5     67    8

विपरीत रूपांतरण के लिए साथी चुनौती भी देखें ।

चुनौती

Xkcd- संकेतन में एक तिथि को देखते हुए, संबंधित ISO 8601 दिनांक ( YYYY-MM-DD) का उत्पादन करें ।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

आप मान सकते हैं कि इनपुट वर्षों 0000और 9999, के बीच किसी भी मान्य तिथि है ।

इनपुट में कोई अग्रणी स्थान नहीं होगा, लेकिन आप मान सकते हैं कि लाइनें एक आयत के लिए रिक्त स्थान के साथ गद्देदार हैं, जिसमें रिक्त स्थान के अधिकांश एक अनुगामी स्तंभ हैं।

मानक कोड-गोल्फ नियम लागू होते हैं।

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

2  3  1  4
0  1  2  3  7
5     67    8
2013-02-27

2  3  1     4
0  1  2  4  5
   5  67 8
2015-12-24

     1234
1    2
5678
2222-11-11

   1     3  24
0  1  2  7  8
57    6     8
1878-02-08

2   4   1   3
0   1   2   6
5       678
2061-02-22

      1 4 2 3
0 1 2 3 4 5 6 8
6 5 7         8
3564-10-28

1234
1
5678
1111-11-11

1 2 3 4
0 1 2 3
8 5 6 7
0123-12-30

code-golf ascii-art date

— मार्टिन एंडर
स्रोत

11

जो लोग "काली बिल्ली" प्रारूप में तारीख लिखते हैं वे मेरे अस्तित्व का प्रतिबंध हैं।

— कैरिजनेट

1

मेरी अज्ञानता को क्षमा करें, लेकिन वास्तव में तारीख के साथ अजीब प्रारूप कैसे मेल खाता है? मेरे जीवन के पैटर्न के लिए काम नहीं कर सकता।

— टॉम कारपेंटर

2

@TomCarpenter नीचे और शीर्ष रेखा इंगित करती है कि मध्य रेखा में संख्याएँ दिनांक में कहाँ दिखाई देती हैं। जैसे 1ऊपर है 2, इसलिए पहला अंक है 2। 2ऊपर है 0, इसलिए दूसरा अंक है 0। 3ऊपर है 1, 4ऊपर है 3, इसलिए हमें 2013पहले चार अंक मिलते हैं । अब 5नीचे है 0, इसलिए पांचवा अंक है 0, 6और 7दोनों नीचे हैं 2, इसलिए वे दोनों अंक हैं 2। और अंत में, 8नीचे है 7, इसलिए अंतिम अंक है 8, और हम समाप्त करते हैं 2013-02-27। (हाइफ़न xkcd संकेतन में निहित हैं क्योंकि हम जानते हैं कि वे किस स्थिति में दिखाई देते हैं।)

— मार्टिन एंडर

8

सीजेएम, 35 बाइट्स

ll{1$e>}*](l+eeWf%$-8>Wf=\f=2/(o'-*

इसे यहाँ आज़माएँ । यह इनपुट लाइनों को रिक्त स्थान के साथ गद्देदार होने की उम्मीद करता है।

व्याख्या

llइनपुट की दो पंक्तियों को पढ़ता है, और {1$e>}*दूसरे पर एक "स्कैन" करता है: यह अपने इनपुट के सभी उपसर्गों को लेता है और प्रत्येक उपसर्ग की अधिकतम गणना करता है। इनपुट लाइन के लिए "0 1 2 7 8", यह धक्का देता है "0001112227778"। हमारा स्टैक अब इस तरह दिखता है:

"first line" '0 '0 '0 '1 '1 '1 ...

हमें मूल्यों का उपयोग करके खुद को एक सूची में फिर से कब्जा करने की आवश्यकता है ]; यह हमारी पहली पंक्ति को भी कैप्चर करता है, इसलिए हम इसे (प्राप्त करने के लिए उपयोग करके वापस पॉप करते हैं

"0001112227778" "first line"

जैसा सोचा था।

eelee+ इस लाइन को एन्यूमरेट करता है, फिर एक तीसरी इनपुट लाइन के लिए भी ऐसा ही करता है, और नतीजों को समेटता है, स्टैक के शीर्ष पर कुछ इस तरह से छोड़ता है:

[[0 '5] [1 ' ] [2 ' ] [3 ' ] [4 ' ] [5 ' ] [6 ' ] [7 ' ] [8 '6] [9 '7] [10 '8] [11 ' ] [12 ' ]
 [0 '2] [1 ' ] [2 ' ] [3 ' ] [4 '4] [5 ' ] [6 ' ] [7 ' ] [8 '1] [9 ' ] [10 ' ] [11 ' ] [12 '3]]

अब हमारा स्टैक वह है ["0001112227778" X]जहाँ Xऊपर एनुमरेटेड लिस्ट है।

हम प्रत्येक जोड़ी को X( Wf%) में फ्लिप करते हैं , जोड़े को लेक्सोग्राफिक रूप से ( $), और अंतिम 8 जोड़े को छोड़ते हैं -8>। यह हमें कुछ इस तरह मिलता है:

[['1 8] ['2 0] ['3 12] ['4 4] ['5 0] ['6 8] ['7 9] ['8 10]]

यह काम करता है, क्योंकि सॉर्ट सभी जोड़ों को कुंजी '(स्थान) के साथ आरोही क्रम में सभी अंकों से पहले रखता है ।

ये पहली और तीसरी पंक्ति के पात्रों के " x -positions" 12345678हैं: हमें केवल हमारे (संशोधित) दूसरी पंक्ति के पात्रों को फिर से प्राप्त करना होगा जो उनके साथ लंबवत रूप से संरेखित हैं।

ऐसा करने के लिए, हम प्रत्येक स्थिति ( Wf=), हम पहले किए गए स्ट्रिंग में सूचकांक ( ) लेते हैं \f=। हमारे पास "20610222"अभी स्टैक पर है: डैश जोड़ने के लिए, पहले हम लंबाई दो के खंडों में विभाजित होते हैं ( 2/), पहले खंड को एक नई (oरेखा ( ) के बिना प्रिंट करते हैं और शेष खंडों को डैश के साथ जोड़ते हैं ( '-*)।

संपादित करें : शांत स्कैन चाल, मार्टिन! चार बाइट बचाए।

EDIT 2 : के eelee+साथ प्रतिस्थापित करके दो और बाइट्स सहेजे गए l+ee; इस काम करता है, क्योंकि लाइनों सभी एक ही लंबाई है, और CJam में सूची अनुक्रमण स्वचालित रूप से है सूची लंबाई सापेक्ष, इसलिए सूचकांक n+0, n+1, n+2... अच्छी तरह से करने के लिए नक्शे 0, 1, 2...

EDIT 3 : मार्टिन ने प्रक्रिया के अंतिम चरण में एक और बाइट को बचाया। अच्छा!

— लिन
स्रोत

6

Pyth, 48 43

j\-cj\-ctuuXN.xsTZK?qJhtHdKJ+hHeHGC.z*9d4 7

परीक्षण सूट

एक आयत में रिक्त स्थान के साथ पैडिंग की आवश्यकता है।

मुझे नहीं लगता कि यह सबसे अच्छा तरीका है, लेकिन मूल रूप से यह शीर्ष या नीचे के मूल्य द्वारा इंगित स्ट्रिंग में सूचकांक के मध्य मूल्य को लिखता है। वैसे मुझे लगता है कि मेरे पास सबसे अधिक स्पष्ट सामान को देखने के लिए पर्याप्त समय था। : पी

— FryAmTheEggman
स्रोत

4

जावास्क्रिप्ट (ईएस 7), 115

अनाम फ़ंक्शन। टेम्प्लेट स्ट्रिंग्स का उपयोग करते हुए, एक नई रेखा होती है जो कि साइनफीसेंट होती है और बाइट काउंट में शामिल होती है।

आवश्यकता: मध्य इनपुट लाइन पहले या अंतिम से छोटी नहीं हो सकती। आयत बनाने के लिए रिक्त स्थान के साथ इनपुट किए जाने पर यह आवश्यकता पूरी होती है।

x=>([a,z,b]=o=x.split`
`,d=i=0,[for(c of z)o[a[i]-1]=o[b[i++]-1]=d=+c||d],o.splice(4,2,'-',o[4],o[5],'-'),o.join``)

ES6 संस्करण 117 , सरणी समझ के बजाय .map का उपयोग कर रहा है

x=>([a,z,b]=o=x.split`
`,d=0,[...z].map((c,i)=>o[a[i]-1]=o[b[i]-1]=d=+c||d],o.splice(4,2,'-',o[4],o[5],'-'),o.join``)

कम गोल्फ वाला

x=>(
  o=[],
  [a,z,b] = x.split`\n`,
  d=i=0,
  [ for(c of z) (
      d = +c||d, // each new digit found in z goes in d (but not the spaces and not the '0' (d starts at 0 anyway)
      o[a[i]-1] = o[b[i]-1] = d, // if the index char is space, that gives index -1 that is ignored when joining later
      ++i
  )],
  o.splice(4,2,'-',o[4],o[5],'-'), // add the dashes in the right places
  o.join``
)

टेस्ट स्निपेट

f=x=>(
  [a,z,b]=o=x.split`\n`,
  d=i=0,[for(c of z)o[a[i]-1]=o[b[i++]-1]=d=+c||d],
  o.splice(4,2,'-',o[4],o[5],'-'),o.join``
)


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

[['2  3  1  4\n0  1  2  3  7\n5     67    8','2013-02-27']
,['2  3  1     4\n0  1  2  4  5\n   5  67 8','2015-12-24']
,['      1234\n1     2   \n5678','2222-11-11']
,['   1     3  24\n0  1  2  7  8 \n57    6     8','1878-02-08']
,['2   4   1   3\n0   1   2   6  \n5       678','2061-02-22']
,['      1 4 2 3\n0 1 2 3 4 5 6 8\n6 5 7         8','3564-10-28']
,['1234\n1   \n5678','1111-11-11']
,['1 2 3 4\n0 1 2 3\n8 5 6 7','0123-12-30']]
.forEach(t=>(k=t[1],r=f(t[0]),console.log(t[0]+'\n'+r+'\n'+(r==k?'OK\n':'Fail\n'))))

<pre id=O></pre>

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

— edc65
स्रोत

दोनों चुनौतियों को हल करने के लिए सबसे पहले होने पर बधाई। :)

— मार्टिन एंडर

3

हास्केल, 125 106 103 बाइट्स

a#' '=a
a#b=b
f i|[a,b,c]<-('-':)<$>lines i=[o|m<-"1234-56-78",(n,o,p)<-zip3 a(scanl1(#)b)c,m==n||m==p]

एक पूर्ण आयत के लिए रिक्त स्थान के साथ पैडिंग की आवश्यकता है।

प्रयोग उदाहरण: f " 1 3 24\n0 1 2 7 8 \n57 6 8 "-> "1878-02-08"।

यह काम किस प्रकार करता है:

[a,b,c]<-('-':)<$>lines i          -- split input into lines, prepend a '-' to
                                   -- each, call them a, b and c
               (scanl1(#)b)        -- fill spaces of the middle line with the
                                   -- previous char, e.g.
                                   -- "-0  1  2  7  8 " -> "-00011122277788"
        zip3 a (scanl...) c        -- combine the lines element wise into triples.
                                   -- This is our lookup table for "1234-56-78" 
o|m<-"1234...",  (n,o,p)<-zip...,  m==n||m==p
                                   -- whenever m equals n or p (i.e. was originally
                                   -- in the first or last line), take the
                                   -- corresponding char o (middle line)

— nimi
स्रोत

2

जावास्क्रिप्ट ईएस 6, 231

a=>{r=[];var b=[d,f,e]=a.split`
`.map(n=>n.split``);Array(Math.max(...b.map(n=>n.length))).fill().map((m,i)=>{(m=f[i])&&m!=" "&&(c=m);[d,e].map(m=>(g=m[i])&&g!=" "&&(r[g-1]=c))}),r.splice(4,0,"-"),r.splice(7,0,"-");return r.join``}

परीक्षण के मामले ।

— मिचेल पेरोलाकोव्स्की
स्रोत

1

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

sub{$_=$_[1];@n=/\d/g;/ +/;map{map{$p[$i++].=$_}unpack"(a$+[0])*";$i=0}@_[0,2];map{map{$r[$_-1]=$n[$i]if/\d/}s plit$"='';$i++}@p;"@r"=~s/....\K(..)/-$1-/r}

अनगढ़ और समझाया गया

sub{
    $_=$_[1]; # $_[1] is 2nd argument (i.e., 2nd line)
    @n=/\d/g; # @n now contains all digits in 2nd line
    / +/;     # $+[0] now the chunk length in 2nd line
              # Equivalent to /( +)/;$l = 1 + length $1;
    map{      # Perl golfer's for-loop
        map{ 
            $p[$i++] .= $_    # @p contains positions of each digit
        } unpack "(a$+[0])*"; # Split line into same chunk width
        $i=0 # At end of loop so we don't need $i=0 before next one
    } @_[0,2];# Outer map works on 1st and 3rd lines
    map{
        map{
            # Shove $n[$i] into ($_-1)th slot in @r if $_ is a number
            $r[$_-1] = $n[$i] if /\d/
        } split $"=''; # Equivalent to split '', but sets $"='' for free
        $i++
    }@p;
    # Concatenate @r, convert 20130227 to 2013-02-27, and return
    "@r"=~s/....\K(..)/-$1-/r
};

— type_outcast
स्रोत

0

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

s=>[...(r=[,,,,"-",,,"-"],l=s.split`
`)[1]].map((c,i)=>(c>"-"?n=c:0,y=+l[0][i],d=+l[2][i],y?r[y-1]=n:0,d?r[d+(d>6)]=n:0))&&r.join``

व्याख्या

आयत बनाने के लिए रिक्त स्थान के साथ गद्देदार होने के लिए इनपुट की आवश्यकता होती है।

s=>
  [...(
    r=[,,,,"-",,,"-"], // r = array of result characters, prefill with "-" symbols
    l=s.split`
`                      // l = array of lines
  )[1]].map((c,i)=>(   // for each character on the middle line
    c>"-"?n=c:0,       // n = the most recent digit encountered
    y=+l[0][i],        // y = index on the year line at the current position
    d=+l[2][i],        // d = index on the date line at the current position
    y?r[y-1]=n:0,      // if y is a number, put n at the index y of the result
    d?r[d+(d>6)]=n:0   // if d is a number, put n at the index d (accounting for "-"s)
  ))
  &&r.join``           // return the result as a string

परीक्षा

कोड स्निपेट दिखाएं

var solution = s=>[...(r=[,,,,"-",,,"-"],l=s.split`
`)[1]].map((c,i)=>(c>"-"?n=c:0,y=+l[0][i],d=+l[2][i],y?r[y-1]=n:0,d?r[d+(d>6)]=n:0))&&r.join``

<textarea id="input" rows="3" cols="30">   1     3  24
0  1  2  7  8 
57    6     8 </textarea><br />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

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

— user81655
स्रोत

0

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

$r=,'-'*99
($a=$args-split'
')[1]|% t*y|%{if($_-32){$d=$_}
$a[0,2]|%{$r[$_[+$p]-48]=$d}
$p++}
-join$r[1..4+0+5+6+0+7+8]

अनगुल्ड परीक्षण स्क्रिप्ट:

$f = {

$r=,'-'*99                       # init a result as an array of '-' repeated 99 times
($a=$args-split"`n")[1]|% t*y|%{ # split argument string, store a top, middle and bottom to $a, then for each char of the middle line...
    if($_-32){$d=$_}             # store a digit to $d if the current character of the middle is not a space
    $a[0,2]|%{                   # for the top and the bottom lines...
        $r[$_[+$p]-48]=$d        # store a digit to the result array
    }                            # Note: if char in the current position is a space, then expression $_[+$p]-48 less then 0.
                                 # In this case, the expression $r[32-48]=$d changes unused element in a end of the array.
                                 # That is why the array was created by a large.
    $p++                         # next position
}
-join$r[1..4+0+5+6+0+7+8]        # return joined char with specified numbers
                                 # Note: element with index 0 has value '-'
}

@(
,(@"
2  3  1  4   
0  1  2  3  7
5     67    8
"@,"2013-02-27")

,(@"
2  3  1     4
0  1  2  4  5
    5  67 8  
"@,"2015-12-24")

,(@"
     1234
1    2   
5678     
"@,"2222-11-11")

,(@"
1     3  24
0  1  2  7  8 
57    6     8 
"@,"1878-02-08")

,(@"
2   4   1   3
0   1   2   6
5       678  
"@,"2061-02-22")

,(@"
      1 4 2 3  
0 1 2 3 4 5 6 8
6 5 7         8
"@,"3564-10-28")

,(@"
1234
1   
5678
"@,"1111-11-11")

,(@"
1 2 3 4
0 1 2 3
8 5 6 7
"@,"0123-12-30")

) | % {
    $a,$expected = $_
    $result = &$f $a
    "$(""$result"-eq"$expected"): $result"
}

आउटपुट:

True: 2013-02-27
True: 2015-12-24
True: 2222-11-11
True: 1878-02-08
True: 2061-02-22
True: 3564-10-28
True: 1111-11-11
True: 0123-12-30

— Mazzy
स्रोत

0

जेली , 38 बाइट्स

Ỵṙ-Zn⁶Ṫ€œṗƊḊZḟ⁶V€$€;2/p/Ʋ€ẎṢṪ€s2Ḣ;jɗ”-

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

सहायक केवल इनपुट आसान बनाने के लिए है; यह वास्तव में एक पूर्ण कार्यक्रम है। देखभाल के लिए सुनिश्चित करें :

पहली और आखिरी लाइनें ( '''), साथ ही उनके आगे की रेखाएं (खाली, स्पष्टता के लिए)।
- वास्तविक इनपुट प्रारूप में दूसरी और पारमार्थिक खाली रेखाएँ नहीं होती हैं, और स्ट्रिंग इस तरह से बिना किसी बीच-बीच में सीधे उद्धरणों के आगे शुरू और समाप्त होती है, जैसे:
```
'' '१ ३ २४
0 1 2 7 8 
५ '६' ''
```
  आप इस प्रारूप का उपयोग करते समय पाद छोड़ सकते हैं। यह वास्तव में एक पायथन मल्टी-लाइन स्ट्रिंग है, और कुछ इनपुट के लिए उद्धरण आवश्यक हैं।
जाल स्थानों के साथ इनपुट पैड! सही ढंग से गद्देदार इनपुट के बिना कोई भी सही आउटपुट पूरी तरह से संयोग है, और मेरे द्वारा समर्थन नहीं किया गया है।

— आउटगोल्फर को एरिक करें
स्रोत

Xkcd संकेतन में एक तारीख पढ़ें

चुनौती

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

सीजेएम, 35 बाइट्स

व्याख्या

Pyth, 48 43

जावास्क्रिप्ट (ईएस 7), 115

हास्केल, 125 106 103 बाइट्स

जावास्क्रिप्ट ईएस 6, 231

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

अनगढ़ और समझाया गया

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

व्याख्या

परीक्षा

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

जेली , 38 बाइट्स