Les hippocampes ont bien sûr besoin de chaussures. Cependant, un hippocampe, n'ayant qu'une seule queue, n'a besoin que d'une seule chaussure. Malheureusement, les chaussures ne viennent que par paires. L'argent est limité pour le gouvernement des hippocampes, ils doivent donc acheter le moins de paires possible. Chaque hippocampe a une pointure x où x est un entier positif. Cependant, un hippocampe peut porter une chaussure de taille x - 1 ou x + 1 si besoin est.

Votre tâche consiste à produire le nombre minimum de paires que le gouvernement des hippocampes doit acheter pour mettre des chaussures sur tous leurs hippocampes.

Vous pouvez saisir des informations comme vous le souhaitez, des failles standard, etc.

Comme il s'agit de code-golf , le code le plus court en octets l'emporte.

Cas de test

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 octets

Utilise l'approche OP décrite dans les commentaires.

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

Essayez-le en ligne!

Explication

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

Coque , 15 14 octets

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

Utilise l'algorithme gourmand: trier et coupler à partir de la gauche. Essayez-le en ligne!

Merci à Leo d'avoir économisé 1 octet.

Explication

Il s'agit de la première réponse Husk qui utilise Γla fonction de motif correspondant à une liste. Dans ce cas d'utilisation, si aest une valeur et gest une fonction, Γagcorrespond alors à la fonction fdéfinie par l'extrait de code Haskell

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

Je définis le cas de base comme a = 0et

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

où line0fait référence à la ligne entière. Dans le code Husk, xet xssont des arguments implicites à la fonction lambda, et line0est ₀. La liste est à nouveau triée à chaque appel récursif, mais cela n'a pas d'importance dans un défi 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 octets

9 octets grâce à xnor.

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

Essayez-le en ligne!

Gelée , 20 18 octets

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

Essayez-le en ligne!

Fork de ma réponse Python .

Python 2 , 49 octets

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

Essayez-le en ligne!

Basé sur la solution récursive de Leaky Nun .

Python 2 , 59 octets

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

Essayez-le en ligne!

Itère les tailles xdans l'ordre trié. Se souvient du seuil supérieur ppour la taille actuelle à la paire avec la précédente. Si tel est le cas ( x>p), réinitialisez le seuil à 0pour empêcher le jumelage du suivant. Sinon, augmentez le nombre de sorties cet définissez le seuil suivant psur x+2.

Le nouveau seuil p=(x>p)*(x+2)est une expression gonflée. J'aimerais trouver un moyen de le raccourcir.

C #, 111 108 137 102 octets

Cela ne gagnera jamais mais je voulais quand même résoudre l'exercice:

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

Grâce au commentaire de @grabthefish, j'ai pu grignoter quelques octets de plus:

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

En suivant les règles C&C spéciales de 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);}}

Utilisation d'une fonction 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 octets

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

Prend la liste des arguments de la ligne de commande (as @ARGV), imprime STDOUTpar défaut.

À Seahorseville ...

UNE quartier est une séquence de pointures de chaussures voisines. Une fois triés, chaque hippocampe a des voisins immédiats qui peuvent partager la même taille de chaussure. Il peut y avoir plusieurs voisins dans le quartier et aucun voisin ne peut différer de plus de deux:

par exemple 3 3 4 5 5 6 est un seul quartier 2 4 6 6, et1 2 3 5 7 8 10 12

1 1 1 4 5 6contient par exemple deux quartiers:1 1 1 et 4 5 6.

Base de l'algorithme

Il existe deux types de quartiers:

• De taille égale

  Pour ceux-ci, les n/2paires sont toujours suffisantes:

  Par exemple, 3 3 4 5 5 6nécessite trois paires pour 3 3, 4 5et5 6

• De taille bizarre

  Pour ceux-ci, les ceil(n/2)paires sont toujours suffisantes:

  par exemple , 12 13 13 14 15nécessite trois paires pour 12 13, 13 14et 15seul.

Code non golfé pour tester l'algorithme

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

Exemples de résultats

(Quartiers fermés [ ] )

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 octets

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

Essayez dans le bac à sable Wolfram .

Perl, 103 octets

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

Prend la liste des arguments de la ligne de commande (as @ARGV), imprime versSTDOUTpar défaut.

Il s'agit d'une approche alternative, basée sur la relation suivante:

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

(Voir cette réponse pour la définition du quartier )

Javascript, 67 octets

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

Exemple d'extrait de code:

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