Awalnya diposting (dan dihapus) oleh @Tlink , yang kemungkinan besar terinspirasi dari pertanyaan StackOverflow ini .
Karena itu memalukan karena terhapus, karena sepertinya tantangan yang bagus secara umum, saya pikir saya akan memposting ulang dengan format dan aturan yang tepat. (Saya sudah mencoba menghubungi @Tlink dan mendapatkan izin untuk mempostingnya, tetapi dia tidak merespons lagi, itulah sebabnya saya memutuskan untuk mempostingnya sendiri sekarang.)

Input: Enam digit.

Keluaran: Baik waktu valid pertama atau terakhir dalam format 24 jam ( 00:00:00sampai 23:59:59). (Anda dapat memilih sendiri apakah Anda menampilkan waktu valid pertama atau terakhir.)

Contoh:

Ketika input 1,8,3,2,6,4, waktu berikut dapat dibuat:

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

Jadi kita akan menampilkan salah satu 12:36:48atau 23:48:16dalam hal ini, menjadi yang pertama / terakhir.

Aturan tantangan:

• Nyatakan apakah Anda menampilkan waktu valid pertama atau terakhir dalam jawaban Anda.
• I / O fleksibel. Input dapat berupa enam bilangan bulat yang terpisah; string yang berisi enam digit; daftar / array bilangan bulat; satu nomor (mungkin oktal); dll. Keluaran dapat berupa daftar / array angka yang dipesan dengan benar; sebuah String dalam format HH:mm:ss/ HHmmss/ HH mm ss; setiap digit dicetak dengan pembatas baris baru; dll. Panggilan Anda.
• Anda diizinkan untuk mengambil digit dalam urutan apa pun yang Anda inginkan, sehingga mereka sudah dapat diurutkan dari terendah ke tertinggi atau sebaliknya.
• Jika tidak ada waktu yang valid dapat dibuat dengan angka yang diberikan (yaitu 2,5,5,5,5,5), jelaskan dengan cara apa pun yang Anda inginkan. Dapat mengembalikan null/ false; "Not possible"; crash dengan kesalahan; dll. (Anda tidak dapat menampilkan waktu yang tidak valid seperti 55:55:52, atau waktu yang valid seperti lainnya 00:00:00.) Sebutkan bagaimana ia menangani input yang tidak dapat dibuat waktu yang valid.
• Anda tidak boleh menampilkan semua waktu yang valid yang mungkin. Hanya yang paling awal / terbaru yang akan di-output / dikembalikan.
• 24untuk jam (yaitu 24:00:00), atau 60untuk menit / detik (yaitu 00:60:60) tidak valid. Kisarannya adalah [00-23]untuk jam dan [00-59]untuk menit dan detik.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program lengkap. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
• Juga, silakan tambahkan penjelasan jika perlu.

Kasus uji:

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 byte

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;}}

Cobalah online!

-12 byte terima kasih kepada Kevin Cruijssen

Mungkin tidak optimal, tetapi berhasil. Anehnya untuk beberapa alasan dengan 7 argumen implementasi gcc pada TIO mengharuskan Anda benar-benar menyediakannya atau segfaults. Di komputer saya itu tidak perlu.

Format: G (X, 0,6) -> Y di mana X adalah angka 6 digit yang digitnya akan digunakan dan Y adalah angka 6 digit yang bila diambil sebagai waktu (dengan memasukkan: dengan tepat) minimal.

Haskell , 114 96 86 byte

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

Sekarang dengan output yang kurang ketat. Mengambil input sebagai string angka dan membandingkan permutasi terhadap batas dengan perbandingan daftar. Dengan menit dan detik hanya digit pertama yang diperiksa. Hancur dan terbakar jika tidak ada permutasi yang valid.

Cobalah online!

Python 2 , 131 115 112 112 109 105 88 byte

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

Cobalah online!

I / O adalah daftar bilangan bulat

Melempar kesalahan jika tidak ada waktu yang memungkinkan

Alternatif:

Python 2 , 88 byte

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

Cobalah online!

Mengembalikan waktu terbaru

Mengembalikan tuple kosong untuk waktu yang tidak valid

Disimpan

