12

आपके प्रोग्राम / फंक्शन आदि में 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

लिसा और बॉब के बाद पहुंचे 13:15, इसलिए इस कार्यक्रम को "लिसा, बॉब" प्रिंट करना चाहिए।

इनपुट मान्यताओं

इनपुट 1 हमेशा एक नाम (रेगेक्स [A-Z][a-z]*) होगा, फिर एक स्थान, फिर hours:minutesपहली पंक्ति पर फॉर्म में 24 घंटे का समय , फिर एक नाम, एक स्थान और एक सकारात्मक पूर्णांक (बाद में मिनटों की संख्या) अगली पंक्तियों पर। । हमेशा कम से कम 1 लाइन होगी।
यदि आप चाहें, तो आप लाइन ब्रेक के बजाय किसी अन्य वर्ण के साथ इनपुट 1 ले सकते हैं।
इनपुट 2 प्रारूप में होगा hours:minutes।
यदि आप चाहें तो अपने इनपुट को किसी भी वर्ण द्वारा अलग किए गए स्ट्रिंग के रूप में ले सकते हैं। यह वैकल्पिक है।
दिन क्रॉसओवर के बारे में चिंता मत करो। मेरी पार्टियों के बाद कभी नहीं 23:59।

आउटपुट नियम

आउटपुट एक फ़ंक्शन रिटर्न वैल्यू या एक स्ट्रिंग हो सकती है, जो STDIN, एक फ़ाइल आदि के लिए गूँजती है। आपको एक स्ट्रिंग या एक सरणी / सूची वापस करनी होगी।
- यदि आप एक स्ट्रिंग लौटाते हैं, तो यह प्रत्येक व्यक्ति को होना चाहिए जो देर से था (आदेश कोई फर्क नहीं पड़ता), किसी भी गैर-अल्फ़ान्यूमेरिक सीमांकक द्वारा अलग किया गया।
- यदि आप किसी सरणी / सूची को वापस करते हैं, तो यह उन सभी की सूची होनी चाहिए जो देर से आए थे।

code-golf date

— programmer5000
स्रोत

2

क्या सख्त इनपुट प्रारूप आवश्यक है? उदाहरण के लिए, पहला इनपुट सूचियों की एक सूची हो सकती है, जिनमें से प्रत्येक में दो डेटा आइटम वाली "लाइन" हो सकती है?

— जोनाथन एलन

"इनपुट 1 हमेशा एक नाम होगा (regex [A-Z][a-z]*)" क्या इससे यह पता चलता है कि नाम खाली हो सकते हैं?

— हाइपरनेत्रिनो

2

मुझे लगता है कि आपका मतलब था "हाँ सख्त इनपुट प्रारूप आवश्यक है"।

— जोनाथन एलन

2

सख्त इनपुट प्रारूप इस चुनौती को कम दिलचस्प बनाता है

— लुइस मेंडो

3

"मेरी पार्टियां 11:59 के बाद कभी नहीं।" क्या आपका मतलब है 23:59?

— tsh

3

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

— लुइस मेंडो
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 98 97 बाइट्स

नील को धन्यवाद देकर 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'))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

चतुर समाधान! +1। मेरा रास्ता बहुत दूर है ....... :(

— अर्जुन

(.*) (.*)\nकाम नहीं करता है?

— नील

@ नील डिफ़ॉल्ट रूप से लालची होने के कारण, पहली (.*)पूरी रेखा से मेल खाते थे।

— अरनौलड

फिर स्पेस मैच क्या होगा?

— नील

@ नील ओह, माफ करना, तुम सही हो।

— अरनौलड

6

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

— टाइटस
स्रोत

6

सी, 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;}

इसे ऑनलाइन आज़माएं

— जोहान डू टिट
स्रोत

5

जावास्क्रिप्ट ईएस 6, 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'))

स्निपेट का विस्तार करें

— powelles
स्रोत

जहां तक मैं कल्पना से बता सकता हूं कि इनपुट फॉर्म अधिक सख्त हो सकता है।

— जोनाथन एलन

मुझे लगता है कि अब यह सही है।

— पोवल्स

