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

संभवतः सबसे आसानी से उदाहरणों के माध्यम से परिभाषित किया गया है:

वैध मामले

"bat", "sap" => ["bt","sp"]

आदेश को नोटिस करें, का एक आउटपुट ["tb","ps"]इस चुनौती के लिए मान्य नहीं है।

"sense", "12n12" => ["se","12"]

ध्यान दें कि nअनुवाद कैसे नहीं किया जाता है क्योंकि यह 1 से 1 संबंध है।

"rabid", "snail" => ["rabd","snal"]

ध्यान दें कि iअनुवाद कैसे नहीं किया जाता है क्योंकि यह 1 से 1 संबंध है।

"ass", "all" => ["s","l"]

ए शामिल नहीं है, यह एक ही रहता है, पैटर्न मैच के कारण sमैप कर सकता है l।

"3121212", "ABLBLBL" => ["312","ABL"]

पैटर्न पूरी तरह से मेल खाता है।

झूठे मामले

"banana", "angular" => false

(समान लंबाई नहीं, असंभव)।

"animal", "snails" => false

(प्रत्येक वर्ण केवल अनुवाद के प्रत्येक पक्ष पर ONCE का उपयोग किया जा सकता है)।

"can","cnn" => false

(n का अनुवाद में निहित रूप से उपयोग किया जाता है, इसलिए, अनुवाद तालिका को n-> a के साथ परिभाषित करना अमान्य होगा)

इस प्रकार, [aimal,sails]यह एक गलत जवाब है, जिससे यह गलत साबित होता है।

"a1", "22" => false

"कैविट्स" देखें, यह मिथ्या के रूप में सूचीबद्ध है। इस मामले में, यह कारण है aऔर 1दोनों मैप नहीं कर सकते 2। (प्रत्येक वर्ण केवल अनुवाद के प्रत्येक पक्ष पर ONCE का उपयोग किया जा सकता है)।

यह उत्तर एक अच्छा बेंचमार्क लगता है: /codegolf//a/116807/59376

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

I / O नियम

इनपुट 2 तत्व सरणी या 2 अलग इनपुट के रूप में हो सकता है।
आउटपुट एक ऐरे या न्यूलाइन / स्पेस सीमांकित के रूप में हो सकता है, जैसा मैंने इसे दिखाया है।
गलत आउटपुट 0, -1 या गलत हो सकता है। एररिंग / खाली आउटपुट भी ठीक है।
आपको गारंटी है कि aन तो बराबर होगा bऔर न aही bखाली होगा।
aऔर bप्रिंट करने योग्य-एएससीआईआई-केवल अक्षरों के अनुक्रम हैं।

चेतावनियां

अनुवाद बाईं से दाईं ओर होने चाहिए, उदाहरण 1 देखें।
आपको उन वर्णों को आउटपुट नहीं करना चाहिए जो समान रहते हैं।
आपका कार्यक्रम केवल दो तार में हो सकता है aऔर b।
प्रत्येक वर्ण का अनुवाद के प्रत्येक पक्ष पर केवल ONCE का उपयोग किया जा सकता है। यही वह है जो अनुवाद snailsको animalsअसंभव से असंभव बना देता है।
पुनरावर्ती रिप्लेसमेंट नहीं होना चाहिए। पुनरावर्ती प्रतिस्थापन का उदाहरण: "a1","22"->[a1,12]जहां एक को पहले 1 से बदल दिया जाता है, फिर परिणामी 1 को 2 के स्थान पर बदल दिया जाता है। यह सही नहीं है, मान लें कि सभी अनुवाद एक-दूसरे से स्वतंत्र होते हैं, जिसका अर्थ यह गलत है। अर्थ: [a1,12] की अनुवाद तालिका के साथ "a1" 12 का मूल्यांकन करता है (22 नहीं)

code-golf natural-language

— जादू ऑक्टोपस Urn
स्रोत

एक साधारण प्रतिस्थापन सिफर के रूप में इस "अनुवाद" को लेबल करना इरादे को स्पष्ट करने में मदद कर सकता है।

— ग्रेग मार्टिन

क्या साहचर्य सरणियों को आउटपुट के रूप में अनुमति दी जाती है? यह मुझे कुछ बाइट्स बचा सकता है

— Jörg Hülsermann

@ JörgHülserman मुझे यह अनुमति देने के निहितार्थ पर पूरी तरह से यकीन नहीं है, शायद 2 संस्करण बना सकता हूं ताकि मैं अंतर देख सकूं? अगर मुझे लगता है कि यह चुनौती के लिए हानिकारक नहीं है तो मैं इसे संपादित करूँगा।

