Ausgehend von einer Liste von Jobs, die in der Reihenfolge ausgeführt werden müssen, in der jeweils ein Slot ausgeführt wird, wie lange es dauert, sie alle auszuführen, wenn nach dem Ausführen eines Jobs für die nächsten beiden Slots (Abkühlen der Slots) nicht derselbe Job ausgeführt werden kann )? In diesen Cooling-Off-Slots kann jedoch ein anderer Job zugewiesen werden.

Beispielsweise,

[9,10,9,8] => output: 5

Weil Jobs zugewiesen werden als [9 10 _ 9 8].
1. Erstens benötigt 9 zwei Abkühlpunkte _ _. Also fangen wir an mit 9 _ _.
2. Der nächste Job 10 unterscheidet sich vom vorherigen Job 9, sodass wir einen von _ _ zuweisen können. Dann werden wir haben 9 10 _.
3. Drittens kann 9 jetzt nicht zugewiesen werden, da der erste Job 9 derselbe Job ist und eine Abkühlzeit benötigt. 9 10 _ 9.
4. Last, 8 ist nicht dasselbe wie alle anderen vorherigen zwei Jobs, daher kann es direkt nach 9 zugewiesen werden, und da dies der letzte Job ist, muss keine Abkühlzeit eingehalten werden. Die endgültige Liste ist 9 10 _ 9 8und die erwartete Ausgabe ist 5, was der Anzahl der Plätze (oder der Anzahl der Slots) entspricht.

Testfälle:

[1,2,3,4,5,6,7,8,9,10] => output : 10 ([1 2 3 4 5 6 7 8 9 10])
[1,1,1] => output: 7 ([1 _ _ 1 _ _ 1])
[3,4,4,3] => output: 6 ([3 4 _ _ 4 3])
[3,4,5,3] => output: 4 ([3 4 5 3])
[3,4,3,4] => output : 5 ([3 4 _ 3 4])
[3,3,4,4] => output : 8 ([3 _ _ 3 4 _ _ 4])
[3,3,4,3] => output : 7 ([3 _ _ 3 4 _ 3])
[3,2,1,3,-4] => output : 5 ([3 2 1 3 -4])
[] => output : 0 ([])
[-1,-1] => output : 4 ([-1 _ _ -1])

Der Eingabewert kann eine beliebige Ganzzahl sein (negativ, 0, positiv). Die Länge der Jobliste beträgt 0 <= Länge <= 1.000.000.
Die Ausgabe ist eine Ganzzahl, die Gesamtzahl der Slots, die im Testfall als Ausgabe angegeben wird. Die Liste in der Klammer gibt an, wie die Ausgabe generiert werden soll.

Gewinnkriterium
Code-Golf

Jelly , 14 Bytes

ṫ-i⁹⁶ẋ⁸;;µƒ⁶L’

Probieren Sie es online!

05AB1E , 22 Bytes

v¯R¬yQiõˆ}2£yåiˆ}yˆ}¯g

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

v           # Loop over the integers `y` of the (implicit) input-list:
 ¯R         #  Push the global_array, and reverse it
   ¬        #  Get the first item (without popping the reversed global_array itself)
    yQi  }  #  If it's equal to the integer `y`:
       õˆ   #   Add an empty string to the global_array
   2£       #  Then only leave the first 2 items of the reversed global_array
     yåi }  #  If the integer `y` is in these first 2 items:
        ˆ   #   Add the (implicit) input-list to the global_array
 yˆ         #  And push the integer `y` itself to the global_array
}¯g         # After the loop: push the global array, and then pop and push its length
            # (which is output implicitly as result)

Brachylog , 10 Bytes

Es ist immer wieder schön zu sehen, wo Brachylog am besten abschneidet

⊆Is₃ᶠ≠ᵐ∧Il

Erläuterung

⊆I           # Find the minimal ordered superset of the input (and store in I) where:
   s₃ᶠ       #     each substring of length 3
      ≠ᵐ     #     has only distinct numbers
        ∧Il  # and output the length of that superset

Probieren Sie es online!

R , 123 Bytes

