Ursprünglich gepostet (und gelöscht) von @Tlink , was höchstwahrscheinlich von dieser StackOverflow-Frage inspiriert wurde .
Da es eine Schande war, dass es gelöscht wurde, weil es im Allgemeinen eine gute Herausforderung zu sein schien, dachte ich, ich würde es mit den richtigen Formatierungen und Regeln neu veröffentlichen. (Ich habe versucht, @Tlink zu kontaktieren und seine / ihre Erlaubnis zum Posten zu erhalten, aber (s) er antwortet nicht mehr, weshalb ich mich entschlossen habe, es jetzt selbst zu posten.)

Eingabe: Sechs Ziffern.

Ausgabe: Entweder die erste oder die letzte gültige Zeit im 24-Stunden-Format ( 00:00:00bis 23:59:59). (Sie können selbst entscheiden, ob Sie die erste oder die letzte gültige Zeit ausgeben möchten.)

Beispiel:

Bei den Eingaben 1,8,3,2,6,4können die folgenden Zeiten erstellt werden:

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

Also geben wir entweder 12:36:48oder 23:48:16in diesem Fall als erstes / letztes aus.

Herausforderungsregeln:

• Geben Sie an, ob Sie in Ihrer Antwort den ersten oder den letzten gültigen Zeitpunkt ausgegeben haben.
• I / O ist flexibel. Die Eingabe kann aus sechs getrennten Ganzzahlen bestehen. eine Zeichenkette mit den sechs Ziffern; eine ganzzahlige Liste / Array; eine einzelne (möglicherweise oktale) Zahl; usw. Die Ausgabe kann eine korrekt geordnete Liste / Reihe von Ziffern sein. ein String in dem Format HH:mm:ss/ HHmmss/ HH mm ss; Jede Ziffer wird mit einem Trennzeichen für neue Zeilen gedruckt. usw. Ihr Anruf.
• Sie können die Ziffern in beliebiger Reihenfolge eingeben, damit sie bereits von der niedrigsten zur höchsten oder umgekehrt sortiert werden können.
• Wenn mit den angegebenen Ziffern (dh 2,5,5,5,5,5) keine gültige Uhrzeit erstellt werden kann , machen Sie dies auf eine beliebige Weise deutlich. Kann zurückkehren null/ false; "Not possible"; Absturz mit einem Fehler; usw. (Sie können keine ungültige Zeit wie 55:55:52oder eine andere gültige Zeit wie ausgeben 00:00:00.) Geben Sie an, wie Eingaben behandelt werden, für die keine gültige Zeit erstellt werden kann.
• Sie dürfen nicht alle möglichen gültigen Zeiten ausgeben. Es sollte nur das früheste / späteste ausgegeben / zurückgesandt werden.
• 24Stunden (dh 24:00:00) oder 60Minuten / Sekunden (dh 00:60:60) sind nicht gültig. Die Bereiche gelten [00-23]für Stunden sowie [00-59]für Minuten und Sekunden.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

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 Bytes

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

Probieren Sie es online!

-12 Bytes dank Kevin Cruijssen

Wahrscheinlich nicht optimal, aber es funktioniert. Seltsamerweise erfordert die gcc-Implementierung auf TIO aus irgendeinem Grund mit 7 Argumenten, dass Sie sie tatsächlich bereitstellen, oder sie schlägt fehl. Auf meinem Rechner ist das allerdings unnötig.

Format: G (X, 0,6) -> Y wobei X die 6-stellige Zahl ist, deren Ziffern verwendet werden sollen, und Y die 6-stellige Zahl ist, die, wenn sie als Zeit genommen wird (durch Einfügen: passend), minimal ist.

Haskell , 114 96 86 Bytes

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

Jetzt mit weniger strenger Ausgabe. Nimmt die Eingabe als Ziffernfolge und vergleicht die Permutationen mit den Grenzwerten mit dem Listenvergleich. Bei Minuten und Sekunden wird nur die erste Ziffer geprüft. Stürzt ab und brennt, wenn keine Permutation gültig ist.

Probieren Sie es online!

Python 2 , 131 115 112 109 105 88 Bytes

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

Probieren Sie es online!

I / O sind Listen von ganzen Zahlen

Wirft einen Fehler, wenn keine Zeiten möglich sind

Alternative:

Python 2 , 88 Bytes

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

Probieren Sie es online!

Gibt die späteste Zeit zurück

Gibt ein leeres Tupel für ungültige Zeiten zurück

Gerettet

• -21 Bytes dank ovs

05AB1E , 20 15 Bytes