— मैजिक ऑक्टोपस Urn

स्ट्रिंग के रूप में मेरे पोस्ट के पहले समाधान को देखें और दूसरे में आउटपुट एक साहचर्य सरणी के रूप में है

— Jörg Hülsermann

@ JörgHülsermann आह ... मैं देख रहा हूँ कि आप इसे अभी कैसे उपयोग कर रहे हैं, मुझे लगता है कि मैं इसे अस्वीकार करने जा रहा हूं, सभी भाषाएं हैश जैसी संरचनाओं का समर्थन नहीं करती हैं।

— मैजिक ऑक्टोपस Urn

7

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

f=
(s,t)=>!t[s.length]&&[...s].every((c,i)=>n[d=t[i]]==c||d&&!m[c]&&!n[d]&&(n[m[c]=d]=c,c==d||(a+=c,b+=d)),m={},n={},a=b='')&&[a,b]

<div oninput=o.textContent=f(s.value,t.value)><input id=s><input id=t><pre id=o>

स्निपेट का विस्तार करें

— नील
स्रोत

के लिए काम नहीं करता है assऔर all, होना चाहिए s,l।

— मैजिक ऑक्टोपस Urn

हाँ, यह स्निपेट ट्रिप्पिन हो सकता है ', सत्यापित भी, यह ठीक है।

— मैजिक ऑक्टोपस Urn

1

@carusocomputing यह एक चर नाम का टकराव था - यह अब तय हो गया है। उसके लिए माफ़ करना।

— नील

7

जावास्क्रिप्ट (ईएस 6), 108 107 105 106 बाइट्स

संपादित करें : ऐसे इनपुट का समर्थन करने के लिए फिक्स्ड "22" / "a1"होना चाहिए, जो गलत होना चाहिए।

0या तो या दो तार की एक सरणी देता है ।

f=(a,b,x)=>[...a].some((c,i)=>d[C=b[i]]?d[C]!=c:(d[C]=c)!=C&&(s+=c,t+=C,!C),s=t='',d=[])?0:x||f(b,a,[s,t])

प्रारूपित और टिप्पणी की गई

f = (                       // given:
  a,                        // - a = first string
  b,                        // - b = second string
  x                         // - x = reference result from previous iteration,
) =>                        //       or undefined
  [...a].some((c, i) =>     // for each character c at position i in a:
    d[                      //   if we already have a translation
      C = b[i]              //   of the character C at the same position in b,
    ] ?                     //   then:
      d[C] != c             //     return true if it doesn't equal c
    :                       //   else:
      (d[C] = c) != C &&    //     store the translation C -> c in the dictionary
      (                     //     if the characters are different:
        s += c, t += C,     //       append them to the translation strings s and t
        !C                  //       return true if C is undefined
      ),                    //
    s = t = '', d = []      //   initialize s, t and d  
  ) ?                       // if some() returns true:
    0                       //   there was a translation error: abort
  :                         // else:
    x ||                    //   if this is the 2nd iteration, return x
    f(b, a, [s, t])         //   else do a recursive call with (b, a)

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

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

f=(a,b,x)=>[...a].some((c,i)=>d[C=b[i]]?d[C]!=c:(d[C]=c)!=C&&(s+=c,t+=C,!C),s=t='',d=[])?0:x||f(b,a,[s,t])

// truthy
console.log(f('bat','sap'))
console.log(f('sense','12n12'))
console.log(f('rabid','snail'))
console.log(f('ass','all'))
console.log(f('3121212','ABLBLBL'))

// falsy
console.log(f('banana','angular'))
console.log(f('animal','snails'))
console.log(f('a1','22'))
console.log(f('22','a1'))
console.log(f('aaa','bab'))
console.log(f('abc','abcd'))
console.log(f('abcd','abc'))

Expand snippet

— Arnauld
स्रोत

f('22')('a1')मिथ्या भी होना चाहिए।

— नील

उम्मीद है कि मुझे इस बार सही मिला।

— Arnauld

1

यह हमेशा आसान होता है जब आपका बगफिक्स कुछ छोटा करने के लिए सरल हो जाता है!

— नील

7

PHP> = 7.1, 130 बाइट्स

18 बिट्स @ टिट्स द्वारा बचाए गए

for([,$x,$y]=$argv;a&$o=$y[$i];)$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p;echo$y==strtr($x,$c)&$x==strtr($y,$k)?join($k)." ".join($c):0;

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

विस्तारित

