किसी सरणी के दोहराव की गणना करें

Question

आपको एक सरणी मिलेगी और एक से अधिक बार होने वाले पूर्णांकों की संख्या वापस करनी होगी।

[234, 2, 12, 234, 5, 10, 1000, 2, 99, 234]

यह 2 वापस आ जाएगी, में से प्रत्येक के बाद से 234और 2एक बार से अधिक दिखाई देते हैं।

[234, 2, 12, 234]
[2, 12, 234, 5, 10, 1000, 2]

सूची 100k पूर्णांक से अधिक लंबी नहीं होगी, और सूची के अंदर पूर्णांक हमेशा -100k और 100k के बीच में होंगे।

यदि वे एक से अधिक बार घटित होते हैं, तो पूर्णांक को गिना जाना चाहिए, इसलिए यदि पूर्णांक 3 बार होता है, तो यह अभी भी केवल एक बार पूर्णांक के रूप में गिना जाएगा।

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

[1, 10, 16, 4, 8, 10, 9, 19, 2, 15, 18, 19, 10, 9, 17, 15, 19, 5, 13, 20]  = 4
[11, 8, 6, 15, 9, 19, 2, 2, 4, 19, 14, 19, 13, 12, 16, 13, 0, 5, 0, 8]     = 5
[9, 7, 8, 16, 3, 9, 20, 19, 15, 6, 8, 4, 18, 14, 19, 12, 12, 16, 11, 19]   = 5
[10, 17, 17, 7, 2, 18, 7, 13, 3, 10, 1, 5, 15, 4, 6, 0, 19, 4, 17, 0]      = 5
[12, 7, 17, 13, 5, 3, 4, 15, 20, 15, 5, 18, 18, 18, 4, 8, 15, 13, 11, 13]  = 5
[0, 3, 6, 1, 5, 2, 16, 1, 6, 3, 12, 1, 16, 5, 4, 5, 6, 17, 4, 8]           = 6
[11, 19, 2, 3, 11, 15, 19, 8, 2, 12, 12, 20, 13, 18, 1, 11, 19, 7, 11, 2]  = 4
[6, 4, 11, 14, 17, 3, 17, 11, 2, 16, 14, 1, 2, 1, 15, 15, 12, 10, 11, 13]  = 6
[0, 19, 2, 0, 10, 10, 16, 9, 19, 9, 15, 0, 10, 18, 0, 17, 18, 18, 0, 9]    = 5
[1, 19, 17, 17, 0, 2, 14, 10, 10, 12, 5, 14, 16, 7, 15, 15, 18, 11, 17, 7] = 5

Comments

आपका क्या मतलब है Once it counts the repetition, don't count again? इसके अलावा, चूँकि हम एक विशिष्ट पूर्णांक की पुनरावृत्ति को खोजना चाहते हैं, तो हमें यह कैसे पता चलेगा कि किस पूर्णांक को खोजना है यदि हमें नहीं दिया गया है? अंत में, परीक्षण के मामले थोड़े भ्रमित करने वाले होते हैं; कौन से आउटपुट हैं और कौन से इनपुट हैं?

— अज्ञानता का अवतार

मैंने इसे थोड़ा साफ करने की कोशिश के लिए इसे संपादित किया है। क्या आपका यही इरादा है? इसके अलावा, कृपया उन परीक्षण मामलों के लिए उत्तर दें।

— Rɪᴋᴇʀ

मैंने परीक्षण के मामलों में कुछ उत्तर जोड़े हैं, क्षमा करें यदि मैं उन्हें गलत

— मानता हूं

मैंने इस प्रश्न को बंद करने के लिए मतदान किया है जब तक आप इस बात की पुष्टि नहीं करते हैं कि आपका क्या इरादा है।

— R

संबंधित (गैर-अद्वितीय वस्तुओं की मात्रा के बजाय गैर-अद्वितीय आइटम)।

— केविन क्रूज़सेन

Answer 1

आर , 20 बाइट्स

