एक संकेत जो कैफे के खुलने का समय दर्शाता है

Question

आपने शायद विभिन्न दुकानों के दरवाजों पर इन संकेतों को देखा है:

खुलने का समय

मोन-फ्राई 0900-1800 सन्त
-सूर्य 1100-1530

यहां कार्य इस तरह है कि पूरे सप्ताह के शुरुआती घंटों की सूची से, समान उद्घाटन घंटों के साथ लगातार दिनों का समूह बनाना। ध्यान दें कि सप्ताह "चारों ओर घूमता है" जो लगातार माना जाता है।

इनपुट:

• 7 तत्व, सप्ताह में प्रत्येक दिन के लिए शुरुआती घंटों का प्रतिनिधित्व करते हैं, जो सोमवार से शुरू होता है।
• प्रत्येक तत्व एक स्ट्रिंग है, फॉर्म XXXX-XXXX पर

• उदाहरण इनपुट:

  0900-1800 0900-1800 0930-1730 0930-1730 0900-1500 1100-1500 1100-1500
  

• इनपुट को सरणी के रूप में भेजना ठीक है (उदाहरण के लिए किसी फ़ंक्शन के इनपुट के रूप में यदि आप स्टड से नहीं पढ़ते हैं)

आउटपुट:

• शुरुआती घंटों की एक सूची, जहां एक ही उद्घाटन घंटे के साथ लगातार दिन एक सीमा के रूप में दिखाए जाते हैं। ध्यान दें कि रविवार (अंतिम दिन) और सोमवार (पहले दिन) भी लगातार दिन होते हैं।
• एक दिन जहां दिन पहले या बाद के दिनों के समान खुलने का समय नहीं होता है
• दिन को तीन लोअरकेस अक्षरों के रूप में निर्दिष्ट किया जाता है: मोन टी वेड थू फ्रु स सन
• याद रखें कि इनपुट में पहला तत्व टीयू आदि के आगे सोम से मेल खाता है।
• खुलने का समय इनपुट के रूप में दिखाया गया है

• दो उदाहरण

  mon-fri 0900-1800, sat-sun 1100-1500
  mon-wed 1030-1530, thu 100-1800, fri-sun 1200-1630
  

• आउटपुट को सॉर्ट किया जाना चाहिए, इसलिए सप्ताह में दिन के क्रम में सीमाएं दिखाई देती हैं। सोमवार को पहले होना पसंद किया जाता है, लेकिन ऐसा हो सकता है कि यह पहले समूह में न हो क्योंकि सप्ताह की शुरुआत होती है। तो इस मामले में tue पहली श्रेणी है।

  tue-fri 0900-1800, sat-mon 1100-1500
  

• जब तक लगातार समूह न करें, यहां वेडनेसडे और शुक्रवार को एक ही खुलने का समय होता है, लेकिन गुरुवार को अलग-अलग शुरुआती घंटों के साथ अलग किया जाता है ताकि वे स्वयं के साथ सूचीबद्ध हों।

  mon-tue 1000-1200, wed 0900-1500, thu 1000-1800, fri 0900-1500, sat-sun 1000-1500
  

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

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

पहली पंक्ति इनपुट है, दूसरी पंक्ति आउटपुट है

0900-1800 0900-1800 0900-1800 0900-1800 0900-1800 1100-1500 1100-1500
mon-fri 0900-1800, sat-sun 1100-1500

0900-1800 0900-1800 0900-1800 0930-1700 0900-1800 1100-1500 1100-1500
mon-wed 0900-1800, thu 0930-1700, fri 0900-1800, sat-sun 1100-1500

1100-1500 0900-1800 0900-1800 0900-1800 0900-1800 1100-1500 1100-1500
tue-fri 0900-1800, sat-mon 1100-1500

1100-1500 1100-1500 0900-1800 0900-1800 0900-1800 0900-1800 1100-1500
wed-sat 0900-1800, sun-tue 1100-1500

1200-1500 1100-1500 0900-1800 0900-1800 0900-1800 0900-1800 1100-1500
mon 1200-1500, tue 1100-1500, wed-sat 0900-1800, sun 1100-1500

नियम

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

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है। यह एक अच्छी चुनौती है; बहुत बढ़िया! भविष्य में, मैं एक चुनौती पोस्ट करने से पहले सैंडबॉक्स का उपयोग करने की सलाह दूंगा। (आप जानते हैं, बस के मामले में ...)

— wizzwizz4

