Orijinal olarak @Tlink tarafından yayınlanan (ve silinen) bu büyük olasılıkla bu StackOverflow sorusundan esinlenmiştir .
Genel olarak iyi bir meydan okuma gibi göründüğü için silinmesi utanç verici bir şey olduğundan, uygun biçimlendirme ve kurallarla tekrar göndereceğimi düşündüm. ( @Tlink ile iletişim kurmaya ve yayınlama iznini almaya çalıştım , ancak daha fazla yanıt vermiyor, bu yüzden şimdi kendim göndermeye karar verdim.)

Giriş: Altı hane.

Çıktı: 24 saatlik biçimde ( 00:00:00arasında 23:59:59) ilk veya son geçerli zaman . (İlk geçerli mi yoksa son geçerli saatte mi çıkacağınızı kendiniz seçebilirsiniz.)

Örnek:

Girişler olduğunda 1,8,3,2,6,4, aşağıdaki zamanlar oluşturulabilir:

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

Bu nedenle , sırasıyla ilk / son olmak üzere ya 12:36:48da 23:48:16bu durumda çıktı veririz .

Meydan okuma kuralları:

• Cevabınızdaki ilk veya son geçerli zamanı çıkarıp çıkarmayacağınızı belirtin.
• G / Ç esnektir. Giriş altı ayrı tamsayı olabilir; altı basamağı içeren bir dize; bir tamsayı listesi / dizisi; bir tek (muhtemelen sekizli) sayı; Çıktı, doğru sıralı bir liste / rakam dizisi olabilir; HH:mm:ss/ HHmmss/ biçiminde bir dize HH mm ss; yeni satır sınırlayıcı ile basılan her basamak; vb.
• Basamakları istediğiniz herhangi bir sırayla almanıza izin verilir, bu yüzden zaten en alttan en üste veya tam tersine sıralanabilirler.
• Belirtilen rakamlarla (yani 2,5,5,5,5,5) geçerli bir zaman oluşturulamıyorsa , istediğiniz şekilde netleştirin. Dönebilir null/ false; "Not possible"; hatayla çarpmak; (gibi bir geçersiz saat 55:55:52veya benzeri bir geçerli saat çıkaramazsınız 00:00:00.) Lütfen geçerli bir zamanın oluşturulamayacağı girdileri nasıl işlediğini belirtin.
• Tüm geçerli geçerli zamanları vermenize izin verilmiyor. Sadece en erken / en son çıktı / iade edilmelidir.
• 24saatlerce (yani 24:00:00) veya 60dakika / saniye (yani 00:60:60) için geçerli değil. Aralıklar [00-23]saatlerce [00-59], dakikalar ve saniyeler içindir.

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT fonksiyonlarını, uygun parametrelerle fonksiyonlarını ve geri dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, lütfen gerekirse bir açıklama ekleyin.

Test durumları:

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 bayt

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

Çevrimiçi deneyin!

Kevin Cruijssen sayesinde -12 bayt

Muhtemelen optimal değil, ama işe yarıyor. 7 argümanla bir nedenden ötürü garip bir şekilde, TIO'daki gcc uygulamasının gerçekten bunları sağlamanızı veya farklılaşmasını gerektiriyor. Ancak makinemde bu gereksiz.

Biçim: G (X, 0,6) -> Y, burada X, basamakları kullanılacak olan 6 basamaklı sayıdır ve Y, bir zaman olarak alındığında (ekleyerek: uygun şekilde) minimum olan 6 basamaklı sayıdır.

Haskell , 114 96 86 bayt

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

Şimdi daha az katı çıktıyla. Girdiyi bir rakam dizisi olarak alır ve izinleri liste karşılaştırması ile limitlerle karşılaştırır. Dakika ve saniye ile sadece ilk hane kontrol edilir. Müdahale geçerli bir zaman değilse, çarpışır ve yanar.

Çevrimiçi deneyin!

Python 2 , 131 115 112 109 105 88 bayt

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

Çevrimiçi deneyin!

G / Ç tam sayıların listesidir

Hiçbir zaman mümkün değilse bir hata atar

Alternatif:

Python 2,8 bayt

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

Çevrimiçi deneyin!

En son zamanı döndürür

Geçersiz zamanlar için boş bir demet döndürür

