जांचें कि क्या शब्द आइसोमॉर्फ हैं

63

दो शब्द आइसोमॉर्फ हैं यदि उनके पास अक्षर दोहराव का समान पैटर्न है। उदाहरण के लिए, दोनों ESTATEऔर DUELEDपैटर्न हैabcdca

ESTATE
DUELED

abcdca

क्योंकि अक्षर 1 और 6 समान हैं, अक्षर 3 और 5 समान हैं, और आगे कुछ भी नहीं है। इसका मतलब यह भी है कि शब्द एक प्रतिस्थापन सिफर से संबंधित हैं, यहां मिलान के साथ E <-> D, S <-> U, T <-> E, A <-> L।

कोड लिखें जो दो शब्द लेता है और जांचता है कि क्या वे आइसोमॉर्फ हैं। सबसे कम बाइट्स जीतता है।

इनपुट: बड़े अक्षरों के दो गैर-खाली तार A..Z। यदि आप चाहें, तो आप इन्हें दो तारों के संग्रह के रूप में या एक विभाजक के साथ एक स्ट्रिंग के रूप में ले सकते हैं।

आउटपुट: जोड़े के लिए एक सुसंगत सत्य मान जो आइसोमॉर्फ हैं, और यदि वे नहीं हैं तो एक सुसंगत फ़ासी मूल्य । अलग-अलग लंबाई के तार मान्य इनपुट होते हैं जो कभी भी आइसोमॉर्फ नहीं होते हैं।

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

सच:

ESTATE DUELED
DUELED ESTATE
XXX YYY
CBAABC DEFFED
RAMBUNCTIOUSLY THERMODYNAMICS
DISCRIMINATIVE SIMPLIFICATION

असत्य:

SEE SAW
ANTS PANTS
BANANA SERENE
BANANA SENSES
AB CC
XXY XYY
ABCBACCBA ABCBACCAB
ABAB CD

आपके द्वारा उपयोगी पाए जाने वाले अधिक परीक्षण मामलों को जोड़ने के लिए स्वतंत्र महसूस करें।

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

कोड स्निपेट दिखाएं

code-golf  decision-problem  word-puzzle  code-golf  ascii-art 
— XNOR
स्रोत
क्या दो इनपुट की लंबाई समान होने की गारंटी है?
— ऑप्टिमाइज़र
@Optimizer नहीं, लंबाई अलग-अलग हो सकती है।
— xnor
@Jakube नहीं, आपके कोड को किसी भी लम्बाई के इनपुट के साथ सिद्धांत रूप में काम करना चाहिए। यह ठीक है, हालांकि अगर स्मृति पर अतिप्रवाह या स्टैक डेप्थ जैसे मुद्दों के कारण हार्डवेयर पर भारी इनपुट विफल हो जाते हैं।
— xnor
ठीक है फिर मैं अपना उत्तर हटा दूंगा।
— जकुबे
महत्वपूर्ण परीक्षण मामला: ABAB CD(जिप-जैसे दृष्टिकोण के लिए)
— Sp3000

जवाबों:

95

जे, 4 बाइट्स

-:&=

प्रयोग

   'THERMODYNAMICS' (-:&=) 'RAMBUNCTIOUSLY'  NB. parens are optional
1

व्याख्या

  • = 1 तर्क के साथ एक समानता-तालिका बनाता है जो इनपुट के तत्वों और उसके नब की तुलना करता है।

    ='ESTATE' gives the binary matrix

= | E S T A T E    
--+------------
E | 1 0 0 0 0 1
S | 0 1 0 0 0 0
T | 0 0 1 0 1 0
A | 0 0 0 1 0 0

  • -:2 तर्कों के साथ उनकी समानता की जांच करता है (जैसे ==आम तौर पर करता है)। यह विभिन्न आकार के मेट्रिसेस (या अलग-अलग प्रकार) के लिए भी काम करता है।

  • f&gदोनों इनपुट के लिए अलग से लागू होता है और फिर एक साथ दो परिणामों के लिए एफ लागू होता है x f&g y == f(g(x), g(y))।

  • तो हमारे मामले में हम दो समानता-तालिकाओं की तुलना करते हैं।

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

