Dada uma lista de tarefas, que devem ser executadas em ordem, com cada uma ocupando um slot, quanto tempo levará para executá-las todas se, depois de fazer uma tarefa, a mesma tarefa não puder ser executada para os próximos dois slots (esfriando os slots )? No entanto, um trabalho diferente pode ser atribuído nesses slots de resfriamento.

Por exemplo,

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

Porque os trabalhos serão alocados como [9 10 _ 9 8].
1. Primeiro, 9 precisa de dois pontos de reflexão _ _. Então começamos com 9 _ _.
2. O próximo trabalho 10 é diferente do trabalho anterior 9, para que possamos alocar um dos _ _. Então nós teremos 9 10 _.
3. Terceiro, 9 não pode ser alocado agora, pois o primeiro trabalho 9 é o mesmo trabalho e precisa de tempo de reflexão. 9 10 _ 9.
4. Por último, 8 não é o mesmo que os outros dois trabalhos anteriores; portanto, pode ser alocado logo após 9 e, como esse é o último, não precisa de tempo para se refrescar. A lista final é 9 10 _ 9 8e a saída esperada é 5, que é o número de pontos (ou número de slots)

Casos de teste:

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

O valor de entrada pode ser qualquer número inteiro (negativo, 0, positivo). O comprimento da lista de tarefas é 0 <= comprimento <= 1.000.000.
A saída será um número inteiro, o número total de slots, que é indicado no caso de teste como saída. A lista entre parênteses é como a saída seria gerada.

Critério vencedor
código-golfe

Gelatina , 14 bytes

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

Experimente online!

05AB1E , 22 bytes

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

Experimente online ou verifique todos os casos de teste .

Explicação:

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)

Braquilog , 10 bytes

É sempre bom ver o problema em que o Brachylog tem melhor desempenho

⊆Is₃ᶠ≠ᵐ∧Il

Explicação

⊆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

Experimente 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)

Experimente online - programa único!

Experimente online - vários exemplos!

Um programa completo que lê uma lista de números inteiros separados por vírgula como entrada e gera os slots necessários. Tenho certeza de que isso poderia ser um pouco mais divertido, e implementar essa solução baseada em regex em alguns outros idiomas seria mais eficiente em bytes.

Observe no segundo TIO que eu a envolvi em uma função para permitir que vários exemplos sejam mostrados. Esta função também mostra a lista final, mas isso não é exibido no meu programa principal se for executado isoladamente.

Consulta TSQL, 158 bytes

Insira dados como uma tabela.

A consulta é recursiva, portanto

OPÇÃO (MAXRECURSION 0)

é necessário, porque a lista de números pode exceder 100, embora possa lidar apenas com 32.767 recursões - a limitação é realmente necessária nesta tarefa?

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) 

Experimente online

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)

Experimente online!

Após várias tentativas malsucedidas, o código ficou feio e não tão curto, mas pelo menos funciona agora ...

Primeiro, avaliamos o comprimento das execuções consecutivas do mesmo trabalho. Por exemplo, para 3, 3, 4, 3isso dá:

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

Cada uma dessas execuções produz (len - 1) * 3 + 1etapas ( + 1é tratada separadamente).

Em seguida, processamos ocorrências do mesmo trabalho em dois locais, como x, y, x:, usando diff(s, lag=2). O vetor resultante também é dividido em execuções consecutivas ( r) por rlefunção. Agora, devido a várias alternâncias intercaladas, precisamos adicionar ceiling(r$len/2)etapas para todas as execuções de zeros. Por exemplo:

x y x(comprimento 1) e x y x y(comprimento 2) precisam de uma etapa extra:x y _ x (y)

x y x y x(comprimento 3) e x y x y x y(comprimento 4) precisam de 2 etapas extras:x y _ x y _ x (y)

Finalmente, precisamos compensar as ocorrências dessas alternâncias no meio de uma longa execução do mesmo trabalho: x, x, x, x...portanto, em 1-l%/%6vez de simplesmente 1.

Python 2 , 67 bytes

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

Experimente online!

Implementa o desafio literalmente. Usa cópias da lista em si como "espaços em branco", pois não podem ser iguais a nenhum número.

Carvão , 27 23 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｆθ«

Repetir os trabalhos.

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

Adicione pontos de resfriamento enquanto o trabalho é um dos dois últimos no resultado.

⊞υι»

Adicione o trabalho atual ao resultado.

