Враховуючи перелік завдань, які необхідно виконати для того, щоб кожен міг виконувати слот, скільки часу буде потрібно для їх виконання, якщо після виконання однієї і тієї ж роботи неможливо виконати наступні два слоти (охолодження слотів )? Однак в цьому слоті для охолодження може бути призначена інша робота.

Наприклад,

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

Брахілог , 10 байт

Завжди приємно бачити проблему, коли Брахілог найкраще працює

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

Це необхідно, тому що список номерів може перевищувати 100, хоча він може тривати лише 32 767 рекурсій - чи дійсно необхідне обмеження в цьому завданні?

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обробляється окремо).

Далі ми обробляємо події одного і того ж завдання на 2 місця один від одного, наприклад: 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.

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

Спробуйте в Інтернеті!

Конструює робочий масив (у зворотному напрямку), потім бере довжину. Трохи коротше, ніж відповідь Кирила Л. , тому іноді наївний підхід досить хороший. EDIT: знову коротше! Я також запозичив тестовий шаблон Кирила.

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

Спробуйте в Інтернеті!

Маленька розмова, 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 байт завдяки Сара Дж

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

Спробуйте в Інтернеті!

Код, який прокоментував 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 , я написав це, не побачивши його. У будь-якому випадку його краще!

Пояснення

Діадний посилання помічника, приймає поточний список як лівий елемент, а наступний - як правий

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

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

Моя перша в історії спроба гольфу на коді, можливо, може бути багато оптимізована, скорочуючи масив і передаючи його рекурсивно.

Зш , 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 (нг / к) , 27 байт

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

Спробуйте в Інтернеті!