— randomra
स्रोत
2
एक दिलचस्प और सुरुचिपूर्ण दृष्टिकोण। उस के बराबर के बिना &, K में आप जो सबसे करीबी चीज कर सकते थे ~/{x=/:x}', वह शायद होगी , जो अब थोड़ी अच्छी है।
— जॉन
17
यीशु। यह प्रसिद्धि के कोडगॉल्फ हॉल के लिए एक दावेदार होना है।
— ब्रायन गॉर्डन
वाह, उम्मीद नहीं की =थी कि गिनती घटित होने के अलावा किसी और उपयोग के लिए वर्गीकृत हो सकती है।
— मील
37

के, 5 बाइट्स

यह कश्मीर में एक सुखद सुरुचिपूर्ण समाधान है!

~/=:'

"समूह" ऑपरेटर (मोनैडिक =) ठीक वैसा ही हस्ताक्षर बनाता है जैसा हम शब्द समरूपता के लिए चाहते हैं; एक वेक्टर के प्रत्येक तत्व के सूचकांकों को इकट्ठा करना, उपस्थिति द्वारा आदेशित समूहों के साथ:

  ="ABBAC"
(0 3
 1 2
 ,4)

  ="DCCDF"
(0 3
 1 2
 ,4)

एक वेक्टर के रूप में तारों की एक जोड़ी लेते हुए, हमें बस प्रत्येक तत्व ( =:') में समूह को लागू करने की आवश्यकता है और फिर "मैच" ( ~), गहरी-समानता ऑपरेटर के साथ कम करना है :

  ~/=:'("RAMBUNCTIOUSLY";"THERMODYNAMICS")
1
  ~/=:'("BANANA";"SERENE")
0
— JohnE
स्रोत
15

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

f=lambda a,b:map(a.find,a)==map(b.find,b)
— ygramul
स्रोत
4
यही वह समाधान था जिसने मुझे इस चुनौती को बनाने के लिए प्रेरित किया!
— xnor
12

CJam, 9 बाइट्स

r_f#r_f#=

प्रिंट 1यदि शब्द आइसोमॉर्फ हैं और 0यदि वे नहीं हैं।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

r    e# Read a whitespace separated token from STDIN.
_    e# Push a copy.
f#   e# Get the indexes of all characters from the first copy in the second.
r_f# e# Repeat for the second word.
=    e# Check for equality.
— डेनिस
स्रोत
10

जावास्क्रिप्ट, ईएस 7, 62 55 54 52 51 बाइट्स

f=(x,y,g=z=>[for(i of z)z.search(i)]+0)=>g(x)==g(y)

तर्क सरल है। मैं बस दोनों इनपुट को उनके संबंधित वर्ण सूचकांक मानों में परिवर्तित करता हूं, उस सरणी को स्ट्रिंग में परिवर्तित करता हूं और तुलना करता हूं।

f=(x, y,                  // Create a function named f which takes two arguments x and y
   g=                     // There is a third default argument to f which equals to
     z=>                  // and arrow function which takes argument z
     [                    // Return this array which is created using array comprehension
      for(i of z)         // For each character of z
      z.search(i)         // Use the index of that character in z in place of the character
     ]+0                  // And finally type cast that array to a string
                          // Here, the array elements are automatically joined by a ','
                          // and appended by a 0.
                          // Its funny how JS type casts Array + Number to a string
   )=>                    // Now the body of function f starts
      g(x)==g(y)          // It simply returns if index map of x equals index map of y

नीचे दिए गए स्निपेट का उपयोग करके उपरोक्त कोड आज़माएं।

कोड स्निपेट दिखाएं

2 बाइट्स @ edc65 की बदौलत बच गए

— अनुकूलक
स्रोत
7
+1, इसे आज़माया, अच्छी तरह से काम करता है। +0के बजाय +""?
— edc65
1
@ edc65 वाह, टाइपिंग डब्ल्यूटीएफ
— ऑप्टिमाइज़र
1
मुझे अभी पता चला है कि तार 'ए-जेड' हैं, इसलिए आप इंडेक्सऑफ के बजाय सुरक्षित रूप से खोज का उपयोग कर सकते हैं और 1 और बाइट काट सकते हैं।
— edc65
आखिरकार एरे कॉम्प्रिहेंशन havent es7 का कट गया है? यह कोड कहां काम करता है? मुझे लगता है कि केवल मोज़िला में
— डेनियल आइंडी
8

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

[ `tr $@<<<$1``tr $2 $1<<<$2` = $2$1 ]

ध्यान दें कि हम यहाँ सत्य / मिथ्या के सामान्य खोल विचार का उपयोग कर रहे हैं - शून्य का मतलब SUCCESS या TRUE और गैर-शून्य का अर्थ है त्रुटि या FALSE:

$ for t in "ESTATE DUELED" "DUELED ESTATE" "XXX YYY" "CBAABC DEFFED" "RAMBUNCTIOUSLY THERMODYNAMICS" "DISCRIMINATIVE SIMPLIFICATION" "SEE SAW" "ANTS PANTS" "BANANA SERENE" "BANANA SENSES" "AB CC" "XXY XYY" "ABCBACCBA ABCBACCAB"; do
> ./isomorph.sh $t
> echo $t $?
> done
ESTATE DUELED 0
DUELED ESTATE 0
XXX YYY 0
CBAABC DEFFED 0
RAMBUNCTIOUSLY THERMODYNAMICS 0
DISCRIMINATIVE SIMPLIFICATION 0
SEE SAW 1
ANTS PANTS 1
BANANA SERENE 1
BANANA SENSES 1
AB CC 1
XXY XYY 1
ABCBACCBA ABCBACCAB 1
$
— डिजिटल आघात
स्रोत
8

हास्केल, 33 29

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

इस तरह से बहुत देर हो चुकी है, लेकिन मुझे यह सुधार ऐप्लिकेशंस का उपयोग करते हुए मिला, जो कि मार्च 2015 में केवल प्रस्तावना में जोड़े गए थे।

s%k=g s==g k
g s=(==)<$>s<*>s

पुराना संस्करण:

s%k=g s==g k
g s=[a==b|a<-s,b<-s]

जाँच कार्य है (%)

यह प्रत्येक स्ट्रिंग के लिए "समानता रिकॉर्ड" उत्पन्न करके काम करता है: प्रत्येक दो सूचकांकों ij के लिए, यह रिकॉर्ड करता है कि क्या उनके पास समान वर्ण हैं। रिकॉर्ड का आदेश दिया जाता है ताकि दो सूचकांकों i, j के लिए रिकॉर्ड हमेशा एक ही स्थान पर हो * और इसलिए रिकॉर्ड की समानता की जांच करने से यह पता चलेगा कि स्ट्रिंग्स का समान पैटर्न है या नहीं।

उदाहरण के लिए, "एबीसी" का समानता रिकॉर्ड है [1,0,0,0,1,0,0,0,1](1 सच के लिए, 0 झूठे के लिए) - वहाँ है Trueजहाँ किसी भी सूचकांक की तुलना अपने आप से की जाती है। कहीं और झूठ है। (इन चेकों को छोड़ना अधिक कुशल हो सकता है, लेकिन गोल्फ के मामले में कठिन है)

* यदि तार समान लंबाई के हैं। अन्यथा यह गलत है क्योंकि रिकॉर्ड अलग-अलग लंबाई के हैं

— गर्वित हेकलर
स्रोत
6

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

h l=map(`lookup`zip l[1..])l
x!y=h x==h y

रिटर्न Trueया False, जैसे "ESTATE" ! "DUELED"-> True।

मानचित्र-चार-प्रथम-सूचकांक विधि का उपयोग करता है जैसा कि कई अन्य उत्तरों में देखा गया है। एसोसिएशन सूचियाँ काम में आती हैं, क्योंकि पहले की प्रविष्टियाँ ट्रम्प की हैं। "aba"हो जाता है [(a,1),(b,2),(a,3)], जहां lookupहमेशा हासिल करेगा a-> 1।

संपादित करें: @Mauris को बचाने के लिए 4 बाइट्स मिले।

— nimi
स्रोत
आप (flip lookup$zip l[1..])द्वारा प्रतिस्थापित कर सकते हैं (`lookup`zip l[1..])।
— लिन
6

ब्रेनफक, 169 168 162 144 140 131 130

एलेक्स Pankratov के साथ संगत BFF (brainfuck Spoj और ideone पर इस्तेमाल किया दुभाषिया) और थॉमस Cort के बीएफआई (अराजकता गोल्फ पर इस्तेमाल किया)।

अपेक्षित इनपुट एक टैब द्वारा अलग किए गए दो तार हैं, दूसरी स्ट्रिंग के बाद कोई नई रेखा नहीं है। आउटपुट 1आइसोमॉर्फ़्स के लिए है और 0गैर-आइसोमॉर्फ़्स के लिए, जो नेत्रहीन रूप से परिणामों की जाँच के लिए सुविधाजनक है, हालांकि सबसे छोटा विकल्प नहीं है। ( अपडेट: आउटपुट के साथ \x01और उत्तर के निचले हिस्से में विभाजक के \x00रूप में छोटा संस्करण \x00।)

आइडोन पर प्रदर्शन ।

,+
[
  -
  ---------
  >+<
  [
    >>-<
    [
      <
      [
        >+<
        <<<<-<+>>>>>-
      ]
      ++[->+]
      ->+[+<-]
      >[<<<<]
      <
    ]
    <[>+<-]
    +[->+]
    <->
    >>>
  ]
  >
  [
    [[-]<<<<<]
    >>>>
  ]
  <,+
]
>>>+>+
[
  [<->-]
  <[>>>>>]
  <<<<
]
-<[>]
+++++++[<+++++++>-]
<.

यह समस्या ब्रेनफक के लिए बहुत अच्छी है।

अनुक्रमण के साथ मूल विचार वर्तमान स्ट्रिंग उपसर्ग के अंत से पीछे की ओर जाना है। यदि चरित्र पहले नहीं हुआ है, तो हम स्ट्रिंग उपसर्ग की लंबाई ले सकते हैं। उदाहरण के लिए:

STATES
123255

कोड में अनुक्रमण वास्तव में थोड़ा अलग है लेकिन उसी सिद्धांत का उपयोग करता है।

मेमोरी लेआउट 5 के ब्लॉक में है:

0 0 0 0 0 0 c 0 i p 0 c 0 i p 0 c 0 i p 0 0 0 0

cचरित्र के लिए, iसूचकांक के pलिए और पिछले (इंडेक्स) के लिए खड़ा है । जब पहली स्ट्रिंग को संसाधित किया जा रहा है, तो सभी pस्लॉट शून्य हैं। के बाईं ओर स्थित सेल cका उपयोग वर्तमान वर्ण की एक प्रति रखने के लिए किया जाता है जिसे हम अनुक्रमित करने का प्रयास कर रहे हैं। वर्तमान के बाईं ओर स्थित सेल iका उपयोग -1आसान पॉइंटर नैविगेशन के लिए किया जाता है ।

ऐसी कई स्थितियाँ हैं जिन पर सावधानी से विचार करने की आवश्यकता है। अंत में, हम (i,p)जोड़े की तुलना करके आइसोमॉर्फ़ की जांच करते हैं , और हम शून्य कोशिकाओं के समूह तक सबसे बाईं (i,p)जोड़ी के बाईं ओर पहुंचते हैं यदि और केवल अगर स्ट्रिंग्स आइसोमॉर्फ हैं। यहां कोड का एक टिप्पणी संस्करण दिया गया है, जिसका अनुसरण करना आसान है:

,+
[                       while there is input
  -
  ---------
  >+<                   increment char (adjust later)
  [                     if not tab
    >>-<                set navigation flag
    [                   loop to find index
      <                 travel to copy
      [
        >+<             restore char
        <<<<-<+>>>>>-   compare chars and create copy
      ]
      ++[->+]           travel between navigation flags
      ->+[+<-]          increment index by 2 and go back
      >[<<<<]           proceed if not fallen off string
      <                 compare chars
    ]
    <[>+<-]             restore char (or no op)
    +[->+]              go back to navigation flag
    <->                 adjust char
    >>>                 alignment
  ]
  >
  [                     if tab
    [[-]<<<<<]          erase chars and go to beginning
    >>>>                alignment
  ]
  <,+
]
>>>+>+                  check string lengths and start loop
[
  [<->-]                compare indices
  <[>>>>>]              realign if not equal
  <<<<                  proceed
]
-<[>]                   cell to left is zero iff isomorphs
+++++++[<+++++++>-]
<.

अपडेट करें:

यहाँ एक संस्करण है जो आइसोमॉर्फ़ के \x01लिए और \x00गैर-आइसोमॉर्फ़ के लिए प्रिंट करता है । यह निश्चित रूप से ब्रेनफक के लिए ट्रू और फैसी की एक अधिक सटीक व्याख्या है, जिस तरह से [और ]काम के कारण। एकमात्र अंतर बहुत अंत में है।

अतिरिक्त: अब \x0010 बाइट को बचाने के लिए एक विभाजक के रूप में उपयोग कर रहा है ।

+
[
  -
  >+<
  [
    >>-<
    [
      <
      [
        >+<
        <<<<-<+>>>>>-
      ]
      ++[->+]
      ->+[+<-]
      >[<<<<]
      <
    ]
    <[>+<-]
    +[->+]
    <->
    >>>
  ]
  >
  [
    [[-]<<<<<]
    >>>>
  ]
  <,+
]
>>>+>+
[
  [<->-]
  <[>>>>>]
  <<<<
]
-<[>]
<+.
— मिच श्वार्ट्ज
स्रोत
5

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

एक औक्स फ़ंक्शन का उपयोग करना, जो hप्रत्येक शब्द को एक सरणी में मैप करता है जिसमें शब्द में प्रत्येक अक्षर की स्थिति होती है, उदाहरण के लिए: PASS -> [1,2,3,3]। यदि फ़ंक्शन hदो शब्दों को लागू करता है, तो उसी परिणाम पर लौटें ।

f=(a,b,h=w=>0+[for(c of(n=k=[],w))k[c]=k[c]||++n])=>h(b)==h(a)

// TEST

;[
// True
 ['ESTATE','DUELED']
,['DUELED','ESTATE']
,['XXX','YYY']
,['CBAABC','DEFFED']
,['RAMBUNCTIOUSLY','THERMODYNAMICS']
,['DISCRIMINATIVE','SIMPLIFICATION']

// False:

,['SEE','SAW']
,['ANTS','PANTS']
,['BANANA','SERENE']
,['BANANA','SENSES']
,['XXY','XYY']
,['ABCBACCBA','ABCBACCAB']
]
.forEach(t=>(f(t[0],t[1])?OK:KO).innerHTML+=t+'\n')
Ok<br>
<pre id=OK></pre><br>
KO<br>
<pre id=KO></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
1
कभी-कभी, सरल छोटा होता है;)
— ऑप्टिमाइज़र
5

