19

जैसा कि आप शायद अब, 6x10 ग्रिड में पेंटोमिनो पहेली के 2339 समाधान हैं। 12 पेंटोमिनो के लिए अलग-अलग लेबलिंग योजनाएं हैं, उनमें से दो नीचे दी गई छवि पर दिखाई जाती हैं:

चित्र साभार: विकिपीडिया

वर्तमान कार्य के प्रयोजनों के लिए हम कहेंगे कि एक सामान्यीकृत पेंटोमिनो समाधान एक समाधान है जो दूसरी लेबलिंग योजना (कॉनवे के) का उपयोग करता है।

उदाहरण:

O O O O O S S S Z Z
P P R R S S W W Z V
P P P R R W W Z Z V
U U X R T W Y V V V
U X X X T Y Y Y Y Q
U U X T T T Q Q Q Q

Oयोजना के अनुसार, एक पंक्ति में 5 वर्गों वाले टुकड़े को अक्षरों के साथ दर्शाया जाता है । सभी टुकड़ों के लिए समान है।

कार्य:

6x10 पेंटोमिनो के समाधान को देखते हुए जिसमें टुकड़ों को एक यादृच्छिक किन्नर के साथ लेबल किया जाता है, इसे सामान्य करें ताकि सभी टुकड़ों को कॉनवे की लेबलिंग योजना में लेबल किया जाए। आपको टुकड़ों को पहचानने और किसी विशेष टुकड़े के प्रत्येक वर्ग को टुकड़े के प्रतीक के साथ चिह्नित करने की आवश्यकता है।

इनपुट:

किसी भी प्रारूप में, जो आपके लिए सुविधाजनक है, को सामान्यीकृत करने का उपाय, उदाहरण के लिए:

एक मल्टीलाइन स्ट्रिंग
तार की एक सूची
पात्रों की सूची की एक सूची

और इसी तरह

आउटपुट:

एक ही समाधान (सभी टुकड़ों की स्थिति और अभिविन्यास संरक्षित), लेकिन प्रत्येक टुकड़ा कॉनवे की लेबलिंग योजना के अनुसार लेबल किया गया। नोट: आउटपुट को वर्णों के 6x10 ग्रिड के रूप में मुद्रित किया जाना चाहिए। लीडिंग और अनुगामी newlines और रिक्त स्थान की अनुमति है। आप पात्रों के बीच एक स्थान भी प्रिंट कर सकते हैं (लेकिन खाली लाइनें नहीं), जैसा कि ऊपर दिए गए उदाहरण में है।

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

1. इनपुट:

आउटपुट:

UURTTTQQQQ
URRRTVVVSQ
UUXRTVZZSY
PXXXWVZSSY
PPXWWZZSYY
PPWWOOOOOY

2. इनपुट:

45ookkkk00
455ooogk00
4a55gggdd0
4aaa3gnnd.
4am333ndd.
mmmm3nn...

आउटपुट:

OWSSQQQQPP
OWWSSSRQPP
OTWWRRRUUP
OTTTXRZZUV
OTYXXXZUUV
YYYYXZZVVV

जीत मापदंड:

प्रत्येक भाषा में बाइट्स में सबसे छोटा समाधान जीतता है। गोल्फ भाषाओं से निराश मत हो। एल्गोरिदम और कार्यान्वयन का स्पष्टीकरण स्वागत योग्य है।

code-golf pattern-matching

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

1

संबंधित: यह कौन सा tetromino है? और संबंधित: एक पेंटोमिनो आयत मुद्रित करें ।

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

@KevinCruijssen धन्यवाद! (मैं tetromonoes से संबंधित सवालों के लिए जाँच नहीं किया था)

— गैलेन इवानोव

12

APL (Dyalog Classic) , 54 53 50 बाइट्स

⍴⍴{'OXRYTPZQUWSV'[⌊5÷⍨⍋⍋,{×/+⌿↑|(⊢-+/÷≢)⍸⍵}¨⍵=⊂⍵]}

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