Kayıtlı

• -21 bayt, ovs sayesinde

05AB1E , 20 15 bayt

Sıralanmış dize olarak girin.
Çıktı bir dize olarak en küçük zamandır.
Çözüm yoksa, boş bir liste çıktıdır.

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

Çevrimiçi deneyin!

JavaScript (ES6), 93 89 88 bayt

En düşükten en yükseğe kadar 6 basamaklı bir dizi bekler. İlk geçerli zamanın 6 basamaklı dizesini ya falseda bir çözüm yoksa ya döner.

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

Çevrimiçi deneyin!

Yorumlananlar

Hem aritmetik hem de normal ifadeler kullanarak bir hibrit testi geçen birini bulana kadar girdinin tüm permütasyonlarını tekrar tekrar deneriz.

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 bayt

Girdiyi rakam dizisi olarak alır ve ilk geçerli zamanı çıkarır; geçerli bir zaman yoksa sonsuz döngüler.

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

Dene

Uyarı: Son derece yavaş - biraz hızlandırmak *1000için saniyeden sonra ekleyin X. Ve geçersiz bir girişin sonsuz bir döngü yaratacağını ve tarayıcınızı çökertebileceğini unutmayın.

açıklama

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

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

Çevrimiçi deneyin! En erken süreyi veya zaman bulunamazsa boş dizgeyi çıktılar. Düzenleme: @TwiNight sayesinde 5 8 bayt kaydedildi. Açıklama:

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

Tüm permütasyonları üret. :Başında biten permütasyon olarak dize üretilir olsa yolunda çalışır.

