Los caballitos de mar, por supuesto, necesitan zapatos. Sin embargo, un caballito de mar, que tiene una sola cola, necesita solo un zapato. Desafortunadamente, los zapatos solo vienen en pares. El dinero es escaso para el gobierno del caballito de mar, por lo que necesitan comprar la menor cantidad posible de pares. Cada caballito de mar tiene una talla de zapato x donde x es un número entero positivo. Sin embargo, un caballito de mar puede usar un zapato de tamaño x - 1 o x + 1 si es necesario.

Su tarea es producir el número mínimo de pares que el gobierno de caballitos de mar debe comprar para poner zapatos en todos sus caballitos de mar.

Puede tomar la entrada como quiera, lagunas estándar, etc.

Como se trata de código de golf , gana el código más corto en bytes.

Casos de prueba

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 bytes

Utiliza el enfoque OP descrito en los comentarios.

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

Pruébalo en línea!

Explicación

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

Casco , 15 14 bytes

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

Utiliza el algoritmo codicioso: ordenar y emparejar desde la izquierda. Pruébalo en línea!

Gracias a Leo por guardar 1 byte.

Explicación

Esta es la primera respuesta de Husk que utiliza Γ, la función para el patrón que coincide con una lista. En este caso de uso, si aes un valor y ges una función, Γagcorresponde a la función fdefinida por el fragmento de Haskell

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

Defino el caso base como a = 0y

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

donde se line0refiere a toda la línea. En el código Husk, xy xsson argumentos implícitos para la función lambda, y line0es ₀. La lista se ordena nuevamente en cada llamada recursiva, pero eso no importa en un desafío de 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 bytes

9 bytes gracias a xnor.

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

Pruébalo en línea!

Jalea , 20 18 bytes

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

Pruébalo en línea!

Tenedor de mi respuesta Python .

Python 2 , 49 bytes

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

Pruébalo en línea!

Basado en la solución recursiva de Leaky Nun .

Python 2 , 59 bytes

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

Pruébalo en línea!

Itera a través de los tamaños xen orden ordenado. Recuerda el umbral superior ppara el tamaño actual al emparejado con el anterior. Si es así ( x>p), restablezca el umbral a 0para que sea imposible emparejar el siguiente. De lo contrario, incremente el recuento de salida cy establezca el siguiente umbral pen x+2.

El nuevo umbral p=(x>p)*(x+2)es una expresión hinchada. Me gustaría encontrar una manera de acortarlo.

C #, 111 108 137 102 bytes

Esto nunca ganará, pero de todos modos quería resolver el ejercicio:

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

Gracias al comentario de @grabthefish, pude picar algunos bytes más:

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

Siguiendo las reglas especiales de 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);}}

Usando una función 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 bytes

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

Toma una lista de argumentos de la línea de comando (como @ARGV), imprime enSTDOUT por defecto.

En Seahorseville ...

Un barrio es una secuencia de tamaños de zapatos vecinos. Cuando se clasifican, cada caballito de mar tiene vecinos inmediatos que pueden compartir el mismo tamaño de zapato. Puede haber varios vecinos en el vecindario y ningún vecino puede diferir en valor en más de dos:

por ejemplo, 3 3 4 5 5 6es un barrio único, como son2 4 6 6 , y1 2 3 5 7 8 10 12

por ejemplo, 1 1 1 4 5 6contiene dos barrios: 1 1 1y4 5 6 .

Bases del algoritmo.

Hay dos tipos de vecindario:

• De tamaño par

  Para estos, los n/2pares siempre son suficientes:

  por ejemplo, 3 3 4 5 5 6requiere tres pares para 3 3, 4 5y5 6

• De tamaño impar

  Para estos, los ceil(n/2)pares siempre son suficientes:

  por ejemplo, 12 13 13 14 15requiere tres pares para 12 13, 13 14y 15solo.

Código no protegido para probar el algoritmo

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

Resultados de muestra

(Barrios encerrados en [ ] )

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]

Mathematica, 67 bytes

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

Prueba en el sandbox de Wolfram .

Perl, 103 bytes

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

Toma una lista de argumentos de la línea de comando (as @ARGV), imprime enSTDOUT por defecto.

Este es un enfoque alternativo, basado en la siguiente relación:

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

(Vea esta respuesta para ver cómo se define el vecindario )

Javascript, 67 bytes

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

Fragmento de código de ejemplo:

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