프로그램 / 기능 등은 2 개의 입력을받습니다. 첫 번째는 누가 내 파티에 와서 언제 왔는지 목록입니다. 예:

Kevin 13:02  
Ruby 5  
Sam 3  
Lisa 6  
Bob 12  

그게 무슨 뜻이야? 케빈이 먼저 파티 (13:02, 24 시간), 루비 5 분, 샘 3 분, 리사 6 분, 마지막 밥 12 분 후에 파티에 갔다는 의미입니다.

두 번째 입력은 파티가 시작되었을 때입니다. 예:

13:15

(24 시간). 당신의 결과물 은 늦었 던 사람들의 목록이어야합니다 . (정확한 시간에 맞춰도 괜찮습니다.) 계산 예 (예 : 출력하지 않음)

Kevin 13:02
Ruby 13:07
Sam 13:10
Lisa 13:16
Bob 13:28

Lisa와 Bob은 이후 13:15에 도착했습니다 . 따라서이 프로그램은 "Lisa, Bob"을 인쇄해야합니다.

입력 가정

• 입력 1은 항상 이름 (regex [A-Z][a-z]*), 공백, hours:minutes첫 줄 의 24 시간 형식 , 이름, 공백 및 다음 줄의 양의 정수 (분 후)입니다. . 항상 최소한 한 줄이 있어야합니다.
• 원하는 경우 줄 바꿈 대신 다른 문자를 사용하여 입력 1을 사용할 수 있습니다.
• 입력 2는 형식 hours:minutes입니다.
• 원하는 경우 입력을 임의의 문자로 구분 된 하나의 문자열로 취할 수 있습니다. 이것은 선택 사항입니다.
• 일일 크로스 오버에 대해 걱정하지 마십시오. 내 파티는 절대로 23:59.

출력 규칙

• 출력은 함수 반환 값이거나 STDIN에 에코 된 문자열, 파일 등일 수 있습니다. 문자열 또는 배열 / 목록을 반환해야합니다.
  • 문자열을 반환하는 경우 영숫자가 아닌 구분 기호로 구분 된 늦은 사람 (순서는 중요하지 않음)이어야합니다.
  • 배열 / 목록을 반환하면 지각 한 모든 사람의 목록이어야합니다.

MATL , 31 바이트

jYb1L&)1&)XUYs1440/0whwYO+jYO>)

첫 번째 입력은 줄 바꿈 대신 공백을 사용합니다 (챌린지에 의해 허용됨).

출력은 줄 바꿈을 구분 기호로 사용합니다.

온라인으로 사용해보십시오!

설명

j       % Input first string
Yb      % Split at spaces. Gives cell array of strings
1L&)    % Separate into subarrays with odd and even indices. Odd are names, even
        % are time and increments in minutes
1&)     % Separate the subarray of even indices into first entry and remaining
        % entries. The first is a string representing the time of first arrival,
        % the rest are strings representing increments in minutes
XU      % Convert strings representing increments into the actual numbers
Ys      % Cumulative sum
1440/   % Divide by 1440 (number of minutes in a day)
0wh     % Prepend a 0
w       % Swap. Bring the string with time of first arrival to the top
YO      % Convert to serial date number. Fractional part indicates time
+       % Add. This gives all arrivals as serial date numbers
j       % Input second string
YO      % Convert to serial date number
>       % Less than?, element-wise
)       % Index: select the names for which the comparison gave true
        % Implicitly display

자바 스크립트 (ES6), 98 97 바이트

Neil 덕분에 1 바이트 절약

카레 구문 으로 손님 목록 l과 파티 시간 h을 가져옵니다 (l)(h). 목록에서 후행 줄 바꿈이 예상됩니다. 공백으로 구분 된 이름 목록 (예 :)을 반환합니다 Lisa Bob.

l=>h=>l.replace(/(.* )(.*)\n/g,(_,a,b)=>(t-=T(b))<0?a:'',t=(T=h=>eval(h.replace(/:/,'*60+')))(h))

형식화 및 의견