क्या यह आप के बाद कर रहे हैं? tableप्रत्येक scanइनपुट मानों की घटनाओं को गिनने के लिए उपयोग करता है । यदि परीक्षण गिनती है> 1 और ट्रम्स गाती है।

sum(table(scan())>1)

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

Comments

मेरा मन duplicatedपहली बार गया - विनम्र tableगोल्फ के लिए बहुत उपयोगी है!

— ग्यूसेप

@giuseppe तालिका अब एक पसंदीदा है :)

— मिकी

Answer 2

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

f s=sum[1|x<-[-9^6..9^6],filter(==x)s>[x]]

इसे ऑनलाइन आज़माएं! इस तथ्य का दुरुपयोग करता है कि सूची में पूर्णांक -100 k और 100k के भीतर होने की गारंटी है।

Answer 3

बैश + कोरुटिल्स, 18

sort|uniq -d|wc -l

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

Answer 4

एपीएल (Dyalog यूनिकोड) , 9 8 बाइट्स ^SBCS

-1 ngn के लिए धन्यवाद

बेनामी tacit उपसर्ग समारोह।

+/1<⊢∘≢⌸

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

+/ का योग

1< क्या 1 से कम है

... ⌸ प्रत्येक अद्वितीय तत्व के लिए:

 ⊢∘ वास्तविक अद्वितीय तत्व की अनदेखी,

 ≢ इसकी घटनाओं की गिनती

Comments

{1<≢⍵}⌸->1<⊢∘≢⌸

— nnn

@ngn धन्यवाद। शामिल।

— आदम

Answer 5

सी (क्लैंग) 175 117 95 बाइट्स

c(*a,*b){return*a-*b;}r(*l,m){qsort(l,m,4,c);return((!m||l[1]-*l)&l[-1]==*l)+(m?r(l+1,m-1):0);}

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

यह पहली बार है जब मैंने इनमें से एक को जमा किया है, इसलिए मुझे बताएं कि क्या प्रारूपण या किसी भी मुद्दे पर कोई समस्या है।

टिप्पणियों से अपडेट:

• -जो किंग से -58 से 117 बाइट्स
• -80 से 95 बाइट्स ASCII-only से

मूल सबमिशन

Comments

आपका स्वागत है, अच्छी शुरुआत। मैं एक सी व्यक्ति नहीं हूँ, लेकिन यहाँ एक करने के लिए एक लिंक भी है गोल्फ सी के लिए सुझाव दिए गए पेज

— MickyT

117 बाइट्स => d,i;c(*a,*b){return*a-*b;}r(l[],m){qsort(l,m,4,c);for(i=d=0;++i<m;)d+=((l[i+1]-l[i]||i>m-2)&&l[i-1]==l[i]);return d;}। जैसा कि @ ASCII- केवल उल्लेख किया गया है, includeआपके कार्यक्रम के संकलन को प्रभावित नहीं करता है

— Jo King

@ जॉकिंग 100:d;c(*a,*b){return*a-*b;}r(*l,m){qsort(l,m,4,c);for(d=0;~m--;)d+=(!m||l[1]-*l)&l[-1]==*l++;return d;}

— एएससीआईआई-केवल

@ कोलिनपिलिप्स हाँ। जैसा कि आप मेरे द्वारा पोस्ट किए गए लिंक में देख सकते हैं, यह अभी भी शामिल किए बिना ठीक संकलन करता है

— ASCII- केवल

95:c(*a,*b){return*a-*b;}r(*l,m){qsort(l,m,4,c);return((!m||l[1]-*l)&l[-1]==*l)+(m?r(l+1,m-1):0);}

— एएससीआईआई-केवल

Answer 6

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

n=>n.GroupBy(c=>c).Count(c=>c.Count()>1)

कल्पना का पहला मसौदा स्पष्ट नहीं था, और मुझे लगा कि इसका मतलब है कि उन सभी तत्वों को वापस करें जो एक से अधिक बार दिखाई देते हैं। यह अपडेटेड वर्जन है।