इनपुट में प्रत्येक पेंटोमिनो के लिए एक इंवेरिएंट की गणना करें: माप (ofx, ∆y) इसके प्रत्येक वर्ग से इसके गुरुत्वाकर्षण के केंद्र तक, abs ()x) और abs (∆y) ले जाएं, x घटकों और अलग से y का योग करें घटकों, और गुणा दो रकम। यह 12 अलग परिणाम देता है। फिर, सभी इनवेरिएंट के सॉर्ट किए गए संग्रह में प्रत्येक पेंटोमिनो के अपरिवर्तित के सूचकांक को ढूंढें। 0 के साथ बदलें 'O', 1 के साथ 'X', 2 के साथ 'R', आदि।

— NGN
स्रोत

तेजी से जवाब और स्पष्टीकरण के लिए धन्यवाद, मेरी तरफ से +1! मेरा मतलब था कि समाधान 6x10 ग्रिड के रूप में स्पष्ट रूप से मुद्रित किया जाएगा। मैंने डिसक्शन को बदल दिया, कृपया अपना समाधान अपडेट करें - मैं असुविधा के लिए माफी चाहता हूं।

— गैलेन इवानोव

@GalenIvanov लेकिन ... यह एक ग्रिड है । परिणाम प्रिंट करने के बजाय मेरा परीक्षण आउटपुट "ठीक है" - शायद यह बहुत भ्रामक है?

— ngn

हां, मैं परीक्षणों से भ्रमित था।

— गैलेन इवानोव

3

अब वे इसे सत्यापित करने से पहले परिणाम प्रिंट करते हैं

— ngn

4

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

ŒĠZÆmạƊ€ḅı§AỤỤị“æṂ⁾+’Œ?¤+78Ọ,@FQṢƊyⱮY

स्ट्रिंग्स की एक सूची लेने वाला एक पूरा कार्यक्रम (क्योंकि हमें प्रिंट करना होगा - अन्यथा ट्रेलिंग को हटा दें Y और आपके पास संख्याओं या वर्णों की सूची की सूची लेने वाला एक मोनाड है जो वर्णों की सूची की सूची लौटाता है)।

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

कैसे?

मेरा मानना है कि यह एनटीईएल के एपीएल समाधान के समान पेंटोमिनोज के वर्गीकरण का उपयोग करके काम करता है , यद्यपि यह थोड़े अलग तरीके से होता है (मुझे APL भी नहीं पता है, इसलिए मुझे यकीन नहीं है कि यह विधि कैसे वर्गीकरण के परे है)।

(ध्यान दें कि “æṂ⁾+’Œ?¤+78Ọकेवल एक बाइट बचा है “XRPTZWUYSVQO”!)

ŒĠZÆmạƊ€ḅı§AỤỤị“æṂ⁾+’Œ?¤+78Ọ,@FQṢƊyⱮY - Main Link: list of lists of characters L
ŒĠ                                    - group multidimensional indices by value
      Ɗ€                              - last three links as a monad for €ach i.e. f(x):
  Z                                   -   transpose x
   Æm                                 -   mean (vectorises) (i.e. the average of the coordinates)
     ạ                                -   absolute difference with x (vectorises) (i.e. [dx, dy])
         ı                            - square root of -1 (i)
        ḅ                             - convert from base (vectorises) (i.e a list of (i*dx+dy)s)
          §                           - sum each
           A                          - absolute value (i.e. norm of the complex number)
            Ụ                         - grade up (sort indices by value)
             Ụ                        - grade up (...getting the order from the result of A back,
                                      -              but now with one through to 12)
                       ¤              - nilad followed by links as a nilad:
               “æṂ⁾+’                 -   base 250 literal = 370660794
                     Œ?               -   permutation@lex-index = [10,4,2,6,12,9,7,11,5,8,3,1]
              ị                       - index into
                        +78           - add seventy-eight
                           Ọ          - cast to characters (character(1+78)='O', etc...)
                                 Ɗ    - last three links as a monad (i.e. f(L)):
                              F       -   flatten
                               Q      -   de-duplicate
                                Ṣ     -    sort
                            ,@        - pair (with sw@pped @rguments) (giving a list of 2 lists)
                                   Ɱ  - Ɱap across L with:
                                  y   -   translate i.e. swap the letters as per the the pair)
                                    Y - join with new lines
                                      - implicit print

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

2

वोल्फ्राम भाषा (गणितज्ञ) , 103 बाइट्स

