Biorąc pod uwagę listę zadań, które należy wykonać w kolejności, z których każda zajmuje miejsce, ile czasu zajmie wykonanie ich wszystkich, jeśli po wykonaniu zadania nie będzie można wykonać tego samego zadania dla kolejnych dwóch miejsc (ochłodzenie miejsc )? Jednak w tych gniazdach chłodzących można przypisać inne zadanie.

Na przykład,

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

Ponieważ zadania zostaną przydzielone jako [9 10 _ 9 8].
1. Po pierwsze, 9 potrzebuje dwóch punktów ochłodzenia _ _. Więc zaczynamy od 9 _ _.
2. Następne zadanie 10 różni się od poprzedniego zadania 9, więc możemy przydzielić jedno z _ _. Wtedy będziemy mieli 9 10 _.
3. Po trzecie, nie można teraz przydzielić 9, ponieważ pierwsze zadanie 9 jest tym samym zadaniem i wymaga czasu na ostygnięcie. 9 10 _ 9.
4. Na koniec 8 nie jest tym samym, co inne poprzednie dwa zadania, więc można je przydzielić zaraz po 9, a ponieważ jest to ostatnie zadanie, nie wymaga czasu na ostygnięcie. Ostateczna lista to 9 10 _ 9 8i oczekiwany wynik to 5, czyli liczba miejsc (lub liczba miejsc)

Przypadki testowe:

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

Wartością wejściową może być dowolna liczba całkowita (ujemna, 0, dodatnia). Długość listy zadań wynosi 0 <= długość <= 1 000 000.
Wyjście będzie liczbą całkowitą, łączną liczbą gniazd, która jest wskazana w przypadku testowym jako wyjście. Lista w nawiasie określa sposób generowania danych wyjściowych.

Kryterium wygranej
kod-golf

Galaretka , 14 bajtów

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

Wypróbuj online!

05AB1E , 22 bajty

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

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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 bajtów

Zawsze miło jest widzieć problem, w którym Brachylog działa najlepiej

⊆Is₃ᶠ≠ᵐ∧Il

Wyjaśnienie

⊆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

Wypróbuj online!

R , 123 bajty

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

Wypróbuj online - pojedynczy program!

Wypróbuj online - wiele przykładów!

Pełny program, który jako dane wejściowe odczytuje listę liczb całkowitych oddzieloną przecinkami i wysyła potrzebne miejsca. Jestem pewien, że można by to jeszcze trochę pograć w golfa, a wdrożenie tego rozwiązania opartego na wyrażeniach regularnych w innych językach byłoby bardziej wydajne w bajtach.

Uwaga na temat drugiego TIO umieściłem w funkcji, aby umożliwić pokazanie wielu przykładów. Ta funkcja pokazuje także końcową listę, ale nie jest ona wyświetlana w moim głównym programie, jeśli jest uruchamiany w izolacji.

Zapytanie TSQL, 158 bajtów

Wprowadź dane jako tabelę.

Zapytanie jest więc rekurencyjne

OPCJA (MAXRECURSION 0)

jest konieczne, ponieważ lista liczb może przekroczyć 100, chociaż może obsłużyć tylko 32 767 rekurencji - czy ograniczenie jest naprawdę potrzebne w tym zadaniu?

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) 

Wypróbuj online

R , 81 70 bajtów

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

Wypróbuj online!

Po kilku nieudanych próbach kod stał się raczej brzydki i nie tak krótki, ale przynajmniej działa teraz ...

Najpierw oceniamy długości kolejnych serii tego samego zadania. Np. Do 3, 3, 4, 3tego daje:

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

Każdy z tych przebiegów generuje (len - 1) * 3 + 1kroki ( + 1obsługiwane osobno).

Następnie przetwarzamy wystąpienia tego samego zadania w 2 miejscach od siebie, np .: x, y, xza pomocą diff(s, lag=2). Powstały wektor jest również dzielony na kolejne przebiegi ( r) według rlefunkcji. Teraz, z powodu różnych przeplatanych alternatyw, musimy dodać ceiling(r$len/2)kroki dla wszystkich przebiegów zer. Na przykład:

x y x(długość 1) i x y x y(długość 2) wymagają 1 dodatkowego kroku:x y _ x (y)

x y x y x(długość 3) i x y x y x y(długość 4) wymagają 2 dodatkowych kroków:x y _ x y _ x (y)

Wreszcie, musimy zrekompensować występowanie tych zmian w środku długiej serii tego samego zadania: x, x, x, x...stąd 1-l%/%6zamiast po prostu 1.

Python 2 , 67 bajtów

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

Wypróbuj online!

Realizuje wyzwanie dosłownie. Używa kopii samej listy jako „pustych miejsc”, ponieważ nie mogą one równać się żadnej liczbie.

Węgiel drzewny , 27 23 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｆθ«

Pętla nad zadaniami.

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

Dodaj punkty ochładzania, gdy zadanie będzie jednym z dwóch ostatnich.

⊞υι»

Dodaj bieżącą pracę do wyniku.

ＩＬυ

Wydrukuj liczbę miejsc.

R , 74 68 bajtów

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

