क्या ये पहचानकर्ता समान हैं?

Question

निम की भाषा में , पहचानकर्ताओं को अलग करने के नियम अधिकांश अन्य भाषाओं की तुलना में थोड़ा अधिक आराम से हैं। यदि वे इन नियमों का पालन करते हैं तो दो पहचानकर्ता समान हैं या समान चर को संबोधित करते हैं :

• दोनों का पहला चरित्र एक ही है (मामला संवेदनशील)
• पात्रों के सभी उदाहरणों को हटाने के बाद दोनों तार समान ( संवेदनशील में मामला ) हैं और-_

चुनौती

एक प्रोग्राम / फ़ंक्शन लिखें जो दो स्ट्रिंग लेता है जो निम पहचानकर्ता का प्रतिनिधित्व करते हैं और ऊपर दिए गए नियमों के आधार पर एक सत्य या गलत मूल्य पर आधारित हैं ।

विशेष विवरण

• मानक I / O नियम लागू होते हैं ।
• मानक खामियों को मना किया जाता है ।
• स्ट्रिंग्स में केवल ASCII प्रिंटबल होंगे । आप नहीं है अगर यह एक वैध पहचानकर्ता है की जाँच की जरूरत है।
• स्ट्रिंग्स को दो अलग-अलग इनपुट्स, स्ट्रिंग्स की सूची आदि के रूप में लिया जा सकता है (आप ड्रिल जानते हैं)
• खाली तारों को संभालने की जरूरत नहीं है।
• आउटपुट को सत्य और असत्य दोनों मूल्यों के अनुरूप होना चाहिए ।
• यह चुनौती सभी भाषाओं में सबसे छोटा दृष्टिकोण खोजने के बारे में नहीं है, बल्कि, यह प्रत्येक भाषा में सबसे छोटा दृष्टिकोण खोजने के बारे में है ।
• आपका कोड बाइट्स में स्कोर किया जाएगा , आमतौर पर एन्कोडिंग UTF-8 में, जब तक कि अन्यथा निर्दिष्ट न हो।
• अंतर्निहित कार्य जो इस कार्य को करते हैं, उन्हें अनुमति दी जाती है, लेकिन एक ऐसे समाधान को शामिल किया जाता है जो बिल्ट-इन पर भरोसा नहीं करता है।
• स्पष्टीकरण, यहां तक ​​कि "व्यावहारिक" भाषाओं के लिए भी प्रोत्साहित किया जाता है ।

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

Input                                    Output

count, Count                             falsey
lookMaNoSeparator, answer                falsey
_test, test                              falsey
test, tset                               falsey
aVariableName, a_variable_name           truthy
numbers_are_cool123, numbersAreCool123   truthy
symbolsAre_too>_>, symbols_areTOO>>      truthy

अनपेक्षित संदर्भ कार्यान्वयन

यह निम में ही लिखा गया है।

import strutils, re

proc sameIdentifier(a, b: string): bool =
  a[0] == b[0] and
    a.replace(re"_|–", "").toLower == b.replace(re"_|–", "").toLower

Comments

मैं एक परीक्षण के मामले का सुझाव देता हूं f("_test", "test")।

— दरवाज़े

@ डॉर्कनोब जोड़ा गया।

— जुआन

मैं जोड़ने का सुझाव f("test", "tset")देता हूं, क्योंकि मुझे लगता है कि एक उत्तर इसके लिए अप्रत्याशित परिणाम देता है।

— अर्जन जोहानसन

@ ØrrrJohansen किया।

— जुआन

प्रतीक्षा करें, इसलिए इनपुट स्ट्रिंग्स है जो "निम पहचानकर्ताओं का प्रतिनिधित्व करता है", और हमें "यह जांचने की आवश्यकता नहीं है कि क्या यह एक वैध पहचानकर्ता है", लेकिन फिर एक उदाहरण में शामिल है >?

— 21

Answer 1

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

@JohanKarlsson को 1 बाइट धन्यवाद दिया

करी सिंटैक्स में इनपुट लेता है (a)(b)। एक बूलियन देता है।

a=>b=>(r=s=>s[0]+s.replace(/-|_/g,'').toUpperCase())(b)==r(a)

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

let f =

a=>b=>(r=s=>s[0]+s.replace(/-|_/g,'').toUpperCase())(b)==r(a)

