โพสต์ครั้งแรก (และลบ) โดย@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]เป็นนาทีและวินาที

กฎทั่วไป:

• นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ
  อย่าปล่อยให้ภาษาโค้ดกอล์ฟกีดกันคุณจากการโพสต์คำตอบด้วยภาษาที่ไม่ได้เข้ารหัส พยายามหาคำตอบสั้น ๆ ที่เป็นไปได้สำหรับภาษาโปรแกรม 'ใด ๆ '
• กฎมาตรฐานจะใช้สำหรับคำตอบของคุณดังนั้นคุณจึงได้รับอนุญาตให้ใช้ 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

C (gcc) , 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 ไบต์ขอบคุณ Kevin Cruijssen

อาจไม่ดีที่สุด แต่ก็ใช้งานได้ ผิดปกติพอสมควรด้วยเหตุผลบางอย่างที่มีข้อโต้แย้ง 7 ข้อการใช้งาน gcc บน TIO นั้นคุณต้องระบุหรือใช้ segfaults บนเครื่องของฉันที่ไม่จำเป็นอย่างไรก็ตาม

รูปแบบ: G (X, 0,6) -> Y โดยที่ X คือตัวเลข 6 หลักที่จะใช้ตัวเลขและ Y คือตัวเลข 6 หลักซึ่งเมื่อใช้เป็นเวลา (โดยการแทรก: เหมาะสม) จะน้อยที่สุด

Haskell , 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']

ขณะนี้มีเอาต์พุตที่เข้มงวดน้อยกว่า รับอินพุตเป็นสตริงของตัวเลขและเปรียบเทียบวิธีเรียงสับเปลี่ยนกับขีด จำกัด กับการเปรียบเทียบรายการ ด้วยนาทีและวินาทีเฉพาะการตรวจสอบตัวเลขตัวแรก หยุดทำงานและเบิร์นหากไม่มีการเปลี่ยนแปลงเป็นเวลาที่ถูกต้อง

ลองออนไลน์!

Python 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 เป็นรายการจำนวนเต็ม

โยนข้อผิดพลาดหากไม่สามารถทำได้

ทางเลือก:

Python 2 , 88 ไบต์

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

ลองออนไลน์!

ส่งคืนเวลาล่าสุด

ส่งคืน tuple ที่ว่างเปล่าสำหรับเวลาที่ไม่ถูกต้อง

ที่บันทึกไว้

• -21 ไบต์ขอบคุณ ovs

05AB1E , 20 15 ไบต์

อินพุตเป็นสตริงที่เรียงลำดับ
เอาต์พุตเป็นเวลาที่เล็กที่สุดเป็นสตริง
ในกรณีที่ไม่มีวิธีแก้ปัญหารายการว่างคือเอาต์พุต

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

ลองออนไลน์!

JavaScript (ES6), 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

Japt , 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?

เรติน่า , 77 74 69 65 62 ไบต์

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

ลองออนไลน์! เอาต์พุตเวลาที่เร็วที่สุดหรือสตริงว่างถ้าไม่พบเวลา แก้ไข: บันทึก5 8 ไบต์ขอบคุณ @TwiNight คำอธิบาย:

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

สร้างวิธีเรียงสับเปลี่ยนทั้งหมด วิธีการ:ทำงานของมันแม้ว่าสตริงเป็นพีชคณิตจะถูกสร้างขึ้นสิ้นสุดที่จุดเริ่มต้น

