29

मूल रूप से @Tlink द्वारा पोस्ट किया गया (और हटा दिया गया) , जो इस StackOverflow प्रश्न से सबसे अधिक प्रेरित था ।
चूंकि यह शर्म की बात थी, इसलिए इसे हटा दिया गया, क्योंकि यह सामान्य रूप से एक अच्छी चुनौती थी, मुझे लगा कि मैं इसे उचित प्रारूपण और नियमों के साथ फिर से तैयार करूंगा। (मैंने @Tlink से संपर्क करने की कोशिश की है और उसे इसे पोस्ट करने की अनुमति प्राप्त कर रहा हूं , लेकिन वह कोई भी प्रतिक्रिया नहीं देता है, यही कारण है कि मैंने इसे अब स्वयं पोस्ट करने का फैसला किया है।)

इनपुट: छह अंक

आउटपुट: या तो 24 घंटे के प्रारूप में (पहले के 00:00:00माध्यम से 23:59:59) अंतिम या अंतिम वैध समय । (आप अपने आप को चुन सकते हैं कि क्या आप पहले या अंतिम वैध समय का उत्पादन करते हैं।)

उदाहरण:

जब इनपुट होते हैं 1,8,3,2,6,4, तो निम्नलिखित समय बनाए जा सकते हैं:

12:36:48    12:38:46    12:46:38    12:48:36
13:26:48    13:28:46    13:46:28    13:48:26
14:26:38    14:28:36    14:36:28    14:38:26
16:23:48    16:24:38    16:28:34    16:28:43
16:32:48    16:34:28    16:38:24    16:38:42
16:42:38    16:43:28    16:48:23    16:48:32
18:23:46    18:24:36    18:26:34    18:26:43
18:32:46    18:34:26    18:36:24    18:36:42
18:42:36    18:43:26    18:46:23    18:46:32
21:36:48    21:38:46    21:46:38    21:48:36
23:16:48    23:48:16

इसलिए हम क्रमशः पहले / अंतिम होने के नाते 12:36:48या तो 23:48:16इस मामले में उत्पादन करेंगे ।

चुनौती नियम:

यह बताएं कि आप अपने उत्तर में पहले या अंतिम वैध समय का उत्पादन करते हैं या नहीं।
I / O लचीला है। इनपुट छह अलग पूर्णांक हो सकते हैं; छह अंकों से युक्त एक स्ट्रिंग; एक पूर्णांक सूची / सरणी; एक एकल (संभवतः अष्टाधारी) संख्या; आदि आउटपुट अंकों की सही क्रमबद्ध सूची / सरणी हो सकते हैं; प्रारूप HH:mm:ss/ HHmmss/ में एक स्ट्रिंग HH mm ss; हर अंक नई लाइन सीमांकक के साथ मुद्रित; आदि आपका फोन।
आपको किसी भी क्रम में अंकों को लेने की अनुमति है, इसलिए वे पहले से ही सबसे कम से उच्चतम या इसके विपरीत क्रमबद्ध हो सकते हैं।
यदि दिए गए अंकों (यानी 2,5,5,5,5,5) के साथ कोई वैध समय नहीं बनाया जा सकता है , तो किसी भी तरह से स्पष्ट करें जो आप चाहते हैं। लौट सकते हैं null/ false; "Not possible"; एक त्रुटि के साथ दुर्घटना; आदि (आप एक अमान्य समय जैसे 55:55:52, या कोई अन्य मान्य समय आउटपुट नहीं कर सकते हैं 00:00:00।) कृपया बताएं कि यह उन इनपुटों को कैसे संभालता है जिनके लिए कोई वैध समय नहीं बनाया जा सकता है।
आपको हर संभव वैध समय में आउटपुट की अनुमति नहीं है। केवल सबसे पहले / नवीनतम को आउटपुट / लौटाया जाना चाहिए।
24घंटे (यानी 24:00:00) के लिए, या 60मिनट / सेकंड के लिए (यानी 00:60:60) मान्य नहीं हैं। रेंज [00-23]घंटे और [00-59]मिनट और सेकंड के लिए हैं।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति दी जाती है। तुम्हारा कॉल।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

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

Input:          Earliest output:     Latest output:

