एक सोलमेट की खोज में

Question

पूर्णांक की एक गैर-रिक्त परिमित सूची को देखते हुए, एक सत्य मान का उत्पादन करें यदि बिल्कुल दो समान प्रविष्टियां हैं और अन्य सभी प्रविष्टियां अलग हैं, और एक गलत मूल्य है अन्यथा।

उदाहरण

truthy:
[1,1]
[1,2,1]
[1,6,3,4,4,7,9]

falsey:
[0]
[1,1,1]
[1,1,1,2]
[1,1,2,2]
[2,1,2,1,2]
[1,2,3,4,5]

Comments

मुझे लगता है कि हम यह नहीं मान सकते कि पूर्णांक हमेशा 10 से कम होंगे?

— मार्टिन एंडर

हां, सिवाय इसके अगर आपकी भाषा किसी बड़े पूर्णांक का समर्थन नहीं करती है।

— दोष

क्या आप सुसंगत रूप से विस्तृत कर सकते हैं ?

— दोष

HNQ के शीर्ष पर इसे देखा और सोचा कि हम अंतिम

— इंटरपर्सनल.से

@Walfrat इसे अपनी चुनौती के रूप में पोस्ट करें। सैंडबॉक्स में भी इस तरह की प्रतिक्रिया की सराहना की जाती है।

— दोष

Answer 1

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

lambda m:len({*m})+1==len(m)

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

{*m}किसी setऑब्जेक्ट को सूची , डुप्लिकेट के बिना आइटम की एक अनियंत्रित सूची। ऐसा करने से इसमें हमेशा डुप्लिकेट की संख्या से सूची की लंबाई कम हो जाएगी। यह गणना करके कि लंबाई कितनी बदल गई है, हम आसानी से बता सकते हैं कि सूची में एक ही डुप्लिकेट था और परीक्षण के परिणाम को वापस कर दिया।

^{-2 बाइट्स ओव्स के लिए धन्यवाद।}

Comments

वास्तव में समाधान मेरे पास था, लेकिन {*m}शॉर्टकट के बारे में भूल गया set, अच्छी तरह से गोल्फ!

— FlipTack

नकार के लिए 27 बाइट्स । (झूठा जब यह सत्य होना चाहिए, आदि)

— mbomb007

