Đưa ra một danh sách các công việc, phải được thực hiện theo thứ tự, với mỗi lần lấy một vị trí để thực hiện, sẽ mất bao lâu để thực hiện tất cả chúng nếu sau khi thực hiện một công việc, hai công việc tương tự không thể được thực hiện cho hai vị trí tiếp theo (làm mát các vị trí )? Tuy nhiên, một công việc khác có thể được chỉ định trong khe làm mát này.

Ví dụ,

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

Bởi vì công việc sẽ được phân bổ như [9 10 _ 9 8].
1. Đầu tiên, 9 cần hai điểm làm mát _ _. Vì vậy, chúng tôi bắt đầu với 9 _ _.
2. Công việc tiếp theo 10 khác với công việc trước 9, vì vậy chúng tôi có thể phân bổ một trong _ _. Rồi chúng ta sẽ có 9 10 _.
3. Thứ ba, 9 không thể được phân bổ ngay bây giờ, vì công việc đầu tiên 9 là cùng một công việc và nó cần thời gian nghỉ mát. 9 10 _ 9.
4. Lần cuối, 8 không giống như bất kỳ hai công việc trước nào khác, vì vậy nó có thể được phân bổ ngay sau 9 và vì đây là công việc cuối cùng, nên không cần thời gian nghỉ mát. Danh sách cuối cùng là 9 10 _ 9 8và đầu ra dự kiến ​​là 5, đó là số lượng điểm (hoặc số lượng vị trí)

Các trường hợp thử nghiệm:

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

Giá trị đầu vào có thể là bất kỳ số nguyên nào (âm, 0, dương). Độ dài của danh sách công việc là 0 <= length <= 1.000.000.
Đầu ra sẽ là một số nguyên, tổng số vị trí, được chỉ định trong trường hợp thử nghiệm là đầu ra. Danh sách bên trong dấu ngoặc đơn là cách đầu ra sẽ được tạo.

Giành được tiêu chí
đánh gôn

Thạch , 14 byte

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

Hãy thử trực tuyến!

05AB1E , 22 byte

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

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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 byte

Thật tuyệt khi thấy vấn đề mà Brachylog hoạt động tốt nhất

⊆Is₃ᶠ≠ᵐ∧Il

Giải trình

⊆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

Hãy thử trực tuyến!

R , 123 byte

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

Dùng thử trực tuyến - chương trình duy nhất!

Hãy thử trực tuyến - nhiều ví dụ!

Một chương trình đầy đủ đọc danh sách các số nguyên được phân tách bằng dấu phẩy làm đầu vào và xuất ra các vị trí cần thiết. Tôi chắc chắn rằng điều này có thể được đánh gôn thêm và thực hiện giải pháp dựa trên regex này trong một số ngôn ngữ khác sẽ hiệu quả hơn bằng byte.

Lưu ý về TIO thứ hai tôi đã bọc nó trong một chức năng để cho phép nhiều ví dụ được hiển thị. Hàm này cũng hiển thị danh sách cuối cùng, nhưng đây không phải là đầu ra chương trình chính của tôi nếu chạy độc lập.

Truy vấn TSQL, 158 byte

Dữ liệu đầu vào dưới dạng bảng.

Các truy vấn là đệ quy vì vậy

TÙY CHỌN (MAXRECURSION 0)

là cần thiết, bởi vì danh sách các số có thể vượt quá 100 mặc dù nó chỉ có thể xử lý 32.767 lần thu hồi - giới hạn có thực sự cần thiết trong nhiệm vụ này không?

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) 

Dùng thử trực tuyến

R , 81 70 byte

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

Hãy thử trực tuyến!

Sau nhiều lần thử không thành công, mã trở nên khá xấu và không quá ngắn, nhưng ít nhất nó vẫn hoạt động ...

Đầu tiên, chúng tôi đánh giá độ dài của các lần chạy liên tiếp của cùng một công việc. Ví dụ cho 3, 3, 4, 3điều này mang lại:

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

Mỗi lần chạy này tạo ra (len - 1) * 3 + 1các bước ( + 1được xử lý riêng).

Tiếp theo, chúng tôi xử lý các lần xuất hiện của cùng một công việc cách nhau 2 nơi, như : x, y, x, bằng cách sử dụng diff(s, lag=2). Vectơ kết quả cũng được chia thành các lần chạy liên tiếp ( r) theo rlehàm. Bây giờ, do có nhiều cách xen kẽ khác nhau, chúng tôi cần thêm ceiling(r$len/2)các bước cho tất cả các lần chạy số không. Ví dụ:

x y x(chiều dài 1) và x y x y(chiều dài 2) cả hai cần thêm 1 bước:x y _ x (y)

x y x y x(chiều dài 3) và x y x y x y(chiều dài 4) cả hai cần thêm 2 bước:x y _ x y _ x (y)

Cuối cùng, chúng ta cần phải bù đắp cho sự xuất hiện của những sự thay thế này ở giữa một thời gian dài của cùng một công việc : x, x, x, x..., do đó 1-l%/%6thay vì đơn giản 1.

Python 2 , 67 byte

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

Hãy thử trực tuyến!

Thực hiện thử thách theo đúng nghĩa đen. Sử dụng các bản sao của danh sách là "khoảng trống", vì chúng không thể bằng bất kỳ số nào.

Than , 27 23 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆθ«

Vòng qua các công việc.

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

Thêm các điểm làm mát trong khi công việc là một trong hai kết quả cuối cùng.

⊞υι»

