फ्रिज चुंबक प्रतिस्थापन

29

फ्रिज मैग्नेट के साथ एक संदेश लिखते समय, आप अक्सर खुद को एक के 1लिए प्रतिस्थापित करते हुए पाएंगे I। इस चुनौती में, आपका लक्ष्य यह पता लगाना है कि क्या एक संदेश दूसरे संदेश के अक्षरों का उपयोग करके लिखा जा सकता है। अनुमत प्रतिस्थापन हैं:

A = 4
B = 8
C = U
E = M = W = 3
G = 6 = 9
I = 1
L = 7
N = Z
O = 0
R = 2
S = 5

उदाहरण के लिए, संदेश CIRCA 333को वर्तनी के लिए फिर से व्यवस्थित किया जा सकता है ICE CREAM, जहां पहले दो 3एस को दो Eएस बनाने के लिए 180 डिग्री घुमाया जाता है , और अंतिम 3को 90 डिग्री वामावर्त घुमाया जाता है M। व्हाट्सएप संदेशों में शामिल किया जा सकता है, लेकिन उन्हें आपके समाधान में नहीं होना चाहिए, क्योंकि वे मैग्नेट को फ्रिज में रखकर बनाए जाते हैं।

इनपुट

दो तार (या चरित्र सरणियाँ)। सभी संदेश मेल खाएँगे^[A-Z0-9 ]+$

उत्पादन

सच्चाई अगर दो इनपुट तार एक दूसरे के वैध पुनर्व्यवस्था हैं, तो अन्यथा गलत है।

उदाहरण

["CIRCA 333", "ICE CREAM"] => true
["DCLV 00133", "I LOVE CODE"] => true
["WE ARE EMISSARIES", "33   423    3315542135"] => true
["WE WANT ICE CREAM", "MET CIRCA 334 MEN"] => true
["I HAVE ICE CREAM", "HAVE 2 ICE CREAMS"] => false

अधिक थ्रस्टी उदाहरण

ये सभी 15+ अक्षर वाले शब्द हैं जो दूसरे शब्द में मैप करते हैं। कुछ तुच्छ विकल्प हैं, लेकिन मैंने वह सब शामिल किया जो मुझे मिला।

["ANTHROPOMORPHISE","ANTHROPOMORPHISM"]
["ANTIPHILOSOPHIES","ANTIPHILOSOPHISM"]
["CIRCUMSTANTIALLY","ULTRAMASCULINITY"]
["DECENTRALIZATION","DENEUTRALIZATION"]
["DIMETHYLNITROSAMINE","THREEDIMENSIONALITY"]
["INSTITUTIONALISE","INSTITUTIONALISM"]
["INTERCRYSTALLINE","INTERCRYSTALLIZE"]
["INTERNATIONALISE","INTERNATIONALISM"]
["OVERCENTRALIZATION","OVERNEUTRALIZATION"]
["OVERCENTRALIZING","OVERNEUTRALIZING"]
["PREMILLENNIALISE","PREMILLENNIALISM"]
["TRANSCENDENTALIZE","TRANSCENDENTALIZM"]

जैसा कि यह एक कोड गोल्फ चुनौती है, सबसे छोटा समाधान जीतता है! मैं पोस्टिंग से 7 दिनों में सबसे छोटा समाधान स्वीकार करूंगा। हैप्पी गोल्फिंग!

नमूना समाधान, गैर-गोल्फ वाला

सम्बंधित

संपादित करें :, प्रतिस्थापन में एक त्रुटि कर दिया था G = 6और 6 = 9अलग प्रतिस्थापन के रूप में, उन्हें एक में मिला दिया।

code-golf  string  decision-problem  substitution 
— maxb
स्रोत
2
मुझे लगता है कि 48 घंटे थोड़े कम हैं। उन लोगों के बारे में जो केवल सप्ताहांत पर गोल्फ करते हैं?
— Adám
अच्छी बात है, मैं इसे एक सप्ताह दूंगा।
— अधिकतम
1
अन्य विकल्प जिन्हें आप अनुमति देने पर विचार कर सकते हैं वे हैं T के लिए 7, I के लिए H (लेकिन H के लिए 1 नहीं), और N या Z के लिए 2
— Jeff Zeitlin
1
@JeffZeitlin हमारे पास चुनौती सैंडबॉक्स में इस बारे में एक चर्चा थी, और मैंने उन सभी प्रतिस्थापनों को बाहर करने के लिए चुना, जो प्रतिवर्ती नहीं हैं। चूंकि Tऔर Lविनिमेय नहीं हैं, इसलिए मैं जोड़ नहीं सकता T = 7। वही जाता है N = Z = 2, जो इसका मतलब होगा N = Z = R = 2। हालाँकि, आपके द्वारा सुझाए गए प्रकार के विकल्प इस चुनौती के अधिक कठिन संस्करण के लिए बनाएंगे, जिन्हें मैं बाद में पोस्ट कर सकता हूं। मैं सिर्फ यह देखना चाहता था कि क्या इस प्रकार की चुनौतियाँ पहले प्राप्त होंगी।
— अधिकतम
1
@ 3D1T0R हां, प्रतिस्थापन दोनों तरीकों से जाना चाहिए। यदि दो तार एक-दूसरे के मान्य पुनर्व्यवस्था हैं, तो यह जाँच है । आपका उदाहरण वापस आएगा false।
— अधिकतम