`-`=nchar;x=scan(,'');while(x!=(y=gsub("([^,]+),(([^,]*,){0,1})\\1(,|$)","\\1,\\2,\\1\\4",x)))x=y;-gsub("[^,]","",y)+(-y>1)

Probieren Sie es online aus - einzelnes Programm!

Probieren Sie es online aus - mehrere Beispiele!

Ein vollständiges Programm, das eine durch Kommas getrennte Liste von Ganzzahlen als Eingabe liest und die benötigten Slots ausgibt. Ich bin mir sicher, dass dies noch ein bisschen mehr Spaß machen könnte, und die Implementierung dieser auf Regex basierenden Lösung in einigen anderen Sprachen wäre in Byte effizienter.

Hinweis zum zweiten TIO Ich habe es in eine Funktion eingeschlossen, damit mehrere Beispiele angezeigt werden können. Diese Funktion zeigt auch die endgültige Liste an, diese wird jedoch nicht im Hauptprogramm ausgegeben, wenn sie isoliert ausgeführt wird.

TSQL-Abfrage, 158 Byte

Eingabedaten als Tabelle.

Die Abfrage ist also rekursiv

OPTION (MAXRECURSION 0)

ist notwendig, weil die Liste der Zahlen 100 überschreiten kann, obwohl sie nur 32.767 Rekursionen verarbeiten kann - ist die Einschränkung wirklich für diese Aufgabe erforderlich?

DECLARE @ table(a int, r int identity(1,1))
INSERT @ VALUES(3),(3),(4),(4);

WITH k as(SELECT null b,null c,1p
UNION ALL
SELECT iif(a in(b,c),null,a),b,p+iif(a in(b,c),0,1)FROM @,k
WHERE p=r)SELECT sum(1)-1FROM k
OPTION(MAXRECURSION 0) 

Probieren Sie es online aus

R , 81 70 Bytes

sum(l<-rle(s<-scan())$l*3-3,1-l%/%6,((r=rle(diff(s,2)))$l+1)%/%2*!r$v)

Probieren Sie es online!

Nach mehreren erfolglosen Versuchen wurde der Code ziemlich hässlich und nicht so kurz, aber zumindest funktioniert es jetzt ...

Zuerst bewerten wir die Länge aufeinanderfolgender Läufe desselben Jobs. ZB 3, 3, 4, 3dafür gibt es:

Run Length Encoding
  lengths: int [1:3] 2 1 1
  values : num [1:3] 3 4 3

Jeder dieser Läufe erzeugt (len - 1) * 3 + 1Schritte ( + 1wird separat behandelt).

Als Nächstes verarbeiten wir Vorkommen desselben Jobs, die zwei Stellen voneinander entfernt sind, z. B .: x, y, xmit diff(s, lag=2). Der resultierende Vektor wird rdurch die rleFunktion auch in aufeinanderfolgende Läufe ( ) aufgeteilt . Aufgrund verschiedener verschachtelter Abwechslungen müssen wir jetzt ceiling(r$len/2)Schritte für alle Nulldurchläufe hinzufügen . Z.B:

x y x(Länge 1) und x y x y(Länge 2) benötigen beide 1 zusätzlichen Schritt:x y _ x (y)

x y x y x(Länge 3) und x y x y x y(Länge 4) benötigen jeweils 2 zusätzliche Schritte:x y _ x y _ x (y)

Schließlich müssen wir das Auftreten dieser Wechsel in der Mitte einer langen Laufzeit desselben Jobs kompensieren: x, x, x, x...also 1-l%/%6statt einfach 1.

Python 2 , 67 Bytes

r=[]
for x in input():
 while x in r[-2:]:r+=r,
 r+=x,
print len(r)

Probieren Sie es online!

Implementiert die Herausforderung buchstäblich. Verwendet Kopien der Liste selbst als "Leerzeichen", da diese keiner Zahl entsprechen können.

Kohle , 27 23 Bytes

Ｆθ«Ｗ№✂υ±²¦¦¦ι⊞υω⊞υι»ＩＬυ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｆθ«

Schleife über die Jobs.

Ｗ№✂υ±²¦¦¦ι⊞υω

Fügen Sie Abkühlungspunkte hinzu, während der Job einer der letzten beiden im Ergebnis ist.