for([,$x,$y]=$argv;a&$o=$y[$i];)
$o==($p=$x[$i++])?:$k[$c[$p]=$o]=$p; # if char string 1 not equal char string 2 make key=char1 value=char2 and key array
echo$y==strtr($x,$c) # boolean replacement string 1 equal to string 2
    &$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP> = 7.1, 148 बाइट्स

स्ट्रिंग के रूप में झूठे आउटपुट के लिए 0 प्रिंट करता है

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;echo$y==strtr($x,($f=array_flip)($k=$f($c)))&$x==strtr($y,$k)?join($k)." ".join($c):0;

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

विस्तारित

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)
$x[$i]==$o?:$c[$x[$i]]=$o; # if char string 1 not equal char string 2 set key=char1 value=char2
echo$y==strtr($x,($f=array_flip)($k=$f($c))) # boolean replacement string 1 equal to string 2
&$x==strtr($y,$k) # boolean replacement string 2 equal to string 1
    ?join($k)." ".join($c) # output for true cases
:0; #Output false cases

PHP> = 7.1, 131 बाइट्स

यदि साहचर्य सरणियों की अनुमति दी जाती है तो दूसरा उत्तर इसके लिए संक्षिप्त किया जा सकता है

स्ट्रिंग के बजाय साहचर्य सरणी के रूप में गलत आउटपुट के लिए 0 प्रिंट करता है

for([,$x,$y]=$argv;a&$o=$y[$i];$i++)$x[$i]==$o?:$c[$x[$i]]=$o;print_r($y==strtr($x,($f=array_flip)($f($c)))&$x==strtr($y,$k)?$c:0);

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

PHP> = 7.1, 227 बाइट्स

झूठी के लिए प्रिंट 0

[,$x,$y]=$argv;echo strlen($x)==strlen($y)?strtr($x,$c=array_filter(($f=array_flip)($z=$f(array_combine(($p=str_split)($x),$p($y)))),function($v,$k){return$k!=$v;},1))==$y&$x==strtr($y,$z)?join(array_keys($c))." ".join($c):0:0;

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

विस्तारित

[,$x,$y]=$argv; # 
echo strlen($x)==strlen($y) #compare string lengths
?strtr($x,  # replace function
$c=array_filter( # filter 
($f=array_flip)($z=$f( # # remove doubles like in testcase: a1 => 22
    array_combine(($p=str_split)($x),$p($y))  # replacement array keys string 1 values string 2 
))
    ,function($v,$k){return$k!=$v;},1)) # remove all keys that equal to values in array
    ==$y # boolean replacement string 1 equal to string 2
&$x==strtr($y,$z) # boolean replacement string 2 equal to string 1        
?join(array_keys($c))." ".join($c) # output for true cases
    :0 # Output if replacement from string 1 is not equal to string 2
:0; #Output for different lengths

— जार्ग हुल्सरमन
स्रोत

1

@carusocomputing बधाई के लिए धन्यवाद। मैं एक छोटी सी चाल भूल गया हूँ। मुझे पता है कि यहाँ बहुत से लोग हैं तो वे मेरे लिए बेहतर हैं

— Jörg Hülsermann

2

समाधान +1 खोजने में आपका निश्चित रूप से अच्छा है लेकिन array_values()अंदर join()पूरी तरह से बेकार है और इसे गिराया जा सकता है।

— क्रिस्टोफ़

1

यह a1 22 => falseपरीक्षण के मामले में विफल रहता है । इसके अलावा, आपका पहला कार्यक्रम ऑनलाइन परीक्षक में काम नहीं करता है।

— mbomb007

1

चुप रहो। यह अद्भुत है।

— टाइटस

1

फ़्लिपर्स जा सकते हैं: ($p=$x[$i])==$o?:$k[$c[$p]=$o]=$p;लूप के साथ और $y==strtr($x,$c)पहले परीक्षण के लिए 18 बाइट्स सहेजें ।

— टाइटस

5

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

ẠaQ⁼µ€Ạ
z0EÐḟQZẋÇ$

एक सूची ले रहा है, जो रिटर्न देता है
; या
एक सूची जिसमें सत्य मामलों में दो पात्रों की सूची है।

इसे ऑनलाइन आज़माएं! (पाद लेख एक सुस्पष्ट प्रतिनिधित्व को मुद्रित करने से बचने के लिए एक स्थान के साथ सूची को विभाजित करता है)
... या एक परीक्षण सूट देखें ।

कैसे?

ẠaQ⁼µ€Ạ - Link 1, valid?: mapping list
    µ€  - perform the code to the left for €ach mapping entry
