Cá ngựa, tất nhiên, cần giày. Tuy nhiên, một con cá ngựa, chỉ có một cái đuôi, chỉ cần một chiếc giày. Thật không may, đôi giày chỉ đi theo cặp. Tiền rất eo hẹp đối với chính phủ cá ngựa, vì vậy họ cần mua càng ít cặp càng tốt. Mỗi con cá ngựa có cỡ giày x trong đó x là số nguyên dương. Tuy nhiên, một con cá ngựa có thể mang giày có kích thước x - 1 hoặc x + 1 nếu cần.

Nhiệm vụ của bạn là đưa ra số lượng đôi tối thiểu mà chính phủ cá ngựa phải mua để đặt giày lên tất cả cá ngựa của họ.

Bạn có thể lấy đầu vào theo cách bạn muốn, sơ hở tiêu chuẩn, v.v.

Vì đây là môn đánh gôn , mã ngắn nhất tính bằng byte sẽ thắng.

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

2 4 6 6 8 14 ->        4
2 1 3 1 1 ->           3
4 1 4 9 1 8 9 1 8 4 -> 6
1 2 3 5 7 8 10 12 ->   4

05AB1E , 13 byte

Sử dụng phương pháp OP mô tả trong các ý kiến.

{¥3‹J0¡€gÌ2÷O

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

Giải trình

{¥3‹J0¡€gÌ2÷O   Argument l
{               Sort l
 ¥              Push deltas
  3‹            Map to lower than 3 (1 for true, 0 for false)
    J0¡         Join and split on 0
       €g       Map to length
         Ì      Each + 2
          2÷    Integer division by 2
            O   Sum

Husk , 15 14 byte

Γ0(→₀?tI↑<+3)O

Sử dụng thuật toán tham lam: sắp xếp và ghép từ bên trái. Hãy thử trực tuyến!

Cảm ơn Leo vì đã tiết kiệm 1 byte.

Giải trình

Đây là câu trả lời Husk đầu tiên sử dụng Γ, hàm cho mẫu khớp với danh sách. Trong trường hợp sử dụng này, nếu alà một giá trị và glà một hàm, thì Γagtương ứng với hàm fđược xác định bởi đoạn mã Haskell

f [] = a
f (x:xs) = g x xs

Tôi xác định trường hợp cơ sở là a = 0và

g x xs = 1 + line0 (if head xs < x+3 then tail xs else xs)

trong đó line0đề cập đến toàn bộ dòng. Trong mã Husk, xvà xslà các đối số ngầm cho hàm lambda, và line0là ₀. Danh sách được sắp xếp lại trong mỗi cuộc gọi đệ quy, nhưng điều đó không quan trọng trong một thử thách golf.

Γ0(→₀?tI↑<+3)O
             O  Sort
Γ               and pattern match
 0              giving 0 for an empty list
  (         )   and applying this function to a non-empty list:
          +3     Add 3 to first argument (x),
         <       make a "test function" for being less than that,
        ↑        take values from second argument (xs) while they pass the test.
     ?           If that prefix is nonempty (next value can be paired),
      t          take tail of xs,
       I         otherwise take xs as is.
    ₀            Apply the main function (line0) to this list
   →             and add 1 for the singleton/pair we just processed.

Python 3 , 69 66 60 byte

9 byte nhờ xnor.

f=lambda a:a[1:a.sort()]and-~f(a[1+(a[1]-a[0]<3):])or len(a)

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

Thạch , 20 18 byte

ṢLµIḢ<3+2⁸ṫß‘µLỊ$?

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

Ngã ba câu trả lời Python của tôi .

Python 2 , 49 byte

f=lambda a:a>[a.sort()]and-~f(a[[3+a.pop(0)]>a:])

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

Dựa trên giải pháp đệ quy của Leaky Nun .

Python 2 , 59 byte

p=c=0
for x in sorted(input()):c+=x>p;p=(x>p)*(x+2)
print c

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

Lặp lại thông qua các kích thước xtheo thứ tự sắp xếp. Ghi nhớ ngưỡng trên pcho kích thước hiện tại được ghép nối với kích thước trước đó. Nếu vậy ( x>p), hãy đặt lại ngưỡng để 0không thể ghép nối cái tiếp theo. Nếu không, hãy tăng số lượng đầu ra cvà đặt ngưỡng tiếp theo pthành x+2.

Ngưỡng mới p=(x>p)*(x+2)là một biểu hiện cồng kềnh. Tôi muốn tìm cách rút ngắn nó.

C #, 111 108 137 102 byte

Điều này sẽ không bao giờ chiến thắng nhưng dù sao tôi cũng muốn giải bài tập:

Array.Sort(a);var c=0;for(var i=0;i<a.Length;i++){c++;i+=a.Length-i>1&&a[i+1]-a[i]<3?1:0;}Console.WriteLine(c);

Nhờ nhận xét của @grabthefish, tôi đã có thể nhấm nháp thêm một vài byte:

Array.Sort(a);int c=0,i=0;for(;i<a.Length;i++){c++;i+=a.Length-i>1&&a[i+1]-a[i‌​]<3?1:0;}Console.Wri‌​teLine(c);

Theo quy tắc C # đặc biệt của PC & G:

class P{static void Main(){Array.Sort(a);int c=0,i=0;for(;i<a.Length;i++){c++;i+=a.Length-i>1&&a[i+1]-a[i]<3?1:0;}Console.WriteLine(c);}}

Sử dụng chức năng lambda:

a=>{System.Array.Sort(a);int c=0,i=0;for(;i<a.Length;c++)i+=a.Length-i>1&&a[i+1]-a[i]<3?2:1;return c;}

Perl, 113 byte

say sub{for(1..$#_){$x{$i}++;$i++if$_[$_]-$_[$_-1]>2}$x{$i}++;$-+=$_/2+$_%2for values%x;$-}->(sort{$a<=>$b}@ARGV)

Đưa danh sách các đối số từ dòng lệnh (as @ARGV), in ra STDOUTtheo mặc định.

Ở Seahorseville ...

Một khu phố là một chuỗi các kích cỡ giày lân cận. Khi được sắp xếp, mỗi con cá ngựa có hàng xóm ngay lập tức có thể chia sẻ cùng cỡ giày. Có thể có nhiều hàng xóm trong khu phố và không có hàng xóm nào có thể khác nhau về giá trị nhiều hơn hai:

ví dụ như 3 3 4 5 5 6một khu phố duy nhất, như là 2 4 6 6, và1 2 3 5 7 8 10 12

ví dụ 1 1 1 4 5 6chứa hai vùng lân cận: 1 1 1và 4 5 6.

Cơ sở của thuật toán

Có hai loại khu phố:

• Kích thước thậm chí

  Đối với những điều này, n/2các cặp luôn luôn là đủ:

  ví dụ như 3 3 4 5 5 6đòi hỏi ba cặp cho 3 3, 4 5và5 6

• Kích thước lẻ

  Đối với những điều này, ceil(n/2)các cặp luôn luôn là đủ:

  ví dụ như 12 13 13 14 15đòi hỏi ba cặp cho 12 13, 13 14và 15một mình.

Mã xác thực để kiểm tra thuật toán

sub pairs {
    @_ = sort { $a <=> $b } @_;
    my @hood;
    my $i = 0;
    for (1..$#_) {
        push @{$hood[$i]}, $_[$_-1];
        $i++ if $_[$_]-$_[$_-1]>2
    }
    push @{$hood[$i]}, $_[$#_];
    my $pairs;
    $pairs += int(@{$hood[$_]} / 2) + @{$hood[$_]} % 2 for 0..$#hood;
    return "$pairs : @{[map qq([@$_]), @hood]}\n";
}

Kết quả mẫu

(Vùng lân cận kèm theo [ ] )

4 : [2 4 6 6 8] [14]
3 : [1 1 1 2 3]
6 : [1 1 1] [4 4 4] [8 8 9 9]
4 : [1 2 3 5 7 8 10 12]
17 : [1 2 3] [6 8 9 11 13 13 15 17 19 20 21] [27 28 29 30 32 33 35 35] [38 38 40] [43 45 45 46] [49]
18 : [3 3 3] [8 10 11 11 11 12 14] [18] [21 22 23] [29] [32 33 34 34 34 35 37 38 39 41] [44 46 48 49 49]
18 : [1 2 3] [6] [9] [12 13 15 17 18 19 20 21 21 23 24 25 25] [35 36] [40 41 41 41 43 45 46 46 46] [49]
16 : [1 3] [6 6 6 6] [11 12 14 14 15 17 19 20 20 21 21 22] [25 25 27 29 31 32 33] [38 39] [44 45] [49]
16 : [2 4] [7 7 8 10 12 13 15 16] [22 22 24 24] [27 29 31 31 33 34] [37 38 39] [42 43 43 44 45 46 47]
17 : [2 4 5 6 7] [11 11 13 13 14 15 16 17 17 17 19] [29] [34 35 36] [39 39 41 41 41 42 44 46] [49 49]
18 : [3 4 5 7 7] [10 10 12 12 12 14 15 15 17 18] [21] [24 24] [28] [32] [39 40 41 42 43 44 44] [47 47] [50]
16 : [2 4] [7 7 8 8] [11 11] [14 16 17 17 18 19] [22 24 26 26] [30 31 33 34 34 35] [38 38 39] [42 43] [50]
16 : [1 3 4 5] [11 11] [15 15 17 18 19 21 22 23 23 25 27 27 27 27 28 29 30 30] [33 34] [41 41] [45] [48]
17 : [2 2 3 4 6 6 7] [10 10] [13 14 15 16 17 19] [23 25] [28 30 31 32 33 34 36 37 38] [42] [48 49 50]
17 : [2] [7 9 9 9 9 10 10 12] [16 16] [19 21 21 22 24] [27 27 27] [36 36 36 37 39 39 40 40 40 41] [46]
18 : [1] [5 6 6 8] [11 11 12] [19 19 20 21 22 24 26 26] [29 30 31 32 34 35 35] [38] [42] [45] [48 48 49 49]
16 : [2 4 4 6] [11 12 13 13 13] [21 21 21 23] [30 31 31 33 35] [41 41 41 43 45 46 47 48 48 49 49 50]
16 : [2 2] [8 10 12] [15 15 15 15 16 16] [19 20] [23 24] [28 28 29] [32 34 36 36 36 37 39 41] [44 45 47 48]
17 : [3 3] [6] [9 10 11] [17 18] [21 23 23] [27 28 29 29 30 31 31 33] [37 37 39 39 39 40] [43 44] [47 48 49]
17 : [4] [7 9 10 10] [14 14 14] [17] [21] [25 25 27 27 28 30] [33 35 37 37 38 40 41 43 44 45 47 48 49 50]
18 : [3 4 5 6 7] [10 11 12 12 14 15 16 17] [20] [23 24 25 25 26 26] [31] [35] [38 40 41 42] [45 46 47] [50]
17 : [1 3] [8 10] [16 16 18 19 20 20] [23 23] [26] [30 31 33 34 35] [39 39 39 40 41 42 43] [46 46 47 47 49]
18 : [2 4 4 4 4 6 7 8 8 10 10] [13] [16 17] [20 22 23 25 25] [29 29 29] [33] [39 40 42] [48 48 49 49]
16 : [1 1 3 4] [7 8 10 10] [18 18 20 21] [24 25 26 27 29 31 33 33 34 34] [37 37 39] [45 46 48 49 49]
17 : [1] [4 4] [7 9 9 11 12] [15 16 17 17 18 19 21 21 21 22 23] [27 28 30 31] [37 39] [42] [48 49 49 50]
17 : [3 4 6 7 7 8 9 10 10 11 13 14 14] [21 21 23] [26 27] [31 32] [35 36] [39 40 41 41 41] [44 44] [49]
16 : [1] [4 6 6 8 10 12 13 15] [20 20 21 21] [29 29 30] [34 36 36 37 37 38 38 40] [44 45 46 47 47 48]
17 : [3 4 4 6] [12 14 15 16 17] [20 21 22 22 22 23 24 26 26] [29 30 32] [35 37 37 37 38 39 41 42] [48]
19 : [1] [5] [8 9] [14 14 14 16 16 17 17 17 17] [21] [24 24 24] [30] [34 35 36 37 39 40 40] [45 46 46 47 48]

Toán học, 67 byte

Length@Flatten[Partition[#,UpTo@2]&/@Split[Sort@#,Abs[#-#2]<3&],1]&

Hãy thử trong hộp cát Wolfram .

Perl, 103 byte

say sub{for(1..$#_+1){$x{$i}++;$i++if$_[$_]-$_[$_-1]>2}@_/2+.5*grep$_%2,values%x}->(sort{$a<=>$b}@ARGV)

Đưa danh sách các đối số từ dòng lệnh (as @ARGV), in ra STDOUTtheo mặc định.

Đây là một cách tiếp cận khác, dựa trên mối quan hệ sau:

Minimum pairs = ( Population size + # Odd neighbourhoods ) / 2

(Xem câu trả lời này để biết cách xác định vùng lân cận )

Javascript, 67 byte

a=>(a=a.sort((a,b)=>a-b)).filter((n,i)=>m=!m|n-a[i-1]>2,m=0).length

Đoạn mã ví dụ:

f=
a=>(a=a.sort((a,b)=>a-b)).filter((n,i)=>m=!m|n-a[i-1]>2,m=0).length

v=[[2,4,6,6,8,14],[2,1,3,1,1],[4,1,4,9,1,8,9,1,8,4],[1,2,3,5,7,8,10,12]]
for(k=0;k<4;k++)
  console.log(`f([${v[k]}])=${f(v[k])}`)