यह करने के लिए एक और अजीब तरीका है (यह भी lambda m:~-len(m[len({*m}):])

— उपेक्षा

Answer 2

भूसी , 4 बाइट्स

εṠ-u

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

व्याख्या

εṠ-u  Implicit input.
   u  Unique elements.
 Ṡ-   Delete them from input, counting multiplicities.
ε     Is the result a singleton list?

Answer 3

MATL , 7 , 6 बाइट्स

&=sp4=

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

एक बाइट @Guiseppe के लिए धन्यवाद बचा लिया!

स्पष्टीकरण:

&=  % Table of pair-wise equality comparisons
    %
    % [1 0 0 0 0 0 0
    %  0 1 0 0 0 0 0
    %  0 0 1 0 0 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 0 0 1 0
    %  0 0 0 0 0 0 1]
    %
s   % Sum each Column. Stack:
    %
    % [1 1 1 2 2 1 1]
    %
p   % Product of the array. Stack:
    %
    % [4]
    %
4=  % Compare the stack to '4'

Comments

के बाद से sहै sumऔर sumपहली गैर सिंगलटन आयाम में रकम (कॉलम), और मैट्रिक्स सममित है, यह बस हो नहीं कर सकता है sके बजाय Xs?

— ग्यूसेप

@ गुइसेप्पे आह, टीआईएल। धन्यवाद!

— DJMcMayhem

Answer 4

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

f x=[1|a<-x,b<-x,a==b]==1:1:(1<$x)

इसे ऑनलाइन आज़माएं! H.PWiz के उत्तर पर आधारित है ।

Answer 5

जेली , 8 5 बाइट्स

QL‘=L

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

व्याख्या

QL‘=L  - Main link, argument L (a list)   e.g [1,6,3,4,4,7,9]
Q      - Deduplicated elements                [1,6,3,4,7,9]
 L     - Length                               6
  ‘    - Increment                            7
    L  - Length of the input                  7 ([1,6,3,4,4,7,9])
   =   - Are they equal?                      1

यदि आउटपुट मान किसी भी सुसंगत मान हो सकते हैं, तो QL_Lकाम करता है, जो -1सत्य के लिए आउटपुट करता है और फाल्सी के लिए कोई अन्य गैर-पॉजिटिव नंबर (धन्यवाद @JonathanAllan)

Comments

QL_Lसच्चाई के -1लिए आउटपुट और फाल्सी के लिए -1या उससे कम संख्या होगी 0(उदाहरण के [1,6,3,4,4,7,9,9,9]लिए -3, जबकि [1,6,3,4,7,9]वापस आ जाएगी 0)।

— जोनाथन एलन

@ जोनाथनअलन ओह यस। मुझे लगता है कि मैंने जिन उदाहरणों का परीक्षण किया था, वे वापस लौटने के लिए हुए -2।

— 21-11 को 21

Answer 6

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

a=>new Set(a).size==a.length-1

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

Answer 7

पुष्य , 8 बाइट्स

जाँच का सरल कार्यान्वयन len(set(list)) == len(list)-1:

LtvuL^=#

स्पष्टीकरण:

       \ Implicit: Put all input on stack
Ltv    \ Get the stack length - 1, save in auxiliary stack
u      \ Remove non-unique elements
L      \ Get the new length
^=     \ Compare with the previously saved length
#      \ Print result

यह काम करता है क्योंकि लंबाई केवल 1 से घट जाएगी यदि प्रारंभिक सूची में केवल 1 गैर-विशिष्ट पूर्णांक था।

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

Comments

वाह, उम्र में एक पुष्य जवाब नहीं देखा है! +1

— केयर्ड सिक्काहिंगाहिंग

@cairdcoinheringaahing पुष्य कभी नहीं मरेगा। यह केवल मजबूत होकर वापस आएगा।

— FlipTack

Answer 8

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

यह कई अन्य उत्तरों के रूप में groupया uniqueदृष्टिकोण का उपयोग नहीं कर रहा है, बल्कि सभी संभावित तुलनाओं के "कार्टेशियन उत्पाद" है।

@(x)nnz(triu(x==x',1))==1

व्याख्या

             x==x'        %create a matrix where the entry at (i,j) compares whether x(i) == x(ju)
        triu(x==x',1)     %only consider the strict upper triangular matrix
    nnz(triu(x==x',1))    %count the number of nonzero entries
@(x)nnz(triu(x==x',1))==1 %check whether this number is actually 1

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

और क्योंकि कोई भी कार्यक्रम एक दृढ़ संकल्प के बिना पूरा नहीं होगा (धन्यवाद @LuisMendo एक गलती को ठीक करने के लिए):

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

@(x)nnz(~conv(sort(x),-1:2:1,'same'))==1

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

Comments

आपने मुझे इस दृष्टिकोण के साथ आने के लिए प्रेरित किया :)

— स्टीवी ग्रिफिन

@StewieGriffin मुझे लगता है कि MATL उत्तर ने आपके सटीक दृष्टिकोण का उपयोग किया :)

— दोष

Answer 9

जे , 7 6 बाइट्स

=&#0,=

=हर अद्वितीय तत्व के साथ समानता के लिए हर तत्व की जाँच करें, के साथ एक मैट्रिक्स बनाता मीटर के लिए पंक्तियों  मीटर  अद्वितीय तत्व।
0,शीर्ष पर एक खाली पंक्ति जोड़ें।
=&#इनपुट की लंबाई के बराबर पंक्तियों की संख्या क्या है?

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

Comments

मुझे लगता है कि आप की जगह ले सकता .~साथ=

— H.PWiz

@ H.PWiz नाइस, संपादित।

— FrownyFrog

Answer 10

रेटिना , 15 12 11 बाइट्स

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

D`
Mm2`^$
1

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

इनपुट लाइनफीड-अलग है। (परीक्षण सूट सुविधा के लिए अल्पविराम-जुदाई का उपयोग करता है।)

व्याख्या

D`

इनपुट में लाइनों को डेडुप्लिकेट करें, जो पहले प्रकट हुए किसी भी पूर्णांक को निकालता है (लेकिन आसपास के लाइनफीड (एस) को छोड़ देता है)।

Mm2`^$

खाली लाइनों की संख्या की गणना करें, जो हमने हटाए गए डुप्लिकेट की संख्या के बराबर है, लेकिन केवल पहले दो मैचों पर विचार करें। तो आउटपुट केवल 0(कोई डुप्लिकेट नहीं) होगा, 1(एक डुप्लिकेट), 2(दो या अधिक डुप्लिकेट)।

1

सुनिश्चित करें कि वास्तव में एक डुप्लिकेट हटा दिया गया था।

Comments

न्यूलाइन मैच को 2 तक सीमित करके एक बाइट को बचाएं, ताकि परीक्षण को सरल बनाने के लिए तीसरी पंक्ति में इनपुट हमेशा 0, 1 या 2 हो। (वास्तव में आप A`.नई संख्याओं को गिनने के लिए उपयोग नहीं कर सकते हैं , क्योंकि यह आखिरी ड्रॉप करता है।)

— नील

@ नील धन्यवाद, सीमा एक साफ विचार है। मैंने भी प्रयोग करने की कोशिश की A`., लेकिन समस्या यह है कि आप एक भी खाली लाइन को अलग-अलग नहीं होने से अलग नहीं कर सकते। हो सकता है कि अगर कोई रेखाएं हैं तो मुझे एक लाइनफीड के साथ समाप्ति Aऔर Gआउटपुट पर विचार करना चाहिए । यद्यपि यह संभवतः एक विकल्प होना चाहिए क्योंकि मैं कल्पना कर सकता हूं कि अन्य परिदृश्यों में परेशान होने वाले लाइनफीड।

— मार्टिन एंडर

एक भी खाली लाइन का मिलान आसान है - बस ^$¶।

— नील

@ नोइल नो, मेरा मतलब है कि आउटपुट Aसमान है चाहे वह एक सिंगल लाइन को बरकरार रखे या सभी लाइनों को डिस्क्राइब करे ।

— मार्टिन एंडर

क्षमा करें, मेरा मतलब है कि "अंतिम एक को गिराता है" - यह एक कम खाली लाइन देता है, लेकिन फिर आप 0 और 1. के बीच अंतर नहीं कर सकते हैं

— नील

Answer 11

05AB1E , 4 बाइट्स

{¥_O

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

सत्य के 1रूप में आउटपुट , मिथ्या के रूप में किसी भी अन्य गैर-नकारात्मक पूर्णांक। 05AB1E में, 1एकमात्र सत्य संख्या (धन्यवाद @ अंतर्दृष्टि के लिए धन्यवाद!) है।

व्याख्या

{       Implicit input. Sort
 ¥      Consecutive differences
  _     Boolean negate
   O    Sum. Implicit display

Answer 12

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

->(s){s.uniq.length==s.length-1}

Comments

PPCG में आपका स्वागत है! क्योंकि यह कोड गोल्फ है, आपको अपने प्रोग्राम की बाइट गिनती शामिल करने की आवश्यकता है। मैंने इस बार आपके लिए इसे करने की स्वतंत्रता ली है।

— पावेल

कैसे के बारे में Array#size?

— ट्रैविस

आप 26 बाइट्स का उपयोग करके नीचे उतर सकते हैं->s{s.uniq.size==s.size-1}

— कॉनर ओ'ब्रायन

Answer 13

सी # (.NET कोर) , 35 + 18 बाइट्स

+18 उपयोग करने के लिए System.Linq।

n=>n.Distinct().Count()==n.Length-1

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

67 बाइट अल्टरनेटिव बिना Linq:

n=>new System.Collections.Generic.HashSet<int>(n).Count==n.Length-1

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

Answer 14

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

डेनिश भाषा संस्करण

=TÆLV(A:A)=SUM(--(FREKVENS(A:A,A:A)>0))+1

कॉलम में अलग सेल में सूची से प्रत्येक पूर्णांक मानता है A।
यदि हमें असंगत गलत मूल्यों के लिए अनुमति दी गई थी , तो हम 3 बाइट्स बचा सकते थे:

=TÆLV(A:A)+SUM(-(FREKVENS(A:A,A:A)>0))

अंग्रेजी भाषा संस्करण (44 बाइट्स)

=COUNTA(A:A)=SUM(--(FREQUENCY(A:A,A:A)>0))+1

Answer 15

आर , 32 31 बाइट्स

-1 बाइट थैंक्स टू @ जार्कोडबेलडैम

cat(sum(duplicated(scan()))==1)

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

स्टड से पढ़ता है, स्टडआउट को लिखता है।

duplicatedसूची के माध्यम से दोहराता, के मूल्यों की जगह lके साथ TRUEकरता है, तो है कि मूल्य सूची में पहले, और तब होता है FALSEअन्यथा। यदि आत्माधारियों की एक अद्वितीय जोड़ी है TRUE, तो वास्तव में एक मूल्य होना चाहिए, इसलिए योग होना चाहिए 1।

Comments

31 बाइट्स

— JAD

@JarkoDubbeldam आह, बिल्कुल। तुमसे फिर से मिल कर अछा लगा! इसे बीते एक अर्सा हो गया है।

— ग्यूसेप

कुछ अन्य सामान के साथ व्यस्त हो गया, यकीन नहीं कि मैं अभी तक पूरी तरह से वापस आ गया हूं।

— JAD

@Giuseppe, मैंने अभी इस प्रश्न को पढ़ा और तुरंत अपने मूल दृष्टिकोण के बारे में सोचा .... बहुत अच्छा! मैंने scan()दृष्टिकोण के बारे में कभी नहीं सोचा होगा ।

— जोसफ वुड

Answer 16

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

($args|sort -u).count-eq$args.count-1

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

Sort-Objectआदेश (उर्फ sort) के साथ -unique झंडा केवल इनपुट के अनूठे घटकों बाहर खींचती है। उदाहरण के लिए, इनपुट के लिए @(1,3,3,2), यह परिणाम देगा @(1,2,3)।

इस प्रकार, हमें बस यह सुनिश्चित करने की आवश्यकता है कि .countइस वस्तु (यानी, कितने तत्व हैं) हमारे इनपुट सरणी के -eqलिए ual है (यानी, हमारे पास एक डुप्लिकेट प्रविष्टि है)।.count-1

3 बाइट्स को साइनसॉइड के लिए सहेजा गया।
TessellatingHeckler के लिए फिक्स्ड बग धन्यवाद।

Comments

क्या आप समान परिणाम तक पहुंचने के लिए समूह के बजाय अद्वितीय-यूनीक उर्फ ​​'gu' का उपयोग कर सकते हैं?

— साइनसॉइड

@ साइनसॉइड हाँ, हम कर सकते हैं। धन्यवाद!

— AdmBorkBork

यह दूसरे परीक्षण मामले पर काम नहीं करता है 1,2,1- get-uniqueकेवल पूर्व-सॉर्ट किए गए इनपुट पर काम करता है। कैसे के बारे में ($args|sort -u).count-eq$args.count-1जो 37 भी है लेकिन सभी परीक्षण मामलों के लिए काम करता है, अगर आप f 1 2 1इसके बजाय इसे कहते हैं f 1,2,1?

— TessellatingHeckler

@TessellatingHeckler आह, अच्छी पकड़। मेरे द्वारा किए गए सभी परीक्षण पूर्व-सॉर्ट किए गए इनपुट के साथ थे। धन्यवाद!

— AdmBorkBork

Answer 17

पर्ल 5 , 36 + 1 ( -a) = 37 बाइट्स

map$k{$_}++,@F;@a=keys%k;say@a+1==@F

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

Comments

गोल्फ हो सकता है@k{@F}++;say@F==1+keys%k

— नहुएल फौलीउल

Answer 18

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

f x=sum[1|a<-x,b<-x,a==b]==2+length x

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

Answer 19

ऑक्टेव / MATLAB (सांख्यिकी पैकेज / टूलबॉक्स के साथ), 21 बाइट्स

@(x)nnz(~pdist(x))==1

अनाम फ़ंक्शन। इनपुट एक कॉलम वेक्टर है। आउटपुट है true(के रूप में प्रदर्शित 1) या false(के रूप में प्रदर्शित 0)।

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

व्याख्या

pdist(x)पंक्तियों के सभी जोड़े के बीच यूक्लिडियन दूरी के एक वेक्टर की गणना करता है x। यह प्रत्येक जोड़ी को केवल एक बार मानता है (दो पंक्तियों का क्रम मायने नहीं रखता है), और दो बार एक ही पंक्ति द्वारा गठित जोड़े पर विचार नहीं करता है।

हमारे मामले xमें एक स्तंभ वेक्टर है, इसलिए दो पंक्तियों के बीच यूक्लिडियन दूरी दो संख्याओं के बीच का पूर्ण अंतर है।

~तार्किक (बूलियन) नकार है, nnzगैर-संख्या की संख्या है, और ==1तुलना करता है 1। तो नतीजा यह है trueकि अगर केवल और केवल एक जोड़ी है जो शून्य दूरी देती है।

Answer 20

Jq 1.5 , 53 25 बाइट्स

length-(unique|length)==1

रिले के जवाब से प्रेरित और बहुत छोटा है तो मेरा मूल समाधान।

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

Answer 21

जूलिया, 39 26 बाइट्स

!a=sum(a.==a')==endof(a)+2

व्याख्या

कोड बूलियन्स की एक 2-आयामी तालिका उत्पन्न करता है, जिसे तब सम फ़ंक्शन का उपयोग करके एकत्र किया जाता है, ए के कार्टेशियन वर्ग में समान-तत्व जोड़े की संख्या की गणना करता है। फिर यह स्ट्रिंग प्लस दो की लंबाई की तुलना में है, और मात्राएँ बराबर होती हैं, जब एक ही दोहरा चरित्र होता है।

यह कोड नहीं ऑपरेटर को फिर से परिभाषित करता है।

Comments

!a=sum(a.==a')==endof(a)+2कुछ बाइट्स बचाता है। इसे ऑनलाइन आज़माएं!

— डेनिस

Answer 22

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

qtlQl{

सभी परीक्षण मामलों की जाँच करें।

• l{ - अद्वितीय तत्वों की संख्या हो जाती है।

• tlQ - इनपुट सूची की लंबाई हो जाती है, घट जाती है।

• q - समानता की जाँच करता है।

7 बाइट्स

q1l.-Q{

सभी परीक्षण मामलों की जाँच करें

Answer 23

ऑक्टेव , 23 26 बाइट्स

@(x)prod(sum(x==x'))==4

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

x==x'भाग से प्रेरित था flawr का जवाब । यह लुइस के उत्तर से अधिक लंबा है, लेकिन यह किसी भी टूलबॉक्स का उपयोग नहीं करता है।

स्पष्टीकरण:

यह एक अनाम फ़ंक्शन है जो एक वेक्टर xको इनपुट के रूप में लेता है , और इसकी तुलना स्वयं ट्रांसपोज़्ड करता है। यह एक मैट्रिक्स देगा जहां सभी विकर्ण तत्व हैं 1, और कोई भी विकर्ण तत्व संकेत देता है कि डुप्लिकेट तत्व हैं।

किसी भी दिए गए कॉलम के साथ योग से पता चलता है कि उस नंबर के कितने डुप्लिकेट हैं। हम चाहते हैं कि दो संख्याओं में एक डुप्लिकेट हो, इसलिए हमारे पास दो मान दो के बराबर हैं, और बाकी दो के लिए असमान हैं।

यदि हम इस मैट्रिक्स के उत्पाद को लेते हैं, तो हम प्राप्त करेंगे 4यदि केवल दो समान तत्व ( 2*2*1*1*1*1*...) हैं, और इसके अलावा कुछ और 4नहीं तो कोई डुप्लिकेट, या दो से अधिक नहीं हैं।

Answer 24

PHP, 46 बाइट्स

<?=count(array_unique($argv))==count($argv)-1;

इसमें प्रविष्टियों की संख्या की गणना करता है $argvऔर इसकी तुलना अद्वितीय प्रविष्टियों की संख्या से करता है। यदि पूर्व 1 से बाद का है, तो सत्य, और गलत है।

इसे eval.in पर आज़माएं!

Comments

क्या आपको चर नाम का उपयोग करना है $ argv क्या आप इसके बजाय $ का उपयोग नहीं कर सकते हैं?

— dading84

@ dading84 $argvकमांड लाइन मापदंडों की सूची है। इसलिए: नहीं, वह सिर्फ उपयोग नहीं कर सकता $a।

— टाइटस

Answer 25

05AB1E , 6 5 बाइट्स

{¥>ΘO

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

{¥>ΘO   # example input:               [1, 6, 3, 4, 4, 7, 9]
{       # sort                      -> [1, 3, 4, 4, 6, 7, 9]
 ¥      # get deltas                -> [  2, 1, 0, 2, 1, 2 ]
  >     # increment                 -> [  3, 2, 1, 3, 2, 3 ]
   Θ    # truthify (only 1 gives 1) -> [  0, 0, 1, 0, 0, 0 ]
    O   # sum                       -> 1

105AB1E में एकमात्र सत्य मूल्य होने के नाते, हम यहां रुक सकते हैं। (साभार @Emigna जो इस ओर इशारा करते हैं।)

केवल दो अलग-अलग मान प्राप्त करने के लिए, हम वैकल्पिक रूप से जोड़ सकते हैं:

     Θ  # equals 1?                 -> 1

Comments

यदि फाल्सी मामलों के लिए किसी भी गलत मूल्य को वापस करना ठीक है, तो आप इसे छोड़ सकते हैं Θ, जैसा 1कि 05.11E में एकमात्र सत्य मूल्य है।

— एमिग्ना

@Emigna धन्यवाद! मुझे यकीन नहीं था कि यह ओपी द्वारा अनुमोदित किया गया था, लेकिन मुझे लगता है कि यह है।

— अरनौलड

मुझे डर है कि आपको पिछले समाधान पर वापस जाने की आवश्यकता है क्योंकि ¢काम नहीं करेगा। यह [19,4,4,9]झूठे और [19,9]सच के रूप में गिना जाएगा क्योंकि यह अंदर पाता 0है 10।

— एमिग्ना

@Emigna को स्पॉट करने के लिए धन्यवाद। मुझे लगता है कि यह तय है।

— अरण्युलद

{¥_Oसाथ ही ठीक होना चाहिए।

— एमिग्ना

Answer 26

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

1=≢-≢∘∪

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

स्पष्टीकरण:

1=≢-≢∘∪  ⍝ Monadic function train
    ≢∘∪  ⍝ Generate a list of unique items in the input,
         ⍝ and return the length of that list
  ≢-     ⍝ Take the length of the input and subtract the above
1=       ⍝ If the difference is 1, true, otherwise false

Answer 27

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

ċ@€`QṢ⁼1,2

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

एक लंबा लेकिन अलग दृष्टिकोण

Answer 28

जाप, 7 बाइट्स

â ʶUÊÉ

कोशिश करो

---

व्याख्या

डुप्लिकेट निकालें ( â), लंबाई प्राप्त करें ( Ê) और समानता ( ¶) Êइनपुट की लंबाई ( ) के साथ तुलना करें ( U) शून्य से 1 ( É)।

Comments

12 बाइट्स नहीं है? âÊɶमल्टीबाइट वर्ण नहीं हैं ?

— रेडक्लोवर

Answer 29

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

f x=sum[1|0<-(-)<$>x<*>x]==2+length x

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

Answer 30

05AB1E , 5 बाइट्स

gIÙg-

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

g     # Get number of elements in input
 IÙg  # Get number of unique elements in input
    - # Subtract

05AB1E 1 में केवल सत्य मूल्य है, इसलिए एक सत्य परिणाम के लिए विशिष्ट रूप से हटाए गए 1 डुप्लिकेट तत्व होना चाहिए।