Ạ       -     none of mapping entry falsey? (this & Main's z0 handle unequal input lengths)
  Q     -     deduplicate mapping entry
   ⁼    -     is equal to mapping list? (non-vectorising)
 a      -     and
      Ạ - none falsey (both mapping lists must pass that test)
        - The whole function returns 1 if the mapping list is acceptable, 0 if not

z0EÐḟQZẋÇ$ - Main link: list of strings
z0         - transpose with filler 0 (unequal lengths make pairs containing zeros)
   Ðḟ      - filter discard:
  E        -     all equal? (removes the untranslated character pairs)
     Q     - deduplicate (removes the repeated translation pairs)
      Z    - transpose (list of pairs to pair of lists)
         $ - last two links as a monad:
       ẋ   -     repeat list this many times:
        Ç  -         call last link (1) as a monad

— जोनाथन एलन
स्रोत

5

रेटिना , 194 191 185 229 225 241 बाइट्स

.+
$&;$&
+`^\w(\w*;)\w
$1
^;\w.*|.+;;.*|;;

^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4
+`((.)(.)*)\2((.)*;.*(.)(?<-3>.)*(?(3)(?!)))\6((?<-5>.)*(?(5)(?!)))$
$1$4$7
^(.)*(.)(.)*(\2)?.*;(?<-1>.)*(?(1)(?!))(.)(?<-3>.)*(?(3)(?!))(?(4)(?!\5)|\5).*

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

इनपुट ;-सेपोरेटेड लेता है । आउटपुट भी ;अलग हो गया है। खाली इनपुट से गलत इनपुट का संकेत मिलता है।

मुझे पता है कि यह दर्दभरी क्रिया है, मैं अभी भी बाइट्स काटने की कोशिश कर रहा हूं। इनमें से अधिकांश बाइट्स गलत इनपुट हटाने में जाते हैं।

संपादित करता

यह पता चला है कि मुझे अपने कार्यक्रम के साथ एक महत्वपूर्ण दोष था। यह अभी तय है, लेकिन 40 से अधिक बाइट की कीमत पर।
एक और गलती पाई गई जहां मेरे कार्यक्रम ने इनपुट को a1;22झूठा घोषित नहीं किया , लेकिन मैं इसे ठीक करने के बाद कार्यक्रम को 250 बाइट के तहत रखने में सक्षम था

व्याख्या

(अधिक विस्तृत विवरण शीघ्र ही आने वाला है)

पहले हमें जांचना होगा कि क्या तार की लंबाई aऔर हैb समान हैं या नहीं। यदि वे नहीं हैं, तो हम सब कुछ हटा देते हैं।

इनपुट को संरक्षित करने के लिए डुप्लिकेट करता है जबकि हम कुछ लंबाई परीक्षण करते हैं।

.+                      Matches everything
$&;$&                   $& indicates the match, so $&;$& will duplicate the match and separate it with a semi-colon

अब एक लूप में, हम पहले वर्ण aऔर पहले वर्ण को bतब तक हटाते हैं जब तक कि एक तार खाली न हो जाए।

+`                     Repeatedly (until no more substitutions could be made) replace
  ^\w                   A word character (letter or number) at the beginning
     (\w*;)             Capture Group 1: matches any number of word characters and a semicolon
           \w           And a word character after the semi-colon
                       with
$1                      The result of the first capture group

अब "पैटर्न स्पेस" के लिए संभावनाएं हैं।

;;abc दोनों तार बराबर लंबाई के हैं
def;;abc a से लंबा है b
;def;abc b से लंबा है a

अब हमें इनपुट खाली करना होगा यदि तार समान लंबाई (परिदृश्य 2 और 3) के नहीं हैं। नीचे यह प्रतिस्थापन है। यह ऐसे पाठ को हटाता है जो 2 और 3 परिदृश्यों से मेल खाता है।

^;\w.*|.+;;.*|;;

यह उन वर्णों को हटा देता है जिन्हें स्ट्रिंग्स में लिप्यंतरित नहीं किया गया है aऔर b। abc;1b2=>ac;12

^((.)*)(.)(.*;(?<-2>.)*(?(2)(?!)))\3
$1$4

उसके बाद, हमें डुप्लिकेट वर्णों को निकालना होगा। sese;1212=> se;12, लेकिन यह इनपुट्स को संरक्षित रखता हैaba;123

+`((.)(.)*)\2((.)*;.*(.)(?&lt;-3&gt;.)*(?(3)(?!)))\6((?&lt;-5&gt;.)*(?(5)(?!)))$
$1$4$7

अंत में, हम इनपुट को हटाते हैं यदि डुप्लिकेट वर्ण होते हैं जो विभिन्न वर्णों के लिए मैप करते हैं जैसे aba;123या a1;22।

^(.)*(.)(.)*(\2)?.*;(?.)*(?(1)(?!))(.)(?.)*(?(3)(?!))(?(4)(?!\5)|\5).*

और अंत में, डुप्लिकेट वर्णों को हटा दें।

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

उन संतुलन समूहों का उपयोग करना जिन्हें मैं देख रहा हूँ!

— नील

@ नील सच! मैंने (?(1)(?!))आपके उत्तर से सीखे हुए

— शब्द का

मुझे आश्चर्य है कि क्या पहले डुप्लिकेट को हटाने के लिए यह छोटा होगा और फिर शेष सेटों को मान्य करना होगा - के प्रत्येक पक्ष पर केवल एक अक्षर शेष होना चाहिए ;।

— नील

@ मुझे अपने कोड के साथ प्रयोग करने में एक त्रुटि मिली। मैं आगे सुबह इसे देखूंगा।

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

4

जेली , 28 26 बाइट्स

QL$€⁼L€
EÐḟQZK0Ç?
ZÇ0L€E$?

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

QL$€⁼L€      Checks validity of mapping
QL$€          number of unique characters in mapping
    ⁼         equals
     L€       number of characters in mapping

EÐḟQZK0Ç?  Writes valid mapping or 0
EÐḟ           filter maps where a = b
   Q          filter duplicate maps
    Z         zip by column [["ac"],["bd"]] => ["ab","cd"]
     K0Ç?   print if valid map, else print 0

ZÇ0L€E$?      main link: takes an array of 2 strings
Z              zip by column: ["ab", "cd"] => [["ac"],["bd"]]
 Ç     ?       print mapping if
   L€E$         all pairs are same length (returns 0 if initial strings were
  0             else 0

— layagyasz
स्रोत

1

PPCG में आपका स्वागत है! कैसे नरक आप पहले से ही केवल 21 अंक के साथ जेली पता है? बहुत प्रभावशाली!

— मैजिक ऑक्टोपस Urn

2

धन्यवाद। साइट के चारों ओर थोड़ा सा देखा और यह सीखने के लिए एक साफ भाषा की तरह लग रहा था।

— Layagyasz

05AB1E एक और आसान और मजेदार है जिसे आजमाना है।

— मैजिक ऑक्टोपस Urn

3

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

->a,b{a.size!=b.size||(m=a.chars.zip b.chars).any?{|i,j|m.any?{|k,l|(i==k)^(j==l)}}?0:m.select{|x,y|x!=y}.uniq.transpose.map(&:join)}

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

अधिक आसानी से:

->a, b{
    # Pair the letters in each string - [AB, AB, AB,...]
    pairs = a.chars.zip(b.chars)

    # If there's any combination of two pairs that share one character but not both,
    # or if the strings have different lengths, then the input's invalid.
    if a.size != b.size || pairs.any?{|i,j| pairs.any? {|k, l| (i==k)!=(j==l) }} 
        return 0 # 0 isn't actually falsy in Ruby, but this challenge allows it anyway
    end
    return pairs.select{|x,y| x != y} # Remove unchanged letters
                .uniq                 # Remove duplicates
                .transpose            # Change [AB, AB, AB] form to [AAA, BBB] form.
                .map(&:join)          # Convert the arrays back into strings
}

बस किक के लिए, यहाँ गोरबी में 84 बाइट संस्करण है, जो रूबी है, लेकिन दुभाषिया को संकलित करते समय एक गोल्फ ध्वज सेट के साथ। अन्य बातों के अलावा, यह आपको विधि कॉल को उनके सबसे कम विशिष्ट पहचानकर्ता को संक्षिप्त करने की अनुमति देता है।

->a,b{a.sz!=b.sz||(m=a.ch.z b).ay?{|i,j|m.y?{|k,l|(i==k)^(j==l)}}?0:m.rj{|x,y|x==y}.u.tr.m(&:j)}

— Tutleman
स्रोत

गोरबी कार्यान्वयन के साथ दूसरा उत्तर क्यों नहीं? क्या यह एक स्वीकृत गोल्फिंग भाषा नहीं है?

— मैजिक ऑक्टोपस Urn

@ आरोसोकोम्पुटिंग यह पूरी तरह से है; यह सिर्फ मुझे लग रहा था जैसे कि यह अपने जवाब का गुण नहीं था - यह बिल्कुल मेरे मुख्य उत्तर के समान है, बस विधि नाम संक्षिप्त के साथ। शायद अगर मुझे गोरबी के मतभेदों का अधिक लाभ उठाने का एक तरीका मिल जाए, तो मैं एक अलग उत्तर दूंगा।

— टटलमैन

3

पायथन 2 , 198,193,189,182,179,175,169, 165 बाइट्स

def f(a,b):
 r=([""]*2,0)[len(a)!=len(b)]
 for u,v in zip(a,b):
	if r:
		q,w=r
		f=q.find(u)
		if u!=v:r=(([q+u,w+v],r)[f>-1 and w[f]==v],0)[f<0 and v in w]
 print r

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

-4 निवाले! अंतरिक्ष के बजाय टैब के उपयोग का सुझाव देने के लिए mbomb007 के लिए धन्यवाद।
इनपुट प्रारूप को संशोधित किया, फिर से mbomb007 के लिए धन्यवाद।

— कीर्तन प्रभाकरं
स्रोत

उससे तुम्हारा क्या मतलब है? कृपया अनचाहे संपादन करना बंद करें जो जवाब देने के लिए कोई मूल्य नहीं जोड़ता है!

— कीर्तन प्रभाकरन

टैब 4 बाइट के आसपास बचाया गया! धन्यवाद!

— कीर्तन प्रभाकरन

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— mbomb007

और मैंने आपके कार्यक्रम को प्रत्येक परीक्षण मामले को एक पंक्ति में रखा है, जो आपके कार्यक्रम का परीक्षण करने वाले किसी भी व्यक्ति के लिए अत्यंत उपयोगी है।

— mbomb007 16

यदि आप अपने संपादित टिप्पणी में उल्लेख कर सकते हैं तो बेहतर होगा!

— कीर्तन प्रभाकरन

3

पायथन 3.6, 211 185 181 178 बाइट्स

गलत परिणाम के लिए एक त्रुटि के साथ बाहर निकलता है।

def f(x,y,d={}):
    for a,b in zip(x,y):1/(a not in d or b==d[a]or len(x)-len(y));d[a]=b;1/([*d.values()].count(b)<2)
    return map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]]))