1,2,3,4,6,8     12:36:48             23:48:16
2,5,5,5,5,5     None possible        None possible
0,0,0,1,1,1     00:01:11             11:10:00
1,1,2,2,3,3     11:22:33             23:32:11
9,9,9,9,9,9     None possible        None possible
2,3,5,5,9,9     23:59:59             23:59:59
1,2,3,4,5,6     12:34:56             23:56:41
0,0,0,0,0,0     00:00:00             00:00:00
1,5,5,8,8,8     18:58:58             18:58:58
1,5,5,5,8,8     15:58:58             18:58:55
1,1,1,8,8,8     18:18:18             18:18:18

code-golf date

— केविन क्रूज़सेन
स्रोत

1

23:48:16उदाहरण के लिए एक वैध आउटपुट नहीं है?

— TFeld

क्या मुझे जल्द से जल्द / नवीनतम समय या दोनों में से एक का उत्पादन करना चाहिए?

— tsh

@tsh बस एक। कौन सा आप पर निर्भर है दो पायथन जवाब इस प्रकार जल्द से जल्द उत्पादन।

— केविन क्रूज़सेन

क्या "वैध समय" किसी भी छलांग सेकंड के लिए खाता नहीं है? उदाहरण के लिए, 06:08:60मान्य होगा, यह देखते हुए कि उस मिनट के दौरान एक लीप दूसरा हुआ है?

— एरिक आउटोलॉफ़र

@EriktheOutgolfer नहीं, 60मिनट और सेकंड के लिए मान्य नहीं है। रंग हैं [00-23], [00-59]और [00-59]। चुनौती में इसे स्पष्ट करेंगे।

— केविन क्रूज़सेन

9

सी (जीसीसी) , 186 174 बाइट्स

D[7]={0,1,10,100,1e3,1e4,1e5};G(O,L,F,T,I,M,E){if(!F)O=L<24e4&L%10000<6e3&L%100<60?L:1e9;else{for(T=1e9,I=0;I++<F;M=G(O/10,L*10+E,F-1),T=T>M?M:T,O=(O/10)+E*D[F])E=O%10;O=T;}}

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

-12 बाइट्स केविन क्रूज़सेन को धन्यवाद

शायद इष्टतम नहीं है, लेकिन यह काम करता है। 7 तर्कों के साथ किसी न किसी कारण से पर्याप्त रूप से TIO पर gcc कार्यान्वयन की आवश्यकता है कि आप वास्तव में उन्हें आपूर्ति करते हैं या यह segfaults है। मेरी मशीन पर जो कि अनावश्यक है।

प्रारूप: जी (एक्स, 0,6) -> वाई जहां एक्स 6 अंकों की संख्या है, जिनके अंकों का उपयोग किया जाना है और वाई 6 अंकों की संख्या है जो कि समय के रूप में लिया जाता है (सम्मिलित करके: उचित रूप से) न्यूनतम है।

— LambdaBeta
स्रोत

2

मुझे लगता है कि आप गोल्फ कर सकते हैं {0,1,10,100,1000,10000,100000}करने के लिए {0,1,10,100,1e3,1e4,1e5}। इसके अलावा, आप गोल्फ कर सकते हैं for(I=0;I<F;++I){E=O%10;M=G(O/10,L*10+E,F-1);T=T>M?M:T;O=(O/10)+E*D[F];}करने के लिए for(I=0;I++<F;M=G(O/10,L*10+E,F-1),T=T>M?M:T,O=(O/10)+E*D[F])E=O%10;है, और आसपास कोष्ठक को दूर if। इसे ऑनलाइन 174 बाइट्स आज़माएं । इसके अलावा, मुझे पसंद है G(O,L,F,T,I,M,E)। :)

— केविन क्रूज़सेन

मेरी मशीन का उपयोग करने पर मजेदार, ...1e3,1e4,1e5}काम नहीं किया। सलाह के लिये धन्यवाद।

— लाम्बेबेटा

तुम हर जगह इस आदमी के जवाब पर हो, @ceilingcat, वैसे तो अच्छी गोल्फिंग।

— ज़ाचारि

मैं अंतर्दृष्टि की सराहना करता हूं। यह देखकर हमेशा अच्छा लगता है कि लोग वास्तव में उत्तर पढ़ते हैं और उन्हें सुधारने के तरीके ढूंढते हैं। :) आप उन पर भी अब हर जगह हैं।

— लाम्बेबेटा

130 बाइट्स

— सीलिंगकैट

6

हास्केल , 114 96 86 बाइट्स

import Data.List
f l=minimum[x|x@[a,b,c,d,e,f]<-permutations l,a:[b]<"24",c<'6',e<'6']