l => h =>                         // given a list of guests l and a party time h
  l.replace(                      // for each guest in l:
    /(.* )(.*)\n/g,               //   extract the name a and arrival time b
    (_, a, b) =>                  //   subtract the arrival time from the time counter
      (t -= T(b)) < 0 ?           //   if the result is negative:
        a                         //     the guest is late: keep the name
      :                           //   else:
        '',                       //     the guest is on time: remove this entry
    t = (                         //   initialize the time counter t
      T = h =>                    //   define T():
        eval(                     //     a function that takes either a time
          h.replace(/:/, '*60+')  //     in hh:mm format or an amount of minutes
        )                         //     and returns an amount of minutes   
    )(h)                          //   call it with the party time
  )                               // end of replace()

데모

let f =

l=>h=>l.replace(/(.* )(.*)\n/g,(_,a,b)=>(t-=T(b))<0?a:'',t=(T=h=>eval(h.replace(/:/,'*60+')))(h))

console.log(f(`Kevin 13:02
Ruby 5
Sam 3
Lisa 6
Bob 12
`)('13:15'))

PHP, 118 98 95 91 바이트

while($n=$argv[++$i])$i&1?$p=$n:($t=($f=strtotime)($n)?:$t+60*$n)<=$f(end($argv))?:print$p;

명령 행 인수에서 입력을받습니다 (원하는 경우 공백으로 구분 된 행으로 해석 할 수 있음). 구분 기호없이 이름을 인쇄합니다. 온라인으로 실행 -r하거나 테스트하십시오 .

편집 1 : 직접 인쇄로 20 바이트 저장
편집 2 : 구분 기호를 제거하여 3 바이트 저장
편집 3 : 일반 정수가 유효하지 않은 날짜를 이용하여 4 바이트 저장strtotime

고장

while($n=$argv[++$i])       # loop through arguments, skip [0]
    $i&1                        # if index is odd   
    ?   $p=$n                   # then assign name to $p
    :   ($t=                    # else $t =
        ($f=strtotime)($n)          # if $n is a valid time, parse it
        ?:$t+60*$n                  # else add $n minutes to current $t
        )<=$f(end($argv))           # if $t <= parsed party start
        ?                           # then do nothing
        :print$p;                   # else print name

c, 178 바이트

main(c,o,d,e,g,O,l,f,x,y)char**o,d[80],*O,*l,*f;{for(sscanf(o[2],"%d:%d",&e,&g),x=e*60+g,l=";",f=o[1];O=strtok(f,l);f=0)(y=sscanf(O,"%s%d:%d",d,&e,&g)^2?e*60+g:y+e)>x?puts(d):0;}

온라인으로 사용해보십시오

자바 스크립트 ES6, 185 바이트

l=>t=>l.split`
`.map(p=>p.split` `).map((p,i,a)=>[p[0],i?d(a[0][1])+a.slice(1,i+1).reduce((a,p)=>a+=+p[1],0)*6e4:(d=x=>Date.parse(`2017T${x}`))(p[1])]).filter(p=>p[1]>d(t)).map(p=>p[0])

온라인으로 사용해보십시오!

const f = l=>t=>l.split`
`.map(p=>p.split` `).map((p,i,a)=>[p[0],i?d(a[0][1])+a.slice(1,i+1).reduce((a,p)=>a+=+p[1],0)*6e4:(d=x=>Date.parse(`2017T${x}`))(p[1])]).filter(p=>p[1]>d(t)).map(p=>p[0])


console.log(f('Kevin 13:02\nRuby 5\nSam 3\nLisa 6\nBob 12')('13:15'))

PowerShell , 215 196180 바이트

param($a,$b)$x,[array]$a=$a-split',';$z=@{};$i,$j=-split$x;$z[$i]=($y=date $j);0..($a.count-1)|%{$i,$j=-split$a[$_];$z[$i]=($y=$y|% *es $j)};($z|% *or|?{$_.value-gt(date $b)}).Name

온라인으로 사용해보십시오!

이 중 약 1/3은 입력 구문 분석이므로 골프를 얼마나 더 할 수 있는지 잘 모르겠습니다.