ＩＬυ

Imprima o número de pontos.

R , 74 68 bytes

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

Experimente online!

Constrói a matriz de trabalho (no sentido inverso) e, em seguida, assume o comprimento. Um pouco mais curto que a resposta de Kirill L. , às vezes, a abordagem ingênua é muito boa. EDIT: mais curto novamente! Também emprestei o modelo de teste de Kirill.

-6 bytes substituindo max(0,which(y==x[2:1])) por match(y,x,0) .

Perl 6 , 98 bytes

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

Experimente online!

Blergh, tem que haver uma maneira melhor de fazer isso. Não tenho 100% de certeza de que isso esteja totalmente correto, apesar de passar por todos os casos extremos em que pude pensar.

Basicamente, isso começa agrupando todos os trigêmeos da lista de entrada, com preenchimento para ambos os lados. Por exemplo, [1,2,1,2]torna-se (Any,1,2), (1,2,1), (2,1,2), (1,2,Nil). Obtemos os repeatedelementos em cada trigêmeo, tornando-se (), (1), (2), ().

Em seguida, squishsão apresentados elementos consecutivos que não são da mesma lista, mas têm o mesmo tamanho (para não pressionar algo parecido [1,1,1]), e o primeiro elemento não é igual ao elemento anterior (porque não podemos mesclar as horas [1,1,2,2]), e finalmente, o elemento anterior também não foi esmagado ( [1,2,1,2,1,2]). Assim, (1), (2)no exemplo acima, seriam esmagados juntos.

Por fim, obtemos sumtodos os comprimentos desta lista, que representam nossas horas inseridas, e adicionamos o comprimento da lista original.

Por exemplo:

(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 bytes

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

Experimente online!

Comentado

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

Experimente online!

Recursão direta.

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}((%){$_})};$!}

Experimente online!

45 bytes se a lista tiver pelo menos dois elementos:

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

Experimente 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

Explicação

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

Experimente online!

Lote, 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

A entrada é via argumentos da linha de comando e a saída é via código de saída. Explicação:

@set l=-
@set p=-

Acompanhe os dois últimos trabalhos.

@set n=0

Inicialize a contagem.

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

Processe cada trabalho.

@exit/b%n%

Saída a contagem final.

:c

Para cada trabalho:

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

Se tivermos processado o trabalho recentemente, adicione um número apropriado de pontos de reflexão. Além disso, limpe o último trabalho para que o próximo trabalho apenas acione a refrigeração se for o mesmo que este trabalho.

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

Atualize os dois últimos trabalhos e aloque um local para esse trabalho.

Rápido, 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)")}

Experimente online!

Python 3 , 79 75 bytes

-3 bytes graças a mypetlion
-1 byte graças a 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)

Experimente online!

Java (JDK) , 110 bytes

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

Experimente online!

Código comentado não-golfado:

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

Gelatina , 20 bytes

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

Experimente online!

Embora isso seja bastante semelhante à resposta mais curta de @ EriktheOutgolfer , escrevi sem ver a dele. De qualquer forma, o dele é melhor!

Explicação

Link diádico auxiliar, leva a lista atual como item esquerdo e o próximo item como direito

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

Link monádico principal, recebe a lista de números inteiros como entrada

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

Experimente online!

JavaScript (Node.js) , 52 bytes

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

Experimente online!

APL (Dyalog Classic) , 22 bytes

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

Experimente online!

JavaScript (V8), 101 bytes

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}

Experimente online!

O código descompactado tem a seguinte aparência:

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

Minha primeira tentativa de código-golfe, provavelmente pode ser muito otimizada diminuindo a matriz e passando-a recursivamente.

Zsh , 66 60 bytes

-6 bytes de implícito "$@"

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

Experimente online! Eu recomendo adicionar set -xao início para que você possa acompanhar.

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

asempre contém os dois últimos trabalhos, portanto, se a pesquisa encontrar um trabalho correspondente a[2], aumentamos em três (já que os slots de trabalho serão[... 3 _ _ 3 ...] ).

E se a não estiver definido, a pesquisa falhará e a expansão aritmética retornará um erro, mas isso só acontece no primeiro trabalho e não é fatal.

Podemos salvar mais um byte se usarmos $[x+=i+1], e não há comandos no sistema de usuários compostos inteiramente por dígitos.

K (ngn / k) , 27 bytes

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

Experimente online!