अब कम सख्त आउटपुट के साथ। इनपुट को अंकों की एक स्ट्रिंग के रूप में लेता है और सूची तुलना के साथ सीमा के खिलाफ क्रमपरिवर्तन की तुलना करता है। मिनट और सेकंड के साथ केवल पहले अंक की जाँच की जाती है। यदि कोई क्रमपरिवर्तन मान्य समय नहीं है तो क्रैश और जलता है।

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

— Angs
स्रोत

5

पायथन 2 , 131 115 112 109 105 88 बाइट्स

lambda s:min(d for d in permutations(s)if(2,4)>d[:2]>d[4]<6>d[2])
from itertools import*

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

I / O पूर्णांकों की सूची है

यदि कोई समय संभव नहीं है, तो एक त्रुटि फेंकता है

वैकल्पिक:

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

lambda s:max(d*((2,4)>d[:2]>d[4]<6>d[2])for d in permutations(s))
from itertools import*

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

नवीनतम समय लौटाता है

अमान्य समय के लिए एक खाली टपल लौटाता है

बचाया

-21 बाइट्स, ओव्स के लिए धन्यवाद

— TFeld
स्रोत

5

05AB1E , 20 15 बाइट्स

इनपुट को छाँटे गए स्ट्रिंग के रूप में।
आउटपुट एक स्ट्रिंग के रूप में सबसे छोटा समय है।
समाधान न होने की स्थिति में, एक खाली सूची आउटपुट है।

œʒ2ô•3Èñ•2ô‹P}н

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

— Emigna
स्रोत

5

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

6 अंकों की एक सरणी की अपेक्षा करता है, सबसे कम से उच्चतम तक क्रमबद्ध। या तो पहले मान्य समय के 6-अंक स्ट्रिंग, या falseयदि कोई समाधान मौजूद नहीं है।

f=(a,t='')=>t<24e4&/..([0-5].){2}/.test(t)?t:a.some((v,i)=>s=f(a.filter(_=>i--),t+v))&&s

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

टिप्पणी की गई

हम पुनरावर्ती इनपुट के सभी क्रमपरिवर्तन का प्रयास करते हैं जब तक कि हम एक ऐसा न मिल जाए जो अंकगणित और नियमित अभिव्यक्ति दोनों का उपयोग करके एक हाइब्रिड टेस्ट पास करता है।

f = (                       // f = recursive function taking
  a, t = ''                 // a[] = input array and t = current time
) =>                        //
  t < 24e4 &                // if t is less than 240000
  /..([0-5].){2}/.test(t) ? // and it matches "hhMmSs" with M and S in [0-5]:
    t                       //   return t
  :                         // else:
    a.some((v, i) =>        //   for each digit v at position i in a[]:
      s = f(                //     save in s the result of a recursive call with:
        a.filter(_ => i--), //       a copy of a[] with the current digit removed
        t + v               //       the current digit appended to t
      )                     //     end of recursive call
    ) && s                  //   end of some(); if truthy, return s

— Arnauld
स्रोत

5

जाप , 17 बाइट्स

इनपुट को अंकों की एक स्ट्रिंग के रूप में लेता है और पहले वैध समय को आउटपुट करता है; यदि कोई वैध समय नहीं है तो अनन्त बार लूप करें।

á
@øXr':}a@ÐX ¤¯8

कोशिश करो

चेतावनी: बहुत धीमी गति से - *1000दूसरे के बाद Xइसे कुछ हद तक गति करने के लिए जोड़ें । और यह मत भूलो कि एक अमान्य इनपुट एक अनंत लूप बनाएगा और आपके ब्राउज़र को क्रैश कर सकता है।

व्याख्या

                   :Implicit input of string U
á                  :Get all permutations of U
\n                 :Reassign that array to U
      }a           :Loop until true and then return the argument that was passed
        @          :By default that argument is an integer X which increments on each loop so first we'll pass X through a function
         ÐX        :  new Date(X)
            ¤      :  Get the time
             ¯8    :  Slice to the 8th character to get rid of the timezone info
@                  :The function that tests for truthiness
  Xr':             :  Remove all colons in X
 ø                 :  Does U contain the resulting string?

— झबरा
स्रोत

5

रेटिना , 77 74 69 65 62 बाइट्स

$
:
6+Lv$`(.)(.*):
$%`$2:$1$%'
O`
0L`([01].|2[0-3])([0-5].){2}