입력을 받아 $a이름과 회 / 분의 쉼표로 구분 된 문자열로하고, $b같은 hh:mm문자열로. 첫째, 우리 -split $a에가 ,로 첫 번째 결과를 저장 $x하고에 나머지 $a의 명시 적 재 캐스트, $aAS를 array(그래서 루프가 나중에 제대로 작동하는지). 설명서에서는 우리 해시 테이블 초기화 $z, 설정을 $i하고 $j할 $x -split공백에 설정하고 $z[$i]수 date의을 $j(에 저장 $y나중에 사용하기 위해).

그런 다음 나머지를 반복합니다 $a. 반복 할 때마다 -split공백에있는 문자열 과 비슷한 작업을 수행 하여 $z현재 위치보다 몇 분 더 적절한 인덱스를 설정합니다 . 이것은 대신 속성을 사용하여 바이트를 절약하기 위해 단축 속성 이름 트릭을 사용 |% *es $j합니다 .AddMinutes($j).

마지막으로, 우리는 .GetEnumerator()우리의 해시 테이블 (다시 트릭을 사용), 및 Where-Object로 해당 항목을 선택 value있다는 -greater t한 $b(즉, 그들은 파티에 늦었 어). 그런 다음 .Names 만 선택합니다 . 출력은 내재 된 배열로서 기본적으로 줄 Write-Output바꾸기를 삽입합니다.

[배열]이 하나라는 사실을 상기시켜 준 briantist에게 많은 감사를 전했습니다. 그리고 속성 이름 팁을 단축하기 위해 더 많은 것들.

파이썬 2 , 140,148, 144 바이트

t,h,n=map(str.split,input().replace(':','').split(';')),100,0
for a,v in t[:-1]:
 n+=int(v)
 if n%h/60:n=n/h*h+n%h%60+h
 if`n`>t[-1][0]:print a,

온라인으로 사용해보십시오!

입력 형식 :

'Kevin 13:02;Ruby 5;Sam 3;Lisa 6;Bob 12;13:15'

배시, 135 (124) 115 바이트

a=($1)
for i in `seq 3 2 ${#a[@]}`
do((v+=a[i]))
((`date -d${a[1]} +%s`+v*60>`date -d$2 +%s`))&&echo ${a[i-1]}
done

온라인으로 사용해보십시오!

CJam, 66 54 58 54 51 49 46 바이트