जवाबों:

4

जाप , 38 36 33 30 बाइट्स

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

®d`z³m`i`oiglbg`í)Ôu)ñ xÃr¶

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं

3 बाइट्स ETHProductions की बदौलत बच गए

®d`z...m`i`o...g`í)Ôu)ñ xÃr¶
                                 :Implicit input of array U
®                                :Map each Z
 d                               :  For each pair of characters in the following string,
                                 :  replace all occurrences of the 1st character in Z with the 2nd
  `z...m`                        :    The compressed string "znewem"
         i                       :    Prepend
          `o...g`                :      The compressed string "oireasglbg"
                 í               :      Interleave 0-based indices
                  )              :    End prepend
                   Ô             :    Reverse
                    u            :    Convert to uppercase
                     )           :  End replace
                      ñ          :  Sort
                        x        :  Trim
                         Ã       :End map
                          r      :Reduce
                           ¶     :  By testing equality
— झबरा
स्रोत
अच्छा है, वर्तमान में जेली की पिटाई! मुझे लगता है कि आप r¶3 बाइट्स को बचाने के लिए अंत में कर सकते हैं ।
— ETHproductions
ओह, हाँ, मैं यह भूल रहा था। धन्यवाद, @ETHproductions
— झबरा
10

रूबी , 99 72 71 बाइट्स

->a{!!a.map{|x|x.tr("0-9UZMW","OIREASGLBGCNE").chars.sort-[" "]}.uniq!}

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

तार की एक सरणी लेता है, सभी परीक्षण मामलों की तरह अपरकेस में इनपुट मानता है।

-1 बाईट को बेंजे 2240 द्वारा गोल्‍फ कर दिया गया।

— किरिल एल।
स्रोत
— benj2240
हां, यह काम करता है, धन्यवाद।
— किरिल एल
9

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

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

a=>b=>(g=s=>s.map(c=>'648UD3F6H1JK73Z0PQ25TUV3'[parseInt(c,36)-9]||c).sort().join``.trim())(a)==g(b)

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

कैसे?

प्रत्येक इनपुट s के लिए हेल्पर फंक्शन g () का उपयोग करना :

  • अंक 0 से 8 और अक्षर X , Y और Z अपरिवर्तित रह गए हैं। बाकी सब कुछ स्पष्ट रूप से अनुवादित है।

    0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
         ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
.........648UD3F6H1JK73Z0PQ25TUV3...

    कोड:

    s.map(c => '648UD3F6H1JK73Z0PQ25TUV3'[parseInt(c, 36) - 9] || c)

  • हम पात्रों को छांटते हैं (जो शुरुआत में सभी रिक्त स्थान लाते हैं), उनसे जुड़ें और सभी प्रमुख व्हाट्सएप को हटा दें।

    कोड:

    .sort().join``.trim()

अंत में, हम दोनों आउटपुट की तुलना करते हैं।

— Arnauld
स्रोत
6

रेटिना 0.8.2 , 42 बाइट्स

T` dUZMW`_\OIR\EASG\LBGCN\E
%O`.
^(.*)¶\1$

इसे ऑनलाइन आज़माएं! अलग-अलग लाइनों पर इनपुट लेता है, लेकिन लिंक में परीक्षण के मामले और हेडर शामिल हैं। स्पष्टीकरण:

T` dUZMW`_\OIR\EASG\LBGCN\E

रिक्त स्थान को हटाते हुए सभी अक्षरों को न्यूनतम सेट पर मैप करें।

%O`.

प्रत्येक स्ट्रिंग क्रम में क्रमबद्ध करें।

^(.*)¶\1$

दो मूल्यों की तुलना करें।

— नील
स्रोत
5

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

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

बेनामी tacit उपसर्ग समारोह।

(≡/(⍋⌷¨⊂)¨)(,¨⎕D,'UMWZ ')⎕R('OIREASGLBGCEEN',⊂⍬)

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

⎕R PCRE R eplace:
 'UMWZ ' ये पाँचों वर्ण  अलग-अलग
 ⎕D, अंकों से पहले होते हैं
 ,¨(प्रत्येक को एकल वर्ण होने के बजाय एक स्ट्रिंग में बनाते हैं)
 :  इन वर्णों से पहले
 ⊂⍬ कुछ भी नहीं
 'OIREASGLBGCEEN',

