उप-सरणी में समान संख्याएं

16

के साथ length >=3और की संख्या को देखते हुएlength % 3 == 0

[1, 2, 3, 4, ...]

आप इसे लंबाई 3 की उप-सरणियों में विभाजित करेंगे

[[1, 2, 3], [4, 5, ...], [...

और एक सरणी के साथ लौटें

  • [०] => सब-ऐरे में मामलों की मात्रा जहाँ सभी संख्याएँ समान हैं
  • [१] => यदि उप-सरणी में सभी संख्याएँ समान नहीं हैं, तो उप-सरणी में मामलों की संख्या जहाँ केवल २ संख्याएँ बराबर हैं

उदाहरण और परीक्षण के मामले:

  • इनपुट: [2, 4, 2, 5, 5, 5, 4, 2, 1, 3, 3, 1]आउटपुट[1, 2]

यह है क्योंकि 

[[2, 4, 2], [5, 5, 5], [4, 2, 1], [3, 3, 1]]
  ^     ^    ^  ^  ^               ^  ^ 
   equal    all equal              equal

तो 2 equalऔर 1all equal

  • [3,5,6,5,5,7,6,6,8,7,7,7,3,4,2,4,4,3] => [1, 3]
  • [3,3,3,4,4,4,5,5,5,6,6,6,5,4,3] => [4, 0]
  • [3,4,5,6,7,8,9,8,7,6,5,4,3,2,1] => [0, 0]

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

पीडी: मेरी अंग्रेजी के लिए माफी।

code-golf  array-manipulation 
— लुइस फेलिप डी जीसस मुनोज
स्रोत
परीक्षण के मामलों में संख्या सभी सकारात्मक हैं। क्या हमेशा ऐसा ही होता है?
— डेनिस
@ डेनिस नंबर सकारात्मक और नकारात्मक संख्या हो सकती है।
— लुइस फेलिप डी जीसस मुनोज

जवाबों:

5

ऑक्टेव , 60 52 50 बाइट्स

@(x)sum(sum(~diff(sort(reshape(x,3,[]))))'==[2 1])

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

लुइस के लिए 8 बाइट्स बचाए!

स्पष्टीकरण:

3 पंक्तियों और स्तंभों की उचित मात्रा के साथ एक मैट्रिक्स में इनपुट को रीसेट करता है। यह तब प्रत्येक स्तंभों को क्रमबद्ध करता है, और विभिन्न पंक्तियों पर तत्वों के बीच के अंतर की गणना करता है। यह दो पंक्तियों के साथ एक मैट्रिक्स देता है, जहां समान संख्या में एक शून्य होगा, और विभिन्न संख्याओं में एक सकारात्मक संख्या होगी। यह उपेक्षित है, ताकि सभी समान तत्व हैं 1, और सभी असमान हैं 0। हम तो वे कॉलम में से प्रत्येक के योग, हमें तीन से कोई एक विकल्प दे रही है: 0 = All elements are unequal, 1 = Two elements are equalऔर 2 = All elements are equal। हम फिर जाँचते हैं कि कितने हैं >1, और कितने वास्तव में हैं ==1।

— स्टीवी ग्रिफिन
स्रोत
4

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

f=([a,b,c,...d],t=p=0)=>1/a?f(d,t+!(a-b&&a-c?b-c||++p:b-c&&++p)):[t,p]

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

कैसे?

हम इनपुट फ़ार्म से प्रत्येक ट्रिपल [a, b, c] को पुन: निकालते हैं और निम्न सूत्र का उपयोग करते हुए दो काउंटर्स t (थ्री-ए-तरह) और p (जोड़ी) को अपडेट करते हैं:

t =
t + !(a - b && a - c ? b - c || ++p : b - c && ++p)

5 संभावित मामले हैं जो नीचे विस्तृत हैं, 'सभी समान' से 'सभी अलग-अलग' हैं।

a b c | a-b && a-c | b-c | b-c || ++p | b-c && ++p | t +=
------+------------+-----+------------+------------+------------
4 4 4 | false      | 0   | n/a        | 0          | !0    --> 1
4 4 5 | false      | ≠0  | n/a        | ++p        | !++p  --> 0
4 5 4 | false      | ≠0  | n/a        | ++p        | !++p  --> 0
5 4 4 | true       | 0   | ++p        | n/a        | !++p  --> 0
4 5 6 | true       | ≠0  | ≠0         | n/a        | !(≠0) --> 0
— Arnauld
स्रोत
यदि आउटपुट में केवल [0]और [1]इंडेक्स से अधिक हो सकते हैं "नोट: वें उचित मानों के साथ [0]और [1]लौटने वाले 3-तत्वों की सरणी देता है , और [2]एक डमी मान (सामान्य रूप से किसी भी तत्व के बिना 3-सूचियों की संख्या) लौटाता है। यह पूरी तरह से मान्य है। वर्तमान नियम। " codegolf.stackexchange.com/a/166082/31257 62 बाइट्सa=>a.map(_=>++r[--new Set(a.slice(i,i+=3)).size],r=[i=0,i])&&r
— Guest271314
3

पायथ, 13 14 12 11 बाइट्स

/Lml{kcQ3S2

इसे यहाँ आज़माएँ

व्याख्या

/Lml{kcQ3S2
      cQ3        Split the input into groups of 3.
  ml{k           Deduplicate and get the length of each.
/L               Count the number...
         S2      ... of 1s and 2s.
3rd टेस्ट के लिए फेल (कुछ ऑल-इक्वल और कुछ दो-बराबर ट्रायल्स की जरूरत है)
— जोनाथन एलन
3

आर , 70 बाइट्स

function(v,x=lengths(by(v,seq(0,a=v)%/%3,table)))c(sum(x<2),sum(x==2))

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

पिछला संस्करण :

आर , 82 बाइट्स

function(v,a=!1:2){for(i in lengths(by(v,seq(0,a=v)%/%3,table)))a[i]=a[i]+1;a[-3]}

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

आर , 93 बाइट्स

function(v,a=table(lengths(by(v,0:(length(v)-1)%/%3,unique)))[c('1','2')])`[<-`(a,is.na(a),0)

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

— digEmAll
स्रोत
1
संभवतः ऑक्टेव उत्तर को पोर्ट करना अधिक कुशल होगा, लेकिन a=!1:2थोड़ा कम है।
— ग्यूसेप
@Giuseppe: धन्यवाद, और अन्य 5 बाइट्स के seq(0,a=v)बजाय का उपयोग करके बचाया 0:(length(v)-1);) दुर्भाग्य से मैं ऑक्टेव को नहीं जानता हूं इसलिए मैं उस उत्तर को आसानी से नहीं पढ़ सकता ...
— डाइजेक्ज़ेल
@Giuseppe: दृष्टिकोण बदला और बहुत सारे बाइट्स बचाए :)
— digEmAll
महान दृष्टिकोण! मैं applyआईएनजी से कुछ छोटा था , uniqueलेकिन यह तीसरे परीक्षण के मामले में विफल रहता है। आपका byदृष्टिकोण सुरक्षित है
— JayCe
@JayCe: सौभाग्य से R 3.2.0 ने लंबाई फ़ंक्शन को पेश किया जो बहुत सारे बाइट्स को बचाता है ... लेकिन उन्हें आर में एक शॉर्ट लैम्ब्डा फ़ंक्शन की परिभाषा पेश करनी चाहिए, ताकि कोड गोल्फ में अधिक प्रतिस्पर्धी हो सके: डी
— डाइजेक्जेल
3

जावा (JDK 10) , 116 बाइट्स

l->{int r[]={0,0,0},i=0,a,b,c;for(;i<l.length;b=l[i++],c=l[i++],r[a==b?b==c?0:1:b==c|a==c?1:2]++)a=l[i++];return r;}

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

नोट: वें उचित मानों के साथ [0]और [1]लौटने वाले 3-तत्वों की सरणी देता है , और [2]एक डमी मान (सामान्य रूप से किसी भी तत्व के बिना 3-सूचियों की संख्या) लौटाता है। यह वर्तमान नियमों के अनुसार पूरी तरह से मान्य है।

— ओलिवियर ग्रेजायर
स्रोत
2

पॉवरशेल , 106 बाइट्स

param($a)for(;$a){$x,$y,$z,$a=$a;if($x-eq$y-and$y-eq$z){$i++}else{$j+=$x-eq$y-or$y-eq$z-or$z-eq$x}}+$i,+$j

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

ठीक वह जो यह टिन पर कहता है। इनपुट पर लूप्स $a। प्रत्येक पुनरावृत्ति, $x,$y,$zअगले तीन तत्वों के रूप में छील जाती है । टेस्ट ifवे सभी समान हैं और यदि हां, तो वृद्धि $i। Else, वेतन वृद्धि $jअगर कम से कम एक जोड़ी बराबर है। एक बार लूप पूरा होने के बाद, आउटपुट $iऔर$j पूर्णांक के रूप में।

तो ... कई ... डॉलर ...

— AdmBorkBork
स्रोत
2

रेटिना 0.8.2 , 68 बाइट्स

(.+)¶(.+)¶(.+)
;$1;$2;$3;$1;
%M`(;\d+)(?=\1;)
s`((1)|(3)|.)+
$#3 $#2

इसे ऑनलाइन आज़माएं! लिंक में प्रति पंक्ति एक मान के वांछित प्रारूप में बदलने के लिए हेडर के साथ परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

(.+)¶(.+)¶(.+)
;$1;$2;$3;$1;

विभाजकों के साथ प्रत्येक पंक्ति पर तीन मान लीजिए और अंत में पहले वाले को दोहराएं।

%M`(;\d+)(?=\1;)

डुप्लिकेट के जोड़े की संख्या की गणना करें।

s`((1)|(3)|.)+
$#3 $#2

3एस और 1एस की संख्या की गणना करें ।

— नील
स्रोत
2

कॉमन लिस्प, 113 बाइट्स

(lambda(l &aux(a 0)(b 0))(loop for(x y z)on l by #'cdddr do(if(= x y z)(incf a)(if(/= x y z)()(incf b))))`(,a,b))

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

इस तथ्य का उपयोग किया कि आम लिस्प (= x y z)में सच है यदि सभी तीन तत्व समान हैं, और (/= x y z)यह सच है कि संख्याओं की कोई जोड़ी समान नहीं है।

— रेंज़ो
स्रोत
2

जाप, 14 13 बाइट्स

2õ@ò3 x_â ʶX

कोशिश करो

व्याख्या

2õ                :Range [1,2]
  @               :Pass each X through a function
   ò3             :  Split input to arrays of length 3
       _          :  Pass each through a function
        â         :    Remove duplicates
          Ê       :    Get length
           ¶X     :    Test for equality with X
      x           :  Reduce by addition
— झबरा
स्रोत
2

पायथन 2 , 77 72 65 बाइट्स

lambda a:map([len(set(t))for t in zip(*[iter(a)]*3)].count,(1,2))

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

7 बाइट्स xnor से एक चालाक चाल के माध्यम से बचाया

— चास ब्राउन
स्रोत
आप के रूप में कम ट्रिपल की सूची उत्पन्न कर सकते हैं zip(*[iter(a)]*3)।
— xnor
@xnor: बहुत अच्छा; मुझे आश्चर्य हुआ कि क्या कोई छोटा रास्ता था ...
— चास ब्राउन
2

रेटिना , 23 बाइट्स

S2,3,` 
%Cq`\S+
*\C`1
2

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

व्याख्या

S2,3,`

(0-आधारित) 2 पर शुरू होने वाले हर 3 वें स्थान पर इनपुट को विभाजित करें, अर्थात इनपुट को तीन के समूहों में विभाजित करें।

%Cq`\S+

प्रत्येक पंक्ति पर ( %) Cअद्वितीय ( q) मानों ( \S+) की संख्या ( ) की गणना करें ।

*\C`1

1एस की संख्या की गणना करें और उन्हें एक अनुगामी लाइनफीड ( \) के साथ प्रिंट करें , लेकिन ऐसा ड्राय -रन ( *) में करें ताकि हम पिछले परिणाम को न खोएं।

2

2एस की संख्या की गणना करें (और उन्हें स्वचालित रूप से प्रिंट करें)।

— मार्टिन एंडर
स्रोत
2

जे , 16 15 बाइट्स

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

1#.1 2=/_3#@=\]

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

समाधान के बहुमत के रूप में बहुत ही समान दृष्टिकोण।

स्पष्टीकरण:

        _3    \]  - split the input into sublists of lenght 3
          #@~.    - for each triplet remove duplicates and take the length 
   1 2=/          - compare with 1 and 2
1#.               - add up
— गैलेन इवानोव
स्रोत
#@~.->#@=
— कोल
1

स्टैक्स , 14 बाइट्स

ü┬─*HTÜ╫\Ä╢qm♥

इसे चलाएं और डीबग करें

— wastl
स्रोत
[3,5,6,5,5,7,6,6,8,7,7,7,3,4,2,4,4,3][2,3]इसके बजाय आउटपुट[1,3]
— लुइस फेलिप डी जीसस मुनोज
[3,3,3,4,4,4,5,5,5,6,6,6,5,4,3][1,0]इसके बजाय आउटपुट[4,0]
— लुइस फेलिप डी जीसस मुनोज
[3,4,5,6,7,8,9,8,7,6,5,4,3,2,1][5,0]इसके बजाय आउटपुट[0,0]
— लुइस felipe De jesus Munoz
@LuisfelipeDejesusMunoz तय
— wastl
यह वर्तमान में कोई आउटपुट नहीं दिखाता है [1,1,1]। यदि आप 2(इसके बजाय का उपयोग करते हैं 1Tतो हमेशा ट्रिम / पैड को आकार 2 में ट्रिम करेंगे।
— पुनरावर्ती
1

अमृत , 92 बाइट्स

fn a->import Enum;c=map chunk(a,3),&(length uniq&1);{count(c,&(&1==1)),count(c,&(&1==2))}end

सबसे पहले, सूची को आकार 3 में काट लें chunk(a,3)

दूसरे, यह धर्मान्तरित प्रत्येक तत्व की लंबाई को देखता है, uniqified; map chunk(a,3),&(length uniq&1)।

अंत में, यह एक सरणी देता है जिसमें परिणामी सूची एक बार के बराबर होती है count(c,&(&1==1))और परिणामी सूची की संख्या दो के बराबर होती है count(c,&(&1==2))।

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

— Okx
स्रोत
0

Tcl , 111 बाइट्स

proc S {L a\ 0 e\ 0} {lmap {x y z} $L {expr {$x-$y|$y-$z?$x==$y|$y==$z|$x==$z?[incr e]:0:[incr a]}}
list $a $e}

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

टीईसी , 112 बाइट्स

proc S {L a\ 0 e\ 0} {lmap {x y z} $L {expr {$x-$y||$y-$z?$x==$y|$y==$z|$x==$z?[incr e]:0:[incr a]}}
list $a $e}

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

Tcl , 114 बाइट्स

proc S {L a\ 0 e\ 0} {lmap {x y z} $L {expr {$x==$y&&$y==$z?[incr a]:$x==$y|$y==$z|$x==$z?[incr e]:0}}
list $a $e}

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

— sergiol
स्रोत
0

Tcl , 98 बाइट्स

proc A l {set 1 0;set 2 0
foreach a\ b\ c $l {incr [llength [lsort -u "$a $b $c"]]}
return $1\ $2}

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

कमांड के -uniqueविकल्प का उपयोग करना lsort। मैंने नाम 1और 2सुविधा के लिए अपने चर, कठिन यह कोड के लिए बहुत असामान्य लगता है set 1 0:)

— डेविड
स्रोत
0

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 108 बाइट्स

x=>new[]{1,2}.Select(n=>x.Select((v,i)=>(v,g:i/3)).GroupBy(y=>y.g,y=>y.v).Count(y=>y.Distinct().Count()==n))

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

कम गोल्फ वाले ...

// x is the input list of ints
x=>x
  // 1 distinct number means 3/3 are the same
  // 2 distinct number means 2/3 are the same
  new[]{1,2}
  // iterate over the outer array to get an index
  .Select(n=>x
    // iterate over the whole list with an index
    // and break into groups of size 3
    .Select((v,i)=>v,g:i/3))
    .GroupBy(y=>y.g,y=>y.v)
     // count the distinct values in each group
     // and get the result based on outer array value
    .Count(y=>y.Distinct().Count()==n))
— दाना
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.