Eingabe als sortierte Zeichenfolge.
Die Ausgabe ist die kürzeste Zeit als Zeichenfolge.
Falls keine Lösung vorliegt, wird eine leere Liste ausgegeben.

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

Probieren Sie es online!

JavaScript (ES6), 93 89 88 Bytes

Erwartet ein Array mit 6 Ziffern, sortiert vom niedrigsten zum höchsten. Gibt entweder die 6-stellige Zeichenfolge der ersten gültigen Zeit zurück oder falsewenn keine Lösung vorhanden ist.

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

Probieren Sie es online!

Kommentiert

Wir probieren rekursiv alle Permutationen der Eingabe aus, bis wir eine finden, die einen Hybridtest sowohl unter Verwendung von Arithmetik als auch eines regulären Ausdrucks besteht.

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 Bytes

Übernimmt die Eingabe als Ziffernfolge und gibt die erste gültige Zeit aus. Endlos wiederholbar, wenn keine gültige Zeit vorhanden ist.

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

Versuch es

Warnung: Extrem langsam - fügen Sie *1000nach der Sekunde hinzu X, um es etwas zu beschleunigen. Und vergessen Sie nicht, dass eine ungültige Eingabe eine Endlosschleife erzeugt und Ihren Browser zum Absturz bringen kann.

Erläuterung

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

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

Probieren Sie es online! Gibt die früheste Zeit oder die leere Zeichenfolge aus, wenn keine Zeit gefunden werden kann. Bearbeiten: 5 8 Bytes dank @TwiNight gespeichert. Erläuterung:

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

Generieren Sie alle Permutationen. Das :funktioniert so, wie der String die Permutationen generiert und endet am Anfang.

