각 작업을 수행 할 때 순서대로 수행해야하는 작업 목록이 주어지면 작업을 수행 한 후 다음 두 슬롯에 대해 동일한 작업을 수행 할 수없는 경우 모든 작업을 수행하는 데 걸리는 시간 (슬롯 냉각) )? 그러나이 냉각 슬롯에 다른 작업을 할당 할 수 있습니다.

예를 들어

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

작업으로 할당 할 수 있기 때문에 [9 10 _ 9 8].
먼저, 9는 2 개의 냉각 지점 _ _이 필요합니다. 우리는로 시작합니다 9 _ _.
2. 다음 작업 10은 이전 작업 9와 다르므로 _ _ 중 하나를 할당 할 수 있습니다. 그럼 우리는 할 것이다 9 10 _.
3. 첫 번째 작업 9는 동일한 작업이며 냉각 시간이 필요하므로 세 번째, 9는 지금 할당 할 수 없습니다. 9 10 _ 9.
4. 마지막으로 8은 이전의 두 작업과 동일하지 않으므로 9 직후에 할당 할 수 있으며 마지막 작업이므로 냉각 시간이 필요하지 않습니다. 최종 목록은 9 10 _ 9 85이며 예상 출력은 스폿 수 (또는 슬롯 수)입니다.

테스트 사례 :

[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 바이트

데이터를 테이블로 입력하십시오.

쿼리는 재귀 적이므로

옵션 (MAXRECURSION 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사용하여 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.

파이썬 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()))

온라인으로 사용해보십시오!

작업 배열을 역순으로 구성한 다음 길이를 가져옵니다. Kirill L.의 답변 보다 조금 더 짧기 때문에 때로는 순진한 접근 방식이 꽤 좋습니다. 편집 : 다시 짧게! 또한 Kirill의 테스트 템플릿을 빌 렸습니다.

-6 교체 바이트 max(0,which(y==x[2:1])) 로 match(y,x,0) .

펄 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동일한 목록은 아니지만 크기가 같은 연속 요소 를 es [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

자바 스크립트 (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
}

펄 6 , 48 바이트

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

온라인으로 사용해보십시오!

목록에 두 개 이상의 요소가있는 경우 45 바이트 :

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

온라인으로 사용해보십시오!

스몰 토크, 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.

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

온라인으로 사용해보십시오!

파이썬 3 , 79 75 바이트

mypetlion 덕분에 -3 바이트
Sara J 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

자바 (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;}

온라인으로 사용해보십시오!

Ungolfed 주석 코드 :

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의 짧은 대답 과 다소 비슷하지만 , 나는 그를 보지 않고 썼습니다. 어쨌든 그의 낫다!

설명

도우미 Dyadic 링크, 현재 목록을 왼쪽 항목으로, 다음 항목을 오른쪽으로 가져옵니다.

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

메인 모나 딕 링크, 정수 목록을 입력으로 사용

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

파이썬 2 , 75 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (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 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (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 _ _ 3 ...].

만약 a 설정 해제, 조회가 실패하고 산술 확장은 오류를 반환합니다,하지만 첫 번째 작업에서 발생하고 치명적인 없습니다.

$[x+=i+1]대신 사용하면 바이트를 하나 더 절약 할 수 있으며 사용자 시스템에는 완전히 숫자로 구성된 명령이 없습니다.

K (ngn / k) , 27 바이트

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

온라인으로 사용해보십시오!