समुद्री घोड़ों के लिए जूते

Question

सीहर्स, बेशक, जूते की जरूरत है। हालांकि, एक सीहोरस, जिसकी सिर्फ एक पूंछ होती है, उसे सिर्फ एक जूते की जरूरत होती है। दुर्भाग्य से, जूते केवल जोड़े में आते हैं। सीहोर सरकार के लिए पैसा तंग है, इसलिए उन्हें यथासंभव कुछ जोड़े खरीदने की जरूरत है। प्रत्येक सीहोर में एक जूता आकार x होता है जहाँ x एक धनात्मक पूर्णांक होता है। हालाँकि, यदि आवश्यकता हो तो एक सीहोर आकार x - 1 या x + 1 का जूता पहन सकता है।

आपका काम उन समुंदरों की न्यूनतम संख्या का उत्पादन करना है, जिन्हें सीहोरसी सरकार को अपने सभी समुद्री जहाजों पर जूते रखने के लिए खरीदना चाहिए।

आप इनपुट ले सकते हैं लेकिन आप चाहते हैं, मानक खामियां आदि।

चूंकि यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड।

परीक्षण के मामलों

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

Comments

यह सरणी को सॉर्ट करके और इसके माध्यम से लूपिंग को तुच्छ रूप से किया जा सकता है, लेकिन मैं कुछ रचनात्मक देखना चाहूंगा (इसका वास्तविक स्कोरिंग पर कोई असर नहीं है, मुझे लगता है कि यह एक और दृष्टिकोण देखना दिलचस्प होगा)

— धांधली

मैं नहीं देखता कि यह कैसे तुच्छ किया जा सकता है ...

— लीक नून

@ bushdid911 मुझे लगता है कि मैं समझा नहीं सकता कि जेली एक टिप्पणी में कैसे काम करती है

— लीक नून

@ कॉडीग्रे आपके पास एक आकार 3 जोड़ी हो सकती है, जिसमें 2 और 4 शामिल हैं

— जर्गबुल

संभावित शीर्षक संपादित करें: सी-हॉर्सशो

— क्रेग 8806

Answer 1

05AB1E , 13 बाइट्स

टिप्पणियों में वर्णित दृष्टिकोण ओपी का उपयोग करता है।

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

Answer 2

भूसी , 15 14 बाइट्स

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

लालची एल्गोरिथ्म का उपयोग करता है: बाईं ओर से सॉर्ट और जोड़ी। इसे ऑनलाइन आज़माएं!

1 बाइट बचाने के लिए लियो को धन्यवाद।

व्याख्या

यह पहला हस्क उत्तर है जो Γकिसी सूची से मेल खाते पैटर्न के लिए फ़ंक्शन का उपयोग करता है । इस उपयोग के मामले में, यदि aएक मान है और gएक फ़ंक्शन है, तो हास्केल स्निपेट द्वारा परिभाषित Γ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.

Comments

अपनी भाषा का उपयोग करने वाले ये सभी लोग मुझे अपना बनाना चाहते हैं। पहले मुझे एक नाम के साथ आना होगा: पी

— धांधली

Answer 3

पायथन 3 , 69 66 60 बाइट्स

9 बाइट्स xnor के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि आप कर सकते हैं a.sort()।

— xnor

@ एक्सनोर किया, धन्यवाद।

— लीक नून

छंटाई एक में फंस सकती है lambda:f=lambda a:a[1:a.sort()]and-~f(a[1+(a[1]-a[0]<3):])or len(a)

— xnor

or[]<a3 बाइट्स बचाने के लिए

— फेलिप नार्दी बतिस्ता

Answer 4

जेली , 20 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मेरे पायथन जवाब का कांटा ।

Comments

-4 बाइट्स: IḢ<3+2⁸ṫß‘µLḊ?(मूल रूप से मुझे Ṣपहले करने के लिए कोई कारण नहीं दिखता है L, और अगर 1 या 0 की लंबाई की सूची है तो Ḋवापस आ जाएगी [], और फिर मैं एक µसे निकाल सकता हूं LµḊ?)