{{':/60b}:K~)rSrKs++q+S/2/z~:i[{1$+}*]2$+$@#>}

입력 1은 STDIN을 통해 제공되고 입력 2는 스택에서 문자열로 제공됩니다. 출력은 스택의 배열입니다. 입력 1의 구분 기호는 공백입니다 (예 :) Kevin 13:02 Ruby 5 Sam 3 Lisa 6 Bob 12.

스택 추적 :

         e# Stack:               | "13:15"
{        e# Define K and run it:
  ':/    e#   Split on colon:    | ["13" "15"]
  60b    e#   From base 60:      | 795
}:K~     e# End def
)        e# Increment:           | 796
r        e# Read token:          | 796 "Kevin"
S        e# Push space:          | 796 "Kevin" " "
r        e# Read another token:  | 796 "Kevin" " " "13:02"
K        e# K()                  | 796 "Kevin" " " 782
s        e# Convert to string:   | 796 "Kevin" " " "782"
++       e# Add together:        | 796 "Kevin 782"
q        e# Read rest of input:  | 796 "Kevin 782" " Ruby 5 Sam 3 Lisa 6 Bob 12"
+        e# Add together:        | 796 "Kevin 782 Ruby 5 Sam 3 Lisa 6 Bob 12"
S/       e# Split on spaces:     | 796 ["Kevin" "782" "Ruby" "5" "Sam" "3" "Lisa" "6" "Bob" "12"]
2/       e# Group by 2:          | 796 [["Kevin" "782"] ["Ruby" "5"] ["Sam" "3"] ["Lisa" "6"] ["Bob" "12"]]
z        e# Transpose:           | 796 [["Kevin" "Ruby" "Sam" "Lisa" "Bob"] ["782" "5" "3" "6" "12"]]
~        e# Unpack:              | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] ["782" "5" "3" "6" "12"]
:i       e# Convert all to int:  | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 5 3 6 12]
[{1$+}*] e# Accumulate:          | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 787 790 796 808]
2$       e# Copy back element:   | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 787 790 796 808] 796
+        e# Add into array:      | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 787 790 796 808 796]
$        e# Sort:                | 796 ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] [782 787 790 796 796 808]
#        e# Find index:          | ["Kevin" "Ruby" "Sam" "Lisa" "Bob"] 3
>        e# Slice:               | ["Lisa" "Bob"]

설명:

• 이 절차 K는 hh:mm자정 이후의 시간 (분)을 나타내는 시간 과 숫자 사이를 변환 합니다.
• 첫 번째 사람을 읽고 그들의 시간을 K (그들의 시간)로 바꿉니다. 그런 다음 이것을 입력 앞에 추가합니다.
• 그런 다음 이름 목록과 시간 목록을 얻기 위해 일부 문자열 연산을 수행합니다 [782 5 3 6 12].
• 이 목록을 누적하면 [782 787 790 796 808]모든 사람들이 왔던 시간을 얻을 수 있습니다.
• 누가 늦었는지 찾는 가장 짧은 방법은 시작 시간을 배열에 삽입 한 다음 다시 정렬하여 원래 위치에 놓는 것입니다. 그런 다음 인덱스를 찾아서 위치를 파악한 다음 해당 인덱스에서 이름 목록을 슬라이스합니다.

자바 스크립트, 285 283 바이트

카레 구문 으로 손님 목록 i과 파티 시간 p을 가져옵니다 (i)(p). 쉼표로 구분 된 이름 목록 (예 :)을 반환합니다 Lisa,Bob.

i=>p=>{n=i.split`
`,a=new Date(0,0,0,...n[0].split` `[1].split`:`),y=new Date(0,0,0,...p.split`:`),t=[a];w=a;n.slice(1).map((j,k,l)=>{h=l[k].split` `[1]*6e4;t.push(new Date(w.getTime()+h));w=new Date(w.getTime()+h)});return n.filter((j,k,l)=>t[k]>y).map(j=>j.split` `[0]).join()}

나는 그것이 꽤 길고 현재 마지막에 상당히 여유가 있다는 것을 알고 있지만 그것이 내가 생각해 낼 수있는 것입니다.

f=i=>p=>{n=i.split`
`,a=new Date(0,0,0,...n[0].split` `[1].split`:`),y=new Date(0,0,0,...p.split`:`),t=[a];w=a;n.slice(1).map((j,k,l)=>{h=l[k].split` `[1]*6e4;t.push(new Date(w.getTime()+h));w=new Date(w.getTime()+h)});return n.filter((j,k,l)=>t[k]>y).map(j=>j.split` `[0]).join()}

console.log(f(`Kevin 13:02
Ruby 5
Sam 3
Lisa 6
Bob 12
`)('13:15'))

C # , 269 267 바이트

골프

(l,t)=>{var h=System.DateTime.MinValue;var s=System.DateTime.ParseExact(t,"HH:mm",null);var o="";foreach(var p in l.Split('\n')){var i=p.Split(' ');h=h.Ticks<1?System.DateTime.ParseExact(i[1],"HH:mm",null):h.AddMinutes(int.Parse(i[1]));if(h>s)o+=i[0]+" ";}return o;};

언 골프

( l, t ) => {
   var h = System.DateTime.MinValue;
   var s = System.DateTime.ParseExact( t, "HH:mm", null );
   var o = "";

   foreach( var p in l.Split( '\n' ) ) {
      var i = p.Split( ' ' );

      h = h.Ticks < 1
         ? System.DateTime.ParseExact( i[ 1 ], "HH:mm", null )
         : h.AddMinutes( int.Parse( i[ 1 ] ) );

      if( h > s )
         o += i[ 0 ] + " ";
   }

   return o;
};

언 골프 가능

( l, t ) => {
   // var to check the time of arrival
   var h = System.DateTime.MinValue;

   // var to store the start time of the party
   var s = System.DateTime.ParseExact( t, "HH:mm", null );

   // var with the names of those who arrived late
   var o = "";

   // Cycle through which line
   foreach( var p in l.Split( '\n' ) ) {
      // Split the name and time
      var i = p.Split( ' ' );

      // Check if the time of arrival still has the initial value
      h = h.Ticks < 1

         // If so, grab the time of the first person
         //   Expects to have a time format of 'hh:mm'
         ? System.DateTime.ParseExact( i[ 1 ], "HH:mm", null )

         // Otherwise, add the difference to the var
         : h.AddMinutes( int.Parse( i[ 1 ] ) );

      // Check if the current time is later than the party start time
      if( h > s )

         // If so, add the name to the list
         o += i[ 0 ] + " ";
   }

   // Return the names of the persons who arrived late
   return o;
};

전체 코드

using System;
using System.Collections.Generic;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, String, String> f = ( l, t ) => {
            var h = System.DateTime.MinValue;
            var s = System.DateTime.ParseExact( t, "HH:mm", null );
            var o = "";

            foreach( var p in l.Split( '\n' ) ) {
               var i = p.Split( ' ' );

               h = h.Ticks < 1
                  ? System.DateTime.ParseExact( i[ 1 ], "HH:mm", null )
                  : h.AddMinutes( int.Parse( i[ 1 ] ) );

               if( h > s )
                  o += i[ 0 ] + " ";
            }

            return o;
         };

         List<KeyValuePair<String, String>>
            testCases = new List<KeyValuePair<String, String>> {
               new KeyValuePair<String, String>(
                  "Kevin 13:02\nRuby 5\nSam 3\nLisa 6\nBob 12",
                  "13:15"
               ),
               new KeyValuePair<String, String>(
                  "Kevin 13:15\nRuby 5\nSam 3\nLisa 6\nBob 12",
                  "13:15"
               ),
            };

         foreach( KeyValuePair<String, String> testCase in testCases ) {
            Console.WriteLine( $" Input:\n{testCase.Key}\n\n{testCase.Value}\n\nOutput:\n{f( testCase.Key, testCase.Value )}\n" );
         }

         Console.ReadLine();
      }
   }
}