Thêm công việc hiện tại vào kết quả.

ＩＬυ

In số lượng điểm.

R , 74 68 byte

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

Hãy thử trực tuyến!

Xây dựng mảng công việc (ngược lại), sau đó lấy chiều dài. Chỉ ngắn hơn một chút so với câu trả lời của Kirill L. , nên đôi khi, cách tiếp cận ngây thơ là khá tốt. EDIT: ngắn hơn một lần nữa! Tôi cũng mượn mẫu thử của Kirill.

-6 byte thay thế max(0,which(y==x[2:1])) bằng match(y,x,0) .

Perl 6 , 98 byte

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

Hãy thử trực tuyến!

Blergh, phải có một cách tốt hơn để làm điều này. Tôi không chắc chắn 100% điều này là hoàn toàn chính xác, mặc dù nó vượt qua tất cả các trường hợp cạnh mà tôi có thể nghĩ ra.

Về cơ bản, điều này bắt đầu bằng cách nhóm tất cả các bộ ba của danh sách đầu vào, với phần đệm ở hai bên. Ví dụ, [1,2,1,2]trở thành (Any,1,2), (1,2,1), (2,1,2), (1,2,Nil). Chúng tôi có được các repeatedyếu tố trong mỗi bộ ba, trở thành (), (1), (2), ().

Sau đó, squishcác phần tử liên tiếp không cùng danh sách, nhưng có cùng kích thước (để không squish một cái gì đó giống như [1,1,1]) và phần tử đầu tiên không bằng phần tử trước nó (vì chúng ta không thể hợp nhất số giờ trong [1,1,2,2]) và cuối cùng phần tử trước đó cũng không bị cắt xén ( [1,2,1,2,1,2]). Vì vậy, (1), (2)trong ví dụ trên sẽ được ghép lại với nhau.

Cuối cùng, chúng tôi nhận được sumtất cả độ dài của danh sách này, đại diện cho số giờ được chèn của chúng tôi và thêm độ dài của danh sách ban đầu.

Ví dụ:

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

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

Hãy thử trực tuyến!

Đã bình luận

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 byte

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

Hãy thử trực tuyến!

Đệ quy đơn giản.

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 byte

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

Hãy thử trực tuyến!

45 byte nếu danh sách có ít nhất hai phần tử:

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

Hãy thử trực tuyến!

Smalltalk, 125 byte

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

Giải trình

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 byte

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

Hãy thử trực tuyến!

Mẻ, 184 byte

@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

Đầu vào là thông qua các đối số dòng lệnh và đầu ra là thông qua mã thoát. Giải trình:

@set l=-
@set p=-

Theo dõi hai công việc cuối cùng.

@set n=0

Khởi tạo số đếm.

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

Xử lý từng công việc.

@exit/b%n%

Đầu ra số cuối cùng.

:c

Đối với mỗi công việc:

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

Nếu chúng tôi xử lý công việc gần đây, hãy thêm vào một số điểm làm mát thích hợp. Ngoài ra, xóa công việc cuối cùng để công việc tiếp theo chỉ kích hoạt làm mát nếu nó giống như công việc này.

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

Cập nhật hai công việc cuối cùng và phân bổ một vị trí cho công việc này.

Swift, 114 byte

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

Hãy thử trực tuyến!

Python 3 , 79 75 byte

-3 byte nhờ mypetlion
-1 byte nhờ 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)

Hãy thử trực tuyến!

Java (JDK) , 110 byte

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

Hãy thử trực tuyến!

Mã nhận xét 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;
}

Thạch , 20 byte

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

Hãy thử trực tuyến!

Mặc dù điều này khá giống với câu trả lời ngắn hơn của @ EriktheOutgolfer , tôi đã viết nó mà không thấy câu trả lời của anh ấy. Trong mọi trường hợp của mình là tốt hơn!

Giải trình

Trình trợ giúp liên kết dyadic, lấy danh sách hiện tại làm mục bên trái và mục tiếp theo là bên phải

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

Liên kết đơn nguyên chính, lấy danh sách các số nguyên làm đầu vào

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

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 52 byte

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

Hãy thử trực tuyến!

APL (Dyalog Classic) , 22 byte

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

Hãy thử trực tuyến!

JavaScript (V8), 101 byte

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}

Hãy thử trực tuyến!

Mã chưa giải nén trông như sau:

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

Lần thử đầu tiên của tôi về môn đánh gôn, có thể được tối ưu hóa rất nhiều bằng cách thu nhỏ mảng và chuyển nó theo cách đệ quy.

Zsh , 66 60 byte

-6 byte từ ẩn "$@"

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

Hãy thử trực tuyến! Tôi rất khuyên bạn nên thêm set -xvào đầu để bạn có thể làm theo.

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

aluôn chứa hai công việc cuối cùng, vì vậy nếu tra cứu tìm thấy một công việc phù hợp a[2], chúng tôi sẽ tăng thêm ba (vì các vị trí công việc sẽ là [... 3 _ _ 3 ...]).

Nếu akhông được đặt, việc tra cứu sẽ thất bại và việc mở rộng số học sẽ trả về lỗi, nhưng điều đó chỉ xảy ra ở công việc đầu tiên và không gây tử vong.

Chúng ta có thể lưu thêm một byte nếu chúng ta sử dụng $[x+=i+1]thay thế và không có lệnh nào trên hệ thống người dùng bao gồm toàn bộ các chữ số.

K (ngn / k) , 27 byte

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

Hãy thử trực tuyến!