इसके लिए पायथन 3.6 की आवश्यकता होती है, जिसे आप यहां एक शेल में चला सकते हैं ।

आप TIO पर सही आउटपुट ऑर्डर के बिना इसका परीक्षण कर सकते हैं । (टीआईओ के पास 3.6 नहीं है)।

Ungolfed:

from collections import*
d=OrderedDict()                     # keep order
x,y=input()
if len(x)!=len(y):1/0               # equal lengths
for a,b in zip(x,y):
    if a in d and d[a]!=b:1/0       # no duplicate keys
    else:d[a]=b
    if d.values().count(b)>1:1/0    # no duplicate values
print map(''.join,zip(*[x for x in d.items()if x[0]!=x[1]])) # format, no no-ops

यदि केवल आदेश से कोई फर्क नहीं पड़ता ...

— mbomb007
स्रोत

के बजाय नहीं a1,12लौटना चाहिए ? कैविट्स सेक्शन के तहत कहा जाता है कि [a1,12] की अनुवाद तालिका के साथ "a1" 12 का मूल्यांकन करता है । a1,12False

— फर्ग्यूस्क

1

ठीक है, आपके TIO लिंक में प्रोग्राम रिटर्न करता है False। 1a 21यह भी गलत होगा, क्योंकि ओडर को संरक्षित करना होगा।