रविवार और सोमवार को लगातार मेरे लिए अजीब लगता है ...

— Frédéric

मुझे लगता है कि "मोन-सन" के लिए एक परीक्षण-मामला होना चाहिए, यदि कोई सबमिशन उस विशेष आधार मामले को ठीक से नहीं करता है।

— पैट्रिक रॉबर्ट्स

Answer 1

जावास्क्रिप्ट (ईएस 6), 182 173 170 163 157 बाइट्स

Edc65 की मदद से 6 बाइट्स बचाए

स्ट्रिंग के एक सरणी के रूप में इनपुट लेता है और सीधे कंसोल को परिणाम प्रिंट करता है:

h=>{for(D="montuewedthufrisatsun".match(/.../g),d=c=i=j=0;j<8;y=d)h[i]==h[6]?i++:(v=h[d=(i+j++)%7])!=c&&(j>1&&console.log(D[x]+(x-y?'-'+D[y]:''),c),x=d,c=v)}

प्रारूपित और टिप्पणी की गई

h => {                               // input = list h of opening hours
  for(                               //
    D = "montuewedthufrisatsun"      // D = list of abbreviated names of days
        .match(/.../g),              //
    d =                              // d = current day of week
    c =                              // c = current opening hours
    i =                              // i = first day of week to process
    j = 0;                           // j = day counter
    j < 8;                           // stop when 7 days have been processed
    y = d                            // update y = last day of current day range
  )                                  //
  h[i] == h[6] ?                     // while the opening hours of day #i equal the opening
    i++                              // hours of sunday: increment i
  : (v = h[d = (i + j++) % 7]) != c  // else, if the new opening hours (v) of the current
    && (                             // day (d) doesn't match the current opening hours (c):
      j > 1 &&                       //   if this is not the first iteration:
        console.log(                 //     print:
          D[x] +                     //     - the first day of the current day range (x)
          (x - y ?                   //     - followed by either an empty string
            '-' + D[y]               //       or a '-' and the last day of the range
          : ''),                     //       (if they differ)
          c                          //     - the corresponding opening hours
        ),                           //   (endif)
      x = d,                         //   update x = first day of current day range
      c = v                          //   update c = current opening hours
    )                                // (endif)
}                                    // (end)

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

let f =

h=>{for(D="montuewedthufrisatsun".match(/.../g),d=c=i=j=0;j<8;y=d)h[i]==h[6]?i++:(v=h[d=(i+j++)%7])!=c&&(j>1&&console.log(D[x]+(x-y?'-'+D[y]:''),c),x=d,c=v)}

f(["0900-1800", "0900-1800", "0900-1800", "0900-1800", "0900-1800", "1100-1500", "1100-1500"]);
console.log('-');
f(["0900-1800", "0900-1800", "0900-1800", "0930-1700", "0900-1800", "1100-1500", "1100-1500"]);
console.log('-');
f(["1100-1500", "0900-1800", "0900-1800", "0900-1800", "0900-1800", "1100-1500", "1100-1500"]);
console.log('-');
f(["1100-1500", "1100-1500", "0900-1800", "0900-1800", "0900-1800", "0900-1800", "1100-1500"]);
console.log('-');
f(["1200-1500", "1100-1500", "0900-1800", "0900-1800", "0900-1800", "0900-1800", "1100-1500"]);

Comments

D='montuewedthufrisatsun'.match(/.../g)Dएक समारोह के बजाय एक सरणी के रूप में उपयोग करके कुछ बाइट

— edc65

@ edc65 - दुर्भाग्य से D()कहा जा सकता है -1(जब हम 'सोमवार से पहले दिन' की तलाश करते हैं), जो substr()एक सरणी के साथ काम नहीं करेगा लेकिन काम नहीं करेगा।

— Arnauld

@ edc65 - EDIT: अपने तरीके को एक और फिक्स के साथ जोड़कर, यह निश्चित रूप से एक जीत है। धन्यवाद!

— Arnauld

Answer 2

बैच, 334 बाइट्स

@echo off
set/af=l=w=0
set h=%7
call:l mon %1
call:l tue %2
call:l wed %3
call:l thu %4
call:l fri %5
call:l sat %6
call:l sun %7
if not %w%==0 set l=%w%
if %f%==0 set f=mon
call:l 0 0
exit/b
:l
if not %h%==%2 (
if %f%==0 (set w=%l%)else if %f%==%l% (echo %f% %h%)else echo %f%-%l% %h%
set f=%1
set h=%2
)
set l=%1