Wypróbuj online!

Konstruuje tablicę roboczą (odwrotnie), a następnie przyjmuje długość. Trochę krócej niż odpowiedź Kirilla L. , więc czasami naiwne podejście jest całkiem dobre. EDYCJA: znowu krótsza! Pożyczałem też szablon testowy Kirilla.

-6 bajtów wymianie max(0,which(y==x[2:1])) z match(y,x,0) .

Perl 6 , 98 bajtów

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

Wypróbuj online!

Blergh, musi być na to lepszy sposób. Nie jestem w 100% pewien, że jest to w pełni poprawne, choć spełnia wszystkie przypadki, o których mogłem myśleć.

Zasadniczo zaczyna się od zgrupowania wszystkich trojaczków listy danych wejściowych, z dopełnianiem po obu stronach. Na przykład [1,2,1,2]staje się (Any,1,2), (1,2,1), (2,1,2), (1,2,Nil). Stajemy się repeatedelementami w każdej trójce(), (1), (2), () .

Następnie są to squishkolejne elementy, które nie są tą samą listą, ale mają ten sam rozmiar (aby nie zgnieść czegoś podobnego [1,1,1]), a pierwszy element nie jest równy pierwszemu elementowi (ponieważ nie możemy scalić godzin [1,1,2,2]), i wreszcie element wcześniej również nie został ściśnięty ( [1,2,1,2,1,2]). Tak więc (1), (2)w powyższym przykładzie byłoby ściśnięte razem.

Na koniec otrzymujemy sumwszystkie długości tej listy, które reprezentują nasze wstawione godziny, i dodajemy długość oryginalnej listy.

Na przykład:

(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 bajtów

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

Wypróbuj online!

Skomentował

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 bajtów

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

Wypróbuj online!

Prosta rekurencja.

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 bajtów

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

Wypróbuj online!

45 bajtów, jeśli lista zawiera co najmniej dwa elementy:

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

Wypróbuj online!

Smalltalk, 125 bajtów

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

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Partia, 184 bajty

@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

Dane wejściowe są przekazywane za pomocą argumentów wiersza polecenia, a dane wyjściowe - za pomocą kodu wyjścia. Wyjaśnienie:

@set l=-
@set p=-

Śledź dwa ostatnie zadania.

@set n=0

Zainicjuj liczenie.

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

Przetwarzaj każde zadanie.

@exit/b%n%

Podaj ostateczną liczbę.

:c

Do każdej pracy:

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

Jeśli ostatnio przetworzyliśmy zlecenie, dodaj odpowiednią liczbę miejsc do odstąpienia od umowy. Ponadto wyczyść ostatnie zadanie, aby następne zadanie wyzwoliło chłodzenie tylko wtedy, gdy jest takie samo jak to zadanie.

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

Zaktualizuj dwa ostatnie zadania i przydziel miejsce dla tego zadania.

Szybki, 114 bajtów

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

Wypróbuj online!

Python 3 , 79 75 bajtów

-3 bajty dzięki mypetlion
-1 bajt dzięki 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)

Wypróbuj online!

Java (JDK) , 110 bajtów

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

Wypróbuj online!

Nieskomentowany kod:

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

Galaretka , 20 bajtów

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

Wypróbuj online!

Chociaż jest to raczej podobne do krótszej odpowiedzi @ EriktheOutgolfer , napisałem ją, nie widząc jego. W każdym razie jego jest lepszy!

Wyjaśnienie

Pomocniczy link dynastyczny, przyjmuje aktualną listę jako lewy element, a następny element jako prawy

ṫ-            | 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

Główny link monadyczny, przyjmuje listę liczb całkowitych jako dane wejściowe

⁶             | 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 bajtów

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

Wypróbuj online!

JavaScript (Node.js) , 52 bajty

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

Wypróbuj online!

APL (Dyalog Classic) , 22 bajty

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

Wypróbuj online!

JavaScript (V8), 101 bajtów

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}

Wypróbuj online!

Rozpakowany kod wygląda następująco:

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

Moja pierwsza w historii próba gry w golfa kodowego może być prawdopodobnie znacznie zoptymalizowana poprzez zmniejszenie tablicy i przekazywanie jej rekurencyjnie.

Zsh , 66 60 bajtów

-6 bajtów od niejawnych "$@"

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

Wypróbuj online! Gorąco polecam dodanie set -xna początek, abyś mógł śledzić dalej.

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

azawsze zawiera ostatnie dwa zadania, więc jeśli wyszukiwanie znajdzie pasujące zadanie a[2], zwiększamy o trzy (ponieważ przedziały zadań będą[... 3 _ _ 3 ...] ).

Gdyby a ta opcja nie jest ustawiona, wyszukiwanie zakończy się niepowodzeniem, a interpretacja arytmetyczna zwróci błąd, ale dzieje się tak tylko przy pierwszym zadaniu i nie jest krytyczna.

Możemy $[x+=i+1]zamiast tego zaoszczędzić jeszcze jeden bajt , a system użytkowników nie zawiera poleceń składających się wyłącznie z cyfr.

K (ngn / k) , 27 bajtów

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

Wypróbuj online!