(Bunu 1542 sırasında göndermek istemiştim : Zamanlama Çatışması hala geçerli xkcd idi, ama zamanlama çatışması yaşadım.)

Giriş

Giriş, olayları 3ntemsil eden öğelerin bir listesi olacaktır n. Her 3 gruptaki ilk öğe, bir etkinliğin adı olacaktır; ikinci ve üçüncü, sırasıyla başlangıç ​​ve bitiş zamanı. Örneğin:

foo 12 34 bar 56 78

bir etkinliği gösterdiğini foo"zaman 12" başlar; 34 de ve uçları (kez tamsayılar tarafından sadece temsil dakikalar geçmiş gece yarısı olarak bunlardan düşünebiliriz), ve ikinci bir olay barolduğunu 56 yaşında başlar ve 78'de biter.

Olayların adları her zaman yalnızca alfasayısal karakterlerden oluşacak ve zamanlar her zaman ≥ 0 ve <1440 tamsayıları olacak. Bitiş zamanı her zaman başlangıç ​​zamanından en az 1 büyük olacaktır. Herhangi bir şekilde sıralanmaları garanti edilmez.

İsterseniz, bunu boşlukla ayrılmış tek bir dize olarak kabul edebilirsiniz; aksi takdirde bir dizi, liste, vektör veya dilinizin karşılığı olarak alınmalıdır.

Çıktı

Çıktı, boşlukla ayrılmış bir olay adı listesi olmalıdır. Olay adlarının çıkarılacağı kurallar aşağıdaki gibidir:

• Çıktığınız olayların hiçbiri birbiriyle çakışamaz. Örneğin, giriş ile a 0 10 b 5 15, her iki çıkış olmayabilir ave b, çünkü katı çatışma (olup, kısmen üst üste gelir). Bir olay tam olarak başladığı gibi biterse, her ikisini de ekleyebilirsiniz.

• NSCCGirdide her zaman tam olarak biri olacak olan ("Ulusal Zamanlama Çatışması Yarışması") adlı etkinliği çıkartamazsınız. Ayrıca sen zorunluluk çıkışı en az bir etkinliğin olduğu çakışmaları (kısmen örtüşür) NSCC(ve her zaman sıra bu en az biri olacaktır).

• Yukarıdaki iki kurala uyurken olabildiğince fazla olay çıkarmanız gerekir. (Bu, olabildiğince meşgul görünmek için, böylece NSCC'yi kaçırmak daha güvenilir görünüyor.)

Bu, boşlukla ayrılmış tek bir dize veya bir dizi, liste, vektör vb. Olarak da çıkarılabilir.

Birden fazla olası çıktı olabilir.

Test durumları

Listelenen çıktıların yalnızca örnek olduğunu unutmayın. Kodunuz hala yukarıdaki üç kurala uyduğu sürece farklı bir şey çıktısı alabilir (özellikle bu , örnekte olduğu gibi aynı miktarda olay olması gerektiği anlamına gelir ).

Giriş: UnderwaterBasketWeavingConvention 50 800 NSCC 500 550
Çıkış:UnderwaterBasketWeavingConvention

Giriş: SconeEating 0 50 RegexSubbing 45 110 CodeGolfing 95 105 NSCC 100 200
Çıkış:SconeEating CodeGolfing

Giriş: VelociraptorHunting 0 300 NerdSniping 200 500 SEChatting 400 700 DoorknobTurning 650 750 NSCC 725 775
Çıkış:NerdSniping DoorknobTurning

Giriş: NSCC 110 115 A 100 120 B 120 140 C 105 135 D 100 105 E 135 500
Çıkış:C D E

Giriş: A 800 900 NSCC 700 1000 B 650 750 C 950 1050 D 655 660 E 660 665 F 1030 1040 G 1040 1060
Çıkış:A D E F G

Giriş: A 10 11 B 11 12 C 12 13 D 13 14 NSCC 15 1090 E 10 16
Çıkış:E

Kaçırdığım kenar vakaları varsa, bir düzenlemeye daha fazla test senaryosu eklemekten çekinmeyin.

kurallar

• Makul bir kişisel makinede verilen tüm test durumları için kodunuz 30 saniye içinde tamamlanmalıdır (bu, birleştirilmiş bütün test durumları için muhtemelen daha hızlı tamamlaması gerektiği için bir akıl sağlığı kontrolünden ibarettir).

• Bu kod golf , yani bayt cinsinden en kısa kod kazanır.

Pyth, 45 bayt

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

Bu golf oynamak için oldukça zordu. Epeyce 45 baytlık çözümler bulduğumda, bu muhtemelen en egzotik olanıdır (çünkü Açift ​​eşleştirme) ve .g(grupla).

Çevrimiçi deneyin: Gösteri veya Test koşum

açıklama

                            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

SWI-Prolog, 537 524 516 502 447 436 bayt

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,[]),!.

