Denizatı elbette ayakkabılara ihtiyaç duyar. Ancak, sadece bir kuyruğu olan bir denizatı sadece bir ayakkabıya ihtiyaç duyar. Ne yazık ki, ayakkabılar sadece çiftler halinde gelir. Denizatı hükümeti için para sıkışık olduğundan, mümkün olduğunca az çift almaları gerekiyor. Her denizatı, x'in pozitif bir tamsayı olduğu bir ayakkabı büyüklüğüne x sahiptir . Bununla birlikte, gerekirse bir denizatı x - 1 veya x + 1 boyutunda bir ayakkabı giyebilir .

Göreviniz, denizatı hükümetinin tüm denizatılara ayakkabı koymak için satın alması gereken asgari çift sayısını vermektir.

İsterseniz girişe girebilirsiniz, standart boşluklar vs.

Bu kod golf olduğu için , bayt cinsinden en kısa kod kazanır.

Test durumları

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 bayt

Yorumlarda açıklanan OP yaklaşımını kullanır.

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

Çevrimiçi deneyin!

açıklama

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

Kabuğu , 15 14 bayt

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

Açgözlü algoritmayı kullanır: soldan sıralamak ve eşleştirmek. Çevrimiçi deneyin!

Leo'ya 1 byte kaydettiğin için teşekkürler.

açıklama

Bu, kullanılan Γlistedeki ilk eşleştirme cevabıdır, bir listeyle eşleşen model fonksiyonu. Bu kullanım durumunda, abir değer ve gbir işlev ise, o zaman Haskell pasajı tarafından tanımlanan Γagişleve karşılık gelir.f

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

Temel durumu a = 0ve olarak tanımlarım

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

burada line0tüm hat anlamına gelmektedir. Husk kodunda, xve xslambda işlevine örtük argümanlar vardır ve line0is ₀. Her özyinelemeli aramada liste tekrar sıralanır, ancak bu bir golf mücadelesinde önemli değildir.

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

Xnor sayesinde 9 bayt.

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

Çevrimiçi deneyin!

Jöle , 20 18 bayt

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

Çevrimiçi deneyin!

Python cevabımın çatalı .

Python 2,49 bayt

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

Çevrimiçi deneyin!

Leaky Nun'un özyinelemeli çözümüne dayanarak .

Python 2 , 59 bayt

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

Çevrimiçi deneyin!

Boyutları xsıralanmış düzende sıralar. pGeçerli boyut için önceki ile eşleştirilen üst eşiği hatırlar . Öyleyse ( x>p), 0eşleştirmeyi bir sonrakinin eşleşmesini imkansız hale getirmek için sıfırlayın . Eğer değilse, çıkış sayısını artırmak cve sonraki eşiğini ayarlamak piçin x+2.

Yeni eşik p=(x>p)*(x+2)şişirilmiş bir ifadedir. Kısaltmak için bir yol bulmak istiyorum.

C #, 111 108 137 102 bayt

Bu asla kazanamayacak ama yine de egzersizi çözmek istedim:

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 yorumum sayesinde, birkaç bayttan daha fazla şey başarabildim:

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 özel C # kurallarına uyarak:

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

Bir lambda işlevini kullanarak:

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 bayt

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

Argümanların listesini komut satırından (as @ARGV) alır, STDOUTvarsayılan olarak yazdırır .

Seahorseville'de ...

Bir mahalle , komşu ayakkabı ebatlarının bir dizisidir. Sıralandığında, her denizatı aynı ayakkabı boyutunu paylaşabilen acil komşulara sahiptir. Mahallede çok sayıda komşu olabilir ve hiçbir komşunun değeri ikiden fazla farklı olamaz:

örneğin 3 3 4 5 5 6, olduğu gibi tek bir mahalle 2 4 6 6ve1 2 3 5 7 8 10 12

örneğin 1 1 1 4 5 6iki mahalle içerir: 1 1 1ve 4 5 6.

Algoritmanın temeli

İki tür mahalle vardır:

• Hatta-boy

  Bunlar için n/2çiftler her zaman yeterli:

  örneğin 3 3 4 5 5 6üç çift için gereklidir 3 3, 4 5ve5 6

• Tek-boyutlu

  Bunlar için ceil(n/2)çiftler her zaman yeterli:

  örneğin 12 13 13 14 15üç çift gerektirir 12 13, 13 14ve 15tek başına.

Algoritmayı test etmek için ungolfed kod

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

Örnek Sonuçlar

(Ekteki mahalleler [ ] )

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 bayt

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

Wolfram kum havuzunda deneyin .

Perl, 103 bayt

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

Argümanların listesini komut satırından (as @ARGV) alır, STDOUTvarsayılan olarak yazdırır .

Bu, aşağıdaki ilişkiye dayanan alternatif bir yaklaşımdır:

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

( Mahallenin nasıl tanımlandığı için bu cevaba bakınız )

Javascript, 67 bayt

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

Örnek kod pasajı:

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