O`

Zamanları sıraya göre sıralayın.

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

İlk geçerli zamanı yazdır.

Kırmızı , 157 124 bayt

Bana küfürleri daha dikkatli okumamı hatırlattığın için teşekkür ederim.

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

Çevrimiçi deneyin!

Giriş olarak sıralanmış bir dize alır. İade nonemümkün değilse zaman yapmak.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Arnauld bir bayt kurtardı. Teşekkürler!

['1','2','3','4','6','8']Sıralanacak sıradaki gibi bir liste bekliyor :

Basamakları istediğiniz herhangi bir sırayla almanıza izin verilir, bu yüzden zaten en alttan en üste veya tam tersine sıralanabilirler.

12364812:36:48 gibi bir tam sayı çıkar. Umarım bu kabul edilebilir.

Jöle , 15 bayt

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

Çevrimiçi deneyin!

Bir istekten sonra gönderildi. Yaklaşım diğer cevapların cevaplarıyla aynıdır, ancak bu cevap bağımsız olarak geliştirilmiştir.

Japt , 39 23 bayt

Bunu yapmanın daha kısa bir yolu olduğundan eminim ama Japt'ta Date nesnelerini kullanmayı denemek istedim.

á ®¬ò 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.

Girilenleri bir sayı dizisi olarak alır, en son geçerli zamanı veya hiçbiri yoksa boş çıktıyı döndürür. Shaggy sayesinde
10 kilo bayt kaybetti .

Burada dene .

Ruby , 68 67 62 56 55 bayt

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

Çevrimiçi deneyin!

Girdi: Sıralı basamak dizisi (tam sayı olarak).

Çıktı: Rakam dizisi veya nilçözüm bulunamadığında

Jöle , 17 bayt

^{Neredeyse eminim ki bu en kısa yaklaşım değil ... buna daha sonra tekrar bakacak :)}

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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 63 bayt

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

Çevrimiçi deneyin!

Girdi olarak sıralanmış bir basamak listesi alır. İade Missing[NotFound]geçersiz girişler için.

açıklama

Permutations@#

Girişin tüm permütasyonlarını bulun. Girdi sıralandığından, geçerli tüm zamanların artan sırada olması garanti edilir.

FirstCase[ ... ]

Eşleşen ilk listeyi bul ...

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

Etiketli birinci eleman, a0, 1, ya da 2'dir, ve ikinci, üçüncü etiket ve beşinci elemanları b, cve dsırasıyla ...

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

... öyle ki a*b10'dan az dve c6'dan az d >= c.

Hile tüm numaralar için olmasıdır 00için 24, iki basamaklı bir ürün 9 en ve olası hatalı numaraları 25için 29en az 10 ürünü olan (biz, 0, 1 ya da 2 olduğu ilk rakamı zorlamak için).

Pyth , 37 bayt

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

Test odası

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 ile -palF73 bayt,

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

Çevrimiçi deneyin!

Gibi HHmmssçıktılar ve geçersiz girdiler için boş bir satır çıktılar.

Son zamanlarda yaptığım her cevap globpermütasyonlar için kullandı ... Garip!

Bash + GNU sed, 83 , 72 , 69 bayt

• Girdiyi 6 ayrı argüman olarak kabul eder;
• En erken zamanı döndürür (eğer bulunursa);
• Geçerli bir kombinasyon yoksa, hiçbir şey döndürmez (boş çıktı).

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

Nasıl çalışır

GNU-sed e (xecute) komutunu + kullanarak 0 - 86399 aralığındaki zaman damgaları için olası tüm zaman dizelerini önceden oluşturun date.

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

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

sedHer giriş basamağı için, 6 ardışık değiştirme komutuyla komut dosyası oluşturun .

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

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

Ardından, ikame uygulayın, en az bir rakam kalan giriş satırlarını kaldırın, ilk eşleşen satırı yazdırın (orijinal zaman dizesi, tutma alanından çıkartılır 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

Ölçek

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

Çevrimiçi Deneyin!

Kotlin , 396 391 389 bayt

Bunu nasıl daha küçük yapabileceği hakkında hiçbir ipucu yok. Bunun mümkün olanın iki katı olduğunu düşünüyorum. En erken zamanı üretir. 7 bayt için Kevin'a teşekkürler!

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

Çevrimiçi deneyin!

MATL , 31 30 bayt

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

Çevrimiçi deneyin!

Giriş 6 tamsayıdır, çıkış bir dizideki minimum saat, dakika ve saniyedir. Böyle bir zamanın mümkün olmadığı girişler için çarpma.

(@Luis Mendo sayesinde -1 bayt.)

Perl 6 , 43 bayt

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

Çevrimiçi deneyin!

Sıralanmış bir giriş dizisi bekler. NilGeçersiz giriş için döndürür .

Stax , 15 bayt

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

Koş ve hata ayıkla

Giriş için bir dizi basamaklı basamak alır. Birkaç kriteri karşılayan ilk permütasyonu döndürür.

• sözlük bilgisi olarak "24" den küçük
• Üç karakter çiftinin tümü sözlüksel olarak "6" dan küçük

Retina , 58 47 bayt

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

Çevrimiçi deneyin!

Giriş, sıralanmış düzende 6 hanedir. Çıktı, en erken geçerli zamanı temsil eden 6 basamak veya geçerli bir zaman yoksa boş dizedir.

EDIT: Ben bir aptal, -9 bayt

açıklama

Algoritma

Kısalık için, düşük bir rakamı 0-5 ve yüksek bir rakamı 6-9 olarak tanımlayalım.

İlk önce, her bir pozisyonun "düşüklüğü" veya "yüksekliğini" doğru olacak şekilde rakamları yeniden düzenleyin. Girişteki her bir yüksek basamak sayısı için doğru düzenleme:

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

Herhangi bir yeniden düzenleme başarısız olacağından, girdideki son kontrol 4+ yüksek rakamlı olduğundan, bu durumu tamamen görmezden gelebiliriz.

Ardından alçakları ve yüksekleri ayrı ayrı sıralayın. Yeniden düzenleme ile birleştirildiğinde, dakika ve ikinci kısıtlamaları sağlayan en düşük değeri verir. Yani bu, eğer varsa, en erken geçerli zamanı verir.

Son olarak, geçerli zamanımız olup olmadığını kontrol edin. Değilse, dizeyi atın.

program

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

Maçlar LHHve değişim bu ilk iki basamak (olur HLH), ve tekrar daha fazla no kadar bu LHHbulunmaktadır. Bu doğru düzenlemeyi verir.

Aslında yalan söyledim. Sıralama gerekmez, çünkü 1) değiştirme yalnızca bitişik basamaklar arasında ve yalnızca düşük ve yüksek arasında olur; ve 2) giriş sıralanır. Yani alçaklar ve alçaklıklar ayrı ayrı sıralanmıştır.

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

Dize ancak geçerli bir zamansa