किसी तरह मैंने नोटिस नहीं किया कि मेरे कोड ने एक बार दिखाई देने वाले तत्वों की संख्या वापस कर दी। पॉल करम को पकड़ने के लिए धन्यवाद!

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

Comments

आपका आउटपुट गलत है, इसे तत्वों को 2 या अधिक घटनाओं के साथ गिनने की आवश्यकता है। यह होना चाहिए n=>n.GroupBy(c=>c).Count(c=>c.Count()>=2)। ओपी का कहना है कि इस सूची का उत्तर है 2. आपका कोड रिटर्न 5. मैंने आपको जो बदलाव दिया है, वह 2.

— पॉल करम

या सिर्फ >140 बाइट की गिनती रखने के लिए

— पॉल करम

@PaKKaram मैंने ध्यान नहीं दिया, धन्यवाद!

— अज्ञान का अवतार

Answer 7

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

lambda a:sum(a.count(x)>1for x in{*a})

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

Answer 8

जे , 11 9 बाइट्स

जोनाह के लिए -2 बाइट्स धन्यवाद!

1#.1<1#.=

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

मूल समाधान:

1#.(1<#)/.~

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

स्पष्टीकरण:

        /.~   group the list by itself
   (   )      for each group
    1<#       is the length greater than 1
1#.           sum by base-1 conversion

Comments

हे गेलन। 1#.1<1#.=9 बाइट्स के लिए + अच्छा राजभाषा 'स्व-वर्गीकृत मज़ा।

— योना

@ जॉन धन्यवाद! ईमानदारी से, मुझे इसकी जानकारी नहीं थी।

— गैलेन इवानोव

@ जोनाह नाइस!

— एडम

@ Adám और यहाँ मैं खुश था कि मैं J को APL के साथ बाँधूँगा। फ़ॉइल फिर से :)

— योना

Answer 9

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

->a{a.uniq.count{|x|a.count(x)>1}}

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

Answer 10

05AB1E , 4 बाइट्स

Ù¢≠O

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

   O  # sum
  ≠   # the false values
 ¢    # in the count
Ù     # of each unique digit in input

Comments

तो सभी मान जो 1 नहीं हैं वे झूठे हैं?

— एडम

@ Adám: हाँ, यह सही है।

— एमिगा

Answer 11

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

ĠITL

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

... या ĠIƇL

कैसे?

ĠITL - Link: list of integers   e.g. [234, 2, 12, 234, 5, 10, 1000, 2, 99, 234]
Ġ    - group indices by value        [[2,8],5,6,3,9,[1,4,10],7]
 I   - incremental differences       [[6],[],[],[],[],[3,6],[]]
  T  - truthy indices                [1,6]
   L - length                        2

IƇI( [[6],[3,6]]) की केवल सत्य परिणामों को रखने के लिए फ़िल्टर करेगा जिसमें वांछित लंबाई भी है।

Answer 12

पर्ल 6 , 15 बाइट्स

+*.repeated.Set

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

सुंदर आत्म व्याख्यात्मक। एक अनाम कोड ब्लॉक जो इनपुट के तत्वों के बीच तत्वों की गिनती ( +) प्राप्त करता Setहै ।repeated*

मैंने महसूस किया है कि मैंने संबंधित प्रश्न के लिए लगभग एक ही समाधान पोस्ट किया है ।

Answer 13

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

lambda l:len(C(l)-C({*l}))
from collections import Counter as C

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

Answer 14

जावा 8, 74 73 बाइट्स

L->L.stream().filter(i->L.indexOf(i)<L.lastIndexOf(i)).distinct().count()

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

स्पष्टीकरण:

L->                      // Method with ArrayList parameter and integer return-type
  L.stream()             //  Create a stream of the input-list
   .filter(i->           //  Filter it by:
     L.indexOf(i)        //   Where the first index of a value
     <L.lastIndexOf(i))  //   is smaller than the last index of a value
   .distinct()           //  Deduplicate this filtered list
   .count()              //  And return the count of the remaining values

