एक प्रोग्राम लिखें जो हस्ताक्षरित पूर्णांक के एक सरणी के गैर-अद्वितीय तत्वों को पाता है। परिणामी सरणी किसी भी क्रम में हो सकती है।

आपका उत्तर एक स्निपेट हो सकता है जो इनपुट को एक चर में संग्रहित करने के लिए मानता है ( dऔर कहते हैं) और सही परिणाम का मूल्यांकन करता है।

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

प्रत्येक परीक्षण मामला प्रारूप में एक एकल पंक्ति है input => output। ध्यान दें कि आउटपुट के अन्य क्रमपरिवर्तन भी मान्य हैं।

[]                        => []
[-1, 0, 1]                => []
[1, 1]                    => [1]
[3, 0, 0, 1, 1, 0, 5, 3]  => [3, 0, 1]
[-34, 0, 1, -34, 4, 8, 4] => [-34, 4]

तत्वों का क्रम मायने नहीं रखता है।

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

code-golf array-manipulation counting

— garg10may
स्रोत

4

K5 , 5 बाइट्स

यह मानते हुए कि इनपुट पहले से ही एक चर में है d,

?d^?d

?D के अलग तत्व ( ) को छोड़कर (d d^के अलग तत्व ?d) ( )। अच्छी तरह से सममित, नहीं? यह काम करता है क्योंकि "छोड़कर" ऑपरेटर बाएं तर्क से सही तर्क की केवल पहली घटना को हटा देता है।

आम तौर पर,

nu: {?x^?x}

कार्रवाई में:

  nu'(();-1 0 1;1 1;3 0 0 1 1 0 5 3;-34 0 1 -34 4 8 4)
(()
 ()
 ,1
 0 1 3
 -34 4)

संपादित करें:

यदि हम गैर-अद्वितीय तत्वों की पहली घटना के क्रम को संरक्षित करना चाहते हैं, तो हम 4 अतिरिक्त बाइट्स की लागत को छोड़कर अद्वितीय तत्वों को हटाने से पहले और बाद में स्रोत सूची को उल्टा कर सकते हैं:

  nu: {?|(|x)^?x}
  nu'(();-1 0 1;1 1;3 0 0 1 1 0 5 3;-34 0 1 -34 4 8 4)
(()
 ()
 ,1
 3 0 1
 -34 4)

— JohnE
स्रोत

10

CJam, 10

मान लिया गया है कि चर पहले से ही D में है ( इस टिप्पणी के आधार पर ):

