इसोग्राम चेकर

13

चुनौती :

किसी शब्द को देखते हुए, देखें कि क्या यह एकोग्राम है।

क्या :

एक किलोग्राम एक ऐसा शब्द है जिसमें केवल डुप्लिकेट (केस असंवेदनशील) वाले अक्षरों से युक्त होता है। खाली स्ट्रिंग एक आइसोग्राम है।

उदाहरण :

"Dermatoglyphics"     ---> true
"ab"                  ---> true
"aba"                 ---> false
"moOse"               ---> false
"abc1"                ---> false
""                    ---> true

इनपुट:

आप किसी भी उचित प्रारूप में इनपुट स्वीकार कर सकते हैं

इनपुट में केवल अक्षर और / या नंबर होंगे, कोई स्थान नहीं ( [a-zA-Z0-9])

आउटपुट:

  • true या किसी भी सत्य मान अगर इनपुट एक कार्ड है
  • false या किसी भी मिथ्या मूल्य अन्यथा

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

code-golf  string  decision-problem 
— मुहम्मद सलमान
स्रोत
3
सुझाए गए परीक्षण का मामला:sad2
— एडमंड
1
आइसोग्राम की आपकी परिभाषा में दो अलग-अलग विरोधाभासी कथन शामिल हैं। यह किसका है?
— तदर्थ गार्फ हंटर
9
मैं आपको सलाह दूंगा कि आप सैंडबॉक्स का उपयोग शुरू करें ताकि चुनौती पोस्ट करने से पहले इन मुद्दों को पकड़ा जा सके।
— f --n 19tɪk
3
@MuhammadSalman यह बहुत ही टेढ़ा है, कृपया हटाएं "। कोई भी" आप के अंत में से और कुछ और उदाहरण देते हैं ( यह sad2dasबिना 2कुछ दिखाए भी विफल हो जाएगा )।
— असोन तुहिद
4
"क्या" और "नोट्स" एक दूसरे के विरोधाभास प्रतीत होते हैं: "एक फ़ंक्शन को लागू करें जो यह निर्धारित करता है कि क्या एक स्ट्रिंग जिसमें केवल अक्षर होते हैं एक आइसोग्राम" (जोर दिया गया है) और "संख्याएं हो सकती हैं और वे और झूठी वापस आनी चाहिए" विपरीत बातें कहना। मैंने इस समय के लिए अस्पष्ट के रूप में बंद करने के लिए मतदान किया है, लेकिन एक बार साफ़ होने के बाद इसे खुशी से वापस लेना होगा!
— Giuseppe

जवाबों:

9

अजगर 2/ 3, 36 52 48 बाइट्स

lambda s:len(s)==len({*s.lower()}-{*str(56**7)})

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

मैं इस तथ्य का लाभ उठाता हूं setजिसमें केवल अद्वितीय तत्व होते हैं। __len__प्रत्येक की विधि को लागू करके , मैं यह निर्धारित कर सकता हूं कि क्या sकेवल अद्वितीय तत्व (मामले की अनदेखी) शामिल हैं।

संपादित करें: संख्यात्मक इनपुट के लिए गलत लौटने के लिए पहले से अनदेखी की गई आवश्यकता को पूरा करने के लिए अद्यतन किया गया। सभी अंकों के सेट को एन्कोड किया गया है set(str(56**7))।

EDIT 2: इस उपयोगकर्ता के सुझाव के बाद , अब मैं समझ स्थापित करने के लिए तर्कों को अनपैक करने का लाभ उठाता हूं। यह औपचारिक रूप से पायथन 2 के साथ संगतता को तोड़ता है।