Answer 15

एपीएल (डायलॉग एक्सटेंडेड) , 8 7 बाइट्स ^{एसबीसीएस}

जोनाह की विधि का उपयोग करके बेनामी टैटिट उपसर्ग फ़ंक्शन ।

+/1<∪⍧⊢

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

+/ कुल संख्याएँ
  ^{वस्तुतः सत्य का योग हैं}

1< जहां से कम है

∪ अद्वितीय तत्वों '

⍧ गिनती में

⊢ असम्बद्ध तर्क

Answer 16

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

f(h:t)=sum[1|filter(==h)t==[h]]+f t
f _=0

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

गिनती प्रत्यय जहां पहले तत्व hठीक एक बार दिखाई देने वाले भाग में दिखाई देता है t।

---

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

import Data.List
f l=length$nub$l\\nub l

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

अन्य उत्तरों से विधि चुराना।

Comments

दमयन्ती, हमारे पास सटीक उत्तर था

— गर्वित हैकेलर

Answer 17

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

f[]=0
f(a:s)=sum[1|filter(==a)s==[a]]+f s

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

Answer 18

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

f[]=0
f(a:b)|x<-filter(/=a)b,x/=b=1+f x|1>0=f b

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

यह भोला दृष्टिकोण है। ऐसा होने की संभावना है।

f[]=0

हम 0खाली सूची के लिए लौटते हैं

f(a:b)

एक गैर-रिक्त सूची के मामले में, जिसके साथ शुरू होता है aऔर फिर b।

|x<-filter(/=a)b,x/=b=1+f x

छानने तो aबाहर की bसे अलग है b(जो है aमें है b) तो हम वापस जाने के 1 से अधिक fकरने के लिए लागू bके साथ aफिल्टर करके निकाल रहा है।

|1>0=f b

यदि फ़िल्टरिंग में aपरिवर्तन नहीं होता है bतो हम बस fबाकी हिस्सों में चलते हैं ।

यहां एक और समान दृष्टिकोण है जिसकी लंबाई समान है:

f[]=0
f(a:b)|elem a b=1+f(filter(/=a)b)|1>0=f b

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

Answer 19

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

a=>a.map(o=x=>n+=(o[x]=-~o[x])==2,n=0)|n

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

Answer 20