कमांड-लाइन मापदंडों के रूप में इनपुट लेता है, प्रत्येक समूह को एक अलग लाइन पर आउटपुट करता है। प्रत्येक दिन के घंटों की पिछले दिन से तुलना करके काम करता है f, समूह में पहले दिन के रूप में ट्रैकिंग करता है, hउस समूह के लिए घंटे के lरूप में, समूह में अंतिम दिन के रूप में और wजब अंतिम समूह सप्ताह की शुरुआत में वापस आ जाता है। जब एक बेमेल पाया जाता है तो पिछले समूह को तब तक छापा जाता है जब तक कि सप्ताह की लपेट प्रभाव में न हो। अंत में जब सभी दिनों को संसाधित किया जाता है तो अंतिम समूह को किसी भी सप्ताह के रैपिंग के लिए समायोजित किया जाता है और क्या आउटपुट होने से पहले सभी घंटे समान होते हैं। 0एक प्लेसहोल्डर के रूप में उपयोग किया जाता है क्योंकि बैच में तुलना करने के लिए खाली तारों की कीमत अधिक बाइट्स होती है।

Answer 3

जेली , 87 84 80 75 बाइट्स

• @Dennis की मदद से 4bytes (एक हैक जो मैंने 'त्वरित, "फ्लैट" के साथ उपयोग किया था )

बहुत अच्छा यकीन है कि एक बेहतर तरीका है, लेकिन अभी के लिए:

Ṫ2ị$€;@µ+\µżṙ1’$Ṗị“ḅạṄMḤ9\E¥LḃɓṅÐĿ;$»s3¤Q€j€”-
ṙ7Ḷ¤Œr'€Ėµ2ịLµÐṂḢ
ÇṪḢ€ż@ÇÑ$G

TryiItOnline

कैसे?

            “ḅạṄMḤ9\E¥LḃɓṅÐĿ;$» - compressed string "montuewedthufrisatsun"
                  v  v
Ṫ2ị$€;@µ+\µżṙ1’$Ṗị -- s3¤Q€j€”- - Link 1, getDayStrings: [offset, groupedList]
Ṫ                               - Tail: get groupedList
 2ị$€                           - second index of each: get group sizes, e.g. mon-thu is 4
     ;@                         - concatenate (reversed arguments): prepend with offset
       µ                        - monadic chain separation
        +\                      - cumulative reduce with addition: start indexes
          µ                     - monadic chain separation
           ż                    - zip with
               $                - last two links as a monad
            ṙ1                  -     rotated left by one
              ’                 -     decrement:  end indexes
                Ṗ               - pop: remove last one, it's circular
                 ị              - index into
                        ¤       - last two links as a nilad
                    --          -     compressed string of weekdays (as shown at the top)
                      s3        -     split into 3s
                        Q€      - unique items for each: [tue,tue] -> [tue]
                          j€    - join each with
                            ”-  - literal string "-"

ṙ7Ḷ¤Œr'€Ėµ2ịLµÐṂḢ - Link 2: CalculateGroupingData: list of time strings
   ¤              - last two links as a nilad
ṙ                 -    rotate time strings list left by
 7Ḷ               -    range 7: [0,1,2,3,4,5,6]
       €          - for each
    Œr            -     run length encode
      '           -     flat - i.e. don't vectorise
        Ė         - enumerate [[1,[groupsFromMon]],[2,[groupsFromTue], ...]
         µ        - monadic chain separation
              ÐṂ  - filter for minimum of
             L    -     length of
          2ị      -     item at index 2: The number of groupings
                Ḣ - head: get the first occurring minimal (i.e Mon, or Tue, ...)

ÇṪḢ€ż@ÇÑ$G - Main link: list of time strings
Ç          - call last link (1) as a monad: get the offset and grouping
 Ṫ         - tail: get the grouping
  Ḣ€       - head each: get the time information
        $  - last two links as a monad
      Ç    -      call last link (1) as a monad: get the offset and grouping
       Ñ   -      call the next link as a monad: get the day strings
    ż@     - zip (with reversed arguments)
         G - arrange as a group (performs a tabulation to nicely align the result)

Answer 4

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

a=>a.map((e,d)=>(d='montuewedthufrisatsun'.substr(d*3,3),e!=h&&(f?o(f):w=l,f=d,h=e),l=d),f='',l=w='sun',h=a[6],o=f=>console.log((f==l?l:f+'-'+l)+' '+h))&&o(f||'mon',l=w)

एक सरणी के रूप में इनपुट लेता है और अलग-अलग लाइनों पर कंसोल को आउटपुट करता है। यह लगभग मेरे बैच जवाब का एक बंदरगाह है; fअब निश्चित रूप से एक रिक्त स्ट्रिंग पर चूक है, जबकि मैं भी डिफ़ॉल्ट कर सकते हैं lऔर wकरने के लिए 'sun'(का उपयोग कर एक प्रहरी मूल्य मुझे बैच में 3 बाइट्स बचा लिया क्योंकि मैं में initialisation विलय करने के लिए कर रहा था set/a)।

Answer 5

बाकोन , 514 496 455 बाइट्स

नीचे दिए गए BASIC कार्यक्रम को इसके इंडेंटेशन के साथ दिखाया गया है। लेकिन इंडेंटेशन के बिना इसमें 455 बाइट्स होते हैं।

विचार समय सारणी का उपयोग अनुक्रमणिका के रूप में एक साहचर्य सारणी में किया जाता है। फिर, प्रत्येक दिन एक बिट का प्रतिनिधित्व करता है: सोमवार = बिट 0, मंगलवार = बिट 1, बुधवार = बिट 2 और इसी तरह। साहचर्य सरणी के सदस्यों के लिए वास्तविक मानों की गणना बाइनरी या का उपयोग करके दिनों के संबंधित बिट्स द्वारा की जाती है।

उसके बाद, यह जाँचने का विषय है कि साहचर्य सरणी सदस्यों में कितने लगातार बिट्स मौजूद हैं, जिनकी शुरुआत बिट 0 से होती है।

मामले में बिट 0 और बिट 6 भी सेट हैं, एक सप्ताह की लपेट है। उस स्थिति में, बिट्स के अगले अनुक्रम की शुरुआत की तलाश शुरू करें, इस शुरुआत की स्थिति को याद करते हुए। बाकी अनुक्रमों को प्रिंट करें, और जैसे ही बिट 6 तक पहुंच जाए, दिन की श्रेणी को पहले से याद किए गए स्थान के साथ समाप्त किया जाना चाहिए।

LOCAL n$[]={"mon","tue","wed","thu","fri","sat","sun"}
GLOBAL p ASSOC int
SUB s(VAR t$ SIZE a)
    FOR i = 0 TO a-1
        p(t$[i])=p(t$[i])|BIT(i)
    NEXT
    LOOKUP p TO c$ SIZE o
    b=e=0
    REPEAT
        FOR i=0 TO o-1
            IF p(c$[i])&BIT(b) THEN
                IF b=0 AND p(c$[i])&65=65 THEN
                    WHILE p(c$[i])&BIT(b)
                        INCR b
                    WEND
                    e=b
                    BREAK
                FI
                ?n$[b];
                r=b
                REPEAT
                    INCR b
                UNTIL NOT(p(c$[i])&BIT(b))
                IF e AND b>6 THEN
                    ?"-",n$[e-1];
                ELIF b-r>1 THEN
                    ?"-",n$[b-1];
                FI
                ?" ",c$[i]
            FI
        NEXT
    UNTIL b>6
    FREE p
ENDSUB

SUB को लागू करने के लिए निम्नलिखित कॉल का उपयोग करना:

s("0900-1800", "0900-1800", "0900-1800", "0900-1800", "0900-1800", "1100-1500", "1100-1500")
PRINT "======"
s("0900-1800", "0900-1800", "0900-1800", "0930-1700", "0900-1800", "1100-1500", "1100-1500")
PRINT "======"
s("1100-1500", "0900-1800", "0900-1800", "0900-1800", "0900-1800", "1100-1500", "1100-1500")
PRINT "======"
s("1100-1500", "1100-1500", "0900-1800", "0900-1800", "0900-1800", "0900-1800", "1100-1500")
PRINT "======"
s("1200-1500", "1100-1500", "0900-1800", "0900-1800", "0900-1800", "0900-1800", "1100-1500")

आउटपुट :

mon-fri 0900-1800
sat-sun 1100-1500
======
mon-wed 0900-1800
thu 0930-1700
fri 0900-1800
sat-sun 1100-1500
======
tue-fri 0900-1800
sat-mon 1100-1500
======
wed-sat 0900-1800
sun-tue 1100-1500
======
mon 1200-1500
tue 1100-1500
wed-sat 0900-1800
sun 1100-1500