자료

• v1.1 -- VisualMelon- 2 bytes 덕분에
• V1.0 - 269 bytes- 초기 솔루션입니다.

노트

• 출력 형식 : 공백으로 구분 된 이름을 출력합니다.

CJam , 43 41 바이트

q~':/60b:Y;Sf/()':/60b+a\+{)iT+:TY>{;}|}%

온라인으로 사용해보십시오!

설명

q~        e# Read and eval all input.

':/       e# Split the start time on colons.
60b       e# Convert the result from base 60, to get the start time in minutes.
:Y;       e# Store this time in variable Y, and discard it from the stack.

Sf/       e# Split each string in the guest list on spaces.
(         e# Pull out the first guest from the list.
)         e# Pull out the time from the guest.
':/60b+   e# Convert the time to a number of minutes (same way as before), then add it back
          e#   to the guest.
a\+       e# Add the guest back to the start of the guest list.

          e# At this point, the first guest has his/her arrival time in minutes, and everyone
          e#  else still has their original number.

{         e# Apply this block to each guest:
 )i       e#  Pull out the number and cast it to an integer.
 T+       e#  Add the value of variable T to it (T is initially 0).
 :T       e#  Store the result back into T.
 Y>{;}|   e#  If the resulting number of minutes is not after the start time, delete the 
          e#    guest's name.
}%        e# (end of block)

          e# Implicit output.

루아, 211206 바이트

나를위한 첫 번째 코드 골프는 여전히 골프를 즐길 수 있어야합니다.

편집 : 단축을 사용하여 5 바이트를 절약했습니다. string.match