इसे ऑनलाइन आज़माएं! यदि कोई समय नहीं मिल पाता है तो सबसे पहले या खाली स्ट्रिंग को आउटपुट करता है। संपादित करें: @TwiNight के लिए 5 8 बाइट्स सहेजे गए। स्पष्टीकरण:

$
:
6+Lv$`(.)(.*):
$%`$2:$1$%'

सभी क्रमपरिवर्तन उत्पन्न करें। :अपनी तरह से हालांकि क्रमपरिवर्तन के रूप में स्ट्रिंग उत्पन्न कर रहे हैं काम करता है, शुरू में समाप्त किया गया।

O`

समय को क्रम में क्रमबद्ध करें।

0L`([01].|2[0-3])([0-5].){2}

पहला वैध समय आउटपुट।

— नील
स्रोत

चूंकि आप न्यूलाइन-

— सेपरेट किए

आप इसे हटा भी सकते हैं: grep स्टेज में क्योंकि इसमें 6 अक्षर होने चाहिए और पहले 0, 1, या 2 होना चाहिए

— TwiNight

@TwiNight ओह, अगर ग्रीप छोटी है तो मैं वैसे भी 4 और बाइट्स बचा सकता हूं।

— नील

अरे हाँ आप बस कर सकते हैंL0

— TwiNight

@TwiNight 0Gवास्तव में।

— नील

4

लाल , 157 124 बाइट्स

केविन क्रूज़सेन के धन्यवाद के लिए मुझे याद दिलाने के लिए और अधिक ध्यान से पढ़ें!

func[s][a: 0:0:0 loop 86400[b: to-string a a: a + 1 if b/1 =#"0"[insert b"0"]if s = sort replace/all copy b":"""[return b]]]

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

इनपुट के रूप में एक क्रमबद्ध स्ट्रिंग लेता है। noneयदि समय देना संभव नहीं है तो लौटाता है ।

स्पष्टीकरण:

f: func[s][                                    ; the argument is a sorted string of digits
    a: 0:0:0                                   ; time object, set to 00:00:00 h 
    loop 86400 [                               ; loop through all seconds in 24 h
        b: to-string a                         ; convert the time to string 
        a: a + 1                               ; add 1 second to the current time   
        if b/1 = #"0" [                        ; prepend "0" if necessary
            insert b "0"                       ; (Red omits the leading 0)
        ]
        if s = sort replace/all copy b ":" ""[ ; compare the input with the sorted time
            return b                           ; return it if they are equal 
        ]
    ]
]

— गैलेन इवानोव
स्रोत

3

है sortशुरू में आवश्यक? चुनौती में मैं कहता हूं: " आपको किसी भी क्रम में अंकों को लेने की अनुमति है, इसलिए वे पहले से ही सबसे कम से उच्चतम या इसके विपरीत हल कर सकते हैं। "

— केविन क्रूज़सेन

@ केविन क्रूज़सेन - नहीं, इस मामले में यह आवश्यक नहीं है। मैं हल किए गए इनपुट के साथ काम करने के लिए समाधान को अपडेट करूंगा। धन्यवाद!

— गैलेन इवानोव

3

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

lambda s:min(x for x in range(62**3)if x%100<60>x/100%100<s==sorted('%06d'%x))

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

अरनुलद ने एक बाइट को बचाया। धन्यवाद!

सूची ['1','2','3','4','6','8']को क्रमबद्ध क्रम में पसंद करता है:

आपको किसी भी क्रम में अंकों को लेने की अनुमति है, इसलिए वे पहले से ही सबसे कम से उच्चतम या इसके विपरीत क्रमबद्ध हो सकते हैं।

12364812:36:48 के लिए एक पूर्णांक की तरह आउटपुट देता है। मुझे उम्मीद है कि यह स्वीकार्य है।

— लिन
स्रोत

2

के 62**3बजाय आप का उपयोग कर सकते हैं 240000?

— अरनौलड

3

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

Œ!s€2Ḍf«¥“ç;;‘Ṃ

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

अनुरोध के बाद पोस्ट किया गया। दृष्टिकोण अन्य उत्तर में से एक के समान है, हालांकि यह उत्तर स्वतंत्र रूप से विकसित किया गया था।

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

3

जाप , 39 23 बाइट्स

बहुत यकीन है कि ऐसा करने का एक छोटा तरीका है, लेकिन मैं जाप में दिनांक वस्तुओं का उपयोग करने की कोशिश करना चाहता था।

á ®¬ò q':Ãf@T<ÐXiSiKÅ
Ì

á                     // Get all permutations of the input array.
  ®¬ò q':Ã            // [1,2,3,4,5,6] -> "12:34:56"
          f@          // Filter the results, keeping those that
            T<        // are valid dates
              ÐXiSiKÅ // when made into a date object.
Ì                     // Return the last remaining item, if any.

इनपुट को क्रमबद्ध सरणी के रूप में लेता है, यदि कोई मौजूद नहीं है तो नवीनतम वैध समय या खाली आउटपुट देता है।
10 ~~पाउंड~~ बाइट खो दिया है झबरा के लिए धन्यवाद ।

इसे यहाँ आज़माएँ ।

— लीख
स्रोत

25 बाइट्स

— झबरा

@ शैगी धन्यवाद, वास्तव में साफ-सुथरा। अभी तक मुझे नहीं पता था कि तारीखों के लिए विधि डॉक्स में जाप का एक अलग खंड था, जो मुझे बहुत मूर्खतापूर्ण लगता है, मैंने सोचा कि बस उनके पास नहीं होने के आसपास काम करने की कोशिश की।

— लीख

3

रूबी , 68 67 62 56 55 बाइट्स

->*b{b.permutation.find{|a,b,c,d,e|c<6&&e<6&&a*9+b<22}}

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

इनपुट: अंकों की क्रमबद्ध सरणी (पूर्णांकों के रूप में)।

आउटपुट: अंकों की सरणी या nilयदि कोई समाधान नहीं मिला

— जीबी
स्रोत

आप eval "मेरे विचार से अंतरिक्ष छोड़ सकते हैं ।

— केविन क्रूज़सेन

हाँ, यह काम करता है, धन्यवाद।

— जीबी

मुझे लगता है कि आप a*9+b<22एक बाइट के लिए कर सकते हैं ।

— JayCe

2

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

^{मुझे लगभग तय है कि यह सबसे छोटा तरीका नहीं है ... इस पर बाद में फिर से गौर करेंगे :)}