O`

เรียงเวลาตามลำดับ

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

ส่งออกเวลาที่ถูกต้องครั้งแรก

สีแดง , 157 124 ไบต์

ขอบคุณ Kevin Cruijssen ที่เตือนให้ฉันอ่านการสืบทอดอย่างละเอียดมากขึ้น!

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

Python 2 , 78 ไบต์

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

ลองออนไลน์!

Arnauld บันทึกเป็นไบต์ ขอบคุณ!

คาดหวังรายการเช่น ['1','2','3','4','6','8']ตามลำดับที่เรียง:

คุณได้รับอนุญาตให้ใช้ตัวเลขตามลำดับที่คุณต้องการดังนั้นพวกเขาจึงสามารถเรียงลำดับจากต่ำสุดไปสูงสุดหรือกลับกันได้

ส่งออกจำนวนเต็มเช่น123648สำหรับ 12:36:48 ฉันหวังว่ามันจะเป็นที่ยอมรับ

เยลลี่ 15 ไบต์

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

ลองออนไลน์!

โพสต์หลังจากขอ วิธีการเช่นเดียวกับคำตอบอื่น ๆ อย่างไรก็ตามคำตอบนี้ได้รับการพัฒนาอย่างอิสระ

Japt , 39 23 ไบต์

ค่อนข้างแน่ใจว่ามีวิธีที่สั้นกว่าในการทำเช่นนี้ แต่ฉันต้องการลองใช้วัตถุวันที่ใน Japt

á ®¬ò 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 ปอนด์ไบต์ขอบคุณที่มีขนดก

ลองได้ที่นี่

Ruby , 68 67 62 56 55 ไบต์

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

ลองออนไลน์!

อินพุต: เรียงลำดับแล้วอาร์เรย์ของตัวเลขที่ (เป็นจำนวนเต็ม)

เอาต์พุต: อาร์เรย์ของตัวเลขหรือnilหากไม่พบวิธีแก้ไข

เยลลี่ขนาด 17 ไบต์

^{ฉันเกือบจะแน่ใจว่านี่ไม่ใช่วิธีที่สั้นที่สุด ... จะดูอีกครั้งในภายหลัง :)}

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

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 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

Pyth , 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

Perl 5กับ-palF, 73 ไบต์

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

ลองออนไลน์!

เอาต์พุตชอบHHmmssและเอาต์พุตบรรทัดว่างสำหรับรายการที่ไม่ถูกต้อง

ทุกคำตอบที่ฉันทำเมื่อเร็ว ๆ นี้ใช้globการเรียงสับเปลี่ยน

Bash + GNU sed, 83 , 72 , 69 bytes

• ยอมรับอินพุตเป็น 6 อาร์กิวเมนต์แยกกัน
• ส่งคืนเวลาที่เร็วที่สุด (หากพบ);
• ไม่มีอะไรส่งคืน (เอาต์พุตว่าง) หากไม่มีชุดค่าผสมที่ถูกต้อง

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

มันทำงานอย่างไร

Pre-สร้างทั้งหมดสตริงเวลาที่เป็นไปได้สำหรับการประทับเวลาในช่วง 0-86399 ใช้ GNU-sed อี (xecute) คำสั่ง date+

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

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

สร้างsedสคริปต์ด้วย 6 คำสั่งการทดแทนตามลำดับสำหรับแต่ละอินพุตหลัก

%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

ลองออนไลน์!

Kotlin , 396 391 389 ไบต์

ไม่มีเงื่อนงำวิธีการทำให้สิ่งนี้เล็กลง ฉันคิดว่ามันเป็นสองเท่าของสิ่งที่เป็นไปได้ สร้างเวลาเร็วที่สุด ขอบคุณ Kevin เป็นเวลา 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]}"}()

ลองออนไลน์!

MATL , 31 30 ไบต์

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

ลองออนไลน์!

อินพุตคือ 6 จำนวนเต็มเอาต์พุตเป็นชั่วโมงขั้นต่ำนาทีและวินาทีในอาร์เรย์ เกิดปัญหาสำหรับอินพุตที่ไม่สามารถใช้เวลาดังกล่าวได้

(-1 ไบต์ขอบคุณ @Luis Mendo)

Perl 6 , 43 ไบต์

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

ลองออนไลน์!

คาดว่าอาร์เรย์อินพุตที่เรียงลำดับแล้ว ส่งคืนNilสำหรับอินพุตที่ไม่ถูกต้อง

Stax , 15 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

มันต้องใช้สตริงของตัวเลขที่จัดเรียงสำหรับการป้อนข้อมูล มันส่งกลับการเปลี่ยนแปลงครั้งแรกที่เป็นไปตามเกณฑ์ไม่กี่

• พจนานุกรมน้อยกว่า "24"
• อักขระสามคู่ทั้งคู่มีน้อยกว่า "6"

เรติน่า58 58ไบต์

+,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].

เก็บสตริงเท่านั้นหากเป็นเวลาที่ถูกต้อง