function f(l,T)m=T.match
r=function(X)return
m(X,"^%d+")*3600+60*m(X,"%d+$")end
T=r(T)z={}y=0
for i=1,#l do
h=m(l[i],"%d.*")h=i>1 and y+h*60or r(h)y=h
z[#z+1]=h>T and m(l[i],"%u%l*")or nil
end return z end

설명

function f(l,T)                         -- declare the function f(list,partyTime)
  r=function(X)                         -- declare a function r that convert hh:mm in seconds
    return X:match("^%d+")*3600         -- return the sum of seconds the hours
          +60*X:match("%d+$")           -- and in the seconds
  end                                   
  T=r(T)                                -- convert the partyTime in seconds
  z={}                                  -- create the shameList for late partygoers
  y=0                                   -- y will keep us updated on the second count
  for i=1,#l                            -- iterate over l
  do                                    
    h=l[i]:match("%d.*")                -- h is a shorthand for the time of arrival
    h=i>1                               -- if we're on the second line at least
        and y+h*60                      -- update h with the time of arrival in second
      or r(h)                           -- else use r()(for the first partygoer only)
    y=h                                 -- update our reference for adding time
    z[#z+1]=h>T                         -- if the last partygoer was late
                and l[i]:match("%u%l*") -- add its name to the shameList
              or nil                    -- else, don't do anything
  end                                   
  return z                              -- return the shameList
end                                 

이 코드를 사용하려면 다음 스 니펫을 사용할 수 있습니다

function f(l,T)r=function(X)return
X:match("^%d+")*3600+60*X:match("%d+$")end
T=r(T)z={}y=0
for i=1,#l do
h=l[i]:match("%d.*")h=i>1 and y+h*60or r(h)y=h
z[#z+1]=h>T and l[i]:match("%u%l*")or nil
end return z end

retour = f({"Kevin 13:02","Ruby 5","Sam 3","Lisa 6","Bob 12"},"13:15")
for i=1,#retour
do
  print(retour[i])
end

자바, 346 304 284 275 바이트

• @KevinCruijssen 덕분에 -9 바이트

void g(int m,String[]n,String[]a,int M){for(int i=0;i<n.length;i++)if((M+=i>0?p(a[i]):0)>m)System.out.print(n[i]);}
int p(String n){return new Short(n);}
int h(String t){return p(t.split(":")[0])*60+p(t.split(":")[1]);}
void f(String[]n,String[]a,String b){g(h(b),n,a,h(a[0]));}

자세한 라이브

public static void g(int m, String[] n, String[] a, int M)
{
    for(int i = 0; i < n.length; i++)
    {
        if((M += i>0 ? p(a[i]) : 0) > m)
        {
            System.out.println(n[i]);
        }
    } 
}

public static int p(String n)
{
    return Integer.parseInt(n);
}

public static int h(String t)
{
    return p(t.split(":")[0])*60+p(t.split(":")[1]);
}

public static void f(String[] n, String[] a, String b)
{
    g(h(b),n,a,h(a[0]));
}

배치, 163 바이트

@set/pp=
@set/ap=%p::=*60+%
:l
@set g=
@set/pg=
@if "%g%"=="" exit/b
@set t=%g:* =%
@set/ap-=%t::=*60+%
@for %%g in (%g%)do @(if %p% lss 0 echo %%g)&goto l

STDIN에서 입력을받습니다. 첫 번째 줄은 파티 시작 시간과 손님 목록입니다. @Arnauld의 트릭을 사용하여 hh : mm을 분으로 변환합니다.

이에 대한 배치의 선호되는 입력은 일련의 명령 행 매개 변수 (당의 시간으로 시작한 다음 각 손님과 시간을 별도의 인수로)입니다. 이 작업에는 129 바이트 만 걸립니다.

@set p=%1
@set/ap=%p::=*60+%
:l
@set t=%3
@set/ap-=%t::=*60+%
@if %p% lss 0 echo %2
@shift
@shift
@if not "%2"=="" goto l

그루비, 121 바이트

{g,t->y={Date.parse('hh:mm',it)};u=y(t);d=y(g.remove(0)[1]);g.find{z=it[1];use(groovy.time.TimeCategory){d+z.minutes}>u}}

PowerShell, 170160 바이트

select-string '(?m)^((\w*) )?((\d\d):)?(\d?\d)$'-a|% matches|%{,$_.groups[2,4,5].value}|%{}{$b+=($c=60*$_[1]+$_[2]);$a+=,@{n=$_[0];t=$b}}{$a|? n|? t -gt $c|% n}

온라인으로 사용해보십시오!