Dada una lista de trabajos, que deben hacerse en orden, cada uno de los cuales tiene que hacer un espacio, cuánto tiempo llevará realizarlos si, después de hacer un trabajo, no se puede hacer el mismo trabajo para los siguientes dos espacios (enfriamiento de espacios )? Sin embargo, se puede asignar un trabajo diferente en estas ranuras de enfriamiento.

Por ejemplo,

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

Porque los trabajos se asignarán como [9 10 _ 9 8].
1. Primero, 9 necesita dos puntos de enfriamiento _ _. Entonces comenzamos con 9 _ _.
2. El siguiente trabajo 10 es diferente del trabajo anterior 9, por lo que podemos asignar uno de _ _. Entonces lo haremos 9 10 _.
3. En tercer lugar, 9 no se puede asignar ahora, ya que el primer trabajo 9 es el mismo trabajo y necesita tiempo de enfriamiento. 9 10 _ 9.
4. Por último, 8 no es igual a los otros dos trabajos anteriores, por lo que puede asignarse inmediatamente después de 9 y, dado que este es el último trabajo, no necesita tiempo de enfriamiento. La lista final es 9 10 _ 9 8y la salida esperada es 5, que es el número de puntos (o número de espacios)

Casos de prueba:

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

El valor de entrada puede ser cualquier número entero (negativo, 0, positivo). La longitud de la lista de trabajos es 0 <= longitud <= 1,000,000.
La salida será un número entero, el número total de ranuras, que se indica en el caso de prueba como salida. La lista dentro del paréntesis es cómo se generaría la salida.

Criterio ganador
código-golf

Jalea , 14 bytes

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

Pruébalo en línea!

05AB1E , 22 bytes

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

Pruébalo en línea o verifique todos los casos de prueba .

Explicación:

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

Siempre es agradable ver un problema en el que Brachylog se desempeña mejor

⊆Is₃ᶠ≠ᵐ∧Il

Explicación

⊆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

Pruébalo en línea!

R , 123 bytes

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

Pruébelo en línea: ¡programa único!

Pruébelo en línea: ¡múltiples ejemplos!

Un programa completo que lee una lista de enteros separados por comas como entrada, y genera las ranuras necesarias. Estoy seguro de que esto podría desarrollarse un poco más, y la implementación de esta solución basada en expresiones regulares en algunos otros idiomas sería más eficiente en bytes.

Tenga en cuenta que en el segundo TIO lo he incluido en una función para permitir que se muestren múltiples ejemplos. Esta función también muestra la lista final, pero esto no se muestra en el programa principal si se ejecuta de forma aislada.

Consulta TSQL, 158 bytes

Datos de entrada como una tabla.

La consulta es recursiva, así que

OPCIÓN (MAXRECURSION 0)

es necesario, porque la lista de números puede exceder 100 aunque solo puede manejar 32,767 recursiones. ¿Es realmente necesaria esta limitación en esta tarea?

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) 

Pruébalo en línea

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)

Pruébalo en línea!

Después de varios intentos fallidos, el código se volvió bastante feo y no tan corto, pero al menos funciona ahora ...

Primero, evaluamos las duraciones de ejecuciones consecutivas del mismo trabajo. Por ejemplo, para 3, 3, 4, 3esto da:

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

Cada una de estas ejecuciones produce (len - 1) * 3 + 1pasos ( + 1se maneja por separado).

A continuación, procesamos las ocurrencias del mismo trabajo con 2 lugares separados, como: x, y, xmediante el uso diff(s, lag=2). El vector resultante también se divide en ejecuciones consecutivas ( r) por rlefunción. Ahora, debido a varias alternancias intercaladas, necesitamos agregar ceiling(r$len/2)pasos para todas las ejecuciones de ceros. P.ej:

x y x(longitud 1) y x y x y(longitud 2) ambos necesitan 1 paso adicional:x y _ x (y)

x y x y x(longitud 3) y x y x y x y(longitud 4) ambos necesitan 2 pasos adicionales:x y _ x y _ x (y)

Finalmente, necesitamos compensar las ocurrencias de estas alternancias en el medio de una larga ejecución del mismo trabajo: por lo x, x, x, x...tanto, en 1-l%/%6lugar de simplemente 1.

Python 2 , 67 bytes

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

Pruébalo en línea!

Implementa el desafío literalmente. Utiliza copias de la lista como "espacios en blanco", ya que no pueden ser iguales a ningún número.

Carbón , 27 23 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｆθ«

