给定一个必须按顺序完成的作业列表，每个作业都需要一个插槽来完成，如果在完成一项工作之后接下来的两个插槽不能完成相同的工作（冷却插槽），则要花多长时间来完成全部工作）？但是，可以在此冷却槽中分配其他作业。

例如，

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

因为作业将被分配为[9 10 _ 9 8]。
1.首先，9需要两个冷却点_ _。因此，我们从开始9 _ _。
2.下一个作业10与上一个作业9不同，因此我们可以分配_之一。然后我们将拥有9 10 _。
3.第三，现在不能分配9，因为第一个作业9是相同的作业，需要冷却时间。9 10 _ 9。
4.最后，8与其他任何前两个作业都不相同，因此可以在9之后立即分配，并且由于这是最后一个作业，因此不需要冷却时间。最终列表为9 10 _ 9 8，预期输出为5，即点数（或插槽数）

测试用例：

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

输入值可以是任何整数（负数，0，正数）。作业列表的长度为0 <=长度<= 1,000,000。
输出将是一个整数，即插槽总数，在测试用例中将其表示为输出。括号内的列表是如何生成输出。

获胜标准
代码高尔夫球

果冻，14字节

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

在线尝试！

05AB1E，22 字节

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

在线尝试或验证所有测试用例。

说明：

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个字节

看到Brachylog表现最佳的问题总是很高兴

⊆Is₃ᶠ≠ᵐ∧Il

说明

⊆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

在线尝试！

R，123字节

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

在线试用-单一程序！

在线尝试-多个示例！

完整程序，读取逗号分隔的整数列表作为输入，并输出所需的插槽。我确信这可以解决更多问题，并且以其他一些语言实现这种基于正则表达式的解决方案将以字节为单位提高效率。

关于第二个TIO，请注意，我将其包装在一个函数中，以允许显示多个示例。此函数还会显示最终列表，但如果单独运行，则不会输出到主程序中。

TSQL查询，158个字节

输入数据作为表格。

该查询是递归的，因此

选项（最大偏移量0）

这是必须的，因为数字列表虽然只能处理32,767个递归，但可以超过100个-此任务确实需要限制吗？

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) 

在线尝试

R，81 70字节

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

在线尝试！

经过几次失败的尝试后，代码变得很丑陋，而且不是很短，但是至少现在可以正常工作了。

首先，我们评估同一工作的连续运行时间。例如，3, 3, 4, 3这给出：

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

这些运行中的每一个都会产生(len - 1) * 3 + 1步骤（+ 1单独处理）。

接下来，我们x, y, x通过使用来处理2个相隔的相同作业的出现，例如：diff(s, lag=2)。生成的向量也r按rle功能分为连续的运行（）。现在，由于各种交错的交替，我们需要添加ceiling(r$len/2)为所有零运行步骤。例如：

x y x（长度1）和x y x y（长度2）都需要1个额外的步骤：x y _ x (y)

x y x y x（长度3）和x y x y x y（长度4）都需要2个额外的步骤：x y _ x y _ x (y)

最后，我们需要在同一工作的长期运行中补偿这些替换的发生：x, x, x, x...因此，1-l%/%6而不是简单地1。

Python 2，67字节

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

在线尝试！

从字面上实现挑战。将列表本身的副本用作“空白”，因为这些副本不能等于任何数字。

木炭，27 23字节

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

在线尝试！链接是详细版本的代码。说明：

Ｆθ«

循环工作。

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

当工作是结果的最后两个之一时，增加冷却点。

⊞υι»

将当前作业添加到结果中。

ＩＬυ

打印点数。

R，74 68字节

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

在线尝试！

构造工作数组（反向），然后获取长度。只是有点短的比长基里尔L.的回答，所以有的时候，天真的方法是相当不错的。编辑：再短一点！我还借用了Kirill的测试模板。

-6个字节替换 max(0,which(y==x[2:1])) 为 match(y,x,0)。

Perl 6、98字节

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

在线尝试！

Blergh，必须有一个更好的方法来做到这一点。我不是100％肯定这是完全正确的，尽管它通过了我能想到的所有极端情况。

基本上，这是将输入列表的所有三元组进行分组，并在每一侧进行填充。例如，[1,2,1,2]变为(Any,1,2), (1,2,1), (2,1,2), (1,2,Nil)。我们将repeated每个三元组中的元素变为(), (1), (2), ()。

然后squish，它会生成不相同列表但大小相同的连续元素（以不压缩[1,1,1]），并且第一个元素不等于其之前的元素（因为我们无法合并中的小时[1,1,2,2]），并且最后，之前的元素也没有被压缩（[1,2,1,2,1,2]）。因此(1), (2)，在上面的示例中，上面将被压缩在一起。

最后，我们获得了sum该列表所有长度的，它们代表插入的小时数，然后加上原始列表的长度。

例如：

(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个字节

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

在线尝试！

已评论

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字节

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

在线尝试！

直接递归。

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个字节

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

在线尝试！

如果列表至少包含两个元素，则为45个字节：

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

在线尝试！

Smalltalk，125个字节

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

说明

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个字节

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

在线尝试！

批次，184个字节

@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

输入是通过命令行参数，输出是通过退出代码。说明：

@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

更新最后两个作业，并为该作业分配一个位置。

迅捷，114字节

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

在线尝试！

Python 3中，79 75个字节

-3个字节归于mypetlion，-1个字节归于
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)

在线尝试！

Java（JDK），110字节

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

在线尝试！

取消注释的代码：

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

果冻，20字节

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

在线尝试！

虽然这与 @EriktheOutgolfer的简短答案，但我在没有看到他的情况下写了它。无论如何他都更好！

说明

Helper双向链接，将当前列表作为左侧项目，将下一个项目作为右侧

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

主monadic链接，以整数列表作为输入

⁶             | 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个字节

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

在线尝试！

JavaScript（Node.js），52字节

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

在线尝试！

APL（Dyalog Classic），22字节

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

在线尝试！

JavaScript（V8），101个字节

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}

在线尝试！

解压后的代码如下所示：

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

我的第一次代码高尔夫球尝试可能可以通过缩小数组并递归传递来进行很多优化。

Zsh，66 60字节

隐含的-6个字节 "$@"

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

在线尝试！我强烈建议set -x您从头开始，以便您可以继续。

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总是包含最后两个作业，因此如果查找在中找到匹配的作业a[2]，我们将增加三个（因为作业位置为[... 3 _ _ 3 ...]）。

如果 a未设置，则查找将失败，并且算术扩展将返回错误，但这仅在第一份工作上发生，并且不会致命。

如果$[x+=i+1]改为使用，我们可以再节省一个字节，并且用户系统上没有完全由数字组成的命令。

K（ngn / k），27个字节

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

在线尝试！