• -21 byte, terima kasih atas ovs

05AB1E , 20 15 byte

Masukan sebagai string yang diurutkan.
Output adalah waktu terkecil sebagai string.
Dalam hal tidak ada solusi, daftar kosong adalah output.

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

Cobalah online!

JavaScript (ES6), 93 89 88 byte

Mengharapkan array 6 digit, diurutkan dari terendah ke tertinggi. Mengembalikan string 6 digit pada waktu valid pertama, atau falsejika tidak ada solusi.

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

Cobalah online!

Berkomentar

Kami mencoba semua permutasi input secara rekursif hingga kami menemukan yang lulus tes hibrid menggunakan aritmatika dan ekspresi reguler.

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 byte

Mengambil input sebagai string digit dan output waktu valid pertama; loop tak terhingga jika tidak ada waktu yang valid.

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

Cobalah

Peringatan: Sangat lambat - tambahkan *1000setelah yang kedua Xuntuk mempercepatnya. Dan jangan lupa bahwa input yang tidak valid akan membuat loop tak terbatas dan dapat merusak browser Anda.

Penjelasan

                   :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?

Retina , 77 74 69 65 62 byte

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

Cobalah online! Output waktu paling awal, atau string kosong jika tidak ada waktu dapat ditemukan. Edit: Disimpan 5 8 byte berkat @TwiNight Penjelasan:

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

Hasilkan semua permutasi. Cara :kerjanya melalui string sebagai permutasi dihasilkan, berakhir di awal.

