Cảnh báo: KHÔNG được tư vấn y tế từ bài đăng này. Nếu bạn muốn tư vấn y tế, hãy đến một chuyên gia có trình độ.

Tôi bị đau đầu. Tôi cần thuốc đau đầu.

Tôi sẽ nói với bạn vài liều cuối cùng tôi đã uống, và bạn cho tôi biết khi nào tôi có thể dùng liều tiếp theo mà không cần dùng quá liều.

Tôi sẽ cung cấp cho bạn chuỗi này: P: 00:00, I: 02:00, P: 04:00, I: 06:00

Và bạn sẽ cho tôi điều này: Next P: 08:00, I: 10:00

Đầu vào:

Chuỗi đại diện cho thời gian mỗi loại thuốc đã được thực hiện, theo định dạng sau:

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

Điều này có nghĩa là Paracetamol được uống lúc 00:00 và 04:00, và Ibuprofen được uống lúc 02:00 và 06:00

Đầu ra (cập nhật):

Chuỗi với thời gian tiếp theo của mỗi loại thuốc có thể được thực hiện, theo định dạng sau:

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

• Thứ tự đầu ra phải theo thứ tự thuốc sẽ được thực hiện. - Nếu Ibuprofen được lấy lúc 09:35 và Paracetamol và 10:22, thì đầu ra phải làNext I: 09:35, P: 10:22
• Nếu thời gian cho liều tiếp theo của mỗi loại thuốc là như nhau, thứ tự đầu ra không thành vấn đề: Next P: 08:00, I: 08:00HOẶCNext I: 08:00, P: 08:00
• Nếu chỉ có một loại thuốc được sử dụng (trong chuỗi đầu vào), thì chỉ có loại thuốc đó nên nằm trong chuỗi đầu ra: Next P: 02:00

Quy tắc:

• Sẽ chỉ có hai loại thuốc, Paracetamol 'P' và Ibuprofen 'I'.
• Paracetamol có thể được thực hiện 4 giờ một lần, tối đa 4 lần trong vòng 24 giờ.
• Ibuprofen cũng có thể được thực hiện 4 giờ một lần, tối đa 4 lần trong vòng 24 giờ.
• Paracetamol và Ibuprofen có thể được dùng cùng nhau, hoặc vào những thời điểm riêng biệt. Người ta không tính vào liều lượng của người kia.
• Thời gian trong chuỗi đầu vào sẽ luôn liên tiếp, nhưng có thể kéo dài đến nửa đêm (23:00 -> 03:00)
• Thời gian trong chuỗi đầu vào sẽ không kéo dài quá 24 giờ
• Tối đa 4 lần cho mỗi loại thuốc (tổng cộng tối đa 8 lần)
• Đầu vào sẽ luôn không trống và chứa ít nhất một loại thuốc và một lần

Ví dụ:

Hai liều mỗi lần cách nhau hai giờ:

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

Một liều Paracetamol

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

Liều Paracetamol tối đa trong vòng 24 giờ, liều Ibuprofen đơn

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

Các trường hợp thử nghiệm:

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

Đây là mã golf, vì vậy câu trả lời ngắn nhất int byte thắng.

CẬP NHẬT:

Đầu ra bây giờ có thể là chữ viết tắt của Paracetamol và Ibuprofen; PvàI

JavaScript (ES6), 367 362 354 358 byte

Phiên bản chơi gôn:

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 / bình luận:

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

Để sử dụng nó, hãy gọi F với chuỗi là đối số như vậy:

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

Python 3 - 437 byte

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

Giải trình:

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 byte

yêu cầu 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);

phá vỡ

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

Giải trình:

Vòng lặp trên mỗi liều, Ivà Pliều được tách thành hai mảng. 4 giờ cũng được thêm vào mỗi liều và những lần đó cũng được lưu lại. Các mảng được điền ngược lại để giúp phát hiện 8 mục dễ dàng hơn. Thời gian 4 giờ sau liều đầu tiên cũng được lưu lại để sử dụng trong quá trình phân loại. Tại thời điểm này, mỗi mảng có thể ở một trong ba trạng thái:

• 8 mục, trong trường hợp đó là mục cuối cùng là liều đầu tiên và liều tiếp theo phải là 24 giờ sau liều này (tức là cùng ngày mai)
• 2, 4 hoặc 6 mục, trong trường hợp đó là mục đầu tiên là 4 giờ sau liều cuối cùng, và do đó thời gian của liều tiếp theo
• 0 mục, trong trường hợp chúng tôi nối [], được làm phẳng và do đó loại trừ khỏi kết quả

Đã trích xuất lần liều tiếp theo từ hai mảng, vẫn còn để sắp xếp chúng theo thứ tự. Điều này được thực hiện bằng cách so sánh chúng với thời gian 4 giờ sau liều đầu tiên. Nếu một trong hai lần là trước thời điểm này, thì điều này phải nói đến ngày mai, và liều đó sẽ đến sau cùng. Nếu không, thời gian chỉ đơn giản là so sánh trực tiếp. (Khá bất tiện, thuốc là trước thời gian, vì vậy tôi phải loại bỏ nó để so sánh đúng.)