Warnung: Nehmen Sie KEINE ärztlichen Ratschläge von diesem Beitrag. Wenn Sie ärztlichen Rat benötigen, wenden Sie sich an einen qualifizierten Fachmann.

Ich habe Kopfschmerzen. Ich brauche Kopfschmerztabletten.

Ich sage Ihnen die letzten Dosen, die ich hatte, und Sie sagen mir, wann ich meine nächste Dosis ohne Überdosierung einnehmen kann.

Ich gebe dir diese Zeichenfolge: P: 00:00, I: 02:00, P: 04:00, I: 06:00

Und du gibst mir das: Next P: 08:00, I: 10:00

Eingang:

Zeichenfolge, die angibt, wann jedes Medikament eingenommen wurde, im folgenden Format:

P: 00:00, I: 02:00, P: 04:00, I: 06:00

Dies bedeutet, dass Paracetamol um 00:00 und 04:00 Uhr und Ibuprofen um 02:00 und 06:00 Uhr eingenommen wurde

Ausgabe (aktualisiert):

Zeichenfolge mit der Zeit, zu der das nächste Medikament verabreicht wird, im folgenden Format:

Next P: 08:00, I: 10:00

• Die Ausgabereihenfolge sollte in der Reihenfolge liegen, in der das Medikament eingenommen werden soll. - Wenn Ibuprofen um 09:35 Uhr und Paracetamol um 10:22 Uhr eingenommen werden soll, sollte der Ausgang seinNext I: 09:35, P: 10:22
• Wenn die Zeiten für die nächste Dosis der einzelnen Medikamente gleich sind, spielt die Ausgabereihenfolge keine Rolle: Next P: 08:00, I: 08:00ODERNext I: 08:00, P: 08:00
• Wenn nur ein Medikament eingenommen wird (in der Eingabezeichenfolge), sollte nur dieses Medikament in der Ausgabezeichenfolge enthalten sein: Next P: 02:00

Regeln:

• Es wird immer nur zwei Arten von Medikamenten geben, Paracetamol "P" und Ibuprofen "I".
• Paracetamol kann einmal alle 4 Stunden, maximal viermal innerhalb von 24 Stunden, eingenommen werden.
• Ibuprofen kann auch einmal alle 4 Stunden, maximal viermal innerhalb von 24 Stunden, eingenommen werden.
• Paracetamol und Ibuprofen können zusammen oder zu unterschiedlichen Zeiten eingenommen werden. Einer zählt nicht zur Dosierung des anderen.
• Die Zeiten in der Eingabezeichenfolge sind immer aufeinanderfolgend, können jedoch über Mitternacht (23:00 -> 03:00) liegen.
• Die Zeiten in der Eingabezeichenfolge werden nicht mehr als 24 Stunden umfassen
• Maximal 4-mal für jedes Medikament (maximal 8 insgesamt)
• Die Eingabe ist immer nicht leer und enthält mindestens ein Medikament und ein Mal

Beispiele:

Jeweils zwei Dosen im Abstand von zwei Stunden:

"P: 00:00, I: 02:00, P: 04:00, I: 06:00" -> "Next P: 08:00, I: 10:00"

Einzeldosis Paracetamol

"P: 22:00" -> "Next P: 02:00"

Maximale Paracetamol-Dosis innerhalb von 24 Stunden, einmalige Ibuprofen-Dosis

"P: 04:05, P: 08:10, P: 12:15, I: 12:30, P: 16:25" -> "Next I: 16:30, P: 04:05"

Testfälle:

"I: 06:00" -> "Next I: 10:00"
"P: 22:00" -> "Next P: 02:00"
"P: 22:00, P: 02:00, I: 06:00" -> "Next P: 06:00, I: 10:00"
"P: 00:00, I: 02:00, P: 04:00, I: 06:00" -> "Next P: 08:00, I: 10:00"
"P: 04:05, P: 08:10, P: 12:15, I: 12:30, P: 16:25" -> "Next I: 16:30, P: 04:05"
"I: 06:32, P: 08:15, I: 10:44, P: 13:03" -> "Next I: 14:44, P: 17:03"
"P: 07:30, I: 07:30, P: 11:30, I: 11:30, P: 15:30, I: 15:30, I: 19:30" -> "Next P: 19:30, I: 07:30"
"I: 07:30, P: 11:30, I: 11:30, P: 15:30, I: 15:30, P: 19:30, I: 19:30" -> "Next P: 23:30, I: 07:30"
"P: 07:30, I: 07:30, P: 11:30, I: 11:30, P: 15:30, I: 15:30, P: 19:30, I: 19:30" -> "Next P: 07:30, I: 07:30" OR "Next I: 07:30, P: 07:30"

Dies ist Codegolf, also gewinnt die kürzeste Antwort in Bytes.

AKTUALISIEREN:

Die Ausgabe kann jetzt Abkürzungen von Paracetamol und Ibuprofen sein; PundI

JavaScript (ES6), 367 362 354 358 Byte