Œ!s2Ḍ<ẠʋÐṀ“ð<<‘ṢḢ

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

— जोनाथन एलन
स्रोत

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

— एरिक आउटोलॉफ़र

तथ्य यह है कि इनपुट को छांटा जा सकता है कुछ को बचाता है। गोल्फ पर केवल 2 मिनट बिताने के बाद बेहतर देखना अपमानजनक नहीं है!

— जोनाथन एलन

अधिक सटीक होने के लिए, आप इसे 15 बाइट्स में कर सकते हैं; एक बाइट को बचाने के लिए, आपको कुछ तुच्छ करना होगा; दूसरे को बचाने के लिए, यह इतना तुच्छ नहीं है। माइंड यू, मैं उस 15-बाइट संस्करण को पोस्ट करने जा रहा था, लेकिन यह आपके दृष्टिकोण का उपयोग करता है। वैसे, क्या आपका स्वास्थ्य ठीक है?

— एरिक आउटोलॉफ़र

आगे बढ़ो और पोस्ट करो। स्वास्थ्य ठीक है, मैं काम पर हूँ इसलिए गोल्फ खेलने में समय नहीं बिता सकता हूँ !!

— जोनाथन एलन

की तैनाती। अब आप देख सकते हैं कि मैं "अपमान" की बात क्यों कर रहा था। : पी

— एरिक आउटगॉल्फ

2

वोल्फ्राम भाषा (गणितज्ञ) , 63 बाइट्स