— स्कॉट नॉर्टन
स्रोत
3
PPCG में आपका स्वागत है! यह तब भी माना जाता है falseजब sअंक वर्ण होता है।
— Giuseppe
उपयोग कर रहा है `56**7`( str()छोटे के बजाय अन्य अजगर जवाब में) ? मैं अजगर से परिचित नहीं हूँ लेकिन यह आपके दो उत्तरों के बीच मुख्य अंतर प्रतीत होता है।
— Giuseppe
@Giuseppe python3 के पास नहीं है ``, एक python2- केवल संस्करण 4 बाइट्स बचाएगा (विभाजन के बजाय इस + 1 पर 3 बराबर)
— रॉड
@Rod बिल्कुल सही। मजेदार रूप से पर्याप्त, 56**7नीचे दिए गए अंको के 0-9 के अपने स्वयं के एन्कोडिंग से प्रेरित था, लेकिन 1 बाइट द्वारा आप पर बचाता है।
— स्कॉट नॉर्टन
शायद आप पायथन 2 संस्करण जोड़ सकते हैं? 46 बाइट्स:lambda s:len(s)==len(set(s.lower())-{`56**7`})
— सनी पटेल
4

आर , 41 बाइट्स

!grepl("(.).*\\1|\\d",tolower(scan(,"")))

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

रेगेक्स दृष्टिकोण। !grepl(regex,scan(,""),F)काम नहीं किया तो मुझे लगता है कि कैप्चरिंग केस-असंवेदनशीलता से आर में मेल नहीं खाती है? मैं सामान्य रूप से regex में बुरा हूँ, हालाँकि, मुझे आश्चर्य नहीं होगा अगर मैं इसे गलत कर रहा हूँ ...

आर , 58 बाइट्स

!anyDuplicated(c(el(strsplit(tolower(scan(,"")),"")),0:9))

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

0:9यदि कोई डुप्लिकेट हैं, तो अक्षरों (परीक्षणों) की सूचियों और परीक्षणों के लिए अंकों को जोड़ता है ।

— ग्यूसेप
स्रोत
3

रूबी , 25 23 21 बाइट्स

Giuseppe के लिए दोनों धन्यवाद पर -2 बाइट्स

->s{/(.).*\1|\d/i!~s}

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

-2 बाइट्स का धन्यवाद किरिल एल।

रूबी -n , 21 19 18 16 बाइट्स

p !/(.).*\1|\d/i

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

— आसोन तुहिद
स्रोत
@Giuseppe मुझे नहीं लगता था कि यह काम करेगा, धन्यवाद
— Asone Tuhid
1
मुझे लगता है, दूसरे संस्करण में, आपको इसकी आवश्यकता भी नहीं है $_- बस एक regex में बिना किसी और चीज के फेंकना इसके विपरीत है $_: 16 बाइट्स
— किरिल एल।
@KirillL। धन्यवाद, मैंने !/.../पहले कभी नहीं देखा , इसे ruby-doc.org
— Asone Tuhid
आश्चर्य की बात नहीं है, मैंने भी कुछ पर्ल लड़के से सलाह लेने के बाद यहां इसके बारे में सीखा :)
— Kirill L.
@KirillL। आश्चर्य की बात नहीं है, माणिक विचित्रता आमतौर पर perl से विरासत में मिली है
— Asone Tuhid
3

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

ḷo⊆Ạ

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

विधेय सफल होगा यदि इनपुट एक आइसोग्राम है और यदि यह नहीं है तो असफल हो सकता है, यदि यह सफल होता है तो लोअरकेस लैटिन वर्णमाला को आउटपुट करता है। चूँकि ब्रिकीलॉग का ⊆अंतर्निहित विधेय एक उपसमुच्चय और सुपरसेट के बीच के सामान्य संबंधों से बिल्कुल मेल नहीं खाता है, इसलिए मुझे निचली इनपुट को छांटने पर एक बाइट खर्च करनी थी, लेकिन इसमें डुप्लिकेट के लिए स्पष्ट रूप से जांच नहीं करने पर एक बाइट को बचाया। (यदि इसे संख्याओं के साथ विफल होने की आवश्यकता नहीं थी, तो हम उपयोग कर सकते हैं ḷ≠।)

— असंबंधित स्ट्रिंग
स्रोत
2