Recorrer los trabajos.

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

Agregue puntos de enfriamiento mientras el trabajo es uno de los dos últimos en el resultado.

⊞υι»

Agregue el trabajo actual al resultado.

ＩＬυ

Imprime el número de puntos.

R , 74 68 bytes

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

Pruébalo en línea!

Construye la matriz de trabajo (en reversa), luego toma la longitud. Solo un poco más corto que la respuesta de Kirill L. , así que a veces, el enfoque ingenuo es bastante bueno. EDITAR: más corto de nuevo! También tomé prestada la plantilla de prueba de Kirill.

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

Perl 6 , 98 bytes

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

Pruébalo en línea!

Blergh, tiene que haber una mejor manera de hacer esto. No estoy 100% seguro de que esto sea completamente correcto, aunque supera todos los casos límite que se me ocurren.

Básicamente, esto comienza agrupando todos los tripletes de la lista de entrada, con relleno a cada lado. Por ejemplo, se [1,2,1,2]convierte (Any,1,2), (1,2,1), (2,1,2), (1,2,Nil). Obtenemos los repeatedelementos en cada triplete, convirtiéndose (), (1), (2), ().

Luego squishes elementos consecutivos que no son la misma lista, pero son del mismo tamaño (para no aplastar algo así [1,1,1]), y el primer elemento no es igual al elemento anterior (porque no podemos fusionar las horas [1,1,2,2]), y Finalmente, el elemento anterior tampoco ha sido aplastado ( [1,2,1,2,1,2]). Entonces, (1), (2)en el ejemplo anterior, se aplastarían juntos.

Finalmente, obtenemos sumtodas las longitudes de esta lista, que representan nuestras horas insertadas, y agregamos la longitud de la lista original.

Por ejemplo:

(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

Pruébalo en línea!

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

Pruébalo en línea!

Recurrencia directa.

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

Pruébalo en línea!

45 bytes si la lista tiene al menos dos elementos:

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

Pruébalo en línea!

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

Explicación

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

Pruébalo en línea!

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

La entrada es a través de argumentos de línea de comandos y la salida es a través del código de salida. Explicación:

@set l=-
@set p=-

Rastrea los últimos dos trabajos.

@set n=0

Inicializar el recuento.

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

Procesar cada trabajo.

@exit/b%n%

Salida de la cuenta final.

:c

Para cada trabajo:

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

Si procesamos el trabajo recientemente, agregue un número apropiado de puntos de enfriamiento. Además, borre el último trabajo para que el siguiente solo active el enfriamiento si es el mismo que este.

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

Actualice los dos últimos trabajos y asigne un lugar a este trabajo.

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

Pruébalo en línea!

Python 3 , 79 75 bytes

-3 bytes gracias a mypetlion
-1 byte gracias 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)

Pruébalo en línea!

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

Pruébalo en línea!

Código comentado sin golf:

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

Jalea , 20 bytes

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

Pruébalo en línea!

Aunque esto es bastante similar a la respuesta más corta de @ EriktheOutgolfer , la escribí sin ver la suya. En cualquier caso el suyo es mejor!

Explicación

Enlace diádico auxiliar, toma la lista actual como elemento izquierdo y el siguiente elemento como derecho

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

Enlace monádico principal, toma la lista de enteros 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,[]))

Pruébalo en línea!

JavaScript (Node.js) , 52 bytes

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

Pruébalo en línea!

APL (Dyalog Classic) , 22 bytes

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

Pruébalo en línea!

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}

Pruébalo en línea!

El código desempaquetado tiene el siguiente aspecto:

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

Mi primer intento de código de golf probablemente puede optimizarse mucho reduciendo la matriz y pasándola recursivamente.

Zsh , 66 60 bytes

-6 bytes desde implícito "$@"

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

Pruébalo en línea! Recomiendo agregar set -xal inicio para que pueda seguir.

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

a siempre contiene los dos últimos trabajos, por lo que si la búsqueda encuentra un trabajo coincidente en a[2] , incrementamos en tres (ya que los espacios de trabajo lo estarán [... 3 _ _ 3 ...]).

Si a está configurado, la búsqueda fallará y la expansión aritmética devolverá un error, pero eso solo ocurre en el primer trabajo y no es fatal.

Podemos guardar un byte más si usamos en su $[x+=i+1]lugar, y no hay comandos en el sistema de usuarios compuestos completamente por dígitos.

K (ngn / k) , 27 bytes

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

Pruébalo en línea!