FirstCase[Permutations@#,{a:0|1|2,b_,c_,_,d_,_}/;a*b-4<6>d>=c]&

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

इनपुट के रूप में अंकों की एक क्रमबद्ध सूची लेता है । Missing[NotFound]अमान्य इनपुट के लिए रिटर्न

व्याख्या

Permutations@#

इनपुट के क्रमपरिवर्तन के सभी का पता लगाएं। चूंकि इनपुट छांटा गया है, यह गारंटी है कि सभी मान्य समय बढ़ते क्रम में हैं।

FirstCase[ ... ]

पहली सूची का मिलान करें ...

{a:0|1|2,b_,c_,_,d_,_}

पहला तत्व, लेबल a, 0, 1, या 2 है, और दूसरा, तीसरा लेबल, और पांचवें तत्व b, c, और dक्रमशः ...

... /;a*b-4<6>d>=c

... ऐसा है कि a*bहै कम से कम 10, और dऔर cकम से कम 6 कर रहे हैं, के साथ d >= c।

चाल यह है कि सभी संख्याओं के 00लिए 24, दो अंकों का उत्पाद अधिकतम 9 पर है, और संभव अमान्य संख्याओं के 25लिए 29(क्योंकि हम पहले अंक को 0, 1 या 2 होने के लिए मजबूर करते हैं) में कम से कम 10 का उत्पाद है।

— जंगवान मिन
स्रोत

2

पायथ , 37 बाइट्स

j\:hf&&<shT24<s@T1 60<seT60mcs`Md2S.p

परीक्षण सूट

स्पष्टीकरण:

j\:hf&&<shT24<s@T1 60<seT60mcs`Md2S.pQ # Code with implicit variables
   h                                   # The first element of
                                   .pQ # The list of all permutations of the input list
                                  S    # Sorted
                           mcs`Md2     # Mapped to three two digit long strings
    f                                  # Filtered on whether
       <shT24                          #  The first number is less than 24
      &      <s@T1 60                  #  AND the second number is less than 60
     &               <seT60            #  AND the third number is less than 60
j\:                                    # Joined by a colon

— hakr14
स्रोत

2

पर्ल 5 के साथ `-palF`, 73 बाइट्स

$"=",";($_)=grep@F~~[sort/./g]&/([01]\d|2[0-3])([0-5]\d){2}/,glob"{@F}"x6

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

HHmmssअमान्य प्रविष्टियों के लिए आउटपुट एक रिक्त पंक्ति की तरह और आउटपुट करता है।

मेरे द्वारा हाल ही में किए गए प्रत्येक उत्तर ने globक्रमपरिवर्तन के लिए उपयोग किया है ... अजीब!

— डोम हेस्टिंग्स
स्रोत

2

बैश + जीएनयू सेड, 83 , 72 , 69 बाइट्स

6 अलग-अलग तर्कों के रूप में इनपुट स्वीकार करता है;
जल्द से जल्द समय लौटाता है (यदि पाया जाता है);
यदि कोई वैध संयोजन मौजूद नहीं है तो कुछ भी नहीं (खाली आउटपुट) देता है।

seq 0 86399|sed "s/^/date +%T -ud@/e;h;`printf s/%d//\; $@`/\w/d;x;q"

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

GNU- सेड ई (xecute) कमांड + का उपयोग करते हुए, 0 से 86399 तक के टाइमस्टैम्प के लिए, सभी संभावित टाइम स्ट्रिंग्स को प्री-जेनरेट करें date।

%seq 0 86399|sed "s/^/date +%T -ud@/e;h;"

00:00:00
00:00:01
...
23:59:59

उत्पन्न sed6 अनुक्रमिक प्रतिस्थापन आदेश, एक प्रत्येक इनपुट अंकों के लिए के साथ स्क्रिप्ट।

%echo sed `printf s/%d//\; $@`

sed s/1//;s/2//;s/3//;s/4//;s/6//;s/8//;

फिर, प्रतिस्थापन लागू करें, किसी भी इनपुट लाइनों को हटा दें जिसमें कम से कम एक अंक बचा हो, पहली मिलान रेखा प्रिंट करें (मूल समय स्ट्रिंग को होल्ड स्पेस से निकाला जाता है x)।

%echo 23:45:12|sed 's/1//;s/2//;s/3//;s/4//;s/6//;s/8//;'
:5:2 //non-matching, delete

%echo 12:36:48|sed 's/1//;s/2//;s/3//;s/4//;s/6//;s/8//;'
:: //matching, print and stop

परीक्षा

%./timecomb 1 2 3 4 6 8
12:36:48
%./timecomb 2 5 5 5 5 5
%./timecomb 0 0 0 1 1 1
00:01:11
%./timecomb 1 1 2 2 3 3
11:22:33
%./timecomb 9 9 9 9 9 9
%./timecomb 2 3 5 5 9 9
23:59:59
%./timecomb 1 2 3 4 5 6
12:34:56
%./timecomb 0 0 0 0 0 0
00:00:00
%./timecomb 1 5 5 8 8 8
18:58:58
%./timecomb 1 5 5 5 8 8
15:58:58
%./timecomb 1 1 1 8 8 8
18:18:18

यह ऑनलाइन की कोशिश करो!

— टसेपेल्लिन
स्रोत

2

कोटलिन , 396 391 389 बाइट्स

यह कैसे छोटा करने के लिए कोई सुराग नहीं। मुझे लगता है कि यह संभव है की दोहरी है। जल्द से जल्द समय का उत्पादन करता है। 7 बाइट्स के लिए केविन को धन्यवाद!

fun p(d:Array<Int>)={val s=Array(6,{0})
val f=Array(6,{1>0})
val t=Array(3,{0})
val o=Array(3,{60})
fun r(i:Int){if(i>5){var l=0>1
var e=!l
for(p in 0..2){t[p]=s[p*2]*10+s[p*2+1]
l=l||(e&&t[p]<o[p])
e=e&&t[p]==o[p]}
if(t[0]<24&&t[1]<60&&t[2]<60&&l)for(p in 0..2)o[p]=t[p]}
else
for(p in 0..5)if(f[p]){f[p]=0>1
s[i]=d[p]
r(i+1)
f[p]=1>0}}
r(0)
if(o[0]>23)0
else "${o[0]}:${o[1]}:${o[2]}"}()

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

— JohnWells
स्रोत

2

मैं कोटलिन को नहीं जानता, लेकिन क्या आपको वास्तव में var l=0>1और दोनों की आवश्यकता है var e=1>0? इसके अलावा, क्यों l=lऔर e=eआवश्यक हैं? दो चीजें हैं जो गोल्फ के लिए काम करने लगते हैं कर रहे हैं var e=1>0करने के लिए var e=!lऔर इससे पहले कि अंतरिक्ष को हटाने "None"। इसके अलावा, किसी भी फाल्सी-आउटपुट ठीक है, तो "None"यह भी हो सकता है 0।

— केविन क्रूज़सेन

@ केविन आपको 5 बाइट्स के लिए धन्यवाद। हैरान मैं उनमें से एक को याद किया। चूंकि मैं लूप को खत्म नहीं कर रहा हूं, इसलिए मैं यह जानने से बचने के लिए वैसे भी नहीं देख सकता कि क्या दो बार बराबर रहे ताकि मैं तय कर सकूं कि नया कम है। मैंने तरीकों का एक समूह कोडित किया और यह सबसे छोटा था। हालाँकि, समग्र कोड मुझे पसंद की तुलना में बहुत बड़ा है।

— जॉनवेल्स 12

1

अपने नवीनतम संस्करण में गोल्फ के लिए 2 और बाइट्स: "0"बस हो सकता है0

— केविन क्रूज़सेन

@ केविन एक स्ट्रिंग प्रकार नहीं होगा और मुझे जोड़ना होगा: स्ट्रिंग और इंट दोनों की अनुमति देने के लिए कोई भी।

— जॉनवेल्स

1

हम्म ठीक है। यह TIO में काम करता है, और फिर भी 0त्रुटियों के बिना प्रिंट करता है .. और आपका वर्तमान फ़ंक्शन एक रिटर्न-प्रकार निर्दिष्ट नहीं करता है जहां तक मैं बता सकता हूं, तो क्या यह वैसे भी एक वस्तु के रूप में वापस नहीं आएगा? पुनश्च: मैं कोटलिन को बिल्कुल नहीं जानता, बस इसे उद्धरणों के बिना आज़माया और परिणाम समान थे। ;) हो सकता है कि इसके कारण कुछ और काम न कर रहा हो, जिसकी मुझे जानकारी नहीं है।

