Sırasıyla yapılması gereken işlerin bir listesi göz önüne alındığında, her biri yapılacak bir yuva ile, bir işi yaptıktan sonra sonraki iki yuva için aynı iş yapılamazsa (yuvaları soğutmak) hepsini gerçekleştirmek ne kadar sürer? )? Ancak, bu soğutma yuvalarında farklı bir iş atanabilir.

Örneğin,

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

Çünkü işler olarak tahsis edilecektir [9 10 _ 9 8].
1. İlk olarak 9, _ _ olmak üzere iki soğutma noktasına ihtiyaç duyar. Böylece başlıyoruz 9 _ _.
2. Bir sonraki iş 10, bir önceki işten 9 farklıdır, bu nedenle _ _'ten birini tahsis edebiliriz. O zaman sahip olacağız 9 10 _.
3. Üçüncüsü, 9 şimdi tahsis edilemez, çünkü ilk iş 9 aynı iştir ve soğuma süresi gerekir. 9 10 _ 9.
4. Son olarak, 8 önceki iki iş ile aynı değildir, bu yüzden 9'dan hemen sonra tahsis edilebilir ve bu son iş olduğundan, soğuma süresi gerektirmez. Son liste 9 10 _ 9 8ve beklenen çıktı 5'tir (nokta sayısı (veya yuva sayısı))

Test senaryoları:

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

Giriş değeri herhangi bir tamsayı olabilir (negatif, 0, pozitif). İş listesinin uzunluğu 0 <= uzunluk <= 1.000.000.
Çıktı, test durumunda çıktı olarak belirtilen bir tam sayı, toplam yuva sayısı olacaktır. Parantez içindeki liste çıktının nasıl oluşturulacağıdır.

Kazanan kriter
kod-golf

Jöle , 14 bayt

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

Çevrimiçi deneyin!

05AB1E , 22 bayt

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

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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 bayt

Brachylog'un en iyi performansı gösterdiği sorunu görmek her zaman güzeldir

⊆Is₃ᶠ≠ᵐ∧Il

açıklama

⊆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

Çevrimiçi deneyin!

R , 123 bayt

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

Çevrimiçi deneyin - tek bir program!

Çevrimiçi deneyin - birden fazla örnek!

Girdi olarak virgülle ayrılmış bir tamsayılar listesi okuyan ve gereken yuvaları çıkaran tam bir program. Eminim bu biraz daha golf olabilir ve bu regex tabanlı çözümü bazı dillerde uygulamak baytlarda daha verimli olacaktır.

İkinci TIO ile ilgili not, birden fazla örneğin gösterilmesine izin verecek bir fonksiyona sarıldım. Bu işlev aynı zamanda son listeyi de gösterir, ancak tek başına çalıştırılırsa bu benim ana programım değildir.

TSQL sorgusu, 158 bayt

Verileri tablo olarak girin.

Sorgu özyinelemeli

SEÇENEK (MAKSİMUM 0)

gereklidir, çünkü sayı listesi 100'ü aşabilir, ancak yalnızca 32.767 özyinelemeyi gerçekleştirebilir - bu görevde gerçekten sınırlama gerekli mi?

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) 

Çevrimiçi deneyin

R , 81 70 bayt

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

Çevrimiçi deneyin!

Birkaç başarısız denemeden sonra, kod oldukça çirkinleşti ve çok kısa değil, ama en azından şimdi çalışıyor ...

İlk olarak, aynı işin ardışık çalışma uzunluklarını değerlendiriyoruz. Örneğin bunun için 3, 3, 4, 3:

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

Bu çalışmaların her biri (len - 1) * 3 + 1adımlar üretir ( + 1ayrı olarak ele alınır).

Daha sonra, aynı işin oluşumlarını 2 yer arayla işliyoruz, örneğin: x, y, xkullanarak diff(s, lag=2). Elde edilen vektör ayrıca fonksiyon ile ardışık çalışmalara ( r) ayrılır rle. Şimdi, çeşitli serpiştirilmiş alternatifler nedeniyle eklememiz gerekiyorceiling(r$len/2) tüm sıfırlar için adımlar . Örneğin:

x y x(uzunluk 1) ve x y x y(uzunluk 2) her ikisi de 1 ek adım gerektirir:x y _ x (y)

x y x y x (uzunluk 3) ve x y x y x y (uzunluk 4) her ikisi de 2 ek adım gerektirir:x y _ x y _ x (y)

Son olarak, aynı işin uzun bir döneminin ortasında bu değişimlerin oluşumlarını telafi etmeliyiz: x, x, x, x...dolayısıyla 1-l%/%6basitçe yerine 1.

Python 2 , 67 bayt

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

Çevrimiçi deneyin!

Bu meydan okumayı kelimenin tam anlamıyla uygular. Listenin kendisinin kopyalarını "boşluk" olarak kullanır, çünkü bunlar herhangi bir sayıya eşit olamaz.

Odun kömürü , 27 23 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

Ｆθ«

İşlerin üzerinden geçin.

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