Golf Version:

A=i=>i>9?""+i:"0"+i,B=(s,a=":")=>s.split(a),C=(a,b,c,d)=>[...[s,t]=B((b>3?c:d)||":"),a+` ${A(s=b>3?+s:(+s+4)%24)}:`+A(t=+t)],F=s=>{a=B(s,m=", ");for(b=c=d=e=f=p=q=0;f<a.length;g=="P:"?(b++,d=d?h:p=h):(c++,e=e?h:q=h))[g,h]=B(a[f++]," ");[i,j,k]=C("P",b,p,d),[n,o,l]=C("I",c,q,e),r=B(h)[0];return"Next "+c?b?n*60+(n<r)*1440+j<i*60+(i<r)*1440+o?l+m+k:k+m+l:l:k}

Ungolfed / kommentiert:

// Returns a zero-padded string of the argument.
A=i=>i>9?""+i:"0"+i,

// Since we do a lot of splitting, alias it. Making the
// second argument optional (and defaulting to ':') saved
// 3 bytes
B=(s,a=":")=>s.split(a),

// Constructs a string for output, along with the time
// of the next dose, in the format [hour, minute, string].
// Arguments:               type
// a -> type (P/I)          String
// b -> amount of doses     Number
//      taken
// c -> first dose taken    String
// d -> last dose taken     String
//
// The first two values are split from the string, but
// before the array is returned, they are converted to
// integers (during the string construction).
C=(a,b,c,d)=>[...[s,t]=B((b>3?c:d)||":"),a+` ${A(s=b>3?+s:(+s+4)%24)}:`+A(t=+t)],

// Main function. Returns the time(s) for the next dose.
// Argument:                type
// s -> list of times of    String
//      and types of 
//      doses taken
F=s=>{
    a=B(s,m=", "); // Split the input by comma + space,
                   // and save that string, since we
                   // need it later when constructing
                   // the output string.
    // For loop has been restructured. Original:
    // for(b=c=f=0;f<a.length;g=="P:"?(b++,d=d?h:p=h):(c++,e=e?h:q=h))
    //     [g,h]=B(a[f++]," ");
    b = 0; // P-dose counter
    c = 0; // I-dose counter
    d = 0; // Last P-dose
    e = 0; // Last I-dose
    p = 0; // First P-dose
    q = 0; // First I-dose
    for (f = 0; f < a.length; f++) {
        [g, h] = B(a[f], " ");  // g contains the type,
                                // h contains the time
        if (g == "P:") {
            b++;                // increase the counter

            if (d == 0) {   // store h in p if this is
                p = h;      // the first dose of this
            }               // type
            d = h;
        } else {
            // See the above code block for comments
            c++;

            if (e == 0) {
                q = h;
            }
            e = h;
        }
    }
    // End of restructured for loop.

    // Construct the output strings, and get the times.
    // See comments at C function.
    [i, j, k] = C("P", b, p, d);
    [n, o, l] = C("I", c, q, e);

    // Get the amount of hours of the dose taken last.
    // We use this to get the correct order of the two
    // times.
    r = B(h)[0];

    // Return statement has been restructured. Original:
    // return "Next "+c?b?n*60+(n<r)*1440+j<i*60+(i<r)*1440+o?l+m+k:k+m+l:l:k
    //==================================================
    // Start creating the output string.
    output = "Next "
    // Use the following checks to figure out what needs
    // to be part of the output and in what order.
    if (c > 0) {
        if (b > 0) {
            // Compare the times of next doses
            // P_time = (i + (i < r) * 24) * 60
            // I'm using implicit conversion of
            // booleans to numbers. If the next
            // dose is past midnight, add 1 * 24
            // to the time, so it is compared
            // correctly.
            // Then add the minutes to the number.
            P_time = i*60+(i<r)*1440+o;
            I_time = n*60+(n<r)*1440+j;

            if (I_time < P_time) {
                output += l + m + k; // I first
            } else {
                output += k + m + l; // P first
            }
        } else {
            output += l; // Just I
        }
    } else {
        output += k; // Just P
    }

    // Finally, return the output
    return output;
}

Um es zu benutzen, rufe F mit dem String als Argument wie folgt auf:

F("P: 04:00, I: 06:00")

Python 3 - 437 Bytes

a=input();i=p=l=-1;j=q=0
for x in a.split(", ")[::-1]:
    for y, z in [x.split(": ")]:
        s=lambda q,r,t:[t,sum([a*b for a,b in zip([60,1],map(int,q.split(':')))])][r%4<2]+[0,240][r<2]
        if y=="I":j+=1;i=s(z,j,i)
        else:q+=1;p=s(z,q,p)
        l=[l,p+i-239][j+q<2]
r=lambda d,e:("","%s: %02d:%02d, "%(d,(e/60)%24,e%60))[e>-1];p+=[1440,0][p>=l];i+=[1440,0][i>=l];print("Next "+[r("I",i)+r("P",p),r("P",p)+r("I",i)][p<i][:-2])