— fergusq

@fergusq फिक्स्ड। लेकिन ध्यान दें कि आप अपनी टिप्पणी में एक टाइपो है अगर आप के a1,12बजाय कहा है कि परीक्षण के मामले में आप का उल्लेख कर रहे हैं a1,22।

— mbomb007

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

— फर्ग्यूसक

यह एक अलग नियम को संभालता है, लेकिन यह अभी भी कहता है कि उस परीक्षण मामले का परिणाम गलत है, जो कि मायने रखता है।

— mbomb007

2

रोड़ा , 108 119 बाइट्स

{c=[{_<>_|[[_,_]]|orderedUniq}()]d=[]e=[]c|_|{{d+=a;e+=b}if[a!=b]}for a,b[d,e]if[0,1]|{|n|c|[_[n]]|sort|count|[_2=1]}_}

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

यह एक ऐसा फंक्शन है जो स्ट्रीम से दो लिस्ट लेता है और दो लिस्ट को स्ट्रीम से पुश करता है।

यदि मुझे जोड़े वापस करने की अनुमति दी गई तो यह सॉर्टर हो सकता है।

स्पष्टीकरण (आउट-डेटेड):

{
    c=[{
        _<>_|       /* pull two lists and interleave them */
        [[_,_]]|    /* "unflat", create lists from pairs */
        orderedUniq /* remove duplicates */
    }()]            /* c is a list of the pairs */
    d=[]
    e=[]
    c| /* push the pairs to the stream */
    _| /* flat */
    {  /* for each pair (a, b): */
        { /* if a != b (remove "1-to-1 relations"):  */
            d+=a;
            e+=b
        }if[a!=b]
    }for a,b
    /* return d and e if no character is mapped to more than one character */
    [d,e]if c|[_[0]]|sort|count|[_2=1]
}