O`

Ordne die Zeiten nacheinander an.

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

Geben Sie die erste gültige Zeit aus.

Rot , 157 124 Bytes

Vielen Dank an Kevin Cruijssen, der mich daran erinnert hat, die Beschreibungen genauer zu lesen!

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

Probieren Sie es online!

Nimmt eine sortierte Zeichenfolge als Eingabe. Gibt zurück, nonewenn es nicht möglich ist, Zeit zu machen.

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Arnauld hat ein Byte gespeichert. Vielen Dank!

Erwartet eine Liste wie ['1','2','3','4','6','8']in sortierter Reihenfolge:

Sie können die Ziffern in beliebiger Reihenfolge eingeben, damit sie bereits von der niedrigsten zur höchsten oder umgekehrt sortiert werden können.

Gibt eine Ganzzahl wie 123648für 12:36:48 aus. Ich hoffe das ist akzeptabel.

Gelee , 15 Bytes

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

Probieren Sie es online!

Gepostet nach einer Anfrage. Der Ansatz ist derselbe wie bei der anderen Antwort, diese Antwort wurde jedoch unabhängig entwickelt.

Japt , 39 23 Bytes

Ich bin mir ziemlich sicher, dass es einen kürzeren Weg gibt, aber ich wollte versuchen, Date-Objekte in Japt zu verwenden.

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

Nimmt die Eingabe als sortiertes Array von Zahlen, gibt die letzte gültige Zeit zurück oder gibt eine leere Ausgabe aus, wenn keine vorhanden ist.
10 Pfund verloren dank Shaggy .

Probieren Sie es hier aus .

Ruby , 68 67 62 56 55 Bytes

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

Probieren Sie es online!

Eingabe: Sortiertes Array von Ziffern (als ganze Zahlen).

Ausgabe: Array von Ziffern oder nilfalls keine Lösung gefunden wurde

Gelee , 17 Bytes

^{Ich bin mir fast sicher, dass dies nicht der kürzeste Weg ist ... wir werden uns das später noch einmal ansehen :)}

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 63 Byte

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

Probieren Sie es online!

Nimmt eine sortierte Ziffernliste als Eingabe. Gibt Missing[NotFound]für ungültige Eingaben zurück.

Erläuterung

Permutations@#

Finde alle Permutationen der Eingabe. Da die Eingabe sortiert ist, wird garantiert, dass alle gültigen Zeiten in aufsteigender Reihenfolge sind.

FirstCase[ ... ]

Finden Sie die erste Liste, die passt ...

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

Das erste Element, markiert aist 0, 1 oder 2 ist , und kennzeichnen die zweiten, dritten und fünften Elemente b, cund djeweils ...

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

... so dass a*bweniger als 10 dund cweniger als 6 sind, mit d >= c.

Der Trick ist, dass für alle Zahlen 00bis 24das Produkt der beiden Ziffern höchstens 9 ist und die möglichen ungültigen Zahlen 25bis 29(da wir die erste Ziffer zwingen, 0, 1 oder 2 zu sein) das Produkt von mindestens 10 haben.

Pyth , 37 Bytes

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

Testsuite

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 mit -palF73 Bytes

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

Probieren Sie es online!

Gibt HHmmsseine leere Zeile für ungültige Einträge aus.

Jede Antwort, die ich kürzlich gemacht habe, wurde globfür Permutationen verwendet ... Seltsam!

Bash + GNU sed, 83 , 72 , 69 Bytes

• Akzeptiert Eingaben als 6 separate Argumente;
• Gibt den frühesten Zeitpunkt zurück (falls gefunden);
• Gibt nichts zurück (leere Ausgabe), wenn keine gültige Kombination vorhanden ist.

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

Wie es funktioniert

Generieren Sie mit dem Befehl + GNU-sed e (xecute) alle möglichen Zeitreihen für die Zeitstempel im Bereich von 0 bis 86399 vor date.

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

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

Generieren Sie ein sedSkript mit 6 sequentiellen Ersetzungsbefehlen für jede eingegebene Ziffer.

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

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

Wenden Sie dann Substitutionen an, entfernen Sie alle Eingabezeilen, die noch mindestens eine Ziffer enthalten, und drucken Sie die erste übereinstimmende Zeile aus (die ursprüngliche Zeitzeichenfolge wird mit aus dem Haltebereich extrahiert 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

Prüfung

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

Probieren Sie es online!

Kotlin , 396 391 389 Bytes

Keine Ahnung, wie man das verkleinert. Ich denke, es ist doppelt so viel wie möglich. Erzeugt früheste Zeit. Danke an Kevin für 7 Bytes!

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

Probieren Sie es online!

MATL , 31 30 Bytes

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

Probieren Sie es online!

Die Eingabe ist 6 Ganzzahlen, die Ausgabe ist die minimale Stunde, Minute und Sekunde in einem Array. Abstürze bei Eingaben, bei denen eine solche Zeit nicht möglich ist.

(-1 Byte dank @Luis Mendo.)

Perl 6 , 43 Bytes

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

Probieren Sie es online!

Erwartet ein sortiertes Eingabearray. Gibt Nilfür ungültige Eingaben zurück.

Stax , 15 Bytes

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

Führen Sie es aus und debuggen Sie es

Für die Eingabe wird eine Zeichenfolge mit sortierten Ziffern benötigt. Es wird die erste Permutation zurückgegeben, die einige Kriterien erfüllt.

• lexikografisch weniger als "24"
• Alle drei Zeichenpaare sind lexikografisch kleiner als "6"

Retina , 58 47 Bytes

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

Probieren Sie es online!

Die Eingabe erfolgt 6-stellig in sortierter Reihenfolge. Die Ausgabe besteht aus 6 Ziffern, die die früheste gültige Zeit darstellen, oder einer leeren Zeichenfolge, wenn keine gültige Zeit vorhanden ist.

EDIT: Ich war ein Idiot, -9 Bytes

Erläuterung

Algorithmus

Der Kürze halber definieren wir eine niedrige Ziffer als 0-5 und eine hohe Ziffer als 6-9.

Ordnen Sie zunächst die Ziffern neu an, sodass "Niedrig" oder "Hoch" für jede Position korrekt ist. Die richtige Anordnung für jede Anzahl von hohen Stellen in der Eingabe:

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

Da bei einer eventuellen Neuanordnung die endgültige Überprüfung der Eingabe mit mehr als 4 hohen Ziffern fehlschlagen würde, können wir diesen Fall vollständig ignorieren.

Sortieren Sie dann die Tiefs und Hochs einzeln. In Kombination mit der Neuanordnung ergibt dies den niedrigsten Wert, der die Einschränkungen für Minute und Sekunde erfüllt. Dies gibt also die früheste gültige Zeit an, falls eine existiert.

Überprüfen Sie abschließend, ob wir eine gültige Zeit haben. Wenn nicht, verwerfen Sie die Zeichenfolge.

Programm

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

LHHStimmt mit den ersten beiden Ziffern überein und tauscht sie aus. HLHWiederholen Sie dies, bis keine weiteren mehr LHHvorhanden sind. Dies ergibt die richtige Anordnung.

Eigentlich habe ich gelogen. Es ist keine Sortierung erforderlich, da 1) das Vertauschen nur zwischen benachbarten Ziffern und nur zwischen einem niedrigen und einem hohen Wert erfolgt; und 2) die Eingabe wird sortiert. Die Tiefs und Hochs sind also bereits einzeln sortiert.

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

Behält die Zeichenfolge nur bei, wenn es sich um eine gültige Zeit handelt