İş sonuçtaki son ikiden biriyken, serinleme noktaları ekleyin.

⊞υι»

Geçerli işi sonuca ekleyin.

ＩＬυ

Nokta sayısını yazdırın.

R , 74 68 bayt

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

Çevrimiçi deneyin!

Çalışma dizisini (tersine) oluşturur, sonra uzunluğu alır. Sadece biraz daha kısa daha uzun Kirill L. cevabı , bu yüzden bazen naif yaklaşım oldukça iyidir. EDIT: yine daha kısa! Kirill'in test şablonunu da ödünç aldım.

-6 değiştirilmesi bayt max(0,which(y==x[2:1])) ile match(y,x,0) .

Perl 6 , 98 bayt

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

Çevrimiçi deneyin!

Blergh, bunu yapmanın daha iyi bir yolu olmalı. Düşünebildiğim tüm uç durumları geçmesine rağmen, bunun tamamen doğru olduğundan% 100 emin değilim.

Temel olarak, bu, giriş listesinin tüm üçüzlerini, her iki tarafa dolgu ile gruplayarak başlar. Örneğin, [1,2,1,2]olur (Any,1,2), (1,2,1), (2,1,2), (1,2,Nil). repeatedHer üçlünün içindeki unsurları alıyoruz (), (1), (2), ().

Daha sonra squishaynı liste olmayan, ancak aynı boyutta (benzer bir şeyi ezmemek için [1,1,1]) birbirini takip eden öğelerdir ve ilk öğe, önceki öğeye eşit değildir (çünkü saatleri birleştiremeyiz [1,1,2,2]) ve nihayet önceki eleman da ezilmedi ( [1,2,1,2,1,2]). Dolayısıyla (1), (2)yukarıdaki örnekte birlikte ezilecekti.

Son olarak, sumeklenen saatlerimizi temsil eden bu listenin tüm uzunluklarını elde edip orijinal listenin uzunluğunu ekliyoruz.

Örneğin:

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

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

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

Basit özyineleme.

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 bayt

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

Çevrimiçi deneyin!

Listede en az iki öğe varsa 45 bayt :

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

Çevrimiçi deneyin!

Smalltalk, 125 bayt

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

açıklama

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 bayt

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

Çevrimiçi deneyin!

Toplu, 184 bayt

@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

Girdi komut satırı argümanları üzerinden, çıkış ise çıkış kodu üzerinden gerçekleşir. Açıklama:

@set l=-
@set p=-

Son iki işi takip edin.

@set n=0

Sayımı başlatın.

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

Her işi işleyin.

@exit/b%n%

Son sayımı çıktılar.

:c

Her iş için:

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

İşi yakın zamanda işlediysek, uygun sayıda soğutma noktası ekleyin. Ayrıca, son işi temizleyin, böylece bir sonraki iş yalnızca bu işle aynı ise soğutmayı tetikler.

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

Son iki işi güncelleyin ve bu işe bir nokta ayırın.

Swift, 114 bayt

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

Çevrimiçi deneyin!

Python 3 , 79 75 bayt

Sara J sayesinde mypetlion -1 bayt sayesinde -3 bayt

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

Çevrimiçi deneyin!

Java (JDK) , 110 bayt

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

Çevrimiçi deneyin!

Ungolfed yorum kodu:

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

Jöle , 20 bayt

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

Çevrimiçi deneyin!

Bu @ EriktheOutgolfer'ın daha kısa cevabına oldukça benzese de , onu görmeden yazdım. Her durumda onun daha iyi!

açıklama

Yardımcı ikili bağlantı, geçerli listeyi sol öğe olarak ve sonraki öğeyi sağ olarak alır

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

Ana monadik bağlantı, girdi olarak tamsayıların listesini alır

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

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 52 bayt

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

Çevrimiçi deneyin!

APL (Dyalog Klasik) , 22 bayt

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

Çevrimiçi deneyin!

JavaScript (V8), 101 bayt

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}

Çevrimiçi deneyin!

Ambalajsız kod aşağıdaki gibi görünür:

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

İlk kod golf girişimim, diziyi küçülterek ve tekrar tekrar geçirerek muhtemelen çok optimize edilebilir.

Zsh , 66 60 bayt

Örtükten -6 bayt "$@"

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

Çevrimiçi deneyin! set -xTakip edebilmeniz için başlangıca eklemenizi şiddetle tavsiye ederim .

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

aher zaman son iki işi içerir, bu nedenle aramada eşleşen bir iş bulursa a[2]üçe çıkarırız (iş alanları olacağından [... 3 _ _ 3 ...]).

Eğer aayarlanmazsa, arama başarısız olur ve aritmetik genişleme bir hata döndürür, ama bu sadece ilk işi olur ve ölümcül değildir.

$[x+=i+1]Bunun yerine kullanırsak bir bayt daha kaydedebiliriz ve kullanıcı sisteminde tamamen rakamlardan oluşan komutlar yoktur.

K (ngn / k) , 27 bayt

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

Çevrimiçi deneyin!