जाप , 12 बाइट्स

;v
oC ‰ eUq

स्पष्टीकरण:

;v
;         // Set alternative default vars, where C is the lowercase alphabet
 v        // Make the implicit input lowercase and reassign it
oC ‰ eUq
oC        // Remove all items from the input that are not in the alphabet
   ‰     // Split into chars and select unique array items
      eUq // Check if the result is equal to the input split into chars

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

— लीख
स्रोत
2

जाप 2.0, 12 11 बाइट्स

-1 बाइट नित को धन्यवाद

v
f\l â eUq

इसे ऑनलाइन टेस्ट करें!

— ओलिवर
स्रोत
उह, आपने संस्करण को एक लंबे समय तक क्यों बदल दिया? इसके अलावा, मुझे लगता है कि जप्ट का अंतिम संस्करण 1.4.4 है ...
— एरिक द आउटगॉल्फ
@EriktheOutgolfer मूल संख्या स्वचालित रूप से गलत लौटने पर खाता नहीं था।
— ओलिवर
आह, इसलिए आपने एक अल्फा संस्करण का उपयोग किया क्योंकि यह वास्तव में छोटा है।
— को आउटगोल्फर
@EriktheOutgolfer अधिकार। वेनिला जाप में रेक्सक्स की लागत +2 होगी। ethproductions.github.io/japt/…
— ओलिवर
1
@ धन्यवाद! का अच्छा उपयोगe
— ओलिवर
2

जावास्क्रिप्ट (Node.js) , 29 25 बाइट्स

s=>!/(.).*\1|\d/i.test(s)

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

@BMO , @ l4m2 , @KevinCruijssen के जवाब पर अपडेट के लिए धन्यवाद

-4 बाइट्स @KevinCruijssen को धन्यवाद

s=>!/(.).*\1|[^a-z]/i.test(s)?
— l4m2
@ केविनक्रूजसेन: मैंने अद्यतन संस्करण नहीं देखा
मैं बहुत यकीन है कि कर रहा हूँ [^a-z]के साथ बदला जा सकता है\d
— केविन Cruijssen
@ केविनक्रूजसेन: धन्यवाद। अद्यतन
2

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

Ci`(.).*\1|\d
^0

रिटर्न 1Truthy के रूप में और0 Falsey मूल्यों के रूप में। मेरे प्रारंभिक कोड में बग की खोज करने और उसे ठीक करने के लिए
धन्यवाद @Neil ।

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

स्पष्टीकरण:

C             Check if the input matches part of the following regex:
 i`            Case insensitivity enabled
               Check if part of the input matches either:
  (.)           A character `C`
     .*         followed by zero or more characters
       \1       followed by the same character `C` again
         |     Or
          \d    A digit
^0             Invert Truthy/Falsey, basically replacing every 0 with a 1,
               and every other value with a 1
— केविन क्रूज़सेन
स्रोत
तुम्हारा विपरीत क्यों है?
— मुहम्मद सलमान
@MuhammadSalman दो कारण: मैचों को उलटने से अधिक बाइट्स खर्च होंगे। और मैं रेटिना के साथ बहुत कुशल नहीं हूं, इसलिए मुझे यकीन नहीं है कि कैसे शुरू करने के लिए मैचों को उल्टा करना है .. xD
— केविन क्रूज़सेन
कारण 1)। आह अच्छा। कारण 2)। LOL
— मुहम्मद सलमान
1

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

param($b)($a=[char[]]$b.ToUpper()|group|sort c*)[0].Count-eq$a[-1].count-and$b-notmatch'\d'

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

