Seepferdchen brauchen natürlich Schuhe. Ein Seepferdchen mit nur einem Schwanz benötigt jedoch nur einen Schuh. Leider kommen die Schuhe nur paarweise. Das Geld für die Seepferdchenregierung ist knapp, deshalb müssen sie so wenig Paare wie möglich kaufen. Jedes Seepferdchen hat eine Schuhgröße x, wobei x eine positive ganze Zahl ist. Ein Seepferdchen kann jedoch bei Bedarf einen Schuh der Größe x - 1 oder x + 1 tragen .

Ihre Aufgabe ist es, die Mindestanzahl von Paaren auszugeben, die die Seepferdchenregierung kaufen muss, um alle ihre Seepferdchen mit Schuhen zu bekleiden.

Sie können Eingaben vornehmen, wie Sie möchten, Standardlücken usw.

Da es sich um Code-Golf , kürzeste Code in Bytes gewinnt.

Testfälle

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

Verwendet den in den Kommentaren beschriebenen Ansatz OP.

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

Probieren Sie es online!

Erläuterung

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

Schale , 15 bis 14 Bytes

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

Verwendet den Greedy-Algorithmus: Sortieren und Koppeln von links. Probieren Sie es online!

Danke an Leo für das Speichern von 1 Byte.

Erläuterung

Dies ist die erste Antwort von Husk, die Γdie Funktion für den Mustervergleich mit einer Liste verwendet. Wenn in diesem Anwendungsfall aein Wert und geine Funktion ist, Γagentspricht dies der fdurch das Haskell-Snippet definierten Funktion

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

Ich definiere den Basisfall als a = 0und

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

wo line0bezieht sich auf die gesamte Zeile. In dem Husk - Code, xund xsgeben implizite Argumente an die Lambda - Funktion und line0ist ₀. Die Liste wird bei jedem rekursiven Aufruf erneut sortiert, aber das spielt bei einer Golf-Herausforderung keine Rolle.

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

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

Probieren Sie es online!

Jelly , 20 bis 18 Bytes

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

Probieren Sie es online!

Gabel meiner Python Antwort .

Python 2 , 49 Bytes

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

Probieren Sie es online!

Basierend auf der rekursiven Lösung von Leaky Nun .

Python 2 , 59 Bytes

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

Probieren Sie es online!

Durchläuft die Größen xin sortierter Reihenfolge. Erinnert sich an den oberen Schwellenwert pfür die aktuelle Größe, der mit dem vorherigen gepaart wurde. Wenn dies der Fall ist ( x>p), setzen Sie den Schwellenwert zurück, 0um das Pairing des nächsten Schwellenwerts zu verhindern . Wenn nicht, erhöhen Sie die Ausgangsanzahl cund setzen Sie den nächsten Schwellenwert pauf x+2.

Die neue Schwelle p=(x>p)*(x+2)ist ein aufgeblähter Ausdruck. Ich würde gerne einen Weg finden, es zu verkürzen.

C #, 111 108 137 102 Bytes

Dies wird niemals gewinnen, aber ich wollte die Übung trotzdem lösen:

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

Dank des Kommentars von @grabthefish konnte ich noch ein paar Bytes knabbern:

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

Befolgen Sie die speziellen C # -Regeln von 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);}}

Verwendung einer Lambda-Funktion:

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)

Übernimmt die Liste der Argumente von der Kommandozeile (as @ARGV) und druckt nachSTDOUT standardmäßig auf.

In Seahorseville ...

Eine Nachbarschaft ist eine Folge benachbarter Schuhgrößen. Wenn sortiert, hat jedes Seepferdchen unmittelbare Nachbarn, die die gleiche Schuhgröße teilen können. Es kann mehrere Nachbarn in der Nachbarschaft geben und keine Nachbarn können sich im Wert um mehr als zwei unterscheiden:

zB 3 3 4 5 5 6ist eine einzelne Nachbarschaft, wie es ist2 4 6 6 , und1 2 3 5 7 8 10 12

zB 1 1 1 4 5 6enthält zwei Stadtteile: 1 1 1und4 5 6 .

Grundlage des Algorithmus

Es gibt zwei Arten von Nachbarschaft:

• Gleichmäßig groß

  Für diese, n/2 ist immer ein Paar ausreichend:

  zB 3 3 4 5 5 6benötigt drei Paare für 3 3, 4 5und5 6

• Seltsame Größe

  Für diese, ceil(n/2) ist immer ein Paar ausreichend:

  zB 12 13 13 14 15erfordert drei Paare für 12 13, 13 14und 15allein.

Ungolfed Code zum Testen des Algorithmus

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

Probenergebnisse

(Nachbarschaften eingeschlossen in [ ] )

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]&

Versuchen Sie es in Wolfram Sandbox .

Perl, 103 Bytes

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

Übernimmt die Liste der Argumente von der Kommandozeile (as @ARGV) und druckt nachSTDOUT standardmäßig auf.

Dies ist ein alternativer Ansatz, der auf der folgenden Beziehung basiert:

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

(In dieser Antwort erfahren Sie, wie die Nachbarschaft definiert ist.)

Javascript, 67 Bytes

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

Beispielcode-Snippet:

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