— केविन क्रूज़सेन

2

MATL , 31 30 बाइट्स

Y@3Xy[X1]X*!Y*t[4XX]6*<!AY)1Y)

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

इनपुट 6 पूर्णांक है, आउटपुट एक सरणी में न्यूनतम घंटे, मिनट और सेकंड है। इनपुट्स के लिए क्रैश जहां ऐसा कोई समय संभव नहीं है।

(-1 बाईट मेन्डो @ धन्यवाद के लिए धन्यवाद।)

— sundar - मोनिका को बहाल करना
स्रोत

मुझे लगता है कि आप 2&Aद्वारा प्रतिस्थापित कर सकते हैं !A, क्योंकि बाइनरी मैट्रिक्स कभी भी एक पंक्ति वेक्टर नहीं होगा

— लुइस मेंडो

1

पर्ल 6 , 43 बाइट्स

*.permutations.first:{24e4>.join&&6>.[2&4]}

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

एक सॉर्ट किए गए इनपुट ऐरे की अपेक्षा करता है। Nilअमान्य इनपुट के लिए रिटर्न

— nwellnhof
स्रोत

1

स्टैक्स , 15 बाइट्स

╝a╣=→aá≈#8(⌂≈58

इसे चलाएं और डीबग करें

यह इनपुट के लिए सॉर्ट किए गए अंकों की एक स्ट्रिंग लेता है। यह पहला क्रमचय लौटाता है जो कुछ मानदंडों को पूरा करता है।