""<>Riffle[(t=#)/.Thread[SortBy[Union@@t,Tr@Kurtosis@Position[t,#]&]->Characters@"UPSWZVRTQXYO"],"\n"]&

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

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

यहां मुख्य विचार यह है कि इनपुट में प्रत्येक वर्ण के लिए, हम निर्देशांक ढूंढते हैं जहां यह होता है, कुर्तोसिस लेते हैं और इसके निर्देशांक को जोड़ते हैं। यह हमें प्रत्येक टुकड़े के लिए एक अनौपचारिक देता है।

(कर्टोसिस आँकड़ों से कुछ अधिकांशतः अप्रासंगिक संचालक है - कुंजी यह है कि यह अनुवाद के तहत अपरिवर्तनीय है, जबकि प्रतिबिंब और घूर्णन निर्देशांक के क्रम को अधिक से अधिक स्विच कर सकते हैं। हम निर्देशांक जोड़ते हैं, इसलिए अपरिवर्तनीय कभी नहीं बदलता है।)

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

अंत में, ""<>Riffle[...,"\n"]प्रिंट-ए-ए-ग्रिड कोड है।

— मिशा लावरोव
स्रोत

एक ऑपरेशन के बारे में जानने के लिए +1, जिसे मैंने कभी सुना भी नहीं था और इसे अच्छे इस्तेमाल के लिए रखा था

— ब्लैक आउल काई

मेरे एक समाधान का पहला प्रयास था Sort@Varianceके स्थान पर Tr@Kurtosis, और शायद अधिक लोगों को विचरण के बारे में सुना है। लेकिन Tr@Varianceकाम नहीं करता क्योंकि कई pentominoes (जैसे P और X) में x-भिन्नता और y-variance का योग है। इसलिए मैं कुछ कट्टर लोगों के लिए मैथमेटिका के दस्तावेज़ों को देख रहा था।

— मीशा लावरोव

2

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

def y(o):print"".join(['XPRTWZUYSVQO\n'[[w for v,w in sorted([sum(abs(u-sum(t)/5)for t in[[complex(r%11,r/11)for r,q in enumerate(o)if q==p]]for u in t),p]for p in o)].index(x)/5]for x in o])

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

एक अनुगामी न्यूलाइन के साथ एक मल्टी-लाइन स्ट्रिंग लेता है और छह नेस्टेड सूची बोध करता है।

Ungolfed संस्करण

def pentomino_normalizer(input_string):
    # input_string is a multi-line string with a trailing newline

    results = []  # For saving the results of the for loop
    for current_char in input_string:
        # current_char = p in the golfed version

        # The python data type complex stores a real and a imaginary value and
        # is used for storing the x and y coordinates.
        # In the end, the positions list contains a complex number for every
        # occurence of current_char in the string
        # positions_list = t in the golfed version
        positions_list = [complex(i % 11, i / 11) for i, c
                          in enumerate(input_string) if c == current_char]
        # average_pos is the midpoint of all occurences of current_char, 
        # to get rid of translations
        average_pos = sum(positions_list)/5
        # Calculates a value for each tile that is invariant under 
        # translations and rotations,
        # simply the sum of all the distances between the midpoint
        # and the positions
        invariant = sum(abs(pos - average_pos) for pos in positions_list)

        # Saves the invariant value to a list
        results.append(invariant, current_char)

    # This new list contains the characters occuring in the string, sorted
    # by the invariant value. Because this was done with each char in the 
    # input string, this lists contains every value five times and also 
    # contains six newlines
    # at the end of the list
    sorted_results = [w for v, w in sorted(results)]

    # This code snippet maps each char from the input string to its according
    # output and prints to stdout
    chars = ['XPRTWZUYSVQO\n'[sorted_results.index(c)/5] for c in input_string]
    print "".join(chars)

— काला उल्लू काई
स्रोत

पेंटोमिनो 6x10 सॉल्यूशन नॉर्मलाइज़र

कार्य:

इनपुट:

आउटपुट:

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

जीत मापदंड:

APL (Dyalog Classic) , 54 53 50 बाइट्स

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

कैसे?

वोल्फ्राम भाषा (गणितज्ञ) , 103 बाइट्स

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