O`

Urutkan waktu ke dalam urutan.

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

Keluarkan waktu valid pertama.

Merah , 157 124 byte

Terima kasih kepada Kevin Cruijssen karena mengingatkan saya untuk membaca descritions lebih cermat!

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

Cobalah online!

Mengambil string yang diurutkan sebagai input. Kembali nonejika tidak memungkinkan untuk meluangkan waktu.

Penjelasan:

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 byte

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

Cobalah online!

Arnauld menyimpan satu byte. Terima kasih!

Mengharapkan daftar seperti ['1','2','3','4','6','8']dalam urutan:

Anda diizinkan untuk mengambil digit dalam urutan apa pun yang Anda inginkan, sehingga mereka sudah dapat diurutkan dari terendah ke tertinggi atau sebaliknya.

123648Menghasilkan bilangan bulat seperti untuk 12:36:48. Saya harap itu bisa diterima.

Jelly , 15 byte

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

Cobalah online!

Diposting setelah permintaan. Pendekatannya sama dengan jawaban yang lain, namun jawaban ini dikembangkan secara mandiri.

Japt , 39 23 byte

Cukup yakin ada cara yang lebih pendek untuk melakukan ini, tetapi saya ingin mencoba menggunakan objek Date di 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.

Mengambil input sebagai susunan angka yang diurutkan, mengembalikan waktu valid terbaru atau output kosong jika tidak ada.
Kehilangan 10 pound byte berkat Shaggy .

Coba di sini .

Ruby , 68 67 62 56 55 byte

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

Cobalah online!

Input: array angka yang diurutkan (sebagai bilangan bulat).

Output: Array digit atau niljika tidak ada solusi yang ditemukan

Jelly , 17 byte

^{Saya hampir yakin ini bukan pendekatan terpendek ... akan melihat ini lagi nanti :)}

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

Cobalah online!

Bahasa Wolfram (Mathematica) , 63 byte

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

Cobalah online!

Mengambil daftar digit yang diurutkan sebagai input. Pengembalian Missing[NotFound]untuk input yang tidak valid.

Penjelasan

Permutations@#

Temukan semua permutasi dari input. Karena input diurutkan, dijamin bahwa semua waktu yang valid dalam urutan meningkat.

FirstCase[ ... ]

Temukan daftar pertama yang cocok ...

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

Unsur pertama, diberi label a, adalah 0, 1, atau 2, dan label kedua, ketiga, dan elemen kelima b, cdan dmasing-masing ...

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

... sedemikian rupa sehingga a*bkurang dari 10, dan ddan ckurang dari 6, dengan d >= c.

Caranya adalah bahwa untuk semua nomor 00untuk 24, produk dari dua digit adalah paling 9, dan angka-angka tidak valid mungkin 25untuk 29(karena kita memaksa digit pertama menjadi 0, 1, atau 2) memiliki produk dari setidaknya 10.

Pyth , 37 byte

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

Suite uji

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 dengan -palF, 73 byte

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

Cobalah online!

Output suka HHmmssdan output baris kosong untuk entri yang tidak valid.

Setiap jawaban yang saya buat baru-baru ini telah digunakan globuntuk permutasi ... Aneh!

Bash + GNU sed, 83 , 72 , 69 byte

• Menerima input sebagai 6 argumen terpisah;
• Mengembalikan waktu paling awal (jika ditemukan);
• Tidak menghasilkan apa-apa (output kosong) jika tidak ada kombinasi yang valid.

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

Bagaimana itu bekerja

Pra-hasilkan semua string waktu yang mungkin, untuk cap waktu di kisaran 0 hingga 86399, menggunakan perintah GNU-sed e (xecute) + date.

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

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

Hasilkan sedskrip dengan 6 perintah substitusi berurutan, untuk setiap digit input.

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

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

Kemudian, terapkan substitusi, hapus semua jalur input yang memiliki setidaknya satu digit tersisa, cetak baris yang cocok pertama (string waktu asli diekstraksi dari ruang penahanan dengan 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

Uji

%./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

Cobalah secara Online!

Kotlin , 396 391 389 byte

Tidak ada petunjuk bagaimana membuat ini lebih kecil. Saya pikir itu dua kali lipat dari apa yang mungkin. Menghasilkan waktu paling awal. Terima kasih kepada Kevin untuk 7 byte!

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]}"}()

Cobalah online!

MATL , 31 30 byte

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

Cobalah online!

Input adalah 6 bilangan bulat, output adalah jam minimum, menit, dan detik dalam sebuah array. Gangguan input yang tidak memungkinkan waktu seperti itu.

(-1 byte terima kasih kepada @Luis Mendo.)

Perl 6 , 43 byte

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

Cobalah online!

Mengharapkan array input yang diurutkan. Pengembalian Niluntuk input yang tidak valid.

Stax , 15 byte

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

Jalankan dan debug itu

Dibutuhkan serangkaian digit yang diurutkan untuk input. Ini mengembalikan permutasi pertama yang memenuhi beberapa kriteria.

• leksikografis kurang dari "24"
• ketiga pasang karakter secara leksikografis kurang dari "6"

Retina , 58 47 byte

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

Cobalah online!

Input adalah 6 digit dalam urutan terurut. Output adalah 6 digit yang menunjukkan waktu valid paling awal, atau string kosong jika tidak ada waktu yang valid.

EDIT: Saya idiot, -9 byte

Penjelasan

Algoritma

Untuk singkatnya, mari tentukan digit rendah sebagai 0-5, dan digit tinggi sebagai 6-9.

Pertama, atur ulang digit sehingga "low-ness" atau "high-ness" dari setiap posisi benar. Pengaturan yang benar, untuk setiap jumlah digit tinggi pada input:

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

Karena penataan ulang akan gagal pemeriksaan akhir dalam input memiliki 4+ digit tinggi, kita dapat mengabaikan kasus itu sepenuhnya.

Kemudian, sortir posisi terendah dan tertinggi secara terpisah. Dikombinasikan dengan penataan ulang, ini memberikan nilai terendah yang memenuhi batasan menit dan kedua. Jadi ini memberikan waktu valid paling awal, jika ada.

Akhirnya, periksa apakah kami memiliki waktu yang valid. Jika tidak, buang string.

Program

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

Cocokkan LHHdan tukarkan dua digit pertama dalam (menjadi HLH) itu, dan ulangi sampai tidak LHHada lagi . Ini memberikan pengaturan yang benar.

Sebenarnya saya berbohong. Tidak diperlukan penyortiran karena 1) swapping hanya terjadi antara digit yang berdekatan dan hanya antara yang rendah dan yang tinggi; dan 2) input diurutkan. Jadi posisi terendah dan tertinggi secara individual sudah dalam urutan diurutkan.

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

Hanya menyimpan string jika itu adalah waktu yang valid