— एरिक आउटगोल्फर

लेकिन आप कहीं भी सॉर्ट नहीं करते ...

— लीक नून

अब मैं थोड़ा उलझन में हूँ tbf ... मुझे लगता है कि आपका आशय आपके कोड वास्तव में क्या करता है की तुलना में थोड़ा अलग है? Ṣअगर मैं सही तरीके से समझूँ तो आप मेरे गोल्फ को प्रेपेंड कर सकते हैं ।

— एरिक आउटगोल्फर

कुछ अपने तरह के साथ अस्थिर है। [1, 1, 1, 1, 4, 4, 4, 8, 8, 9, 9] काम करता है लेकिन [4,1,4,9,1,8,9,1,8,4,1] doesn ' टी।

— धांधली

@ bushdid911 वे दोनों काम करते हैं। क्या आप प्रदर्शित कर सकते हैं?

— लीक नन

Answer 5

पायथन 2 , 49 बाइट्स

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

इसे ऑनलाइन आज़माएं!

लीक नून के पुनरावर्ती समाधान पर आधारित है ।

---

पायथन 2 , 59 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आकार के माध्यम से xक्रमबद्ध क्रम में Iterates । pपिछले एक के साथ युग्मित करने के लिए वर्तमान आकार के लिए ऊपरी सीमा को याद करता है । यदि ऐसा है ( x>p), 0अगले एक जोड़े के लिए इसे असंभव बनाने के लिए दहलीज को रीसेट करें । यदि नहीं, तो आउटपुट गणना बढ़ाएँ cऔर अगली दहलीज़ pको सेट करें x+2।

नई दहलीज p=(x>p)*(x+2)एक फूला हुआ अभिव्यक्ति है। मैं इसे छोटा करने का तरीका खोजना चाहता हूं।

Answer 6

सी #, 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;}

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

उत्तर के माध्यम से प्रगति को बनाए रखने के लिए धन्यवाद - यह अंतिम उत्तर के समान ही दिलचस्प है।

— क्राइगी जूल

Answer 7

पर्ल, 113 बाइट्स

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

कमांड लाइन (जैसे @ARGV) से तर्क की सूची लेता है , STDOUTडिफ़ॉल्ट रूप से प्रिंट करता है।

Seahorseville में ...

एक पड़ोस पड़ोसी जूते के आकार का एक क्रम है। जब सॉर्ट किया जाता है, तो प्रत्येक सीहोर में तत्काल पड़ोसी होते हैं जो समान जूते का आकार साझा कर सकते हैं। पड़ोस में कई पड़ोसी हो सकते हैं और कोई भी पड़ोसी दो से अधिक मूल्य में भिन्न नहीं हो सकता है:

उदा 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अकेले।

एल्गोरिथ्म का परीक्षण करने के लिए अनगुल्ड कोड

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]

Answer 8

गणितज्ञ, 67 बाइट्स

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

वोल्फ्राम सैंडबॉक्स में आज़माएं ।

Comments

किसी भी तरह से हम परीक्षण कर सकते हैं? वुल्फराम की तरह?

— LiefdeWen

@ LiefdeWen आप इसे ऑनलाइन आज़मा सकते हैं! गणित में। मैथिक्स वुल्फ्राम भाषा के सभी कार्यों का समर्थन नहीं करता है, लेकिन इस प्रविष्टि में उपयोग किए जाने वाले सभी लागू होते हैं, इसलिए या तो मैथिक्स टूट गया है या यह समाधान अमान्य है।

— पावेल

यह sandbox.open.wolframcloud.com पर काम करता है , इसलिए समस्या मैथिक्स के पक्ष में है

— ovs

@ फेनिक्स को लगता है कि मैथिक्स का समर्थन नहीं करता हैUpTo

— मार्टिन

Answer 9

पर्ल, 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

( पड़ोस कैसे परिभाषित होता है, इसके लिए यह उत्तर देखें )

Answer 10

जावास्क्रिप्ट, 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])}`)