राष्ट्रीय निर्धारण संघर्ष चैंपियनशिप

Question

(मैं इसे 1542 तक पोस्ट करने का मतलब था : शेड्यूलिंग संघर्ष अभी भी वर्तमान xkcd था, लेकिन मेरे पास शेड्यूलिंग संघर्ष था।)

इनपुट

इनपुट 3nतत्वों की एक सूची होगी , जो nघटनाओं का प्रतिनिधित्व करती है। 3 के प्रत्येक समूह में पहला तत्व एक घटना का नाम होगा; दूसरा और तीसरा, क्रमशः आरंभ और अंत का समय। उदाहरण के लिए:

foo 12 34 bar 56 78

एक घटना का प्रतिनिधित्व करता है जो foo"समय 12" पर शुरू होता है (समय केवल पूर्णांकों द्वारा दर्शाया जाता है; आप उन्हें आधी रात के रूप में सोच सकते हैं) और 34 पर समाप्त होता है, और एक दूसरी घटना barजो 56 से शुरू होती है और 78 पर समाप्त होती है।

घटनाओं के नाम में हमेशा केवल अल्फ़ान्यूमेरिक वर्ण शामिल होंगे, और समय हमेशा पूर्णांक and 0 और <1440 होगा। अंत समय हमेशा प्रारंभ समय की तुलना में कम से कम 1 अधिक होगा। उन्हें किसी भी तरह से छांटने की गारंटी नहीं है।

यदि आप चाहें, तो आप इसे एकल अंतरिक्ष-पृथक स्ट्रिंग के रूप में ले सकते हैं; अन्यथा इसे एक सरणी, सूची, वेक्टर, या आपकी भाषा के समकक्ष के रूप में लिया जाना चाहिए।

उत्पादन

आउटपुट इवेंट नामों की एक अलग-अलग-अलग सूची होनी चाहिए। जिन आयोजनों के नाम आउटपुट के लिए नियम हैं, वे इस प्रकार हैं:

• आपके द्वारा आउटपुट की जाने वाली कोई भी घटना एक-दूसरे के साथ संघर्ष नहीं कर सकती है। उदाहरण के लिए, इनपुट के साथ a 0 10 b 5 15, आप दोनों आउटपुट नहीं कर सकते हैं aऔर bक्योंकि समय संघर्ष (जो कि आंशिक रूप से ओवरलैप है)। यदि कोई घटना ठीक उसी तरह समाप्त होती है जैसे कोई दूसरा शुरू होता है, तो आप दोनों को शामिल कर सकते हैं।

• आप NSCC"राष्ट्रीय निर्धारण संघर्ष प्रतियोगिता" नामक घटना का उत्पादन नहीं कर सकते हैं , जिनमें से इनपुट में हमेशा एक ही होगा । आपको कम से कम एक घटना का उत्पादन करना होगा जो (आंशिक रूप से ओवरलैप्स) का सामना करता है NSCC(और हमेशा कम से कम उन लोगों में से एक होगा)।

• उपरोक्त दो नियमों का पालन करते हुए आपको अधिक से अधिक घटनाओं का उत्पादन करना चाहिए। (यह इतना है कि आप जितना संभव हो उतना व्यस्त दिखें, ताकि एनएससीसी को गायब करना अधिक विश्वसनीय लगता है।)

यह एकल स्पेस-पृथक स्ट्रिंग या सरणी, सूची, वेक्टर आदि के रूप में भी आउटपुट हो सकता है।

एक से अधिक संभावित आउटपुट हो सकते हैं।

परीक्षण के मामलों

ध्यान दें कि सूचीबद्ध आउटपुट केवल उदाहरण हैं। आपका कोड कुछ अलग उत्पादन कर सकता है, जब तक कि यह अभी भी ऊपर के तीन नियमों का पालन करता है (विशेष रूप से, इसका मतलब है कि उदाहरण के रूप में घटनाओं की समान मात्रा होनी चाहिए )।

में: UnderwaterBasketWeavingConvention 50 800 NSCC 500 550
बाहर:UnderwaterBasketWeavingConvention

में: SconeEating 0 50 RegexSubbing 45 110 CodeGolfing 95 105 NSCC 100 200
बाहर:SconeEating CodeGolfing

में: VelociraptorHunting 0 300 NerdSniping 200 500 SEChatting 400 700 DoorknobTurning 650 750 NSCC 725 775
बाहर:NerdSniping DoorknobTurning