Erläuterung:

a=input();i=p=l=-1;j=q=0
for x in a.split(", ")[::-1]: #Read in reverse order, a="P: 01:00"
    for y, z in [x.split(": ")]:#Y="P", Z="00:00"
        s=
        lambda q,r,t:[t,sum([a*b for a,b in zip([60,1],map(int,q.split(':')))])]#Convert "01:01" to 61
        [r%4<2]#In case it's the first or fourth string calculate a new value, otherwise: return the original value
        +[0,240][r<2]#In case it's the last string: add 4 hours. Otherwise, leave it.
        if y=="I":j+=1;i=s(z,j,i)#Calculate for i
        else:q+=1;p=s(z,q,p)#Calculate for p
        l=[l,p+i-239][j+q<2]#Sets the last record. Since we read in reverse order, this should be the first one. We've added 4 hours though so remove those again
r=lambda d,e:("","%s: %02d:%02d, "%(d,(e/60)%24,e%60))[e>-1];#Print function, don't print anything when we have no value
p+=[1440,0][p>=l];i+=[1440,0][i>=l];    #Add a day if record is before the last record so we can correctly calculate the order
print("Next "+[r("I",i)+r("P",p),r("P",p)+r("I",i)][p<i][:-2])#print it and remove the last ","

PHP, 228 241 239 227 226 Bytes

benötigt PHP 7

Next<?foreach(explode(", ",$argv[1])as$d){[$m,$h,$i]=explode(":",$d);$x[$m][++$$m]=24+$h+$i/60;}foreach($x as$m=>$d)$r[$m]=$d[$$m-3]?:$d[$$m]-20;sort($r);foreach($r as$m=>$t)$o[]=" $m: ".date("i:s",$t%24*60);echo join(",",$o);

Nervenzusammenbruch

Next<?                              // print "Next"
foreach(explode(", ",$argv[1])as$d) // loop through string split by comma+space
{
    [$m,$h,$i]=explode(":",$d);         // separate drug, hours and minutes
    $x[$m][++$$m]=24+$h+$i/60;          // append time to array, track count in ${$m}
}                                       // (i.e. $P for drug "P" etc.)
foreach($x as$m=>$d)                // loop through drugs
    $r[$m]=                             // add time to result
        $d[$$m-3]                           // if more than 3 medications, use $$m-3
            ??$d[$$m]-20                    // else use last medication - 20 hours
    ;
sort($r);                           // sort results by time
foreach($r as$m=>$t)$o[]=" $m: "    // prepare for output: drug name and formatted time:
    .date("i:s",$t%24*60)           // use hrs as mins and mins as secs to avoid TZ problems
;
echo join(",",$o);                  // print

JavaScript (ES6), 246 Byte

s=>s.split`, `.map(s=>(m[s[0]].unshift(t=s.replace(/\d+/,h=>(h=(1+h)%24)>9?h:`0`+h),s),l=l||t.slice(1)),l=0,m={I:[],P:[]})&&`Next `+[].concat(m.I[7]||m.I[0]||[],m.P[7]||m.P[0]||[]).sort((i,p)=>((i=i.slice(1))<l)-((p=p.slice(1))<l)||i>p).join`, `

Erläuterung:

Looping über jede Dosis, die Iund Psind Dosen in zwei Arrays getrennt. Zu jeder Dosis kommen 4 Stunden hinzu, und diese Zeiten werden ebenfalls gespeichert. Die Arrays sind in umgekehrter Reihenfolge angeordnet, um die Erkennung von 8 Einträgen zu vereinfachen. Die Zeit 4 Stunden nach der ersten Dosis wird ebenfalls zur Verwendung beim Sortieren gespeichert. Zu diesem Zeitpunkt kann sich jedes Array in einem von drei Zuständen befinden:

• 8 Einträge, in diesem Fall ist der letzte Eintrag die erste Dosis, und die nächste Dosis muss 24 Stunden nach dieser Dosis (dh morgen um dieselbe Uhrzeit) erfolgen.
• 2, 4 oder 6 Einträge. In diesem Fall ist der erste Eintrag 4 Stunden nach der letzten Dosis und damit der Zeitpunkt der nächsten Dosis
• 0 Einträge, in diesem Fall konzentrieren wir uns [], was abgeflacht und daher vom Ergebnis ausgeschlossen wird

Nachdem die nächsten Dosiszeiten aus den beiden Arrays extrahiert wurden, müssen sie in der Reihenfolge sortiert werden. Dies erfolgt durch Vergleich mit der Zeit 4 Stunden nach der ersten Dosis. Wenn eine der beiden Zeiten vor dieser Zeit liegt, muss sich dies auf morgen beziehen, und diese Dosis wird zuletzt angewendet. Ansonsten werden die Zeiten einfach direkt verglichen. (Eher unpraktisch, das Medikament ist vor der Zeit, also muss ich es ausziehen, um es richtig zu vergleichen.)