⊞υι»

Fügen Sie dem Ergebnis den aktuellen Job hinzu.

ＩＬυ

Drucken Sie die Anzahl der Punkte.

R , 74 68 Bytes

length(Reduce(function(x,y)c(y,rep("",match(y,x[2:1],0)),x),scan()))

Probieren Sie es online!

Konstruiert das Arbeitsarray (in umgekehrter Reihenfolge) und nimmt dann die Länge an. Nur ein bisschen kürzer als Kirill L.'s Antwort , daher ist der naive Ansatz manchmal ziemlich gut. EDIT: wieder kürzer! Ich habe mir auch Kirills Testvorlage ausgeliehen.

-6 Bytes ersetzen max(0,which(y==x[2:1])) durch match(y,x,0) .

Perl 6 , 98 Bytes

{($!=$,|$_ Z$_ Z .[1..*+1])>>.repeated.squish(:with({$+^=[*] $! ne$^a ne$^b,$b==($!=$a)})).sum+$_}

Probieren Sie es online!

Blergh, es muss einen besseren Weg geben. Ich bin nicht zu 100% sicher, dass dies völlig richtig ist, obwohl es alle Randfälle übersteigt, die mir einfallen.

Grundsätzlich beginnt dies damit, dass alle Triplets der Eingabeliste gruppiert werden und nach beiden Seiten aufgefüllt werden. Zum Beispiel [1,2,1,2]wird (Any,1,2), (1,2,1), (2,1,2), (1,2,Nil). Wir bekommen die repeatedElemente in jedem Triplett, werden (), (1), (2), ().

Es gibt dann squishaufeinanderfolgende Elemente, die nicht dieselbe Liste, aber dieselbe Größe haben (um etwas nicht zu zerquetschen [1,1,1]), und das erste Element ist nicht gleich dem Element davor (weil wir die Stunden nicht zusammenführen können [1,1,2,2]), und Schließlich wurde das vorhergehende Element nicht ebenfalls zerquetscht ( [1,2,1,2,1,2]). So würde (1), (2)im obigen Beispiel oben zusammengequetscht werden.

Schließlich erhalten wir sumdie Gesamtlänge dieser Liste, die unsere eingefügten Stunden darstellt, und fügen die Länge der ursprünglichen Liste hinzu.

Beispielsweise:

(1,1,1) => (Any,1,1),(1,1,1),(1,1,Nil) => (1),(1,1),(1) => (no squishes) => 4+3 = 7
(1,2,1,2,1,2) => (Any,1,2), (1,2,1), (2,1,2), (1,2,1), (2,1,2), (1,2,Nil) => (),(1),(2),(1),(2),() => squish (1),(2) and (1),(2) => 2+6 = 8

JavaScript (ES6), 57 Byte

f=([x,...a],p,q)=>1/x?1+f(x!=p&x!=q?a:[x,...a,x=f],x,p):0

Probieren Sie es online!

Kommentiert

f = (             // f is a recursive function taking:
  [x,             //   x   = next job
      ...a],      //   a[] = array of remaining jobs
  p,              //   p   = previous job, initially undefined
  q               //   q   = penultimate job, initially undefined
) =>              //
  1 / x ?         // if x is defined and numeric:
    1 +           //   add 1 to the grand total
    f(            //   and do a recursive call to f:
      x != p &    //     if x is different from the previous job
      x != q ?    //     and different from the penultimate job:
        a         //       just pass the remaining jobs
      :           //     else:
        [ x,      //       pass x, which can't be assigned yet
          ...a,   //       pass the remaining jobs
          x = f   //       set x to a non-numeric value
        ],        //
      x,          //     previous job = x
      p           //     penultimate job = previous job
    )             //   end of recursive call
  :               // else:
    0             //   stop recursion

C (gcc) , 69 Bytes

f(j,l)int*j;{j=l>1?(*j-*++j?j[-1]==j[l>2]?j++,l--,3:1:3)+f(j,l-1):l;}

Probieren Sie es online!

Einfache Rekursion.