(... ) उस के लिए निम्नलिखित tacit फ़ंक्शन लागू करें:

 (… )¨ प्रत्येक के लिए निम्नलिखित tacit फ़ंक्शन लागू करें:

  ⊂ इसे संलग्न करें (इसे संपूर्ण मानें)

  ⍋⌷¨ प्रत्येक सूचकांक का उपयोग करें जो इसे पूरे स्ट्रिंग में अनुक्रमित करने के लिए क्रमबद्ध करेगा (सॉर्ट)

 ≡/ क्या वे समान हैं? (lit. मैच में कमी)

— एडम
स्रोत
''-> ⍬
— ngn
@ नहीं यकीन है कि क्यों काम करता है, लेकिन वैसे भी धन्यवाद।
— आदम
5

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

lambda a,b:g(a)==g(b)
g=lambda s:sorted('85930A4614012B3C4D5EF6378GH9AI2J3KL7'[int(c,36)]for c in s if'!'<c)

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

पात्रों के 23 समतुल्य वर्ग हैं। 36-वर्ण स्ट्रिंग का उपयोग करते हुए '85930A4614012B3C4D5EF6378GH9AI2J3KL7', हम प्रत्येक वर्ण को उसके समतुल्य वर्ग (रिक्त स्थान की अनदेखी) में मैप करते हैं, फिर परिणामी सरणी को सॉर्ट करते हैं। दो तार बराबर हैं यदि परिणामी सूचियां समान हैं।

— चास ब्राउन
स्रोत
4

जावा 10, 262 260 258 216 208 174 बाइट्स

a->b->n(a).equals(n(b));String n(String s){return s.chars().mapToObj(x->x<48?"":"OIREASGLBG.......ABCDEFGHIJKLENOPQRSTCVEXYN".split("")[x-48]).sorted().reduce("",(a,b)->a+b);}

-2 बाइट्स @Arnauld को धन्यवाद ।
-76 बाइट्स @ OlivierGrégoire को धन्यवाद ।

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

स्पष्टीकरण:

a->b->                      // Method with two String parameters and boolean return-type
  n(a).equals(n(b))         //  Return if both Strings are equal in the end

String n(String s){         // Separated method with String as both parameter return-type
  return s.chars()          //  Loop over all characters as integers
          .mapToObj(x->x<48?//   If the current character is a space:
             ""             //    Replace it with an empty String to skip it
            :               //   Else:
             "OIREASGLBG.......ABCDEFGHIJKLENOPQRSTCVEXYN".split("")[x-48]
                            //    Convert multi-substitution characters to a single one
          .sorted()         //  Sort all of the converted characters
          .reduce("",(a,b)->a+b);}
                            //  And join all of them together as single String
— केविन क्रूज़सेन
स्रोत
2
"A4B8CUEMEWE3G6G9I1L7NZO0R2S5".split("(?<=\\G.{2})")काम करने लगता है ... हालाँकि मुझे भी यकीन नहीं है कि कैसे। : पी
— अरनौलड
@ अरनल्ड धन्यवाद, -2 बाइट्स, और एक और -2 बाइट्स के लिए {2}हो सकता है .। मैं भी 100% निश्चित नहीं हूं कि यह कैसे काम करता है। मुझे पता (?<= ... )है कि विभाजित करने के लिए उपयोग किया जाता है, लेकिन प्रति आइटम सीमांकक को पीछे रखना है । लेकिन मैं थोड़ा उलझन में हूँ कि क्यों (?=\\G..)(प्रमुख सीमांकक रखना) उस संबंध में काम नहीं करता है। और वास्तव में यह भी नहीं पता है कि \\G..बनाम कैसे ..विभाजन में यहां कार्य करता है। यह देखूंगा कि क्या मैं इसे समझ सकता हूं, क्योंकि मैं उत्सुक नहीं हूं। ; पी बचाए बाइट्स के लिए किसी भी तरह धन्यवाद। \\Gयहां तक ​​कि आकार के ब्लॉकों पर विभाजित करते समय याद रखने की आवश्यकता है । :)
— केविन क्रूज़सेन
1
@Arnauld यदि आप (?<=\\G..)एक विभाजन के अंदर के बारे में कुछ पृष्ठभूमि चाहते हैं , तो मैंने एक StackoverFlow प्रश्न बनाया है, जिसमें कुछ प्रकाश डाला गया है। मूल रूप से यह लगभग हर भाषा में अलग तरह से काम करने वाला अपरिभाषित व्यवहार है। हालाँकि \G, शून्य-लंबाई है, जावा में विभाजन के अंदर सकारात्मक लुक-बैक के साथ, यह थोड़े दोनों नियमों का विरोध करता है, जिससे हम यहां दिखाई देने वाले व्यवहार का कारण बनते हैं। यह अभी भी व्यक्तिगत रूप से मेरे लिए थोड़ा अस्पष्ट है, लेकिन कम से कम इसने इस जवाब में 4 बाइट्स बचाए। ;)
— केविन क्रूज़सेन
1
217 बाइट्स । हालांकि अधिक बाइट्स बचा सकते हैं।
— ओलिवियर ग्रेजायर
1
— ओलिवियर ग्रेगोइरे
3