भोले समाधान, लेकिन मैं एक बेहतर एल्गोरिथ्म के साथ नहीं आ सकता। इनपुट लेता है $b, इस ToUpperमामले को परिवर्तित करता है, इसे एक char-रे के रूप में रखता है। उस सरणी को पाइप करता है Group-Objectजिसमें एक वस्तु का निर्माण होता है जिसमें प्रत्येक इनपुट पत्र के लिए नाम / गिनती जोड़े होते हैं। हम इसके बाद ount sortपर आधारित होते cहैं और 0वें को लेते हैं। हम जाँच करें कि अपनी .Countहै -eqकरने के लिए UAL .Countपिछले की[-1] जोड़ी। यदि ऐसा है, तो गिनती सभी समान हैं, अन्यथा हमारे पास पत्रों की एक अलग राशि है।

हम तो -andयह देखते हुए कि इनपुट में किसी भी अंक को बाहर करने के लिए इनपुट के -notmatchखिलाफ है \dया नहीं। उस बूलियन परिणाम को पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

— AdmBorkBork
स्रोत
1

पायथन 2 , 57 56 बाइट्स

x=input().lower()
print len(set(x)-set(`763**4`))/len(x)

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

पहले यह एक सेट में इनपुट को चालू करता है, डुप्लिकेट को हटाता है, फिर अंकों (इनकोडिंग `763**4`) को हटाता है , फिर जांचें कि क्या लंबाई मूल इनपुट के समान है

— छड़ी
स्रोत
1

जावा 8, 61 39 बाइट्स

s->!s.matches("(?i).*((.).*\\2|\\d).*")

स्पष्टीकरण:

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

s->  // Method with String parameter and boolean return-type
  !s.matches("(?i).*((.).*\\2|\\d).*")
     //  Return whether the input does not match the regex

रेगेक्स स्पष्टीकरण:

String#matchesसंक्षेप में जोड़ता है ^...$।

^(?i).*((.).*\2|\d).*$
 (?i)                      Enable case insensitivity
^    .*                    Zero or more leading characters
       (       |  )        Followed by either:
        (.)                 Any character `C`
           .*               with zero or more characters in between
             \2             followed by that same character `C` again
               |           Or:
                \d          Any digit
                   .*$     Followed by zero or more trailing characters
— केविन क्रूज़सेन
स्रोत
1

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

अनाम मौन कार्य।

(∪≡~∘⎕D)819⌶

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

819⌶ लोअरकेस

(... ) उस पर निम्नलिखित कार्य समारोह लागू करें:

 ~∘⎕Dडी igits को तर्क से  हटा दें

 ∪≡ क्या तर्क के अद्वितीय तत्व उसी के समान हैं?

— एडम
स्रोत
1

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

{!(.uc~~/(.).*$0|\d/)}

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

किसी किरदार के लिए कोई मेल नहीं तो बाद में वही किरदार। कोड ब्लॉक के रूप में निहित कार्य, $ _ पर अंतर्निहित रूप से मेल खाते हैं, साथ में इनवर्टर बुक करें !। जोड़ा |\d(ता अदम) लेकिन यह भी जरूरत है .uc~~, जो कोष्ठक की जरूरत ...

बैग के साथ वैकल्पिक, 23 बाइट्स

{.uc.ords.Bag⊆65..97}

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

यह एक सामान्य स्थिति है फिर एक बैग बनाता है (घटना की गिनती के साथ सेट)। सबसेट या बराबर केवल तभी सही होता है जब सभी सदस्य तुलना बैग के सदस्य होते हैं, और सभी घटनाएं मायने रखती हैं या तुलना बैग में उन लोगों के बराबर होती हैं। इसलिए कोई भी दोहराव या अंक तुलना को गलत बना देगा।

— फिल एच
स्रोत
पर विफल रहता है abc1।
— एडम
आह, यह जवाब संख्या कल्पना जोड़े जाने से पहले लिखा था।
— फिल एच।
क्या आप नहीं जोड़ सकते |\d?
— आदम
@ Adám: क्रमबद्ध करें। एहसास हुआ कि अगर उन पत्रों के मामले अलग-अलग थे, तो बार-बार लिखे गए पत्रों का पता नहीं लगता, इसलिए मामले को सामान्य करने और परेंस को जोड़ने की जरूरत है।
— फिल एच।
1
— जो किंग
1