"24" से कम
सभी तीन जोड़े वर्ण "6" से कम हैं।

— पुनरावर्ती
स्रोत

1

रेटिना , 58 47 बाइट्स

+,V^2`[0-5][6-9]{2}
G`([01].|2[0-3])([0-5].){2}

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

इनपुट क्रमबद्ध क्रम में 6 अंक है। यदि कोई वैध समय मौजूद नहीं है, तो आउटपुट 6 अंकों का सबसे पहले मान्य समय या खाली स्ट्रिंग का प्रतिनिधित्व करता है।

संपादित करें: मैं एक बेवकूफ था, -9 बाइट्स

व्याख्या

कलन विधि

संक्षिप्तता के लिए, आइए 0-5 के रूप में एक कम अंक और 6-9 के रूप में एक उच्च अंक को परिभाषित करें।

सबसे पहले, अंकों को फिर से व्यवस्थित करें ताकि प्रत्येक स्थिति का "कम-नेस" या "उच्च-नेस" सही हो। इनपुट में उच्च अंकों की प्रत्येक संख्या के लिए सही व्यवस्था:

# of highs  arrangment
0           LLLLLL
1           LLLLLH
2           LLLHLH
3           LHLHLH
4+          Not possible

चूँकि इनपुट में अंतिम जांच में कोई भी पुनर्व्यवस्था असफल होगी, 4+ उच्च अंक हैं, हम उस मामले को पूरी तरह से अनदेखा कर सकते हैं।

फिर, व्यक्तिगत रूप से चढ़ाव और उच्च को छाँटें। पुनर्व्यवस्था के साथ संयोजन करें, इससे न्यूनतम मूल्य मिलता है जो मिनट और दूसरी बाधाओं को संतुष्ट करता है। तो यह सबसे पहला वैध समय देता है, अगर कोई मौजूद है।

अंत में, जांचें कि क्या हमारे पास वैध समय है। यदि नहीं, तो स्ट्रिंग को छोड़ दें।

कार्यक्रम

+,V^2`[0-5][6-9]{2}

मेल खाता है LHHऔर उसमें (पहले) दो अंकों को स्वैप करता है HLH, और तब तक दोहराता है जब तक कि कोई और LHHमौजूद न हो। यह सही व्यवस्था देता है।

दरअसल, मैंने झूठ बोला था। कोई छंटाई की आवश्यकता नहीं है क्योंकि 1) स्वैपिंग केवल आसन्न अंकों के बीच और केवल निम्न और उच्च के बीच होती है; और 2) इनपुट को क्रमबद्ध किया गया है। तो व्यक्तिगत रूप से चढ़ाव और उच्च पहले से ही क्रमबद्ध क्रम में हैं।

G`([01].|2[0-3])[0-5].[0-5].

केवल स्ट्रिंग रखता है यदि यह एक वैध समय है

— TwiNight
स्रोत

द टाइम अनाग्राम

चुनौती नियम:

सामान्य नियम:

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

सी (जीसीसी) , 186 174 बाइट्स

हास्केल , 114 96 86 बाइट्स

पायथन 2 , 131 115 112 109 105 88 बाइट्स

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

05AB1E , 20 15 बाइट्स

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

टिप्पणी की गई

जाप , 17 बाइट्स

व्याख्या

रेटिना , 77 74 69 65 62 बाइट्स

लाल , 157 124 बाइट्स

स्पष्टीकरण:

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

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

जाप , 39 23 बाइट्स

रूबी , 68 67 62 56 55 बाइट्स

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

वोल्फ्राम भाषा (गणितज्ञ) , 63 बाइट्स

व्याख्या

पायथ , 37 बाइट्स

पर्ल 5 के साथ -palF, 73 बाइट्स

बैश + जीएनयू सेड, 83 , 72 , 69 बाइट्स

कोटलिन , 396 391 389 बाइट्स

MATL , 31 30 बाइट्स

पर्ल 6 , 43 बाइट्स

स्टैक्स , 15 बाइट्स

रेटिना , 58 47 बाइट्स

व्याख्या

पर्ल 5 के साथ `-palF`, 73 बाइट्स