console.log(f("count")("Count"))                           // falsey
console.log(f("lookMaNoSeparator")("answer"))              // falsey
console.log(f("_test")("test"))                            // falsey
console.log(f("aVariableName")("a_variable_name"))         // truthy
console.log(f("numbers_are_cool123")("numbersAreCool123")) // truthy

Comments

/-|_/gएक बाइट बचाता है

— जोहान कार्ल्ससन

Answer 2

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

lambda a,b:f(*a)==f(*b)
f=lambda f,*r:[f+k.lower()for k in r if~-(k in'-_')]

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

-1 बाइट धन्यवाद नॉटजैगन
-3 बाइट्स व्हीट विजार्ड का धन्यवाद

Comments

-1 बाइट।

— नॉटजैगन

@notjagan नीट ट्रिक; धन्यवाद!

— हाइपरन्यूट्रीनो

@ नॉटजगन मुझे नहीं पता था कि आप ऐसा कर सकते हैं, लेकिन मुझे लगता है कि यह समझ में आता है, शांत

— स्टीफन

-14 बाइट्स!

— नॉटजैगन

इससे भी कम

— गेहूं जादूगर

Answer 3

दरअसल , 15 बाइट्स

⌠p"-_"(-Σùo⌡M═Y

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

मजेदार तथ्य: यह किसी भी संख्या में इनपुट के साथ काम करता है (यह हमेशा 2 इनपुट से कम के लिए सत्य देता है)।

स्पष्टीकरण:

⌠p"-_"(-Σùo⌡M═Y
⌠p"-_"(-Σùo⌡M    for each input:
 p                 separate the first character
  "-_"(-           remove all dashes and underscores from the rest of the string
        Σù         concatenate the list from the last operation and lowercase the string
          o        append it to the first character
             ═Y  are none of the elements unique?

Answer 4

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

qFm[hd-r0d"-_

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

व्याख्या

qFm[hd-r0d"-_
  m              For each value in the input (which is a list of two strings):
   [             Create a list consisting of
    hd               the first character of each value
      -r0d"-_        and the lowercase version of the value without "-" or "_"
qF               Fold over equivalence; checks to see if both lists are the same

Answer 5

05AB1E , 12 बाइट्स

εćs„-_SKl«}Ë

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

-1 अदनान को धन्यवाद ।

सैद्धांतिक रूप से, εćs„-_-«}Ë 10 बाइट्स के लिए काम करना चाहिए था, लेकिन दुर्भाग्य से यह व्यवहार अब के लिए पदावनत है।

Comments

ओह, हाँ, मुझे अभी भी इसे ठीक करने की आवश्यकता है। आप „-_SKइसके बजाय का उपयोग करके एक बाइट बचा सकते हैं '-K'_K।

— अदनान

@ अदनान और मुझे पता था कि एक रास्ता था। धन्यवाद!

— आउटगोल्फ जूल

11 बाइट्स अगर आप को बदलने SKके लिए м।

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

@ केविनक्रूजसेन एचएम, मैं इस उत्तर को अपडेट करूंगा। मुझे नहीं लगता कि мतब अस्तित्व में था। : पी

— एरिक आउटगॉल्फ

Answer 6

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

ḟ⁾-_Œl,Ḣµ€E

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

-2 बाइट्स की बदौलत एरिक आउटगॉल्फर
-1 बाइट की बदौलत जोनाथन एलन

Comments

जैसे दो स्ट्रिंग्स की सूची लें ["symbolsAre_too>_>", "symbols_areTOO>>"]और Ḣ;ḟ⁾-_Œl$µ€E-2 के बजाय उपयोग करें । उस प्यारे को मारो!

— एर्ग आउटफोलर

... या सिर्फ ḟ⁾-_Œl,Ḣµ€E11 बाइट्स के लिए।

— जोनाथन एलन

कोई समस्या नहीं, शायद 2 के लिए एरिक और 1 :) के लिए मुझे श्रेय

— जोनाथन एलन

@JonathanAllan आह। अच्छा विचार; मैं करता हूँ कि :)

— HyperNeutrino

Answer 7

रूबी , 86 64 63 61 51 बाइट्स

f=->x{x[0]+x.upcase.delete("-_")}
->x,y{f[x]==f[y]}

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

यह वास्तव में लंबा लगता है अभी भी थोड़ा लंबा लगता है। मैं वहाँ किसी भी रूबी गुरुओं की मदद की सराहना करता हूँ ताकि यह कम से कम थोड़ा कम हो सके।

Comments

गुरु नहीं, लेकिन मैं स्ट्रिंग विधि सूची की जाँच करने के लिए प्रेरित हुआ । .delete("_-")छोटा है।

— अर्जन जोहान्सन

f[x]हमेशा के लिए एक वैध प्रतिस्थापन है, f.call(x)जब स्टैम्ड लैम्ब्डा शामिल होते हैं।

— मान स्याही

@ValueInk धन्यवाद! मैं यह जानने की कोशिश कर रहा हूं कि स्टैक ओवरफ्लो उत्तरों के आधार पर रूबी में गोल्फ कैसे किया जाए, इसलिए मुझे नहीं पता था कि यह एक विकल्प था।

— गेहूं जादूगर

Answer 8

सी ++, 288 248 बाइट्स

-5 बाइट्स Zacharý के लिए धन्यवाद

#include<string>
#include<algorithm>
#define E(a,v)a.erase(std::remove(a.begin(),a.end(),v),a.end());
#define F(a)for(auto&c:a)c=toupper(c);
int e(std::string&a,std::string&b){if(a[0]!=b[0])return 0;E(a,45)E(b,45)E(a,95)E(b,95)F(a)F(b)return a==b;}

धन्यवाद, प्रीप्रोसेसर। इसके अलावा, यह कोड इस तथ्य का लाभ उठाता है कि C ++ में int को bool करने का नियम हैint_var!=0

Comments

;की परिभाषा के बाद जोड़ें F। फिर, पहले returnकथन को बदल दें return 0;E(a,45)E(b,45)E(a,95)E(b,95)F(a)F(b)।

— जचार्इ

Answer 9

CJam, 20 बाइट्स

{_"-_"f-:el:=\:c:=*}

["String1", "string2"] के रूप में इनपुट लेता है।

इसे ऑनलाइन आज़माएं (परीक्षण संस्करण)

{
_      e# make copy of input
"-_"f- e# remove all "-" and "_" from both words in copy
:el    e# convert words in copy to lowercase
:=     e# 1 if both words in copy are equal, 0 if not
\      e# move original version of input to top of stack
:c     e# convert each word in original input to only 1st character
:=     e# 1 if both characters from original input are equal, 0 if not
*      e# multply the two numbers we obtained. If and only if both are 1 (true) we return 1 (true)
}

Answer 10

हास्केल , 85 78 76 71 68 बाइट्स

2 बाइट्स ने अर्जन जोहान्सन को धन्यवाद दिया

import Data.Char
s(a:x)=a:[toLower a|a<-x,all(/=a)"-_"]
x!y=s x==s y

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

खाली स्ट्रिंग पर त्रुटियाँ।

Comments

all(/=a)"-_"। आपके नवीनतम संपादन के बाद भी fएक ऑपरेटर बनने की आवश्यकता है।

— अर्जन जोहानसन

@ ØrjanJohansen आह धन्यवाद। मैंने सोचा था कि ऐसा करने का एक छोटा तरीका है notElemलेकिन मैं इसे अपने जीवन के लिए याद नहीं कर सकता।

— गेहूं जादूगर

Answer 11

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

lambda x,y:r(x)==r(y)
r=lambda x:x[0]+x[1:].lower().translate(None,"-_")

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

नए translateवाक्य-विन्यास के कारण पायथन 3 के साथ काम नहीं करेंगे ।

Answer 12

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

=AND(CODE(A1)=CODE(B1),SUBSTITUTE(SUBSTITUTE(A1,"_",""),"-","")=SUBSTITUTE(SUBSTITUTE(B1,"_",""),"-",""))

CODE () पहले वर्ण का संख्यात्मक कोड लौटाता है।

एक्सेल में स्ट्रिंग तुलना असंवेदनशील है।

Answer 13

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

¤=§,←(m_ω-"-_

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

प्रत्येक स्ट्रिंग के लिए एक जोड़ी बनाता है जिसमें स्ट्रिंग के पहले वर्ण और पूरे स्ट्रिंग कम होते हैं और - / _ हटाए जाने की सभी घटनाओं के साथ। फिर जांचता है कि क्या दोनों जोड़े समान हैं।

एक ख़ासियत यह है कि -हस्क में अंतर होता है (यानी यह केवल पहली घटना को हटाता है): सभी घटनाओं को हटाने के लिए, निर्धारित बिंदु के -"-_साथ पाया जाता है ω-"-_।

Answer 14

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

g ¥Vg ©Uu k"_-" ¥Vu k"_-"

शब्द 1 से सभी वर्णों को हटाकर और -_वर्णों को हटाकर केस-असंवेदनशील स्ट्रिंग समानता की जाँच करता है ; ""शब्दों के बराबर होने पर एक रिक्त स्ट्रिंग ( ) में परिणाम ।
इस के साथ समस्या को इंगित करने के लिए धन्यवाद अर्जन जोहान्सन।

पहली-चार समानता की जाँच करता है और यदि अपरकेस इनपुट हटाने के बाद समान हैं _- ।

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

व्याख्या

अंतर्निहित इनपुट: Uऔर Vइनपुट स्ट्रिंग्स हैं

g ¥Vg

जांचें कि क्या U(अव्यक्त) का पहला अक्षर बराबर है ( ¥) V।

©Uu k"_-" ¥Vu k"_-"

और ( ©) अगर U, अपरकेस ( u) और _-हटाए गए ( k), बराबर ( ¥) के लिए समान की जांच करें V। जानबूझकर बूलियन परिणाम लौटाएं।

Comments

मुझे काम करने के लिए लिंक नहीं मिल सकता है, लेकिन यह स्पष्टीकरण ऐसा लगता है जैसे यह गलत काम करता है। यह testबनाम के लिए क्या देता है tset?

— अर्जन जोहानसन

@'LlrjanJohansen अच्छी बात ... यह उस मामले के लिए विफल रहेगा। लिंक के लिए, मैंने इसका परीक्षण किया है और यह ठीक काम करता है।

— जस्टिन मेरिनर

हाँ लिंक मेरी अपनी गलती है - इन दिनों में से एक मुझे एक आधुनिक ब्राउज़र में बदलने की आवश्यकता है। मैं इसे ऑनलाइन कोशिश के

— अर्जन जोहानसन

@ BrowserrjanJohansen क्या मैं पूछ सकता हूँ कि आप किस ब्राउज़र का उपयोग कर रहे हैं? मैं उस CodePen को सुधारने की प्रक्रिया में हूं और इसे TIO की तरह ही संगत बनाना चाहूंगा।

— जस्टिन मेरिनर

इंटरनेट एक्सप्लोरर का उपयोग करके अभी भी खांसी ।

— अर्जन जोहानसन

Answer 15

अजगर 2 , 79 73 बाइट्स

-6 बाइट्स के लिए @ नोटजगन को धन्यवाद: सभी कम किए गए नामों के सेट की लंबाई 1 या नहीं है।

lambda*l:len({x[0]+re.sub('-|_','',x[1:].lower())for x in l})<2
import re

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

Comments

-6 बाइट्स।

— नॉटजागन

बेशक, सेट, मैं अपने अस्तित्व को भूल गया !! बहुत बहुत धन्यवाद!!

— आधिकारिक

Answer 16

पर्ल 5 , 67 बाइट्स

s/.//,push@a,$&,y/_-//dr for<>;say($a[0]eq$a[2]&&lc$a[3]eq lc$a[1])

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

अलग-अलग लाइनों पर इनपुट के रूप में पहचानकर्ताओं को ले जाता है।

स्पष्टीकरण:

s/.//,             # remove the first character
push@a,            # storage space, even positions are first character
                   # odd positions are remainder
$&,                # implicit variable holding last matched pattern (first char)
y/_-//dr           # Remove _ and - from remainder of input
for<>;             # iterate over all input lines
say                # output
($a[0]eq$a[2]&&    # check that first character is identical and
lc$a[3]eq lc$a[1]) # so is the lowercase version of the rest

Answer 17

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

T`L\_-`l_`(?<=.).+
^(.*)¶\1$

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

Answer 18

चारकोल , 29 बाइट्स

∧⁼§θ⁰§η⁰⁼↧⪫⪪⪫⪪θ_ω-ω↧⪫⪪⪫⪪η_ω-ω

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

यह -सच्चाई के लिए और झूठे के लिए कुछ भी नहीं प्रिंट करता है ।

वर्बोज़ संस्करण से लिंक करें । यह पहले दोनों इनपुट स्ट्रिंग्स ( ⁼§θ⁰§η⁰) के पहले चरित्र की तुलना करता है और फिर अंडरस्कोर और हाइफ़न ( ⪫⪪⪫⪪θ_ω-ω) को हटाने और लोअरकेस ( ↧) में परिवर्तित करने के बाद दोनों स्ट्रिंग्स के बाकी हिस्सों की तुलना करता है ।

Answer 19

सी #, 101 89 बाइट्स

string g(string s)=>string.Concat(s.ToUpper().Split('-','_'));f=>s=>f[0]==s[0]&g(f)==g(s)

12 बाइट्स @ kusi581 के लिए धन्यवाद सहेजा गया।

Comments

यदि आप string.Concat(...)2 बाइट्स बचा सकते हैं, तो आप स्थानीय फ़ंक्शन का उपयोग करते हैं;)

— kusi581

@ kusi581 धन्यवाद, 12 बाइट्स बचाए गए।

— TheLethalCoder

Answer 20

जावा (ओपनजेडके 8) , 95 बाइट्स

a->b->a.charAt(0)==b.charAt(0)&&a.replaceAll("_|-","").equalsIgnoreCase(b.replaceAll("_|-",""))

इसे ऑनलाइन आज़माएं! बहुत सीधा।

Answer 21

पाइके , 13 बाइट्स

F'hl1"-_"-)Xq

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

F         )   -  for i in input():
 'hl1         -   i[0], i.lower()
     "-_"-    -         ^.remove("-_")
           Xq - equal(^)

Answer 22

सी (जीसीसी) , 126 114 बाइट्स

#define p(s)do++s;while(*s==45||*s==95);*s>95?*s-=32:0;
f(char*a,char*b){while(*a&&*a==*b){p(a)p(b)}return*a==*b;}

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

व्हाट्सएप और टिप्पणियों के साथ:

#define p(s)                   // Define helper macro p           \
    do ++s;                    // Increment pointer at least once \
    while (*s==45 | *s==95);   // and past any '-' or '_'         \
    *s>95 ? *s -= 32 : 0;      // If lowercase letter, convert to upper

f(char* a, char* b) {          // Define main function f
    while (*a && *a == *b) {   // Loop until end of either string
                               // or a difference found
        p(a)                   // Transform pointer and one char
        p(b)                   // via helper p above
    }
    return *a==*b;             // Test chars equal (on success, both '\0')
}

Comments

प्रश्न ASCII प्रिंटबेल्स को निर्दिष्ट करता है, इसलिए (1) पहले whileपरीक्षण को छोटा किया जा सकता है *s%50==45। (२) हालाँकि, लोअरस्किंग गलत है, जैसे यह t~बनाम पर विफल है t^।

— अर्जन जोहान्सन

@ AssumerjanJohansen मुझे लगा कि हम मान सकते हैं कि इनपुट दोनों मान्य पहचानकर्ता थे। लेकिन फिर उस उदाहरण के साथ >जोड़ा गया था, हम्म।

— 22

हुह। मैं उस उदाहरण से भी जा रहा था। निम मैनुअल में अब भी -देखने की अनुमति नहीं है, लेकिन एल्गोरिथ्म में अभी भी इसे शामिल किया गया है ...

— अर्जन जोहान्सन

@ Isn'trjanJohansen हाँ, मैंने देखा -कि पहचानकर्ता के व्याकरण विवरण में नहीं है - लेकिन फिर उस दस्तावेज़ के अन्य भागों का अर्थ है कि इसकी अनुमति है।

— aschepler

Answer 23

दिल्लोग एपीएल, 47 32 28 27 26 22 बाइट्स

-4 बाइट्स कृतिका लिथोस के लिए धन्यवाद

{(=/⊃¨⍵)∧≡/819⌶⍵~'-_'}   

स्ट्रिंग्स की सूची के रूप में इनपुट लेता है।

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

कैसे?

{(=/⊃¨⍵)∧≡/819⌶⍵~'-_'}
               ⍵~'-_'   Remove '-' and '_'
           819⌶         Lowercase
         ≡/             Equality between elements
        ∧               And
 (=/⊃¨⍵)                The first element of each element is equal

Comments

मुझे लगता है कि आप ⊃⍺=⍵इसके बजाय कर सकते हैं⍺[1]=⍵[1]

— क्रिति लिथोस

नहीं, क्योंकि तर्क अलग लंबाई के हो सकते हैं!

— जकार्इ

उस मामले में, काम ⊃⍵करने के बजाय⍵[1]

— क्रिस्ति लिथोस

शायद ⊃⍺=⊃⍵इसके बजाय भी⍺[1]=⍵[1]

— कृति लिथोस

Answer 24

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

(lambda(x y)(and(eql(elt x 0)(elt y 0))(string-equal(#1=remove #\-(#1##\_ y))(#1##\-(#1##\_ x)))))

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

Ungolfed (सुपर स्ट्रेटवर्ड!) संस्करण:

(defun f(x y)
  (and (eql (elt x 0) (elt y 0))         ; check if initial characters are identical
       (string-equal                     ; string comparison (case insensitive)
         (remove #\- (remove #\_ y))     ; remove from both strings the unwanted chars
         (remove #\- (remove #\_ x)))))

Answer 25

आर , 76 बाइट्स

function(l)(g=substr(l,1,1))[1]==g[2]&(h=tolower(gsub('-|_','',l)))[1]==h[2]

बेनामी फ़ंक्शन जो इनपुट को दो स्ट्रिंग्स की सूची के रूप में लेता है। इस तथ्य का लाभ उठाता है कि आर के स्ट्रिंग ऑपरेशन, जबकि वर्णों के # लंबे समय में, सदिश हैं। इसके अतिरिक्त कोष्ठक में एक असाइनमेंट लपेटने से वैरिएबल बंध जाएगा, इसलिए (g=substr(l,1,1))एक वैरिएबल को बाद में लाइन में पुन: उपयोग किए जाने के लिए बनाए रखता है और इसके लिए समान है h।

फ़ंक्शन आउटपुट के रूप में अंतिम मूल्यांकित अभिव्यक्ति देता है।

Ungolfed:

function(l){
  g <- substr(l,1,1)
  h <- tolower(gsub("_|-","",l))
  (g[1]==g[2])&(h[1]==h[2])
}

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले)

Answer 26

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

hᵛ&{{¬∈"_-"&ụ}ˢ}ᵛ

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

सफलता / विफलता की भविष्यवाणी के माध्यम से आउटपुट।

h                    The first element
 ᵛ                   is the same for each element of the input,
  &                  and
   {           }ᵛ    for each element of the input the following are the same:
    {      &ụ}ˢ      every element uppercased which satisfies the condition that
     ¬∈              it is not an element of
       "_-"          the string "_-".

Answer 27

एरलांग 113 बाइट्स

A=fun(L)->string:to_lower(lists:flatten(string:tokens(L,"-_")))end,fun([C|D],[C|E])->A(D)==A(E);(_,_)->a==b end.

दो कार्यों की तुलना करने वाले अनाम कार्यों की एक जोड़ी। एरांग खोल में चिपकाया जाना है।

अधिक पठनीय:

A=fun(L) ->
    string:to_lower( % case insensitive
        lists:flatten( % squash all characters back into one list
            string:tokens(L,"-_") % return a list of list of characters
        )
    )
end.
fun([C|D],[C|E]) -> % are the first characters exactly the same?
    A(D)==A(E); % does the rest compare correctly?
   (_,_) -> % first chars not the same
    a==b % shorter than 'false'
end.

Answer 28

क्लिप , 25 बाइट्स

&=(x(y=AxAy[Aa--m.L`a'-'_

व्याख्या :

x, yऔर zक्लिप इनपुट प्रोग्राम में संदर्भित किया जा सकता है ताकि तीन इनपुट तक का अनुमान लगाया जा सके। चूंकि यह कार्यक्रम केवल संदर्भ देता है xऔर y, इसमें दो इनपुट लगते हैं जिन्हें xऔर को सौंपा गया है y।

 =(x(y                    First characters of x and y are equal
&                         And
      =AxAy               A(x) == A(y)
           [Aa            Function A, takes parameter a
                m.L`a     Map all elements of a to lower case
              --     '-'_ Remove all occurrences of '-' and '_'

मानक इनपुट से दो तार लेता है, आउटपुट 1और 0क्रमशः सच और गलत के लिए।