f(j,l)int*j;{               //Jobs, (array) Length
    j=l>1                   //if l > 1, do a recursion:
        ? (*j-*++j          // check if first and second elements are equal (j++)
            ? j[-1]==       //  1st!=2nd; check if first and third are equal
                j[l>2]      //  (first and second if l==2, but we already know 1st!=2nd)
                ? j++,l--,3 //   1st==3rd (j++,l--) return 3+f(j+2,l-2)
                : 1         //   1st!=3rd (or l==2) return 1+f(j+1,l-1)
            : 3             //  1st==2nd            return 3+f(j+1,l-1)
          )+f(j,l-1)        // j and l were modified as needed
        : l;                // nothing more needed  return l
}

Perl 6 , 48 Bytes

{$!=0;.map:{{$_=($!=$!+1 max$_)+3}((%){$_})};$!}

Probieren Sie es online!

45 Bytes, wenn die Liste mindestens zwei Elemente enthält:

+*.reduce:{$^b,|(*xx 3-(|$^a,*,$b...$b)),|$a}

Probieren Sie es online!

Smalltalk, 125 Bytes

c:=0.n:=q size.1to:n-2do:[:i|(j:=q at:i)=(k:=q at:i+1)ifTrue:[c:=c+2].j=(m:=q at:i+2)ifTrue:[c:=c+1]].k=m ifTrue:[c:=c+1].c+n

Erläuterung

c : accumulator of proximity penalty
q : input array.
n := q length
i : iteration index from 1 to: n-2 (arrays are 1-based in Smalltalk).
j := memory for element i, saves some few bytes when reused
k := similar to j but for i+1.
m := similar to k but for i+2.

Perl 5 -pl , 42 40 Bytes