वोल्फ्राम भाषा 34 बाइट्स

 Length@DeleteCases[Gather@#,{x_}]&

Gatherसमूहों को समान सूचियों में सूचीबद्ध करता है। DeleteCases[...{x_}]एकल संख्या वाली सूचियों को समाप्त करता है। Lengthशेष सूचियों की संख्या लौटाता है (प्रत्येक में दो या अधिक समान पूर्णांक होते हैं।

Comments

Count[{_,__}]@*Gather

— alephalpha

Answer 21

जाप , 12 11 9 8 6 बाइट्स

ü èÈÊÉ

@ ASCII- ओनली से बहुत मदद और @Shaggy और @Luis felipe De jesus Munoz के सुझाव।

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

Comments

11

— ASCII- केवल

९ १ ९ ९?

— एएससीआईआई-केवल

8 8

— ASCII- केवल

6

— एएससीआईआई-केवल

6 6

— ASCII- केवल

Answer 22

अजगर, 6 बाइट्स

l{.-Q{

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

व्याख्या

l{.-Q{
     {Q   Deduplicate the (implicit) input.
  .-Q     Remove the first instance of each from the input.
l{        Count unique.

Answer 23

ब्रेकीलॉग , 7 बाइट्स

ọzt;1xl

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

स्पष्टीकरण:

ọ          For every unique element E of the input, [E, how many times E occurs]
 zt        The last elements of the previous value.
   ;1x     With every 1 removed,
      l    how many there are.

Answer 24

PHP, 39 बाइट्स

चर चर का उपयोग करने के लिए एक अच्छा अवसर :

foreach($argv as$v)$r+=++$$v==2;echo$r;

कमांड लाइन तर्कों से इनपुट लेता है। इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

---

$argv[0]यह -तर्क में केवल एक बार दिखाई देता है, इसलिए यह परिणाम को प्रभावित नहीं करता है।

Answer 25

तत्व , 40 बाइट्स

_(#'{"2:0+4:'~1+";~2=[''1+""]$2+'[(#]'}`

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

इसके लिए एक सटीक प्रारूप में इनपुट की आवश्यकता होती है जैसे [234, 2, 1000, 2, 99, 234]( []अल्पविराम के साथ संलग्न और पूर्णांक के बीच का स्थान)।

स्पष्टीकरण:

_                                        input
 (#                                      delete the [ at start of input
   '{"                               '}  WHILE the string is non-empty
   '{"2:                             '}    duplicate it
   '{"  0+                           '}    add 0 to coerce to integer (gets next number in array)
   '{"    4:                         '}    make 3 additional copies
   '{"      '                        '}    temporarily move 1 copy to control stack
   '{"       ~                       '}    fetch the current map value for given integer
   '{"        1+                     '}    increment map value
   '{"          "                    '}    retrieve temporary copy of integer (the key for the map)
   '{"           ;                   '}    store updated map value
   '{"            ~                  '}    fetch map value again (1 if 1st instance, 2 if 2nd, etc.)
   '{"             2=                '}    test for map value = 2, this is the first duplication
   '{"               [      ]        '}    IF
   '{"               [''    ]        '}      move stuff from main stack to control stack
   '{"               [  1+  ]        '}      increment the counter of duplicate (bottom of stack)
   '{"               [    ""]        '}      move stuff back to main stack
   '{"                       $       '}    take length of current integer
   '{"                        2+     '}    add 2 (for the comma and space)
   '{"                          '[  ]'}    FOR loop with that number
   '{"                          '[(#]'}      trim those many characters from front of input string
                                       ` output result

Answer 26

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

O`.+
m`^(.+)(¶\1)+$

इसे ऑनलाइन आज़माएं! लिंक में टेस्ट सूट शामिल है जो कॉमा पर प्रत्येक पंक्ति को विभाजित करता है। स्पष्टीकरण:

O`.+

समान मूल्यों को एक साथ क्रमबद्ध करें।

m`^(.+)(¶\1)+$

कम से कम दो मूल्यों के रनों की संख्या की गणना करें।

Answer 27

क्लीन , 59 54 बाइट्स

import StdEnv,StdLib
$l=sum[1\\[_,_:_]<-group(sort l)]

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

सूची, समतुल्य समान तत्वों वाले समूहों को सॉर्ट करता है, और संख्या को 1 से अधिक आइटम के साथ गिनता है।

Answer 28

जंग, 126 बाइट्स

let f=|v:Vec<i32>|{let mut u=v.clone();u.sort();u.dedup();u.iter().filter(|i|v.iter().filter(|n|**n==**i).count()>1).count()};

मैं हार मानता हूं। यह मूल रूप से रूबी के समान है। इनपुट वेक्टर में मानों का उपयोग करते हुए एक सरणी बनाने और उसमें अनुक्रमण करने का एक और तरीका है, +100000, हालांकि प्रकार रूपांतरण (usize / as i32) बहुत अधिक स्थान लेते हैं।

Answer 29

MATL , 5 बाइट्स

8#uqz

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

8#u   % Number of ocurrences of each unique value
q     % Subtract 1
z     % Number of nonzeros

Answer 30

k, 8 बाइट्स

+/1<#:'=

के रूप में पढ़ता है: राशि (प्रत्येक समूह की लंबाई)> 1

+/ is sum (plus over)

#:' is length each

= is group (ex. =1 2 1 6 7 2 generates 1 2 6 7!(0 2;1 5;,3;,4) (dictionary of unique value and its positions)

उदाहरण का उपयोग करें (पहला परीक्षण मामला)

+/1<#:'=1 10 16 4 8 10 9 19 2 15 18 19 10 9 17 15 19 5 13 20

लिखता है ४