물론 해마는 신발이 필요합니다. 그러나 꼬리 하나만있는 해마는 단 하나의 신발 만 필요합니다. 불행히도 신발은 쌍으로 만 제공됩니다. 해마 정부는 돈이 부족하기 때문에 가능한 한 적은 수의 제품을 구매해야합니다. 각 해마의 신발 크기 x 는 x 가 양의 정수입니다. 그러나 해마는 필요한 경우 x-1 또는 x + 1 크기의 신발을 신을 수 있습니다.

당신의 임무는 해마 정부가 모든 해마에 신발을 신기 위해 구입해야하는 최소 페어 수를 출력하는 것입니다.

원하는대로 입력하거나 표준 허점 등을 사용할 수 있습니다.

이것이 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

테스트 사례

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

주석에 설명 된 접근 방식 OP를 사용합니다.

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

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

설명

{¥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

껍질 , 15 14 바이트

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

욕심 많은 알고리즘을 사용합니다 : 왼쪽에서 정렬 및 쌍. 온라인으로 사용해보십시오!

1 바이트를 절약 해 준 Leo에게 감사합니다.

설명

이것은 Γ리스트를 일치시키는 함수 인를 사용하는 첫 번째 Husk 답변입니다 . 이 사용 사례에서 a값 g이 함수이고 함수 인 경우 Haskell 스 니펫에 의해 정의 된 Γag함수에 해당합니다.f

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

기본 사례를 다음 a = 0과 같이 정의합니다.

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

여기서 line0전체 줄을 나타냅니다. 껍질 코드에서 x와 xs람다 함수 내재적 인자이고, line0이다 ₀. 목록은 각 재귀 호출마다 다시 정렬되지만 골프 챌린지는 중요하지 않습니다.

Γ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.

파이썬 3 , 69 66 60 바이트

xnor 덕분에 9 바이트

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

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

젤리 , 20 18 바이트

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

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

내 파이썬 답변 포크 .

파이썬 2 , 49 바이트

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

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

Leaky Nun의 재귀 솔루션을 기반으로 합니다 .

파이썬 2 , 59 바이트

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

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

x정렬 된 순서대로 크기 를 반복합니다 . p현재 크기에 대한 상위 임계 값 을 이전 크기와 쌍으로 기억합니다 . 그렇다면 ( x>p) 다음 임계 값을 0페어링 할 수 없도록 임계 값을 재설정하십시오 . 그렇지 않은 경우 출력 카운트를 늘리고 c다음 임계 값 p을로 설정하십시오 x+2.

새로운 임계 값 p=(x>p)*(x+2)은 부풀린 표현입니다. 그것을 단축하는 방법을 찾고 싶습니다.

C #을 111 108 137 102 바이트

이것은 결코 이길 수 없지만 어쨌든 운동을 해결하고 싶었습니다.

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

@grabthefish의 의견 덕분에 몇 바이트를 더 조금씩 쓸 수있었습니다.

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

PC & G 특수 C # 규칙 준수 :

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

람다 함수 사용 :

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

펄, 113 바이트

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

명령 줄 ( @ARGV) 에서 인수 목록을 가져 와서 STDOUT기본적으로 인쇄합니다 .

해마 빌에서 ...

동네 신발 크기를 이웃의 순서입니다. 분류 할 때, 각 해마에는 동일한 신발 크기를 공유 할 수있는 인접 이웃이 있습니다. 이웃에는 여러 이웃이있을 수 있으며 이웃은 두 개 이상 차이가있을 수 없습니다.

예를 들어 3 3 4 5 5 6, 단일 이웃 2 4 6 6이며,1 2 3 5 7 8 10 12

예를 들면 1 1 1 4 5 6두 지역을 포함 1 1 1하고 4 5 6.

알고리즘의 기초

이웃에는 두 가지 유형이 있습니다.

• 균일 한 크기

  이를 위해 n/2쌍은 항상 충분합니다.

  예를 들면 3 3 4 5 5 6삼쌍을위한 필요 3 3, 4 5및5 6

• 이상한 크기

  이를 위해 ceil(n/2)쌍은 항상 충분합니다.

  예를 들면 12 13 13 14 15위한 삼쌍 필요 12 13, 13 14그리고 15혼자.

알고리즘을 테스트하기위한 ungolfed 코드

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

샘플 결과

(에 포함 된 지역 [ ] )

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]

수학, 67 바이트

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

Wolfram 샌드 박스를 사용해보십시오 .

펄, 103 바이트

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

명령 줄 ( @ARGV) 에서 인수 목록을 가져 와서 STDOUT기본적으로 인쇄합니다 .

이는 다음 관계를 기반으로하는 대체 방법입니다.

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

( 이웃 정의 방법에 대해서는 이 답변 을 참조하십시오 )

자바 스크립트, 67 바이트

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

코드 스 니펫 예제 :

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])}`)