$a{$_}=~s/.*/$\=$&if++$\<$&;$\+3/e}{$_=0

Probieren Sie es online!

Batch, 184 Bytes

@echo off
@set l=-
@set p=-
@set n=0
@for %%j in (%*)do @call:c %%j
@exit/b%n%
:c
@if %1==%l% (set l=-&set/an+=2)else if %1==%p% set l=-&set/an+=1
@set p=%l%&set l=%1&set/an+=1

Die Eingabe erfolgt über Befehlszeilenargumente und die Ausgabe erfolgt über Exit-Code. Erläuterung:

@set l=-
@set p=-

Verfolgen Sie die letzten beiden Jobs.

@set n=0

Initialisieren Sie die Zählung.

@for %%j in (%*)do @call:c %%j

Verarbeiten Sie jeden Job.

@exit/b%n%

Die endgültige Zählung ausgeben.

:c

Für jeden Job:

@if %1==%l% (set l=-&set/an+=2)else if %1==%p% set l=-&set/an+=1

Wenn wir den Auftrag kürzlich bearbeitet haben, fügen Sie eine angemessene Anzahl von Abkühlungspunkten hinzu. Löschen Sie außerdem den letzten Job, damit der nächste Job nur dann eine Abkühlung auslöst, wenn er mit diesem Job identisch ist.

@set p=%l%&set l=%1&set/an+=1

Aktualisieren Sie die letzten beiden Jobs und weisen Sie diesem Job einen Platz zu.

Schnell, 114 Bytes

func t(a:[Int]){
var s=1
for i in 1...a.count-1{s = a[i-1]==a[i] ? s+3:i>1&&a[i-2]==a[i] ? s+2:s+1}
print("\(s)")}

Probieren Sie es online!

Python 3 , 79 75 Bytes

-3 Byte dank mypetlion
-1 Byte dank Sara J

f=lambda a,b=[]:a and f(*[a[1:],a,a[:1]+b,[b]+b][a[0]in b[:2]::2])or len(b)

Probieren Sie es online!

Java (JDK) , 110 Byte

j->{int p,q;for(p=q=j.length;p-->1;q+=j[p]==j[p-1]?2:(p>1&&j[p]==j[p-2]&(p<3||j[p-1]!=j[p-3]))?1:0);return q;}

Probieren Sie es online!

Ungolfed kommentierte Code:

j -> {
    int p, q = j.length; // Run all jobs
    for (p = q; p-- > 1;) { // reverse iterate
        q += j[p] == j[p - 1] ? 2 : // add 2 if prev same
        (p > 1 && j[p] == j[p - 2] & // 1 if 2prev same
        (p < 3 || j[p - 1] != j[p - 3]) // except already done
        ) ? 1 : 0; // otherwise 0
    }
    return q;
}

Gelee , 20 Bytes

ṫ-i⁹⁶x;
⁶;ç³Ṫ¤¥¥³¿L’

Probieren Sie es online!

Obwohl dies der kürzeren Antwort von @ EriktheOutgolfer ziemlich ähnlich ist , habe ich sie geschrieben, ohne seine zu sehen. Auf jeden Fall ist sein besser!

Erläuterung

Dyadischer Helfer-Link, aktuelle Liste als linkes Element und nächstes Element als rechtes Element

ṫ-            | take the last two items in the list
  i⁹          | find the index of the new item
    ⁶x        | that many space characters
      ;       | prepend to new item

Monadischer Hauptlink, verwendet eine Liste von Ganzzahlen als Eingabe

⁶             | start with a single space
 ;            | append...
  ç³Ṫ¤¥       | the helper link called with the current list
              | as left item and the next input item as right
       ¥³¿    | loop the last two as a dyad until the input is empty
          L   | take the length
           ’  | subtract one for the original space

Python 2 , 75 Bytes

lambda a:len(reduce(lambda b,c:b+[c]*-~((c in b[-2:])+(c in b[-1:])),a,[]))

Probieren Sie es online!

JavaScript (Node.js) , 52 Byte

(a,i=0,h={})=>a.map(n=>h[n]=3+(i=h[n]>++i?h[n]:i))|i

Probieren Sie es online!

APL (Dyalog Classic) , 22 Byte

≢∊(⊢,⍨⊣,# #↓⍨⍳⍨)/⍵,⊂⍬⍬

Probieren Sie es online!

JavaScript (V8), 101 Byte

f=a=>for(var c=0,i=0;i<a.length;i++,c++)a[i-1]==a[i]?c+=2:a[i-2]==a[i]&&(c++,a[i-1]=void 0)
return c}

Probieren Sie es online!

Der entpackte Code sieht wie folgt aus:

function f(a)
{
    var c = 0;
    for (var i = 0; i < a.length; i++, c++)
    {
        if (a[i - 1] == a[i])
            c+=2;
        else if (a[i - 2] == a[i])
            c++,a[i-1]=undefined;
    }

    return c;
}

Mein allererster Code-Golf-Versuch kann wahrscheinlich erheblich optimiert werden, indem das Array verkleinert und rekursiv übergeben wird.

Zsh , 66 60 Bytes

-6 Bytes von implizit "$@"

for j
{((i=$a[(I)$j]))&&a=
a=("$a[-1]" $j)
((x+=i+1))}
<<<$x

Probieren Sie es online! Ich empfehle dringend set -x, den Start zu ergänzen, damit Sie mitmachen können.

for j                   # Implicit "$@"
{                       # Use '{' '}' instead of 'do' 'done'
    (( i=$a[(I)$j] )) \ # (see below)
        && a=           # if the previous returned true, empty a
    a=( "$a[-1]" $j )   # set the array to its last element and the new job
    (( x += i + 1 ))    # add number of slots we advanced
}
<<<$x                   # echo back our total

((i=$a[(I)$j]))
    $a[     ]           # Array lookup
       (I)$j            # Get highest index matched by $j, or 0 if not found
  i=                    # Set to i
((           ))         # If i was set nonzero, return true

aEnthält immer die letzten beiden Jobs. Wenn die Suche also einen passenden Job in findet a[2], erhöhen wir uns um drei (da die Job-Slots dies sind [... 3 _ _ 3 ...]).

Wenn anicht festgelegt, schlägt die Suche fehl und die arithmetische Erweiterung gibt einen Fehler zurück, der jedoch nur beim ersten Auftrag auftritt und nicht schwerwiegend ist.

Wir können ein weiteres Byte speichern, wenn wir $[x+=i+1]stattdessen verwenden, und es gibt keine Befehle auf dem Benutzersystem, die ausschließlich aus Ziffern bestehen.

K (ngn / k) , 27 Bytes

{#2_``{y,#[0|2-x?y;`],x}/x}

Probieren Sie es online!