किसी सरणी में परिवर्तन गिनें

20

आपका कार्य आज एक प्रोग्राम या फ़ंक्शन लिखना है, जो पूर्णांकों की एक सरणी लेता है, और कई बार गिना जाता है, इसे पढ़ने के लिए बाएं से दाएं, मान बदल जाता है। उदाहरण के साथ दिखाना आसान है:[1 1 1 2 2 5 5 5 5 17 3] => [1 1 1 **2** 2 **5** 5 5 5 **17** **3**] => 4

परीक्षण का मामला:

Input           |   Output
[]              |   0
[0]             |   0
[0 1]           |   1
[0 0]           |   0
[1 2 3 17]      |   3
[1 1 1 2 2 3]   |   2
[-3 3 3 -3 0]   |   3

यह कोड-गोल्फ , सबसे कम बाइट्स जीतता है!

code-golf  array-manipulation 
— पावेल
स्रोत
यदि परिणाम हमेशा सही तरीके से गणना किया जाता है, तो क्या मेरा जवाब मान्य है, लेकिन यदि यह 0 है, तो इसके Falseबजाय मुद्रित किया जाता है?
— 15
1
@FlipTack जो भाषा पर निर्भर करता है। सामान्य तौर पर, अगर मैं कह सकता हूं 2+Falseऔर यह त्रुटि करता है, तो यह ठीक नहीं है, लेकिन अगर मुझे मिलता है 2, तो यह ठीक है।
— पावेल
@FlipTack डिफ़ॉल्ट रूप से, यह सर्वसम्मति है।
— अशुभ
क्या खाली आउटपुट 0स्वीकार्य है?
— टाइटस
@ टिट्स हाँ यह है।
— पावेल

जवाबों:

9

पायथन 3 , 38 बाइट्स

f=lambda x=0,*y:y>()and(x!=y[0])+f(*y)

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

— डेनिस
स्रोत
2
हुह, क्या आप जानते हैं कि आप एक डिफ़ॉल्ट arg का उपयोग कर सकते हैं, अच्छा खोज।
— xnor
— एरिक आउटोलॉफ़र
@ डेनिस कैसे सरणी खाली होने पर पुनरावर्ती लूप से बाहर निकलता है? मैं यह नहीं देखता कि यह कैसे समाप्त नहीं होता है maximum recursion depth exceeded।
— Ioannes
@ आईनोनेस एक बार केवल एक तत्व ( x ) शेष होने पर, गलत काy>() मूल्यांकन करेगा , इसलिए निम्नलिखित कोड निष्पादित नहीं होता है। and
— डेनिस
7

हास्केल , 33 बाइट्स

f(a:b:r)=sum[1|a/=b]+f(b:r)
f _=0

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

बोनस: थोड़ा उत्सुक बिंदु मुक्त अंकगणितीय संस्करण (44 बाइट्स)

sum.(tail>>=zipWith((((0^).(0^).abs).).(-)))

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

एक इनपुट को देखते हुए [1,1,4,3,3,3], हम पहले आसन्न प्रविष्टियों ( [0,3,-1,0,0]) का अंतर लेते हैं , फिर absपूर्ण मान [0,3,1,0,0]:। पहली बार पैदावार लेने वाले प्रत्येक तत्व की शक्ति को शून्य पर ले जाना [1,0,0,1,1], और दूसरी बार सूची को सम्मिलित करता है: [0,1,1,0,0]( (1-)इसके बजाय यहां भी काम करेगा (0^))। अंत में हम sumसूची को पाने के लिए लेते हैं 2।

— Laikoni
स्रोत
5

ब्रेन-आलोचना , 50 बाइट्स

([][()]){{}({}[({})]){{}<>({}())(<>)}{}([][()])}<>

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

आउटपुट 0 के लिए कुछ भी नहीं करता है, जो मस्तिष्क-फ्लैक के बराबर है। यदि यह स्वीकार्य नहीं है, तो इसके लिए इसे आगे बढ़ाएं+4 बाइट्स के :({})

स्पष्टीकरण:

#Push stack-height-1
([][()])

#While true:
{

    #Pop the stack-height-1 off
    {}

    #If 'a' is the element on top of the stack, and 'b' is the element underneath it, then
    #Pop 'a' off, and push (a - b)
    ({}[({})])

    #If (a-b) is not 0...
    {
        #Pop (a-b) off
        {}

        #Switch stacks
        <>

        #Increment the value on the other stack
        ({}())

        #Push a 0 back to the main stack
        (<>)

    #Endif
    }

    #Pop either (a-b) or the 0 we pushed
    {}

    #Push stack-height-1
    ([][()])

#Endwhile
}