में: NSCC 110 115 A 100 120 B 120 140 C 105 135 D 100 105 E 135 500
बाहर:C D E

में: A 800 900 NSCC 700 1000 B 650 750 C 950 1050 D 655 660 E 660 665 F 1030 1040 G 1040 1060
बाहर:A D E F G

में: A 10 11 B 11 12 C 12 13 D 13 14 NSCC 15 1090 E 10 16
बाहर:E

अगर मुझे याद किए गए किनारे-मामले हैं, तो एक संपादन में अधिक परीक्षण मामलों को जोड़ने के लिए स्वतंत्र महसूस करें।

नियम

• आपके कोड को सभी उपलब्ध परीक्षण मामलों के लिए 30 सेकंड के भीतर पूरा करना होगा (यह एक विवेक जांच का अधिक है, क्योंकि यह उचित व्यक्तिगत मशीन पर संयुक्त रूप से सभी परीक्षण मामलों के लिए बहुत तेजी से पूरा होना चाहिए)।

• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

Comments

क्या इनपुट्स में घटनाओं के लिए कैमलकेस का उपयोग करना स्वीकार्य है? उदाहरण के लिए underwaterBasketWeavingConvention 50 800 nscc 550अपने उदाहरण के बजाय का उपयोग कर ?

— घातक

@ जानिए कि आपको क्या मतलब है; जैसा दिखाया गया है वैसा ही इनपुट दिया गया है। आपको अल्फ़ान्यूमेरिक वर्णों के किसी भी संयोजन का समर्थन करने में सक्षम होना चाहिए।

— दरवाज़े

मुझे बाद में इसके समाधान पर काम करना होगा; मेरा अभी एक समयबद्धन संघर्ष है।

— एलेक्स ए।

दूसरे उदाहरण में "कोडगॉल्फिंग" और "95" के बीच दो स्थान हैं - क्या यह एक गलती है, या क्या हमें इनपुट में रिक्त स्थान की मनमानी संख्या के लिए खाते की आवश्यकता है? अभी के लिए, मैं पूर्व को मानने जा रहा हूँ, क्योंकि आप इनपुट के प्रारूप पर थोड़े उदार हैं।

— विज्रोक्स

@ वीजयराममूर्ति हां, यह है। फिक्स्ड।

— दरवाज़े

Answer 1

पायथ, 45 बाइट्स