Her bir tahminin ne yaptığı hakkında kısa açıklama:

• z(A,B) A olayının B listesiyle ilgili hiçbir olayla çakışmadığını kontrol eder
• u(A,B)A listesindeki her olayın B listesindeki herhangi bir olayla çakışmadığını kontrol eder (A listesinde arayarak herhangi bir çakışma olmadığını kontrol etmek için kullanılır u(A,A))
• y(A,B,C) Listeyi üçüzler listesine ayırır (girişleri olay listesine dönüştürmek için)
• d(A) A listesindeki olayların adlarını yazdırır
• l(A,R) A listesindeki en uzun olay listesini R değerlendirir.
• v(A,NSCC,C,R) A’da iç çatışmaları olmayan ve NSCC olayıyla çakışan her olay listesini içeren bir liste R döndürür
• s(A,B) B, A'nın bir alt kümesi ise true
• x(A) Ana yüklem, A girişidir.

Test senaryoları : test.yukarıdaki kodu yükledikten sonra aşağıdaki kodu ekledikten sonra tercümanda çalıştır :

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

Bu beni düşündüğümden daha fazla zaman aldı. Bu muhtemelen çok daha fazla golf oynayabilir. Ayrıca, muhtemelen daha kısa çözümler almak için mevcut olan çeşitli kısıtlama programlama kütüphanelerini kullanabilirsiniz.

Düzenleme: Üçüzler A:B:Cyerine kullanma fikri @Oliphaunt sayesinde [A,B,C]. 14 bayt kaydeder.

Edit2: yüklem `` t / yararsız 3`was işaret için tekrar @Oliphaunt teşekkürler. 55 bayt kaydeder

Edit3: Yüklem üzerinde kesin hüküm dilbilgisi kullanarak 11 bayt kazandı yve d.

JavaScript ( ES6 ), 228

İkinci deneme, umarım bu işe yarar.

Hedefim, zamanlama çatışması olan, ancak NSCC olayı kaldırıldığında zamanlama çatışması olmayan en uzun olay dizisidir. NSCC kaldırılmış olan bu değiştirilmiş dizi istenen çıktıdır.

En uzundan başlayarak aday çözümlerin kuyruğunu inceleyen bir Genişlik İlk Arama kullanıyorum (ilk liste ilk). Bir aday çözeltisinden n ı kurmak olaylar ve enqueue n daha aday çözümleri, olayların birini çıkarıp diğerlerini tutmak.

Bir aday çözüm, 'olduğu gibi' bir zamanlama çatışması varsa geçerlidir, ancak NSCC olayı filtrelendiğinde herhangi bir çatışma yoktur. Çakışmaları kontrol etmek için K alt fonksiyonunu kullanıyorum.

Muhtemelen biraz daha golf oynayabilir ...

Aşağıdaki pasajı çalıştırma testi (yalnızca EcmaScript 6, FireFox olmak)

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>

Java, 828 bayt

Muhtemelen daha özlü bir Java uygulaması var, ama işte benim bıçağım:

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

Python, 373 karakter

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]

Tüm olası kombinasyonları oluşturur ve her birini kontrol eder.

Ölçek

Giriş: ["NSCC",110,115,"A",100,120,"B",120,140,"C",105,135,"D",100,105,"E",135,500]

Çıktı:

D
C
E