#Toggle to the alternate stack and display the counter
<>
— DJMcMayhem
स्रोत
2
— रिले
@ रिले नीली किया! :)
— डीजेएमसीएम
— गेहूं जादूगर
1
@WheatWizard मैंने वह भी करने की कोशिश की, लेकिन यह खाली इनपुट पर हमेशा के लिए बंद हो जाता है। -0+1 = 1
— H.PWiz
5

ब्रेन-फ्लैक , 50 बाइट्स

(([][()]){[{}]<({}[({})])>{(<{}>)()}{}([][()])}<>)

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

# Get ready to push the answer
(

# Push stack height - 1
([][()])

# Loop until 0 (until the stack has a height of 1)
{

  # Pop the old stack height and subtract it 
  #(cancels the loop counter from the final answer)
  [{}]

  # Pop the top of the stack and subtract the next element from that
  # Don't include this in the final answer
  <({}[({})])>

  # If not 0
  {

    # Pop the difference between the last two numbers
    # Don't include this in the final answer
    (<{}>)

    # Add 1 to the final answer
    ()

  # End if
  }{}

  # Push stack height - 1
  ([][()])

# End while
}

# Switch to the off stack so we don't print anything extra
<>

# Push the total sum. This is the number of times the if was true
)
— रिले
स्रोत
1
10k प्रतिनिधि के लिए बधाई!
— पावेल
@ फावड़ा धन्यवाद! पिछले कुछ सौ पाने में मुझे हमेशा के लिए लग गया। मैं अन्य सामानों के साथ बहुत व्यस्त हो गया हूं :(
— रिले
मेरे पास यह
— H.PWiz
@ H.PWiz मैं एक बिंदु पर था, लेकिन मुझे पसंद है कि कैसे पॉप स्टैक ऊंचाई धक्का रद्द करता है।
— रिले
5

हास्केल , 35 बाइट्स

-8 बाइट्स H.PWiz को धन्यवाद।

एक पुनरावर्ती संस्करण द्वारा बाहर निकाला गया । हस्केल पुनरावृत्ति में सबसे अच्छा है और मैंने इसे याद किया। > _ <

f l=sum[1|x<-zipWith(/=)l$tail l,x]

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

यह बहुत बढ़िया होगा अगर किसी को भी इस टिप को कैसे लगाया जाए ।

वैकल्पिक समाधान, 36 बाइट्स

f l=sum[1|True<-zipWith(/=)l$tail l]

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

— totallyhuman
स्रोत
1
— एच। दविज़
वह टिप महत्वपूर्ण तथ्य को याद करता है जिसे आपको uncurryकाम fकरने के लिए फ़ंक्शन की आवश्यकता होगी । यह sum.map fromEnum.(zipWith(/=)=<<tail)संभवत: आपको सबसे निकटतम है, लेकिन यह []37 बाइट्स के साथ काम नहीं करेगा ..
— you
5

जावा (ओपनजेडके 8) , 65 बाइट्स

जितना मैं चाहूंगा उतना छोटा नहीं होगा, लेकिन यह सिर्फ आपके लिए जावा है।

सरणी को अल्पविराम सीमांकित सूची के रूप में पास करके परीक्षण करें।

a->{int s=0,i=1;for(;i<a.length;s+=a[i-1]!=a[i++]?1:0);return s;}

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

— ल्यूक स्टीवंस
स्रोत
2
यदि खाली सरणी एक परीक्षण मामला नहीं था (और मुझे यह वास्तव में प्रासंगिक नहीं लगता है, तो वास्तव में), एक का उपयोग किया जा सकता है: a->{int s=0,p=a[0];for(int n:a)s+=p==(p=n)?0:1;return s;}(57 बाइट्स)।
— ओलिवियर ग्रेजायर
@ OlivierGrégoire मुझे पता है! मैंने लिखा है कि मुझे लगा कि मैं बाइट्स में कटौती करूंगा, लेकिन यह उस पहले मामले में विफल रहा।
— ल्यूक स्टीवंस
3
56 बाइट्स:a->{int s=0;for(int i:a)s+=a[0]!=(a[0]=i)?1:0;return s;}
— नेवले
4

वोल्फ्राम भाषा (गणितज्ञ) , २३24 26 29 बाइट्स

Length@Split@#~Max~1-1&

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

  • मार्टिन एंडर को -1 बाइट धन्यवाद!
  • -2 बाइट्स की बदौलत JungHwan Min! का अच्छा उपयोग Split[]।
  • -3 बाइट्स पूरी तरह से धन्यवाद के लिए धन्यवाद!

थोड़ा स्पष्टीकरण:

Splitकिसी सरणी को सूचियों की सूची (समान तत्वों) में विभाजित करेगा, अर्थात, बदल {1, 2, 2, 3, 1, 1}रहा है {{1}, {2, 2}, {3}, {1, 1}}। तो, Length@Split@#लगातार अलगाव की मात्रा है। Max[*****-1, 0]का उपयोग {}इनपुट से निपटने के लिए किया जाता है ।

— कीउ गण
स्रोत
1
— 19
1
24 बाइट्स:Max[Length@Split@#-1,0]&
— जुंगह्वान मिन ऑक्ट
23:Length@Split@#~Max~1-1&
— मार्टिन एंडर
4

प्रतीकात्मक अजगर , 120 117 बाइट्स

+काउंटर वेरिएबल के लिए एक स्पष्ट कलाकारों को पूर्णांक (यूरीरी का उपयोग करके ) को हटाकर गोल्फ 3 बाइट्स - इसका मतलब है कि अगर सरणी में कोई बदलाव नहीं हैं, तो आउटपुट Falseइसके बजाय होगा 0, लेकिन मेटा द्वारा इसकी अनुमति है ।

___=-~(_==_)
__('___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)')
__('__=___=_>_'+';___+=_[__]!=_[-~__];__=-~__'*___)
_=___

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

# LINE 1: Generate value '2' for utility
___=-~(_==_)

# LINE 2: Get len(input) - 1
__('___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)')
   '___=~-'+`_>_`[___::___]+`__`[-~___]+'(_)'     # Generate string '___=~-len(_)'
            `_>_`[___::___]                       #    'le' spliced from 'False'
                           +`__`[-~___]           #    'n' indexed from '<function ...>'
   '___=~-'+                           +'(_)'     #    Remaining characters in plaintext
__(                                          )    # Execute this to get len(input) - 1

# LINE 3: Main calculation loop
__('__=___=_>_'+';___+=_[__]!=_[-~__];__=-~__'*___) 
__(                                               ) # Execute:
   '__=___=_>_'                                     #   Set var1, var2 to 0
               +';                           '*___  #   len(input) - 1 times do:
                       _[__]!=_[-~__]               #   Compare input[var1, var1 + 1]
                  ___+=              ;              #   Add this to var2
                                      __=-~__       #   Increment var1

# LINE 4: Set output variable ('_') to the result calculated.
_=___
— FlipTack
स्रोत
2
= _ = क्या है ये विजार्ड्री?
— अष्टमी
3

जेली , 3 बाइट्स

ITL

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

यह काम किस प्रकार करता है

आईटीएल - पूर्ण कार्यक्रम।

I - वृद्धि (डेल्टास)।
 टी - सत्य मूल्यों के सूचकांकों को प्राप्त करें (गैर-0 तत्वों के अनुक्रमित)।
  एल - लंबाई।
— श्री Xcoder
स्रोत
3

के (ओके) , 8 बाइट्स

समाधान:

+/1_~~':

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

उदाहरण:

+/1_~~':1 1 1 2 2 5 5 5 5 17 3
4
+/1_~~':()
0
+/1_~~':-3 3 3 -3 0
3

स्पष्टीकरण:

सही-बाएँ व्याख्या की गई:

+/1_~~': / the solution
     ~': / equal each-previous
    ~    / not (ie differ)
  1_     / 1 drop, remove first as this is different to null
+/       / sum up trues
— streetster
स्रोत
3

आर , 24 बाइट्स

cat(sum(!!diff(scan())))

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

MATL जवाब के रूप में ही, बस के sum(!!diff))बाद से इस्तेमाल किया है कोई नहीं nnz।

— ग्यूसेप
स्रोत
+1 मैंने सोचा था कि उपयोग rleकरना कम होगा, लेकिन यह length(rle()$v)बहुत अधिक वर्णों का उपयोग करता है और एक से दूर है।
— नील फुल्ट्ज
@NealFultz यह शायद अभी भी एक जवाब के रूप में पोस्ट करने लायक है! हमेशा दूसरे दृष्टिकोण को देखने के लिए अच्छा है। और अगर आप का उपयोग करना चाहिए sum(rle()$v|1)के बजाय lengthवैसे भी। :)
— ग्यूसेप
3