यहाँ एक अंडरस्कोर समाधान है जिसमें कोई चर नहीं है (114 बाइट्स):

{[[{_<>_}()|[[_,_]]|unorderedUniq]]|[[_()|_|[_]if[_1!=_2]],[_1()|_|[_2]if[_1!=_2]]]if[[_1()|_][::2],[_1()|_][1::2]]|[sort(_)|count|[_2=1]]}

वह बहुत अंडरस्कोर है।

— fergusq
स्रोत

क्या करता <>है?

— कृति लिथोस

@KritiiLithos यह इंटरलेव ऑपरेटर है। a() <> b()के रूप में ही है interleave([a()], [b()])(या बस interleave(a, b), अगर aऔर barrays हैं)।

— फर्ग्यूस्क

यह a1 22 => falseपरीक्षण के मामले में विफल रहता है । "सभी अनुवाद एक दूसरे से स्वतंत्र होते हैं, जिसका अर्थ यह मिथ्या है।"

— mbomb007

@ mbomb007 आप जो कहते हैं, वह मुझे समझ में नहीं आता है? क्या आपका मतलब है कि यह एक आपत्ति है, यानी। किसी भी दो वर्णों को समान वर्ण में मैप नहीं किया जाना चाहिए?

— फर्ग्यूसक

हाँ। यही सवाल है। ( प्रत्येक वर्ण केवल अनुवाद के प्रत्येक पक्ष पर ONCE का उपयोग किया जा सकता है )

— mbomb007

1

AWK, 140 बाइट्स

BEGIN{RS="(.)"}RT~/\W/{S=1}RT~/\w/&&S{if(RT!=x=A[++b]){if(B[z=RT]==""){B[z]=x
c=c x
d=d z}a=B[z]!=x?0:a}}!S{A[++a]=RT}END{if(a==b)print c,d}

FILEतब में कोड प्लेस :

awk -f FILE <<< "string1 string2"

इनपुट स्ट्रिंग्स को व्हाट्सएप से अलग करने की आवश्यकता है।

यदि वे विफल होते हैं, तो आउटपुट खाली है, या 2 स्ट्रिंग्स एक स्थान से अलग हो गए हैं।

— रॉबर्ट बेन्सन
स्रोत

1

के, 28 बाइट्स