अनुप्रयोगों के लिए विज़ुअल बेसिक (32 बिट), 102 बाइट्स

s=LCase(InputBox(u)):j=1:For i=1To Len(s):k=Mid(s,i,1):j=j*0^Instr(i+1,s,k)*(k Like"[a-z]"):Next:?j<>0

इस तथ्य का उपयोग किया कि VBA में 0^x1 उपज है यदि x शून्य है और 0 अन्यथा। तत्काल (डीबग) विंडो में चलाएँ।

संपादित करें: जैसा कि टेलर ने टिप्पणी में बताया है कि यह केवल एमएस ऑफिस के 32 बिट इंस्टॉल में काम करता है।

— dnep
स्रोत
यदि आप अपनी भाषा को एक्सेल वीबीए तक सीमित रखते हैं, तो आप इस s=LCase([A1]):j=1:For i=1To Len(s):k=Mid(s,i,1):j=j*0^InStr(i+1,s,k)*(k Like"[a-z]"):Next:?j<>0इनपुट से 95 बाइट्स के लिए स्वैप कर सकते हैं [A1]। इसके अलावा, यह ध्यान देने योग्य है कि क्योंकि VBA में घातांक अजीब है कि यह समाधान कार्यालय के 32 बिट इंस्टॉल तक सीमित है।
— टेलर स्कॉट
इसके अलावा, आप उचित कैपिटलाइज़ेशन (ऊपर देखें) का उपयोग करके और <!-- language-all: lang-vb -->सिंटैक्स हाइलाइटिंग को जोड़ने के लिए अपने उत्तर में एक ध्वज जोड़कर अपने जवाब को बेहतर और अधिक पठनीय बना सकते हैं
— टेलर स्कॉट
1
@TaylorScott धन्यवाद! जोड़ा गया सिंटैक्स हाइलाइटिंग और विख्यात डी 32 बिट प्रतिबंध। एक्सेल इनपुट के बारे में, मैं जब भी संभव हो समाधान समाधान-अपरिवर्तनीय रखना चाहूंगा।
— dnep
1

05AB1E , 4 बाइट्स

lDÔQ

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

व्याख्या

l      # convert input to lowercase
 D     # duplicate and push to stack
  Ô    # uniquify the list of characters
   Q   # check for equality
— LordColus
स्रोत
यह विफल रहता है यदि इनपुट में गैर-अक्षर वर्ण हैं।
— झबरा
— लॉर्डकॉलस जू
The input will only contain letters and/or numbers, no spaces ([a-zA-Z0-9])
— लॉर्डकॉलस
" एक isogram एक ऐसा शब्द है जिसमें केवल डुप्लिकेट वाले कोई अक्षर होते हैं " - अर्थात, "शब्द" जिसमें संख्याएँ हैं, एक गलत मूल्य वापस करना चाहिए। एक उदाहरण के लिए 5 वां परीक्षण मामला देखें।
— झबरा
मेरी गलती। सही 05AB1E कोड के लिए @ Enigma का उत्तर देखें।
— लॉर्डकॉलस
1

सी (जीसीसी) , 87 85 83 बाइट्स

  • सहेजे गए दो करने के लिए चार बाइट्स धन्यवाद ceilingcat ।
f(s,p,b,P)char*s,*p;{for(b=s;*s;++s)for(p=b*=*s>64;b&&p<s;b=(*s^*p++)&95?b:0);s=b;}

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

— जोनाथन फ्रेच
स्रोत
@ceilingcat ठीक सुझाव, धन्यवाद।
— जोनाथन फ्रीच
@ceilingcat धन्यवाद।
— जोनाथन फ्रीच
0

सीजेएम , 11 बाइट्स

qelA,s+_L|=

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

व्याख्या

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