Cubix , 24 बाइट्स

UpO@0I>I!^-u>q.uvv$!^;)p

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

ध्यान दें कि क्यूबिक्स 0 का उपयोग करता है यह इंगित करने के लिए कि अधिक इनपुट नहीं हैं, इसलिए 0 सूची में नहीं हो सकता है।

व्याख्या

सामने आया:

    U p
    O @
0 I > I ! ^ - u
> q . u v v $ !
    ^ ;
    ) p

हम शुरू करते हैं 0, काउंटर को धकेलते हुए (साथ प्रारंभिक 0) और पहला इनपुट (I स्टैक पर ) को ।

हम फिर लूप में प्रवेश करते हैं। लूप के प्रत्येक पुनरावृत्ति पर, हमें अगला इनपुट मिलता है I। यदि यह 0 है, तो हमने इनपुट्स से बाहर चला दिया है, इसलिए हम काउंटर को ऊपर ( p), Output, और बाहर निकलने ( @) में घुमाते हैं ।

अन्यथा, हम शीर्ष दो तत्वों का अंतर लेते हैं। यदि यह नॉनज़ेरो है, तो हम काउंटर को ऊपर की तरफ घुमाते हैं, इसे बढ़ाते हैं, और इसे वापस नीचे की ओर घुमाते हैं p)q। फिर हम ;अगले पुनरावृत्ति पर जाने से पहले अंतर को पॉप करते हैं ।