{$[(y?y)~x?x;+?(~=/)#x,'y;]}

स्पष्टीकरण:

{                          } /function that takes in two strings, x and y
 $[         ;            ;]  /if statement (to check if there is a mapping)
         x?x                 /first index of [each letter in x] in x
   (y?y)                     /first index of [each letter in y] in y
        ~                    /make sure they match
                     x,'y    /zip together the two strings
               (~=/)#        /remove equal pairs
              ?              /unique pairs only
             +               /transpose ("unzip", in a way)

— zgrep
स्रोत

1

APL (Dyalog) AGL के साथ , 22 बाइट्स

{≡/⍳⍨¨⍺⍵:↓⍉↑∪⍺(≠é,¨)⍵}

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

{… } अनाम फ़ंक्शन:

अगर…

⍺⍵ तर्क

⍳⍨¨ जब स्व-अनुक्रमित (अर्थात स्वयं में उनके तत्वों की पहली घटना)

≡/ समतुल्य हैं

: फिर:

⍺(… )⍵ तर्कों के लिए निम्नलिखित टैकट फ़ंक्शन लागू करें:

,¨ समरूप तत्वों (बेमेल लंबाई पर त्रुटियां)

é इसके बाद फ़िल्टर करें ( éबस आदिम फ़ंक्शन है /)

≠ जहां तार अलग हैं

∪ अद्वितीय (डुप्लिकेट हटाएं)

↓⍉↑ जोड़े-के-सूचियों में सूची-ऑफ-द-जोड़े (लिट इन टेबल, ट्रांसपोज़ टेबल, सूचियों में विभाजित)

और, कुछ मत करो

— एडम
स्रोत

1

धैर्यपूर्वक इस उत्तर की व्याख्या की प्रतीक्षा कर रहा है : P

— मैजिक ऑक्टोपस Urn

1

@carusocomputing मैं उस पर हूँ।

— 22

@carusocomputing ठीक है?

— एडम

मुझे वह उत्तर याद आ गया, क्षमा करें! ↓⍉↑अभी भी मुझे थोड़ी उलझन है।

— मैजिक ऑक्टोपस Urn

1

@carusocomputing शायद इससे मदद मिलती है? ध्यान दें कि एपीएल और जे में, मैट्रिक्स सूची की सूची के समान नहीं है।

— 17

0

CJam, 38 बाइट्स

{_:,~={1\/;}:K~z{)\c=!},L|z_{_L|=K}%;}

इनपुट और आउटपुट स्टैक पर सरणियाँ हैं।

— फल तोड़ना
स्रोत

0

PHP (> = 7.1), 165 बाइट्स

for([,$x,$y]=$argv;a&$c=$x[$i];$t[$c]=$d)$z+=($d=$y[$i++])&&$d==($t[$c]??$d);foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;print_r($z<$i|array_unique($r)<$t||a&$y[$i]?0:$t);

0झूठी, साहचर्य सरणी के लिए प्रिंट । इसे ऑनलाइन चलाएं -rया परीक्षण करें ।

टूट - फूट

for([,$x,$y]=$argv;         # import arguments to $x and $y
    a&$c=$x[$i];            # loop through $x
    $t[$c]=$d)                  # 2. add pair to translation
$z+=                            # 1. increment $z if
    ($d=$y[$i++])&&             # there is a corresponding character in $y and
    $d==($t[$c]??$d);           # it equals a possible previous replacement
                            # remove identities from translation
foreach($t as$a=>$b)$a==$b?:$r[$a]=$b;
print_r(
    $z<$i                   # if not all tests passed
    |array_unique($t)<$t    # or there are duplicates in the translation
    ||a&$y[$i]              # or $y has more characters
    ?0                      # then print 0
    :$r                     # else print translation
);

— टाइटस
स्रोत

आउटपुट के रूप में साहचर्य सरणियों की अनुमति है? क्या आप कृपया जोड़ सकते हैं कि यह संस्करण 7.1 से ऊपर काम करता है

— Jörg Hülsermann

@ JörgHülsermann Output can be as an array or ..., तो मैं हाँ कहता हूँ। वर्तमान PHP संस्करण मेरे सभी पोस्टिंग के लिए निहित है; लेकिन अगर मुझे संपादित करने के लिए कुछ महत्वपूर्ण लगता है, तो मैं संस्करण जोड़ूंगा।

— टाइटस

मान्य मामले सरणी आउटपुट का केवल एक अर्थ दिखाता है। यदि साहचर्य सरणियों की भी अनुमति है तो मैं कुछ बाइट्स बचा सकता हूं। अगर इसकी अनुमति है और array_unique($r)!=$rहर मामले में array_unique($r)<$rमैं इस ट्रिक के लिए अकेले ही आपके पोस्ट को बढ़ा दूंगा। पल में मैं एक स्पष्टीकरण के लिए खोज रहा हूँ

— Jörg Hülsermann

@ JörgHülsermann array_unique($t)<$t(परिवर्तन करना पड़ा है कि क्योंकि canके लिए cnnअमान्य है) काम करता है, क्योंकि सरणी तुलना (स्ट्रिंग तुलना के विपरीत) कुछ और करने से पहले लंबाई तुलना करती है।

— टाइटस

टेस्ट मुझे 17 बाइट्स की लागत के canलिए cnnमेरे सुझाव को भूल जाओ

— Jörg Hülsermann

अनुवाद तालिका खोजें

वैध मामले

झूठे मामले

I / O नियम

चेतावनियां

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

जावास्क्रिप्ट (ईएस 6), 108 107 105 106 बाइट्स

प्रारूपित और टिप्पणी की गई

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

PHP> = 7.1, 130 बाइट्स

PHP> = 7.1, 148 बाइट्स

PHP> = 7.1, 131 बाइट्स

PHP> = 7.1, 227 बाइट्स

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

कैसे?

रेटिना , 194 191 185 229 225 241 बाइट्स

संपादित करता

व्याख्या

जेली , 28 26 बाइट्स

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

पायथन 2 , 198,193,189,182,179,175,169, 165 बाइट्स

पायथन 3.6, 211 185 181 178 बाइट्स

रोड़ा , 108 119 बाइट्स

AWK, 140 बाइट्स

के, 28 बाइट्स

APL (Dyalog) AGL के साथ , 22 बाइट्स

CJam, 38 बाइट्स

PHP (> = 7.1), 165 बाइट्स