हां - मैंने इनपुट सख्ती के बारे में भी पूछा है।

— जोनाथन एलन

... वास्तव में आपके पास आपके इनपुट में समय है, न कि यह होना चाहिएf('Kevin 13:02\nRuby 5\nSam 3...

— जोनाथन एलन

1

@JonathanAllan धन्यवाद इसे अब पा लिया है।

— 20

4

पॉवरशेल , 215 196 180 बाइट्स

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 / 3rd इनपुट पार्सिंग है, इसलिए मुझे यकीन नहीं है कि मैं इसे कितना आगे बढ़ा सकता हूं।

$aनाम और समय / मिनट के अल्पविराम-सीमांकित स्ट्रिंग के रूप में इनपुट लेता है , और एक स्ट्रिंग के $bरूप hh:mmमें। पहले, हम -split $aपर ,, पहले परिणाम को $xऔर शेष में स्टोर करते हैं $a, एक स्पष्ट री-कास्ट के $aसाथ एक array(ताकि बाद में लूप ठीक से हो)। हम अपने hashtable प्रारंभ $z, सेट $iऔर $jहोने के लिए $x -splitखाली स्थान के पर, और सेट $z[$i]होने के लिए dateकी $j(में संग्रहीत $yबाद में उपयोग के लिए)।

फिर हम शेष के माध्यम से लूप करते हैं $a। प्रत्येक पुनरावृत्ति, हम ऐसा ही करते हैं - -splitव्हाट्सएप पर स्ट्रिंग, उपयुक्त $zसूचकांक को निर्धारित करें कि हम अभी जहां पर हैं, उससे कई गुना अधिक परे। यह कुछ बाइट्स को बचाने के लिए शॉर्ट प्रॉपर्टी नेम ट्रिक का उपयोग करता है , |% *es $jइसके बजाय .AddMinutes($j)।

अंत में, हम .GetEnumerator()हमारे hashtable की (फिर से चाल का उपयोग कर), और Where-Objectएक साथ उन प्रविष्टियों का चयन valueहै कि -greater tहान $b(यानी, वे पार्टी के लिए देर हो गई)। हम तो बस उसके बाद का चयन करें .Name। आउटपुट एक निहित सरणी के रूप में होता है, जो डिफ़ॉल्ट के Write-Outputबीच newlines सम्मिलित करता है।

मुझे याद दिलाने के लिए रिश्वतखोर का धन्यवाद करने के लिए एक गुच्छा बचा लिया [सरणी] एक बात है। और छोटी संपत्ति नाम टिप के लिए एक गुच्छा अधिक।

— AdmBorkBork
स्रोत

मैं मानता हूँ कि मैंने इस का न्यूनतम पढ़ना और परीक्षण किया है, लेकिन क्या$x,[array]$a=$a-split',' आप ऐसा नहीं कर सकते ?

— ब्रेंटिस्ट

1

@briantist हां, धन्यवाद। मैं कई-असाइनमेंट में कॉमा-ऑपरेटर का उपयोग करने का एक तरीका खोजने की कोशिश करता रहा, और यह सिर्फ काम नहीं कर रहा था। मैं पूरी तरह से भूल गया था कि [array]एक वैध कास्ट है। Haha। बहुत अधिक गोल्फिंग, मुझे लगता है।

— AdmBorkBork

मैं मोबाइल पर हूँ तो बाहर परीक्षण करना मुश्किल होगा लेकिन मुझे लगता है GetEnumeratorऔर AddMinutesके लिए अच्छा उम्मीदवार हैं %विधि वाक्य रचना

— briantist

@ रिश्वतखोर हां। एक और 16 बचाता है। धन्यवाद!

— AdmBorkBork

4

पायथन 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'

— कीर्तन प्रभाकरं
स्रोत

मिनट ओवरफ्लो को सही ढंग से हैंडल नहीं करता है: 'Kevin 13:47;Ruby 5;Sam 3;Lisa 6;Bob 12;14:00'कुछ भी नहीं छापता है, भले ही लिसा और बॉब को अभी भी देर हो चुकी है।

— L3viathan

1

अरे हां। एक गड़बड़ थी! ठीक कर दिया। धन्यवाद!

— कीर्तन प्रभाकरन

3

बैश, 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

इसे ऑनलाइन आज़माएं!

— betseg
स्रोत

3

CJam, 66 54 58 54 51 49 46 बाइट्स

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

इनपुट 1 एसटीडीआईएन के माध्यम से दिया जाता है, इनपुट 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], जो हर किसी को आया समय देता है।
सबसे कम तरीका यह है कि देर से आने वाले व्यक्ति को शुरुआत के समय को सरणी में सम्मिलित करना है और फिर इसे उस स्थान पर रखने के लिए फिर से सॉर्ट करना है जहां यह होना चाहिए। हम तब यह पता लगाने के लिए सूचकांक प्राप्त करते हैं कि यह कहां है, और फिर उस सूचकांक से नामों की सूची को स्लाइस करें।