AGH.gqhk"NSCC"m,hdrFtdcQ3hMef&.{KseMT@KehHtyG

यह एक गोल्फ के लिए काफी कठिन था। काफी 45 बाइट समाधान पाए गए, यह संभवतः सबसे अधिक विदेशी है, क्योंकि यह A(जोड़ी-असाइन) और .g(समूह-द्वारा) का उपयोग करता है।

इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट हार्नेस

व्याख्या

                            implicit: Q = input list
                      cQ3   split Q into triples
              m             map each triple d to:
               ,              the pair containing
                hd              - d[0] (name)
                  rFtd          - range from start-time to end-time
   .g                       group these tuples k by:
     qhk"NSCC"                k[0] == "NSCC"
AGH                         pair assign to G,H. This assigns all
                            tuples != NSCC to G, and the NSCC one to H

                  yG        generate all subsets of G
                 t          remove the first one (the empty subset)
   f                        filter for subsets T, which satisfy:
         eMT                  get the last item (the range) for all tuples in T
        s                     and combine them (sum)
       K                      assign to K
     .{                       check for uniqueness of K (no overlapping times)
    &                         and
            @KehH             check the intersection of K and H[0][1]
  e                         take the last element (most events)
hM                          get the first item (name) for each event
                            and implicitly print this list

Answer 2

एसडब्ल्यूआई-प्रोलॉग, 537 524 516 502 447 436 बाइट्स

z(A:B:C,[D:E:F|G]):-(A=D;B>=F;E>=C),(G=[];z(A:B:C,G)).
u([A|B],C):-z(A,C),(B=[];u(B,C)).
y([A,B,C|D])-->[A:B:C],(y(D);{_=_}).
d-->[A:_],{write(A),tab(1)},d;{_=_}.
l([H|T],R):-T=[],R=H;length(H,N),l(T,X),length(X,M),(N>M,R=H;R=X).
v([],_,R,R).
v([A|T],Z,B,R):-u(A,A),\+z(Z,A),v(T,Z,[A|B],R);v(T,Z,B,R).
s([E|T],[F|N]):-E=F,(N=[];s(T,N));s(T,[F|N]).
x(A):-y(A,D,[]),K="NSCC":_,select(K,D,E),setof(L,s(E,L),B),v(B,K,[],R),l(R,S),d(S,[]),!.

प्रत्येक विधेय क्या करता है इसका संक्षिप्त विवरण:

• z(A,B) जाँचता है कि एक घटना A, B की सूची की किसी भी घटना के साथ संघर्ष नहीं करती है
• u(A,B)जाँच करता है कि किसी सूची A की प्रत्येक घटना B की किसी भी घटना के साथ संघर्ष नहीं करती है (यह जाँचने के लिए कि कॉल करके A सूची में कोई विरोध नहीं है u(A,A))
• y(A,B,C) एक सूची को तीन प्रतियों की सूची में विभाजित करता है (इनपुट को घटनाओं की सूची में बदलने के लिए)
• d(A) एक सूची A में घटनाओं के नाम प्रिंट करता है
• l(A,R) सूची ए की सूची में निहित घटनाओं की सबसे लंबी सूची का मूल्यांकन करता है
• v(A,NSCC,C,R) एक सूची R को उन घटनाओं की प्रत्येक सूची से युक्त करता है जिनमें कोई आंतरिक संघर्ष नहीं है और वह घटना NSCC के साथ है
• s(A,B) सच है अगर B, A का सबसेट है
• x(A) मुख्य विधेय, ए इनपुट है।

परीक्षण के मामले : test.इसके बाद के संस्करण के साथ कोड को लोड करने के बाद दुभाषिया में निष्पादित करें :

test:-
    x(["UnderwaterBasketWeavingConvention",50,800,"NSCC",500,550]),
    nl,
    x(["SconeEating",0,50,"RegexSubbing",45,110,"CodeGolfing",95,105,"NSCC",100,200]),
    nl,
    x(["VelociraptorHunting",0,300,"NerdSniping",200,500,"SEChatting",400,700,"DoorknobTurning",650,750,"NSCC",725,775]),
    nl,
    x(["NSCC",110,115,"A",100,120,"B",120,140,"C",105,135,"D",100,105,"E",135,500]),
    nl,
    x(["A",800,900,"NSCC",700,1000,"B",650,750,"C",950,1050,"D",655,660,"E",660,665,"F",1030,1040,"G",1040,1060]),
    nl,
    x(["A",10,11,"B",11,12,"C",12,13,"D",13,14,"NSCC",15,1090,"E",10,16]).

इससे मुझे जितना समय लगा उससे अधिक समय लगा। यह शायद काफी अधिक गोल्फ हो सकता है। इसके अलावा, आप शायद विभिन्न बाधा प्रोग्रामिंग पुस्तकालयों का उपयोग कर सकते हैं जो छोटे समाधान प्राप्त करने के लिए मौजूद हैं।

संपादित करें: तीनों के A:B:Cबजाय उपयोग करने के विचार के लिए @Oliphaunt का धन्यवाद [A,B,C]। 14 बाइट बचाता है।

Edit2: फिर से @Oliphaunt को इंगित करने के लिए धन्यवाद कि विधेय `` t / 3`w बेकार। 55 बाइट बचाता है

Edit3: 11 बाइट्स की भविष्यवाणी करता है जो कि विधेय पर निश्चित खंड व्याकरण का उपयोग करता है yऔर d।

Comments

प्रोलॉग में प्यार के जवाब! अच्छा है।

— 18:27 पर

मैं एक प्रोलॉग प्रेमी भी हूं। सुझाव: 1. मुझे लगता है कि आप तीन बाइट्स के A/B/Cबजाय उदाहरण के [A,B,C]लिए उपयोग कर सकते हैं , 10 बाइट्स की बचत; 2. आप के \+बजाय उपयोग कर सकते हैं not? 3. क्या आप बता सकते हैं कि आपको अंतिम कट की आवश्यकता क्यों है x(A)?

— ओलिपहंट -

मैं कल अपने लैपटॉप से ​​आपके पास वापस आऊंगा। अभी टेबलेट के साथ बिस्तर पर है जो अनाड़ी टाइपिंग के लिए बनाता है और मुझे शायद वैसे भी सोना चाहिए। :-)

— ओलिपहंट - मोनिका

यहां एक संस्करण है जो 14 बाइट्स बचाता है। मैंने पूर्व की दक्षिण-समरूपता से लाभ उठाने के :बजाय इसका उपयोग किया /, इसलिए मैं इसके A:_लिए शॉर्टहैंड के रूप में लिख सकता था A:_:_(लेकिन A+B/Cसाथ ही साथ काम करता है: आप तब उपयोग कर सकते हैं A+_)। वैसे, अपने मूल में भी आप के [A|_]बजाय इस्तेमाल किया जा सकता है [A,_,_]। नोट करें कि SWI-Prolog का मेरा संस्करण नहीं था nth0/4, इसलिए मैंने select/3इसके बजाय उपयोग किया।

— ओलिपहंट -

मैं पहले की आवश्यकता के बारे में सोच रहा था t(S,T)लेकिन फिर भूल गया। अब परीक्षण किया गया: आप इसे पूरी तरह s(E,L)से सीधे और सीधे कॉल करके 55 और बाइट्स बचा सकते हैं setof/3।

— ओलिपहंट -

Answer 3

जावास्क्रिप्ट ( ईएस 6 ), 228

दूसरी कोशिश, मुझे उम्मीद है कि यह काम करेगा।

मेरा लक्ष्य उन घटनाओं का सबसे लंबा अनुक्रम है जिनमें समय संघर्ष है, लेकिन जब एनएससीसी को हटा दिया जाता है तो कोई समय संघर्ष नहीं होता है। हटाए गए NSCC के साथ यह संशोधित अनुक्रम अनुरोधित आउटपुट है।

मैं उम्मीदवार समाधानों की एक कतार की जांच करने वाली एक चौड़ाई वाली पहली खोज का उपयोग करता हूं, जो सबसे लंबे समय तक शुरू होती है (पहली सूची प्रारंभिक है)। एन घटनाओं के एक उम्मीदवार समाधान से मैं निर्माण करता हूं और एन अधिक उम्मीदवार समाधान को लागू करता हूं , घटनाओं में से एक को हटाकर और दूसरों को रखता हूं ।

एक उम्मीदवार समाधान वैध है यदि समय संघर्ष 'जैसा है' है, लेकिन जब एनएससीसी घटना को फ़िल्टर किया जाता है तो कोई संघर्ष नहीं होता है। मैं संघर्षों की जांच के लिए एक सबफंक्शन K का उपयोग करता हूं।

शायद थोड़ा और गोल्फ हो सकता है ...

नीचे स्निपेट का परीक्षण करना (EcmaScript 6, FireFox केवल)

F=l=>(K=>{
  l.map(v=>l.push(l.splice(0,3)));// I'm particularly proud of this trick for grouping in triplets (in pith it's "cQ3")
  for(S=[l.sort((a,b)=>a[1]-b[1])];!K(l=S.shift())|K(m=l.filter(x=>x[0]!='NSCC'));)
    l.map((v,i)=>(S.push(n=[...l]),n.splice(i,1)));
})(l=>l.some(x=>[p>+x[1],p=+x[2]][0],p=0))||m.map(x=>x[0])

// Less golfed and ES5

function Find(l) {
  var n,m;
  var Check = function(l) {
    // check timing conflict comparing start time and end time of previous event (events must be sorted)
    var p = 0 // previous event end time, init to 0
    return l.some( function(x) {
      var err = p > +x[1]; // unary plus convert string to number
      p = +x[2]; // update end time
      return err;
    });  
  };  
  // group initial array in triplets
  // forEach repeats for the initial number of elements in l, even if l becomes shorter
  // so it loops more times than necesary, but it works anymay
  l.forEach(function() { 
    l.push(l.splice(0,3)); // remove first 3 elements and add to back as a triple
  }) 
  l.sort(function(a,b) { return a[1]-b[1]} ); // sort by start time
  var S=[l]; // S is the main queue, start with complete list 
  
  while (l = S.shift(), // current list
         m = l.filter( function(x) { return x[0]!='NSCC'} ), // current list with NSCC removed
         !Check(l)|Check(m)) // loop while list ha no errors or filtered list do have errors
  {
    // build new candidate to check
    l.forEach ( function(v,i) {
      n = l.slice(); // make a copy of l
      n.splice(i,1); // remove ith element
      S.push(n); // put in S
    });  
  }
  // when exiting while, m has the list with NSCC removed
  return m.map( function(x) { return x[0]; }); // keep the event name only
}

// Test

out=(...x)=>O.innerHTML += x + '\n';

test=[
  ['UnderwaterBasketWeavingConvention 50 800 NSCC 500 550','UnderwaterBasketWeavingConvention']
, ['SconeEating 0 50 RegexSubbing 45 110 CodeGolfing  95 105 NSCC 100 200','SconeEating CodeGolfing']
, ['VelociraptorHunting 0 300 NerdSniping 200 500 SEChatting 400 700 DoorknobTurning 650 750 NSCC 725 775'
  ,'NerdSniping DoorknobTurning']
, ['NSCC 110 115 A 100 120 B 120 140 C 105 135 D 100 105 E 135 500','C D E']
, ['A 800 900 NSCC 700 1000 B 650 750 C 950 1050 D 655 660 E 660 665 F 1030 1040 G 1040 1060','A D E F G']
, ['A 10 11 B 11 12 C 12 13 D 13 14 NSCC 15 1090 E 10 16','E']
]


test.forEach(x=>{
  var l=x[0].split(/\s+/), r=F(l).sort().join(' '), e=x[1].split(/\s+/).sort().join(' ');
  out('Test ' + (r==e ? 'OK':'FAIL')+'\nInput:    '+x[0]+'\nResult:   '+r+'\nExpected: '+e)
} )

<pre id=O></pre>

Comments

क्या मैं एक स्टैक स्निपेट का बिंदु पूछ सकता हूं यदि आप फ़ंक्शन को कॉल नहीं करते हैं तो प्रोग्राम कुछ भी नहीं करता है?

— बीटा डिके

@ बाइटडेके: एडसी 65 आमतौर पर स्निपेट में चलने वाले परीक्षण मामलों को जोड़ता है। लगता है जैसे वह जल्द ही इस जवाब पर लौट रहा होगा, उस समय मुझे लगता है कि वह रन करने योग्य सामान जोड़ देगा। :)

— एलेक्स ए।

@BetaDecay जल्दी में था। और (अभी तक बदतर) यह परीक्षण में से एक को विफल करता है।

— ed6565

Answer 4

जावा, 828 बाइट्स

वहाँ शायद एक और अधिक संक्षिप्त जावा कार्यान्वयन वहाँ है, लेकिन यहाँ मेरा छुरा है:

String s(String e){String[] a=e.split(" ");String m="";String[] c=g(a.length/3);int l=0;for(int i=0;i<a.length;i+=3)if(a[i].equals("NSCC"))l=i/3;for(String p:c)if(p.indexOf(l+"")==-1&&!h(p,a)&&h(p+l,a)&&p.length()>m.length())m=p;String r="";for(int i=0;i<m.length();i++)r+=a[3*(m.charAt(i)-48)]+((i==m.length()-1)?"":" ");return r;}boolean h(String c, String[] e){for(int i=0;i<c.length()-1;i++){int p=c.charAt(i)-48;for(int j=i+1;j<c.length();j++){int q=c.charAt(j)-48;if((Integer.parseInt(e[3*p+1])-Integer.parseInt(e[3*q+2]))*((Integer.parseInt(e[3*p+2])-Integer.parseInt(e[3*q+1])))<0)return true;}}return false;}String[] g(int n){if(n>1){String[] result=new String[(int)Math.pow(2,n)];String[] l=g(n-1);for(int i=0;i<l.length;i++){result[2*i]=l[i];result[2*i+1]=l[i]+(n-1);}return result;}else return new String[]{"","0"};}

Comments

सभी चर को एक स्थान पर घोषित करने से बाइट्स बचेंगे।

— स्पिकैट्रिक्स

आप की जरूरत नहीं है else return।

— lirtosiast

Answer 5

पायथन, 373 वर्ण

import itertools as j
a=zip(*[iter(input())]*3)
f,g,r=[],0,"NSCC"
p=f
for q in a:
 p=(p,q)[q[0]==r]
for h in range(1,len(a)+1):
 for i in j.combinations(a,h):
  s,i,l,m=0,sorted(i,key=lambda k:int(k[1])),-1,len(i)
  for n in i:
   s=(s,1)[p[1]<n[2]or p[2]<n[1]]
   if r==n[0]or n[1]<l:
    m=-1
    break
   else:
    l=n[2]
  if s*m>g:
   g,f=m,i
for o in f:
 print o[0]

हर संभव संयोजन बनाता है और हर एक की जाँच करता है।

परीक्षा

इनपुट: ["NSCC",110,115,"A",100,120,"B",120,140,"C",105,135,"D",100,105,"E",135,500]

आउटपुट:

डी
सी
ए