D{De=(},_&

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

स्पष्टीकरण:

D{…},   filter items of D based on the block
  De=   count occurrences in D
  (     decrement (resulting in true/false for duplicate/unique)
_&      remove duplicates from the results

नोट: a p यदि आप सुंदर छपाई चाहते हैं, तो इसे , अन्यथा परिणामी सरणी बस डिफ़ॉल्ट रूप से बिना सीमांकक के मुद्रित हो जाती है। यह स्वीकार्य है क्योंकि प्रश्न निर्दिष्ट करता है कि स्निपेट को केवल "सही परिणाम का मूल्यांकन करने की आवश्यकता है"।

मानक इनपुट / आउटपुट संस्करण, 13:

q~_{1$e=(},&p

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

स्पष्टीकरण:

q~      read and evaluate the input array
_       duplicate the array
{…},    filter items based on the block
  1$    copy the array
  e=    count occurrences
  (     decrement (resulting in true/false for duplicate/unique)
&       set intersection with the initial array (removes duplicates)
p       pretty print

— aditsu
स्रोत

1

13:q~$e`{((<~}%p

— Sp3000

3

@ Sp3000 मुझे आपकी टिप्पणी पढ़ने से पहले एक और 13-बाइट संस्करण मिला :) यह आदेश को भी संरक्षित करता है।

— 10

9

हास्केल - 32

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

बहुत छोटा है, आयात के साथ भी। a \\ bके प्रत्येक तत्व की पहली घटना को हटाता bहै a, और nubएक सूची के सभी तत्वों को अद्वितीय बनाता है।

— सी। क्विली
स्रोत

7

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

S{.-Q{Q

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

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

अजगर स्वचालित रूप से मूल्यांकन किए गए इनपुट को संग्रहीत करता है Qऔर सभी अप्रयुक्त रिटर्न मूल्यों को प्रिंट करता है।

     {Q  Convert Q into a set. This removes duplicates.
  .-Q    Perform "bagwise" difference of Q and set(Q).
         This removes the first occurrence of all elements in Q.
 {       Convert to set to deduplicate.
S        Sort. Returns a list.

— डेनिस
स्रोत

7

एसक्यूएल, 44 42 बाइट्स

SELECT*FROM D GROUP BY I HAVING COUNT(*)>1

मुझे आशा है कि पूर्णांक तालिका डी में संग्रहीत हैं यह मान लेना ठीक है? यह SQLServer, PostgreSQL और संभवतः अन्य दोनों में काम करेगा। 2 बाइट्स से @manatwork को धन्यवाद।

— MickyT
स्रोत

मान लें कि मैं तालिका d में एकमात्र क्षेत्र है, PostgreSQL में आप इसे कम कर सकते हैं select*from d group by 1having count(*)>1। (MySQL और SQLite के पार्सर भी अनसेप्‍ट किए गए select*fromभाग को संभालेंगे , लेकिन वे समझ नहीं पाते हैं 1having।)

— manatwork

@manatwork उसके लिए चीयर्स करता है, sql सर्वर भी समझता है select*from। 1havingहालांकि पसंद नहीं है .. के रूप में छोड़ देंगेI having

— मिकी

6

गणितज्ञ, २ ९ २६ बाइट्स

यह मानते हुए कि इनपुट में संग्रहीत है d:

Select[d⋃d,d~Count~#>1&]

अन्यथा, यह एक अनाम फ़ंक्शन के रूप में 29 बाइट्स है:

Cases[#⋃#,n_/;#~Count~n>1]&

यहां, d⋃d(या #⋃#) डुप्लिकेट को हटाने के लिए एक गोल्फिंग ट्रिक है - सेट यूनियन को खुद के साथ ले जाकर, मैथेमेटिका सूची को सेट के रूप में व्याख्या करता है, डुप्लिकेट को स्वचालित रूप से हटा देता है, जबकि वास्तविक संघ कुछ भी नहीं करता है।

बाद में, दोनों विधियां केवल उन तत्वों को फ़िल्टर करती हैं जो मूल सूची में कम से कम दो बार दिखाई देते हैं।

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

6

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

इसे जावास्क्रिप्ट कंसोल में चलाएँ:

e={};d.filter(x=>(e[x]=1+e[x]||0)==1)

— क्रिस्टियन लुपस्कू
स्रोत

यह आम तौर पर स्वीकार किया है कि जावास्क्रिप्ट स्पष्ट "उत्पादन / प्रिंट" समारोह के कुछ प्रकार (जैसे की जरूरत है console.log, alert, आदि) पूरा माना जाता है। यदि एक चुनौती कहती है "एक कार्यक्रम या फ़ंक्शन लिखें", तो फ़ंक्शन रिटर्न भी पर्याप्त है। इसके अलावा, बहुत कुशल समाधान!

— Mwr247

1

@ Mwr247 प्रश्न में कहा गया है कि एवर एक स्निपेट हो सकता है जो सही परिणाम का मूल्यांकन करता है ।

— क्रिस्टियन लुपस्कू

1

ऐसा लगता है कि मैंने उस अनुच्छेद की गलत व्याख्या की है। माफी तब =)

— Mwr247

@ Mwr247 कोई बात नहीं! :)

— क्रिस्चियन लुपस्कु

6

मतलाब / ऑक्टेव, 40

मैं मान रहा हूं कि इनपुट मूल्य वास्तविक हैं (जटिल नहीं)। इनपुट एक चर में है d।

unique(d(sum(triu(bsxfun(@eq,d,d')))>1))

इसे ऑक्टेव में ऑनलाइन आज़माएं ।

— लुइस मेंडो
स्रोत

इनपुट की आवश्यकता नहीं है, आप डेटा को 'd'

— garg10may

1

@ garg10may धन्यवाद। अपडेट किया गया। आपको यह निर्दिष्ट करना चाहिए कि आपकी पोस्ट में

— लुइस मेंडो

उत्पादन गलत जब है d = [3, 0, 0, 1, 1, 0, 5, 3]। दो 0एस हैं।

— एलेफाल्फा

@alephalpha धन्यवाद! सही (8 और बाइट्स)

— लुइस मेंडो

छोटा: d(sum(triu(bsxfun(@eq,d,d')))==2)। या ऑक्टेव में:d(sum(triu(d==d'))==2)

— alephalpha

6

पायथन 3.5, 30

[x for x in{*d}if~-d.count(x)]

पायथन 3.5 के सेट को अनपैकिंग का उपयोग करता है। ~-घटाता 1, जो 1 0 की गिनती जो Falsy है लेता है।

यह एक सूची देता है। यदि कोई सेट देना ठीक है, तो हम एक सेट समझ का उपयोग करते हैं, 1 char को बचाते हैं और 3.5 संस्करण की आवश्यकता नहीं है:

{x for x in d if~-d.count(x)}

— XNOR
स्रोत

SyntaxError: invalid syntaxपायथन 3 के लिए यह केवल 3.5 के लिए वैध है? अजगर कब से गूढ़ होने लगा है।

— garg10may

@ garg10may बस प्रतीक्षा करें कि

— Sp3000

1

@ Sp3000 बहुत बढ़िया। स्कैला की तरह ही सेट-अप दिखता है। वास्तव में अधिक विकल्पों की तुलना में अधिक पठनीय है।

— कारिकजेनिक

6

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

($d|group|?{$_.Count-1}).Name

$dमाना जाता है कि पहले से ही आबादी है (जैसा कि दिया गया है) - जैसे $d=@(-34,0,1,-34,4,8,4),।

सरणी को Group-Objectcmdlet में पाइप करता है , जो समूह जैसे आइटमों को एक साथ जोड़ता है और एक वस्तु को बाहर निकालता है जो अनिवार्य रूप से सरणियों का एक सरणी है। हम पाइप को एक Where-Object( ?ऑपरेटर) जो Countएक से अधिक है (यानी, डुप्लिकेट हैं), और आउटपुट आउटपुट करते हैं.Name उन वस्तुओं के । प्रारंभिक ऑर्डर को संरक्षित करने का एक साइड बोनस भी है।

_{संपादित करें - डैंको डर्बीक के लिए दो बाइट्स बचाए गए}

— AdmBorkBork
स्रोत

1

मुझे लगता है कि आप की जगह ले सकता $_.Count-gt1के साथ $_.Count-1जो किसी भी के लिए सच हो सकता है Countएक से अधिक।

— डैंको डर्बीक

@ DankoDurbić बहुत बढ़िया!

— AdmBorkBork

6

एपीएल (डायलॉग यूनिकोड) , 13 9 बाइट्स ^{एसबीसीएस}

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

∊(⊂1↓⊣¨)⌸

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

(... )⌸ प्रत्येक अद्वितीय तत्व (बाएं तर्क) और सूचकांकों के लिए जहां यह (सही तर्क) होता है, निम्नलिखित कार्य फ़ंक्शन लागू करें:

⊣¨ बाईं ओर (अद्वितीय तत्व) में से एक दाईं ओर (सूचकांकों) के लिए

1↓ एक छोड़ दो

⊂ एनक्लोज (गैर-रैग्ड मैट्रिक्स बनाने के लिए शून्य से पैडिंग को रोकता है)

∊ ϵ nlist (समतल)

— एडम
स्रोत

5

जूलिया, 30 29 बाइट्स

∪(d[find(sum(d.==d',1)-1)])

d.==d'i,jसही होने पर वैल्यू के साथ एक सममित मैट्रिक्स बनाता है d[i]==d[j]और अन्यथा गलत। sumएक आयाम में मिंग और फिर 1 को घटाना शून्य का उत्पादन करेगा यदि एक से अधिक तत्व और नॉनज़ेरो हो तो एक से अधिक हो। findगैर-शून्य तत्वों के सूचकांक प्राप्त करेगा, जो तब सरणी को अनुक्रमित करने के लिए उपयोग किया जाता dहै। ∪(संघ) uniqueइस तरह से प्रयोग किया जाता है जब दोहराव को हटाता है।

पुराना समाधान:

∪(filter(i->sum(d.==i)>1,d))

सरल - प्रत्येक प्रविष्टि के लिए, यह जाँचता है कि क्या यह सरणी में एक से अधिक है। जिनके लिए एक से अधिक हैं, उन्हें "फ़िल्टर" द्वारा लौटाया जाता है, और फिर ∪(संघ) की तरह कार्य करता हैunique इस तरह से उपयोग किए जाने पर दोहराव को हटा दिया जाता है।

नोट: मूल रूप से यह एक फ़ंक्शन के रूप में था, लेकिन सवाल सरणी को एक चर में संग्रहीत करने की अनुमति देता है, जिसके लिए मैंने dप्रश्न में सुझाए अनुसार चुना है ।

— ग्लेन हे
स्रोत

5

पायथन 2.7, 36 42

list(set(filter(lambda x:d.count(x)>1,d)))

संपादित करें : प्रश्न में आवश्यक प्रारूप का अनुपालन करने के लिए सूची (..) के साथ अभिव्यक्ति को घेर लिया

— dieter
स्रोत

यह आउटपुट लिस्ट सेट नहीं करेगा

— garg10may

तो क्या मुझे सूची (...) के लिए अपने स्निपेट को घेर लेना चाहिए?

— डाइटर

हाँ आउटपुट केवल एक सरणी होना चाहिए।

— garg10may

5

ऑक्टेव, 22 बाइट्स

लुइस मेंडो के जवाब पर आधारित है ।

d(sum(triu(d==d'))==2)

— alephalpha
स्रोत

5

आर, ३१ 24 बाइट्स

7 बाइट्स के लिए फ्लोडेल के लिए धन्यवाद ।

यह मानते हुए कि इनपुट पहले से है d।

कोड:

unique(d[duplicated(d)])

संपादित करें: अब यह सही ढंग से आउटपुट करता है यदि एडिट्स द्वारा इंगित किए गए 2 से अधिक डुप्लिकेट हैं ।

— Mutador
स्रोत

2

यह सुंदर लग रहा है! लेकिन 4 का परीक्षण मामला सही नहीं लगता ...

— aditsu

1

आप तब तक हटा सकते हैं whichजब आप [तार्किक तर्क को स्वीकार करते हैं।

— फ्लोडेल

5

पायथन 3 - 33 30 बाइट्स

{_ for _ in d if d.count(_)>1}

dइनपुट के रूप में , आउटपुट को दोहराएं ।

— pppery
स्रोत

4

गणितज्ञ, ३ ९ २ ९

Cases[{s_,t_/;t>1}:>s]@*Tally

— alephalpha
स्रोत

4

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

ft/QT{Q

स्पष्टीकरण:

ft/QT{Q
           Q = eval(input())
     {Q    set(Q) - deduplicate
f          filter - with T as the filter variable.
  /QT      count in Q of T
 t         minus 1.

फ़िल्टर उन सभी तत्वों को हटा देता है जो तत्वों के सेट से एक बार दिखाई देते हैं।

— isaacg
स्रोत

4

LINQ, 62 54 बाइट्स

Kinda यहाँ नया है, लेकिन यहाँ कुछ भी नहीं जाता है।

d.GroupBy(c=>c).Where(g=>g.Count()>1).Select(g=>g.Key)

— noisyass2
स्रोत

साइट पर आपका स्वागत है! मुझे LINQ का पता नहीं है, लेकिन कुछ व्हाट्सएप हैं जिनसे आप शायद अपना स्कोर सुधार सकते हैं।

— DLosc

4

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

समाधान:

&1<#:'=

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

स्पष्टीकरण:

&1<#:'= / the solution
      = / group, key => value (index)
   #:'  / count length of each group
 1<     / 1 less than 
&       / keys where true

— streetster
स्रोत

3

शेल + जीएनयू कोरुटिल्स, 12

sort|uniq -d

परीक्षण उत्पादन:

$ printf "%s\n" -34 0 1 -34 4 8 4 | ./nonuniq.sh 
-34
4
$

— डिजिटल आघात
स्रोत

3

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

इनपुट में संग्रहीत d:

Pick[#,#2>1]&@@@Tally@d

एक समारोह के रूप में, 24 बाइट्स:

Pick[#,#2>1]&@@@Tally@#&

उदाहरण के लिए, साथ

d = {3, 0, 0, 1, 1, 0, 5, 3}
Tally@d

यह रिटर्न:

   {{3, 2},
    {0, 3},
    {1, 2},
    {5, 1}}

(प्रत्येक सबलिस्ट का पहला तत्व तत्व है, दूसरा एक घटना की आवृत्ति है)। इस सूची में लागू करने से यह Pick[#,#2>1]&@@@बदल जाता है

{Pick[3,2>1], Pick[0,3>1], Pick[1,2>1], Pick[5,1>1]}

और जहां पहले तर्क के Pickमूल्यांकन का दूसरा तर्क Trueवापस आ गया है।

— LLlAMnYP
स्रोत

3

K (K5 नहीं), 10 बाइट्स

x@&1<#:'=x

मान लिया गया इनपुट में है x। मैंने सोचा कि यह गैर- K5 उत्तर देने के लिए मजेदार होगा!

— kirbyfan64sos
स्रोत

3

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

यह मानते हुए कि सूची में संग्रहीत है $_आप निम्नलिखित स्निपेट में से किसी का उपयोग कर सकते हैं।
_{^{(जिसे विशेष रूप से अनुमति दी गई थी)}}

(--«.BagHash).Set.keys # 23 bytes

keys .Bag (-) .Set # 18 bytes

# U+2216 SET MINUS
keys .Bag∖.Set # 16 bytes in utf8

अगर आपको इस बात की परवाह नहीं है कि आपको एक बैग मिलता है जिसे आप छोड़ सकते हैं keys ।

$_ = [3, 0, 0, 1, 1, 0, 5, 3];
.Bag∖.Set ∋ 3 # True
.Bag∖.Set ∋ 5 # False

इनमें से किसी के पास केवल हस्ताक्षरित पूर्णांकों पर काम करने की सीमा नहीं है, या यहां तक कि उस मामले के लिए केवल संख्याएं हैं।

say keys .Bag∖.Set given |(<a b c d a a c>), 1/3, 2/3 - 1/3;
# (a c 0.333333)

— ब्रैड गिल्बर्ट b2gills
स्रोत

3

रूबी, 30 28 बाइट्स

में इंटरएक्टिव रूबी शैल :

d.select{|x|d.count(x>1)}|[]

^{बची 2 बाइट्स किरिल एल की बदौलत।}

— क्रिस्टियन लुपस्कू
स्रोत

1

2 बाइट्स बचाएं:d.select{|x|d.count(x>1)}|[]

— Kirill L.

3

जावास्क्रिप्ट, 35 28 बाइट्स

a=>a.filter(o=x=>!(o[x]^=1))

यह ऑनलाइन की कोशिश करो!

इसे पोस्ट करने के बाद, मुझे एहसास हुआ कि यह w0lf के समाधान के समान था ।

— झबरा
स्रोत

2

आम लिस्प, 57 बाइट्स

(remove-duplicates(remove-if(lambda(x)(<(count x d)2))d))

— दाई
स्रोत

2

ऑक्टेव, 33 बाइट्स

[~,a]=unique(d);d(a)=[];unique(d)

प्रत्येक अद्वितीय पूर्णांक की पहली घटना के सूचकांकों को ढूँढता है,
उन घटनाओं को हटाता है, और
शेष सरणी के अनन्य तत्व पाता है।

यहाँ यह विचारधारा पर है । मैंने स्निपेट को एक फ़ंक्शन में लपेटा है, इसलिए मैं इसे सभी नमूना इनपुट का उपयोग करके कॉल कर सकता हूं।

— बीकर
स्रोत

2

जावा 8, 80 बाइट्स

x.stream().filter(i->x.indexOf(i)!=x.lastIndexOf(i)).collect(Collectors.toSet())

मान लें कि x में संख्याओं की इनपुट सूची है।

— rnet
स्रोत

2

PHP, 35 37 बाइट्स

बहुत सीधा:

array_diff_key($a,array_unique($a))

नोट के रूप में: मैं ;सवाल के राज्यों के रूप में लाइन के अंत में नहीं जोड़ा गया:

आपका उत्तर एक स्निपेट हो सकता है जो इनपुट को एक चर (डी, कहते हैं) में संग्रहीत करने के लिए मानता है और सही परिणाम के लिए मूल्यांकन करता है

तो इस स्निपेट का उपयोग इस तरह किया जा सकता है और सही परिणाम का मूल्यांकन कर सकता है:

print implode(' ', array_diff_key($a,array_unique($a)));

एक और नोट

उपरोक्त कोड चुनौती में प्रदान किए गए सभी परीक्षण मामलों के लिए काम करता है। उन सभी गैर-अद्वितीय पात्रों में अधिकांश डुप्लिकेट हैं। यदि कोई तत्व दो बार से अधिक हो सकता है, तो दूसरा array_unique()आवश्यक होगा, जो लंबाई को 49 बाइट्स तक बढ़ाता है :

array_unique(array_diff_key($a,array_unique($a)))

संपादित करता

के साथ प्रतिस्थापित करके 2 बाइट्स सहेजे गए । Jörg Hülsermann को धन्यवाद ।array_diff_assocarray_diff_key

— insertusernamehere
स्रोत

1

array_diff_keyइसके बजायarray_diff_assoc

— Jörg Hülsermann

@ JörgHülsermann अच्छा कैच। धन्यवाद। अगले दिनों के भीतर आपके अन्य सुझावों पर एक नज़र डालेंगे।

— सम्मिलन

गैर अद्वितीय तत्व

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

K5 , 5 बाइट्स

संपादित करें:

CJam, 10

मानक इनपुट / आउटपुट संस्करण, 13:

हास्केल - 32

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

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

एसक्यूएल, 44 42 बाइट्स

गणितज्ञ, २ ९ २६ बाइट्स

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

मतलाब / ऑक्टेव, 40

पायथन 3.5, 30

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

एपीएल (डायलॉग यूनिकोड) , 13 9 बाइट्स एसबीसीएस

जूलिया, 30 29 बाइट्स

पायथन 2.7, 36 42

ऑक्टेव, 22 बाइट्स

आर, ३१ 24 बाइट्स

कोड:

पायथन 3 - 33 30 बाइट्स

गणितज्ञ, ३ ९ २ ९

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

LINQ, 62 54 बाइट्स

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

शेल + जीएनयू कोरुटिल्स, 12

परीक्षण उत्पादन:

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

K (K5 नहीं), 10 बाइट्स

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

रूबी, 30 28 बाइट्स

जावास्क्रिप्ट, 35 28 बाइट्स

आम लिस्प, 57 बाइट्स

ऑक्टेव, 33 बाइट्स

PHP, 35 37 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 13 9 बाइट्स ^{एसबीसीएस}