— फल तोड़ना
स्रोत

2

जावास्क्रिप्ट, 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'))

स्निपेट का विस्तार करें

— अर्जुन
स्रोत

2

सी # , 269 267 बाइट्स

golfed

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

Ungolfed

( 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 - - 2 bytes- VisualMelon के लिए धन्यवाद
v1.0 - 269 bytes- प्रारंभिक समाधान।

आप एक using D=System.DateTime;निर्देश जोड़कर कुछ बाइट्स बचा सकते हैं ( varएस को बदलने के लिए मत भूलना !)। इस कोड को पूरी तरह से अस्पष्ट (यानी (string l,string f)) बनाने के लिए आपको लैम्बडा मापदंडों के प्रकार प्रदान करने चाहिए । मुझे भी लगता है कि एक मामूली बग है, आपको "(किसी भी समय बचत ठीक है) के अनुसार (1byte बचत!) की h>sबजाय जरूरत h>=sहै।" क्या आप कर सकते हैं h.Ticks<1? आपको DateTimeउपयोग करने की तुलना में एक नीरस सस्ता मिल सकता है DateTime.Min, लेकिन मैंने यहां पूर्ण प्रभाव की जांच नहीं की है। उपयोग किए गए क्लॉज के साथ, ==D.Minयह भी काम करना चाहिए।

— विज़ुअलमेल

उपयोग करने के बारे में मुझे संदेह है कि मैं अभी भी इसके साथ एक लंबोदर अभिव्यक्ति खींच सकता हूं। मुझे पूरा यकीन है कि मैं इसे मिड-कोड में नहीं जोड़ सकता । स्पष्ट लंबोदर प्रकार एक और चीज है जिसे मैंने लोगों को करते हुए नहीं देखा है, और मैं इसके साथ गया - अगर यह अवैध है , तो ऐसा कहें, लेकिन यहां तक कि मॉड्स ने भी कुछ नहीं कहा है, शायद यह ठीक है। h>sमैं वह करूंगा। h.Ticks<1और यह एक भी।

— औहामन

मुझे विश्वास है कि हम अनुमति देते हैं usingsऔर ऐसे लंबोदर के साथ, मुझे मेटा पर स्पष्ट रूप से यह कहते हुए कुछ भी नहीं मिल रहा है, लेकिन यह प्रश्न दृढ़ता से यह अनुमति देता है। नहीं है एक उचित आम सहमति है कि स्पष्ट पैरामीटर प्रकार आवश्यक होना चाहिए (मैं जोड़ने चाहिए कि मैं पक्ष में मजबूती से कर रहा हूँ)। द्वारा, मोड एसई के दृष्टिकोण से नागरिक को रखने के लिए हैं, पीपीसीजी के अपने नियमों को लागू करने के लिए नहीं।

— विजुअलमेलन

मैं इसके प्रति दयालु हूं usings, ज्यादातर इसलिए क्योंकि मुझे लगता है कि इसके लिए एक पूर्ण कोड की आवश्यकता होगी, इसलिए मुझे यह कहते हुए कि मुझे संदेह है कि मैं एक फ़ंक्शन को समाधान के रूप में खींच सकता हूं - शायद दो ब्लॉक जोड़ रहा हूं, एक usingएस के लिए और दूसरा दूसरे के लिए। भेड़ का बच्चा समारोह? सर्वसम्मति के बारे में, मुझे लगता है कि लापता Func<...> f = ...;को जोड़ने से इसका समाधान हो जाएगा, हालांकि इसे पूरा नाम निर्दिष्ट करना चाहिएSystem.Func<...> f = ...;

— auhmaan

string sयदि आप नामांकित लैंबडैस और usings नहीं मिलाते हैं, तो आप केवल एक अच्छी तरह से नामित फ़ंक्शन (केवल C # 7 (6 मुझे याद नहीं है) सिंटैक्स के साथ कहते हैं ) बेहतर हो सकते हैं।

— विजुअलमेल

2

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.

— बिजनेस कैट
स्रोत

2

लुआ, 211 206 बाइट्स

मेरे लिए वर्ष का पहला कोडगोल्फ, अभी भी गोल्फ होना चाहिए।

संपादित करें: के लिए एक आशुलिपि का उपयोग करके सहेजे गए 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

— Katenkyo
स्रोत

2

जावा, 346 304 284 275 बाइट्स

-9 बाइट्स, @KevinCruijssen को धन्यवाद

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

— Khaled.K
स्रोत

1

अच्छा गोल्फ (जावा के लिए।) क्या आपको String[] n,और के बीच की जगह की आवश्यकता है String[] a?

— प्रोग्रामर

@ प्रोग्रामर 5000 नहीं, मैंने भी घंटों चर को हटा दिया और उन्हें मिनटों के रूप में संचित किया।

— खालिद.के।

1

आप बदल सकते हैं Integer.parseInt(n)के साथ new Short(n)। और चुनौती की टिप्पणी के आधार पर, LisaBobयह भी एक वैध उत्पादन है, तो आप बदल सकते हैं printlnकरने के लिए print।

— केविन क्रूज़सेन

1

बैच, 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 पर इनपुट लेता है। पहली पंक्ति पार्टी का शुरुआती समय है, फिर मेहमानों की सूची। Hh: mm को मिनटों में बदलने के लिए @ Arnauld की ट्रिक का उपयोग करता है।

इसके लिए बैच का पसंदीदा इनपुट कमांड-लाइन मापदंडों की एक श्रृंखला के रूप में होगा (पार्टी के समय से शुरू होता है, फिर प्रत्येक अतिथि और अलग-अलग तर्क के रूप में समय)। यह केवल 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

— नील
स्रोत

1

ग्रूवी, 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}}