q      e# read the input:            | "MOoSE1"
el     e# convert to lowercase:      | "moose1"
A      e# push 10:                   | "moose1" 10
,      e# range [0,N):               | "moose1" [0 1 2 3 4 5 6 7 8 9]
s      e# string representation:     | "moose1" "0123456789"
+      e# concatenate:               | "moose10123456789"
_      e# duplicate:                 | "moose10123456789" "moose10123456789"
L|     e# union with the empty list: | "moose10123456789" "mose1023456789"
       e# (this gets rid of duplicates)
=      e# Equal to original:         | 0
— फल तोड़ना
स्रोत
0

स्मालटाक, 57 बाइट्स

कक्षा स्ट्रिंग में परिभाषित की जाने वाली विधि:

s^(self select:#isLetter)asUppercase asSet size=self size

यह सबसे अधिक संभावना है आत्म-व्याख्यात्मक।

— हंस-मार्टिन मोशनर
स्रोत
0

पायथ , 17 बाइट्स

.Am&!t/rz0d}dGrz0

परीक्षण सूट

स्पष्टीकरण: 
.Am&!t/rz0d}dGrz0 # Code
  m           rz0 # Map the following over the lowercase input:
      /rz0d       #  Count occurrences of d in lowercase input
     t            #   minus 1
    !             #    inverted (0 -> True)
   &              #     and
           }dG    #      d is in the lowercase alphabet
.A                # Print whether all values are truthy
पायथन 3 अनुवाद: 
z=input()
print(all(map(lambda d:not z.lower().count(d)-1and d in "abcdefghijklmnopqrstuvwxyz",z.lower())))
— hakr14
स्रोत
0

सी #, 82 बाइट्स

bool f(string s)=>!!(s.GroupBy(c=>c).Any(c=>c.Count()>1|(!Char.IsLetter(c.Key))));

संपादित करें: चार के लिए जोड़ा गया परीक्षण

संपादित करें: 5 बाइट द्वारा इसे छोटा करने के लिए GroupBy का उपयोग करना

— रेमंड ओस्टरब्रिंक
स्रोत
1
PPCG में आपका स्वागत है! मुझे लगता है कि आप उस आवश्यकता को याद कर रहे हैं जिसे आपको यह भी जांचने की आवश्यकता है कि इनपुट में कोई अंक नहीं है।
— मार्टिन एंडर
0

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

''≡'(.).*\1|\d'⎕S'&'⍠1

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

सत्य के लिए 1 लौटाता है, बाकी 0।

5 बाइट्स @ H.PWiz के लिए धन्यवाद सहेजा गया

फिक्स्ड, और @ Adám के लिए एक और बाइट धन्यवाद बचाया

कैसे?

''≡'(.).*\1|\d'⎕S'&'⍠1 ⍝ Tacit fn
                    ⍠1 ⍝ Ignore case
               ⎕S'&'   ⍝ Search and return the match(es)
   '(.).*\1|\d'        ⍝ For this regex
''≡                    ⍝ And compare to the empty string
— जे। सल्ल
स्रोत
पर विफल रहता है abc1।
— आदम
नहीं है \w → .वैध?
— एड्म
अगर आपका मतलब है (.).*\1, नहीं। यह भी विफल रहता हैabc1 : /
— जे। सेले
मुझे समझ नहीं आ रहा है। "यह भी विफल" से आपका क्या अभिप्राय है?
— आदम
अगर तुम इसे ऑनलाइन आज़माएँ! आप इसे 1 रिटर्न के लिए देख सकते हैं abc1, जब इसे 0.
— जे। सेले
0

Tcl , 114 बाइट्स

proc I w {lmap c [set L [split $w ""]] {if {[regexp -all -nocase $c $w]>1|![string is alp $c]} {return 0}}
expr 1}

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

Tcl , 121 बाइट्स

proc I w {lmap c [set L [split $w ""]] {if {[llength [lsearch -al -noc $L $c]]>1|![string is alp $c]} {return 0}}
expr 1}

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

अभी भी मेरे स्वाद के लिए बहुत लंबा है!

— sergiol
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.