आर , 123 बाइट्स

function(x,y=chartr("48UMW36917Z025","ABCEEEGGILNORS",gsub(" ","",x)))all(g(y[1])==g(y[2]))
g=function(z)sort(utf8ToInt(z))

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

utf8ToInt एक स्ट्रिंग को यूनिकोड कोड पॉइंट के वेक्टर में परिवर्तित करता है।

!sd(a-b)एक बाइट से कम है,all(a==b) लेकिन यह यहाँ मदद नहीं करता है क्योंकि मैं वास्तव में पूर्णांक के साथ काम कर रहा हूं और तार्किक नहीं।

— एन जी एम
स्रोत
बहुत अच्छा! मुझे लगता है कि आपको तत्वों !anyकी जगह की आवश्यकता है !sdक्योंकि सभी समान हो सकते हैं, लेकिन 1. कोशिश करें:f(list("BCDEF","ABCDE"))
— JayCe
2

जे , 56 बाइट्स

-:&(-.&' '/:~@rplc'0123456789UMWZ';"0'OIREASGLBGCEEN'"1)

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

स्पष्टीकरण:

& बाएँ और दाएँ दोनों तर्कों के लिए

-.&' ' इनपुट से रिक्त स्थान निकालता है,

rplc की जगह

'0123456789UMWZ';"0'OIREASGLBGCEEN'"1 बाएं कॉलम में वर्णों के प्रतिस्थापन द्वारा इनपुट में वर्णों को दायें वाले में: (यहाँ पर बचत के साथ ट्रांसपोज़ किया गया है)

      |:'0123456789UMWZ';"0'OIREASGLBGCEEN'
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│4│5│6│7│8│9│U│M│W│Z│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│O│I│R│E│A│S│G│L│B│G│C│E│E│N│
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘

/:~@ और परिणामस्वरूप स्ट्रिंग्स को सॉर्ट करें

-: क्या छंटनी के तार समान हैं?

मेरा प्रारंभिक समाधान:

जे , 77 73 बाइट्स

-:&(1#.(' '-.~])e."1[:(,a.,.@-.,)'EMW3','G69',9 2$'A4B8CUI1L7NZO0R2S5'"1)

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

स्पष्टीकरण:

(' '-.~]) दोनों तर्कों से रिक्त स्थान हटाता है और

e."1 follwing तालिका में सदस्यता के लिए प्रत्येक वर्ण का परीक्षण करता है:

[:(,a.,.@-.,)'EMW3','G69',9 2$'A4B8CUI1L7NZO0R2S5'"1 सन्दर्भ: 

EMW3
G69 
A4  
B8  
CU  
I1  
L7  
NZ  
O0  
R2  
S5  
.
.
.  
All other symbols one in a row

1#. प्रत्येक तर्क के लिए तुलना तालिकाओं को जोड़ता है

-:& क्या वे मेल खाते हैं?

— गैलेन इवानोव
स्रोत
1

05AB1E , 38 33 बाइट्स

εðK.•2Θ`ĆĀÑεÉ•u6«•B/óÕ¦•…CN9«‡{}Ë

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ε                   # Map each value in the (implicit) input-list by:
 ðK                 #  Remove all spaces
   .•2Θ`ĆĀÑεÉ•      #  Push compressed string "abemwgilorsuz"
              u     #  To uppercase: "ABEMWGILORSUZ"
               6«   #  Append a 6: "ABEMWGILORSUZ6"
   •B/óÕ¦•          #  Push compressed integer 48333917025
          …CN9«     #  Append "CN9": "48333917025CN9"
   ‡                #  Transliterate; map all characters in "ABEMWGILORSUZ" in the
                    #  map-string to "48333917025CN9" at the same indices
    {               #  Then sort all characters
}                   # Close the map
 Ë                  # And check if both are equal (which is output implicitly)

मेरा यह 05AB1E टिप देखें (वर्गों कैसे संपीड़ित तार शब्दकोश का हिस्सा नहीं? करने के लिए और कितना बड़ा पूर्णांक संपीड़ित करने के लिए? ) को समझने के लिए क्यों .•2Θ`ĆĀÑεÉ•है "abemwgilorsuz"और •B/óÕ¦•है 48333917025।

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