— जादू ऑक्टोपस Urn
स्रोत

1

पॉवरशेल, 170 160 बाइट्स

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}

इसे ऑनलाइन आज़माएं!

— आंद्रेई ओडेगो
स्रोत

देर आए दुरुस्त आए!

— प्रोग्रामर

मैं आज आराम कर रहा हूं इसलिए थोड़े समय के लिए कुछ मजा लेना है

— आंद्रेई ओडेगो

देर आए दुरुस्त आए!

इनपुट मान्यताओं

आउटपुट नियम

MATL , 31 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 98 97 बाइट्स

प्रारूपित और टिप्पणी की गई

डेमो

PHP, 118 98 95 91 बाइट्स

सी, 178 बाइट्स

जावास्क्रिप्ट ईएस 6, 185 बाइट्स

इसे ऑनलाइन आज़माएं!

पॉवरशेल , 215 196 180 बाइट्स

पायथन 2 , 140,148, 144 बाइट्स

बैश, 135 124 115 बाइट्स

CJam, 66 54 58 54 51 49 46 बाइट्स

स्टैक ट्रेस:

जावास्क्रिप्ट, 285 283 बाइट्स

सी # , 269 267 बाइट्स

golfed

Ungolfed

अनपढ़ पठनीय

पूर्ण कोड

विज्ञप्ति

टिप्पणियाँ

CJam , 43 41 बाइट्स

लुआ, 211 206 बाइट्स

स्पष्टीकरण

जावा, 346 304 284 275 बाइट्स

बैच, 163 बाइट्स

ग्रूवी, 121 बाइट्स

पॉवरशेल, 170 160 बाइट्स