यहां वर्णित सभी वर्ण केवल नियंत्रण प्रवाह हैं। क्यूबिक्स कार्यक्रमों में बहुत सारे लोग होते हैं।

@MickyT अच्छा तरीका है, लेकिन आप 1 से आगे निकल जाते हैं। आप 0एक के लिए स्वैप कर सकते हैं (, लेकिन यह खाली इनपुट पर विफल रहता है।
माफी, इसे फिर से
— देखेंगे
3

ब्रेन-फ्लैक , 50 बाइट्स

(([][()]){[{}({}[({})])]{{}()(<()>)}{}([][()])}<>)

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

चूंकि हर कोई अपने 50 बाइट समाधान यहाँ पोस्ट कर रहा है, मेरा है (मेरे पास एक 48 बाइट है लेकिन यह DjMcMayhem का एक सरल संशोधन था, इसलिए मैंने इसे पोस्ट करने के लायक महसूस किया)

व्याख्या

यह उत्तर बड़े पैमाने पर मूल्य रद्द करने का उपयोग करता है।

अन-गोल्फ यह जैसा दिखता है

([][()])({<{}({}[({})])>{<{}>()(<()>)}{}<([][()])>}<>)

यहां हम डेल्टा की गणना करते हैं, जब तक कि स्टैक में एक आइटम नहीं बचा है, जब तक कि डेल्टा शून्य न हो, हर बार हम आंतरिक लूप से एक मान जमा करते हैं।

यह इसे करने का एक बहुत सीधा आगे तरीका है।

इस गोल्फ को बनाने के लिए हम मूल्य रद्द करना शुरू करते हैं। पहले एक और एक है कि किसी भी कठोर मस्तिष्क के लिए स्पष्ट होना चाहिए गोल्फ खिलाड़ी स्टैक हाइट्स है। यह एक जाना माना तथ्य है कि

([])({<{}>...<([])>}{})

के समान है

(([]){[{}]...([])}{})

जब मूल्यों को एक द्वारा संशोधित किया जाता है, तो वही धारण करता है। यह हमें देता है

(([][()]){[{}]<({}[({})])>{<{}>()(<()>)}{}([][()])}<>)

आप देख सकते हैं कि इसने हमें बाइट्स भी नहीं बचाए, लेकिन हम आगे बढ़ते ही इसे ज्यादा उपयोगी नहीं समझेंगे।

यदि आप एक बयान देखते हैं तो हम एक और कमी कर सकते हैं

<(...)>{<{}> ...

आप वास्तव में इसे कम कर सकते हैं

[(...)]{{} ...

यह काम करता है क्योंकि अगर हम लूप में प्रवेश करते हैं [(...)]और {}रद्द कर देंगे, और यदि हम [(...)]पहले से ही शून्य नहीं हैं, तो पहले से ही रद्द करने की आवश्यकता नहीं है। चूंकि हमारे पास हमारे कोड में इस पैटर्न की घटना है इसलिए हम इसे कम कर सकते हैं।

(([][()]){[{}][({}[({})])]{{}()(<()>)}{}([][()])}<>)

इसने हमें 2 बाइट्स बचाए लेकिन इसने एक दूसरे के बगल में दो नेग भी लगाए। ये हमें एक और 2 को बचाने के लिए संयोजित किया जा सकता है।

(([][()]){[{}({}[({})])]{{}()(<()>)}{}([][()])}<>)

और यही हमारा कोड है।

— गेहूं का जादूगर
स्रोत
3

गैया , 2 बाइट्स

ėl

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

यह गैया के एक बग (या सुविधा?) का दुरुपयोग करता है, जो रन-लंबाई-एन्कोडिंग तत्वों के अंतिम रन को ध्यान में नहीं रखता है। ध्यान दें कि मैंने दोहरी जांच की है, यह सभी परीक्षण मामलों के लिए काम करता है।

  • ė - लंबाई एन्कोडिंग चलाएं (ऊपर वर्णित दोष के साथ)।
  • l - लंबाई।
— श्री Xcoder
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 35 बाइट्स

a=>a.filter((e,i)=>e-a[i+1]).length
— नील
स्रोत
मुझे आश्चर्य है कि अगर पुनरावृत्ति का उपयोग करके इसे छोटा किया जा सकता है। लेकिन मेरा सबसे अच्छा प्रयास 35 के रूप में अच्छी तरह से है:f=([a,...b])=>1/a?!!(a-b[0])+f(b):0
— Arnauld
@Arnauld मैंने भी ऐसा करने की कोशिश की, लेकिन यह गलत था और सोचा कि यह 36 बाइट्स था, अन्यथा मैंने इसे एक विकल्प के रूप में जोड़ा होगा।
— नील
2

APL (Dyalog) , 8 बाइट्स

+/2≠/⊃,⊢

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

कैसे?

⊃,⊢ - सूची, एकल तत्व के मामले में पहले मूल्य के साथ दोहराया गया

2≠/ - परिवर्तन की सूची, हर 2 तत्वों के लिए बराबर नहीं

+/ - योग

— Uriel
स्रोत
2

रूबी , 31 बाइट्स

->a{a.chunk{|x|x}.drop(1).size}

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

— जॉर्डन
स्रोत
इसके बजाय .drop(1)आप कर सकते हैं[1..-1]
— Cyoce
@ कैस दुर्भाग्य से dropएक एन्यूमरेटर लौटाता है, न कि एक ऐरे, ताकि काम न करे।
— जॉर्डन
हुह। यह मेरे संस्करण पर एक Array देता है।
— साइओस
@ कौन सा संस्करण?
— जॉर्डन
मैं 1.9.3 पर हूं, लेकिन sizeफिर भी आप किसी ऐरे में क्यों नहीं जा सकते ?
— साइओस
2

सी (जीसी 5.4.0), 61 बाइट्स

f(c,v)int*v;{int*p=v,s=0;for(;p<v+c-1;s+=*p++!=*p);return s;}

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

f सरणी के पहले तत्व के लिए सरणी और एक सूचक की लंबाई लेने वाला एक फ़ंक्शन है, और सरणी में परिवर्तनों की संख्या को लौटाता है;

यह प्रस्तुत अपरिभाषित व्यवहार का उपयोग करता है (*p++!=*p ,, p का उपयोग एक अभिव्यक्ति में दो बार किया जाता है जिसमें इसे बदल दिया जाता है), जो मेरी मशीन (gcc 5.4.0) और TIO पर काम करता है, लेकिन अन्य कार्यान्वयन या संस्करणों पर काम नहीं कर सकता है।

स्पष्टीकरण:

f(c,v)int*v;{ // old-style declaration for v, and implicit-int for c and return value
    int*p=v,s=0; // p is a pointer to the current item, s is the number of changes
    for(;p<v+c-1;s+=*p++!=*p); // for each consecutive pair of integers, if they are different, add one to the number of changes
    return s; // return the number of changes
}
— pizzapants184
स्रोत
क्या आप शायद ऑनलाइन परीक्षण वातावरण के लिए एक लिंक जोड़ सकते हैं?
— जोनाथन फ्रेच
@JonathanFrech जोड़ा गया
— pizzapants184
2

05AB1E , 3 बाइट्स

γ¦g

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

एरिक के जवाब के लिए एक विकल्प।

γ¦g ~ पूर्ण कार्यक्रम।

jac ~ समीपवर्ती तत्वों के रन में समूह।
 ¦ ~ पहला समूह निकालें (यदि कोई हो)।
  जी ~ लंबाई।
— श्री Xcoder
स्रोत
आह, याद किया कि यह एक मामला था।
— मैजिक ऑक्टोपस Urn
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.