आर, 78

function(x,y)identical((g=function(z)match(a<-strsplit(z,"")[[1]],a))(x),g(y))

डी-golfed:

word_to_num <- function(word) {
   chars <- strsplit(word,"")[[1]]
   match(chars, chars)
}
are_isomorph <- function(word1, word2) identical(word_to_num(word1), 
                                                 word_to_num(word2))
— flodel
स्रोत
मुझे इससे हराएं! (+1)
— छायाकार
मुझे लगता all( (g=...)(x)==g(y))है कि इससे छोटा है identical...
— Giuseppe
5

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

t=->x{y=0;z=?`;x.gsub!(y[0],z.succ!)while y=x.match(/[A-Z]/);x};f=->a,b{t[a]==t[b]}

यह एक ऐसा फंक्शन है fजिसमें दो तर्क दिए जाते हैं और रिटर्न trueया false।

व्याख्या:

test = -> str {
    y = nil  # we're just initializing this; it doesn't matter to what
             # this is the variable we use to store the `match' result
    z = '`'  # backtick is the ASCII character before `a'
    while y = str.match(/[A-Z]/) do  # while there is an uppercase letter in str
        str.gsub!(y[0], z.succ!)  # replace all instances of the uppercase letter
                                  # with the next unused lowercase letter
    end
    str  # return the new string
}
# self-explanatory
f=->a,b{test[a]==test[b]}
— Doorknob
स्रोत
1
यह 4 बाइट बचा t=->x{z=?`;x.chars.to_a.uniq.map{|c|x.gsub!(c,z.succ!)};x};f=->a,b{t[a]==t[b]}सकता है : और यदि आप प्रतिस्थापन प्राप्त करने के लिए हैश का उपयोग करते हैं, तो आप इसे 68 तक ले जा सकते हैं:t=->x{h={};i=9;x.gsub!(/./){|c|h[c]||h[c]=i+=1}};f=->a,b{t[a]==t[b]}
— blutorange
5

जावा, १०

(s,t)->java.util.Arrays.equals(s.chars().map(s::indexOf).toArray(),t.chars().map(t::indexOf).toArray())

से प्रत्येक चरित्र के नक्शे sऔर tइसके स्थान पर, और समानता के लिए जाँच करता है।

विस्तारित:

class Isomorphs {
    public static void main(String[] args) {
        java.util.function.BiFunction<String, String, Boolean> f =
            (s, t) -> java.util.Arrays.equals(
                                              s.chars().map(s::indexOf).toArray(),
                                              t.chars().map(t::indexOf).toArray()
                                             )
           ;
        System.out.println(f.apply("XXY", "XYY"));
    }
}
— Ypnypn
स्रोत
मुझे नहीं लगता कि यह सही ढंग से काम करेगा अगर तार अलग-अलग लंबाई के हों।
— जॉन
@ जॉन हाँ, यह करता है।
— यज्ञपिन
आह, ठीक है- मुझे लगता है कि "विस्तारित" संस्करण भ्रामक है।
— जॉनई
4

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

f=lambda a,b:''.join(map(lambda g:dict(zip(a,b))[g],a))==b
g=lambda a,b:f(a,b)&f(b,a)
— नंबर एक
स्रोत
इस पर इनपुट / आउटपुट कहां है?
— DJMcMayhem
@DJMcMayhem gमुख्य कार्य है, fसहायक है। gअंदर चर का एक भ्रामक विकल्प है f, लेकिन यह एक असंबंधित बाध्य चर है .. g=सत्तारूढ़ एनोन कार्यों के अनुसार वैकल्पिक है, जो दो वर्णों को बचाता है। '
— xnor
4

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

qFmmxdkdQ

निम्नलिखित रूप में इनपुट लेता है:

"ESTATE", "DUELED"

यदि यह स्वीकार्य नहीं है, तो निम्नलिखित कोड 10 बाइट्स हैं:

qFmmxdkd.z

और इस इनपुट फॉर्म का उपयोग करता है:

ESTATE
DUELED

स्ट्रिंग प्रतिनिधित्व में चार के सूचकांक का उपयोग करता है।

— isaacg
स्रोत
पहला इनपुट प्रारूप ठीक है। मुझे दिलचस्पी है कि आप समानता की जांच कैसे कर रहे हैं, लेकिन मैं इस बात पर अस्पष्ट हूं कि कैसे Fगुना के रूप में काम करता है। क्या है <binary>F?
— xnor
@xnor <binary>F<seq>पर <binary>मुड़ा हुआ है <seq>। यह <binary>तत्वों के हर जोड़े के बीच प्रतिच्छेदन के बराबर है <seq>। इस प्रकार, <binary>Fएक 2 तत्व अनुक्रम पर केवल फ़ंक्शन को अनुक्रम पर लागू करता है, पायथन .*या *पायथन में बराबर ।
— ईसैकग
मुझे लगा कि Qपाइलिंग में ट्रेलिंग निहित थी?
— साइओस
@Cyoce नॉट बैक तो - यह फीचर अप्रैल 2016 में जोड़ा गया था, लगभग एक साल बाद।
— 3
4

मतलाब, 50 बाइट्स

f=@(s,t)isequal(bsxfun(@eq,s,s'),bsxfun(@eq,t,t'))

फ़ंक्शन को कुछ स्थान बचाने के लिए अनाम के रूप में परिभाषित किया गया है।

उदाहरण:

>> f=@(s,t)isequal(bsxfun(@eq,s,s'),bsxfun(@eq,t,t'));
>> f('ESTATE','DUELED')
ans =
     1
>> f('ANTS','PANTS')
ans =
     0
— लुइस मेंडो
स्रोत
4

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

@(s,t)isequal(s==s',t==t')
— alephalpha
स्रोत
3
दिलचस्प लग रहा है। स्पष्टीकरण?
— गर्वित हेकलर
==मैट्रिक्स तत्व के लिहाज से समानता है, और के बाद से sऔर s'विभिन्न आकारों हैं, सप्तक के "प्रसारण" स्वचालित रूप से संचालित करने के लिए एक ही आकार के मैट्रिक्स निकलने की कोशिश करता है - इस मामले में लगातार दोहरा जिसका मतलब है sऔर स्तंभs'
— rakslice
यह @ लुइसमेन्डो के मतलाब समाधान के समान दृष्टिकोण है, लेकिन वहां विस्तार स्पष्ट है।
— रासलीला
4

05AB1E , 6 बाइट्स

εæδË}Ë

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

सूची के रूप में इनपुट लेता है: ['ESTATE', 'DUELED']

स्पष्टीकरण:

    εæδË}Ë   Full program
    ε        Apply on each
     æ         Powerset
      δË       For each generated substring: 1 if all equal, 0 otherwise
        }    End for each
         Ë   1 if all equal, 0 otherwise
— scottinet
स्रोत
4

APL (Dyalog) , 5 4 बाइट्स

-1 ngn के संकेत के लिए धन्यवाद।

अनाम मौन उपसर्ग फ़ंक्शन जो तर्क के रूप में दो तारों की एक सूची लेता है।

≡.⍳⍨

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

यह एक आंतरिक उत्पाद है, लेकिन सामान्य के बजाय +और ×इसका उपयोग करता है

≡ identicalness

. तथा

⍳ɩ ndex (प्रत्येक तत्व की पहली घटना)

⍨ दोनों तर्कों के रूप में उपयोग किए जाने वाले शब्दों की पूरी दो-तत्व सूची के साथ

यदि हम शब्दों को कहते हैं Aऔर B, तो हम पिछले समाधान को निम्नानुसार निकाल सकते हैं:

≡.⍳⍨ A B
A B ≡.⍳ A B
(A⍳A) ≡ (B⍳B)
(⍳⍨A) ≡ (⍳⍨B)
≡/ ⍳⍨¨ A B

पिछला समाधान

अनाम मौन उपसर्ग फ़ंक्शन जो तर्क के रूप में दो तारों की एक सूची लेता है।

≡/⍳⍨¨

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

≡ identicalness

/ भर में

⍳ɩ ndex (प्रत्येक तत्व की पहली घटना ...)

⍨ सेल्फी (… अपने आप में)

¨ प्रत्येक की

— एडम
स्रोत
क्या आप आंतरिक उत्पाद देख सकते हैं? :)
— नागिन 30'17
@ हाँ हाँ बिल्कुल। मुझे मूर्ख।
— आदम
क्या शीर्ष लिंक को पुराने समाधान से जोड़ना है?
— Zacharý
बहुत बुरा यह उच्च रैंक सरणियों पर काम नहीं करता है: P
— Zacharý
1
@ Zacharý के रूप में वादा किया: ngn.github.io/apl-codegolf-2017/readme.txt
— ngn
3

मैथेमेटिका, 46 बाइट्स

Equal@@Values@*PositionIndex/@Characters@{##}&
— alephalpha
स्रोत
3

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

30 बाइट्स छोटे रूबी कोड। इससे पहले कि मैंने समाधानों पर एक नज़र डाली, दोनों तार के प्रत्येक चरित्र की जाँच करता है कि क्या उस चरित्र की पहली घटना का सूचकांक मेल खाता है; अर्थात। एक स्ट्रिंग को उसके सामान्यीकृत रूप 01121आदि में बदल देता है और उनकी तुलना करता है।

->x,y{g=->z{z.chars.map{|c|z=~/#{c}/}};g[x]==g[y]}

Ideone पर परीक्षण के मामले एक अतिरिक्त बोनस के रूप में, यह ideone के कोड हाइलाइटिंग को तोड़ता है।

— blutorange
स्रोत
3

पीसीआरई, 84 बाइट्स

^((.)(?=.+ (\3.|)(.))(?=((?=(\2|)?+.* \3\4(\7?(?(?=.*+\6)(?!\4).|\4))).)+ ))+. \3..$

विषय दो अलग-अलग शब्द होने चाहिए, जैसे कि ओपी में। यहाँ एक सरसरी व्याख्या है:

पहले शब्द में प्रत्येक अक्षर X के लिए:

दूसरे शब्द के आगे देखें और याद करने के लिए वापस संदर्भ स्थापित करें कि हम X के अनुरूप दूसरे शब्द में Y के साथ कितनी दूर हैं।

प्रत्येक अक्षर Z के लिए पहले शब्द में वर्तमान स्थिति पिछले:

उपरोक्त समान संदर्भों को स्थापित करें।

दूसरे शब्द में संबंधित पत्र के आगे देखें और जांचें कि Z = X एक Y से मेल खाता है, अन्यथा एक पत्र से मेल खाता है जो Y नहीं है।

यह पुनरावृत्ति तब तक समाप्त हो सकती है जब तक कि हम पहले शब्द में दिए गए पत्र से मेल नहीं खाते। इस बिंदु पर, चूंकि कोई और सत्यापन आवश्यक नहीं है, इसलिए यह सब परीक्षण करना है कि शब्द समान लंबाई के हैं (दूसरे शब्द के संचित सब्सट्रेट वाले पीछे का संदर्भ हमेशा 1 अक्षर से पीछे है)।

— jaytea
स्रोत
2

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

->a{!!a.uniq!{|s|s.tr s,'a-z'}}

एक प्रोक जो स्ट्रिंग्स की एक सरणी लेता है और जांचता है कि क्या कोई एक दूसरे के लिए आइसोमोर्फिक है। tr s,'a-z'इन तर्कों के साथ sप्रत्येक अक्षर को वर्णमाला में nth अक्षर से बदलकर एक स्ट्रिंग को सामान्य करता है, जहां nसबसे बड़ा सूचकांक है जिसके साथ वह अक्षर स्ट्रिंग में दिखाई देता है। उदाहरण के लिए, estateहो जाता है fbedef, के रूप में करता है dueled।

— histocrat
स्रोत
1

कोबरा, 72 बाइट्स

do(a='',b='')=(for i in a get a.indexOf(i))==for i in b get b.indexOf(i)
— Οurous
स्रोत
क्या आप सुनिश्चित हैं कि यह AB CCपरीक्षण के मामले को गलत बनाता है?
— xnor
@xnor ने अभी तय किया है
— ousurous
1

जावास्क्रिप्ट (ईएस 5), 142 98

काफी बड़ा है, लेकिन मैंने अभी तक एक ES5 संस्करण नहीं देखा था।

for(l=j=2;j--;){c=prompt();for(i=c.length;i--;)c=c.replace(RegExp(c[i],"g"),i);b=l==c;l=c}alert(b)

बस पहले अक्षर की हर घटना को रिवर्स इंडेक्स वैल्यू से बदल देता है। हर चरित्र के लिए इसे दोहराता है।

यह दोनों इनपुट के लिए एक ही करता है और उत्पन्न पैटर्न की तुलना करता है।

तुलना काफी बदसूरत है, लेकिन मैं स्टोर करने और तुलना करने के लिए एक सरणी का उपयोग नहीं करना चाहूंगा।

— C5H8NNaO4
स्रोत
1
क्या आप एक बाइट ;l=cको स्थानांतरित करने for(l=j=2;j--;और बचाने के लिए नहीं जा सकते थे ?
— जोनाथन फ्रीच
1

पर्ल, 38 बाइट्स

($_,$a)=@ARGV;eval"y/$_/$a/";say$_~~$a

ऐसे दोड़ो perl -E '($_,$a)=@ARGV;eval"y/$_/$a/";say$_~~$a' RAMBUNCTIOUSLY THERMODYNAMICS

प्रिंट 1 अगर सच है, तो कुछ भी गलत नहीं है।

— गेब्रियल बेनामी
स्रोत
1

सी ++, 213 196 162 बाइट्स

-51 बाइट्स Zacharý को धन्यवाद

#include<map>
#define F(X,x)for(auto&e:X){if(x.end()==x.find(e))x[e]=65+x.size();e=x[e];}
auto i=[](auto a,auto b){std::map<int,int>c,d;F(a,c)F(b,d)return a==b;};

लंबोदर को कॉल करने के लिए, आपको 2 तर्क पास करने होंगे जो std::stringडेटा प्रकार हैं

परीक्षण के लिए कोड:

std::initializer_list<std::pair<std::string, std::string>> test{
    {"ESTATE","DUELED"},
    {"DUELED","ESTATE"},
    {"XXX","YYY"},
    {"CBAABC","DEFFED"},
    {"RAMBUNCTIOUSLY","THERMODYNAMICS"},
    {"DISCRIMINATIVE","SIMPLIFICATION"},
    {"SEE","SAW"},
    {"ANTS","PANTS"},
    {"BANANA","SERENE"},
    {"BANAnA","SENSES"},
    {"AB","CC"},
    {"XXY","XYY"},
    {"ABCBACCBA","ABCBACCAB"},
    {"ABAB","AC"}
};

for (const auto& a : test) {
    std::cout << "Test with " << a.first << " and " << a.second <<
        " outputs : " << (i(a.first, a.second)?"TRUE":"FALSE") << '\n';
}

कोड के लिए परीक्षण, सहित iostreamऔर stringहेडर फ़ाइल की आवश्यकता है

— HatsuPointerKun
स्रोत
1
ऐसा नहीं लगता है कि आप स्ट्रिंग हेडर से किसी भी चीज़ का उपयोग करते हैं, तो क्या आप इसे हटा सकते हैं और उपयोगकर्ता इसे स्वयं शामिल कर सकते हैं?
— Zacharý
क्या यह 161 बाइट्स के लिए काम करता है ?
— Zacharý
@ Zacharý यदि आप eतर्क के रूप में जोड़ते हैं find, हाँ, यह काम करता है
— HatsuPointerKun
वह क्षण जब आप ब्रेनफक से हार जाते हैं, हालांकि _ <
— ज़ाचारि
1

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

यह संस्करण सरणी समझ का उपयोग नहीं करता है, और करी सिंटैक्स का उपयोग करके इनपुट लेता है।

a=>b=>(f=x=>0+[...x].map(c=>x.search(c)))(a)==f(b)

कोड स्निपेट दिखाएं

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