मोलेहिल के बाहर पहाड़ बनाना

Question

आपको इलाके की एक स्ट्रिंग दी जाती है, जिसमें तिल और पहाड़ होते हैं:

                        /\
                       /  \
              _/\__   /    \
          ___/     \_/      \_
____/\___/                    \___

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

एक छतरियों में आसन्न स्तंभ होते हैं, जहां भूभाग ऊपर जाता है, इसके तुरंत बाद आसन्न स्तंभ होते हैं जहां भूभाग नीचे जाता है। सबसे छोटा पक्ष ठीक एक स्तंभ चौड़ा होना चाहिए।

ये सभी तिल हैं:

_____/\______

   /\________
__/

________/\
          \__

\           /
 \         /
  \       /
   \     /
    \/\_/

ये तिल नहीं हैं :

    /\
___/  \______

      ___
_____/   \___

____  _______
    \/

एक पर्वत एक अणु की तरह है, लेकिन सबसे छोटा पक्ष एक के बजाय चार रेखाओं वाला है।

उदाहरण

                  /\
                 /  \
           ->   /    \
____/\____    _/      \_

                       /\
                      /  \
                     /    \
           __ ->    /      \__
_     /\__/      __/
 \___/

                         /\
                        /  \
               ->      /    \
  /\                /\/      \
_/  \__/\_____    _/          \_

_                _    _                _
 \              /      \      /\      /
  \            /        \    /  \    /
   \          /          \  /    \  /
    \        /     ->     \/      \/
     \      /
      \    /
       \/\/

                             /\      /\
                            /  \    /  \
                           /    \  /    \
_                     -> _/      \/      \
 \                                        \
  \                                        \
   \/\______/\_______                       \_

                        /\                           /\       /\
                       /  \               /\        /  \     /  \
              _/\__   /    \       ->    /  \      /    \   /    \
          ___/     \_/      \_          /    \  __/      \_/      \_
____/\___/                    \___    _/      \/                    \___

अतिरिक्त नियम

• मानक खामियों को मना किया जाता है।
• इनपुट और आउटपुट किसी भी उचित प्रारूप में हो सकते हैं।
• आप इनपुट स्ट्रिंग में व्हॉट्सएप के पीछे उपस्थिति या अनुपस्थिति मान सकते हैं।
• स्ट्रिंग के किनारों के साथ-साथ किसी भी पहाड़ों के लिए हमेशा पर्याप्त स्थान होगा जहां आपको आवश्यकता हो सकती है।
• यदि पहाड़ों के साथ तिलों को बदलने से अतिरिक्त तिल पैदा होते हैं, तो आपको उन तिलों को पहाड़ों में बदलने की आवश्यकता नहीं है।
• इलाके एक ही कॉलम में ऊपर और नीचे दोनों नहीं जा सकते। यदि ऐसा होता है, तो इलाका हिलता नहीं है।
• यदि कोई विशेष स्तंभ किसी पर्वत का हिस्सा नहीं बनता है, तो उसकी ऊंचाई अपरिवर्तित रहनी चाहिए।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है।

Comments

यह एक अच्छी चुनौती है!

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

मुझे लगता है कि दूसरा-अंतिम उदाहरण चार \ _ और चार के साथ समाप्त होना चाहिए, न कि सात \ _ और एक के साथ।

— एनजीएम

क्या आपका इरादा यह है कि पहले और आखिरी पात्रों को ऊर्ध्वाधर स्थिति में परिवर्तन नहीं करना चाहिए और यह भी कि जितना संभव हो उतना कम वर्णों को बदलना चाहिए ? ऐसा लगता है कि उदाहरण क्या सुझाव देते हैं, खासकर अगर दूसरा आखिरी एकमात्र सही उत्तर है।

— 14

इन बिंदुओं को स्पष्ट करने के लिए चुनौती विनिर्देश को संपादित करना एक अच्छा विचार होगा।

— ng

इसके अलावा, अंतिम नियम "इलाके एक ही स्तंभ में ऊपर और नीचे दोनों नहीं जा सकते हैं" - इसका क्या मतलब है? निश्चित रूप से "इलाके" केवल तीन वर्णों में से एक है /, \, _, इसलिए यह संभवतः एक ही समय में ऊपर और नीचे कैसे जा सकता है?

— चास ब्राउन

Answer 1

पायथन 2 , 509 495 480 बाइट्स

def f(S):
 B='\\';F='/';s=''.join(map(max,*S.split('\n')));t=list(re.sub(r'..((./\\[^\\])|([^/]/\\.))..',r'////\\\\\\\\',s));C=s.count;D=t.count;d=C(F)-D(F)+D(B)-C(B);m=[{'_':F,B:'_'},{'_':B,F:'_'}][d<0];d=abs(d);i=1
 while d:
	if s[i]!=t[i]:i+=7
	elif t[i]in m:d-=1;t[i]=m[t[i]]
	i+=1
 return'\n'.join(u for u in map(''.join,zip(*[u.ljust(2*len(S))for u in reduce(lambda (a,p),c:(a+[' '*[p,p-1][c==B]+c],p+[[0,-1][c==B],1][c==F]),t,([],len(t)))[0]]))[::-1]if u.strip())
import re

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

अभी भी स्पष्ट नहीं है कि वास्तविक नियम क्या हैं; लेकिन यहाँ अतिरिक्त बाधाएँ हैं जो ऊपर और नियम से लागू होती हैं कि तिलों को पहाड़ों में बदल दिया जाएगा:

• आउटपुट का पहला और अंतिम इलाक़ा वर्ण होना चाहिए _, जैसा कि उन्हें मान्य इनपुट के लिए होना चाहिए।
• पहले _और आखिरी के बीच ऊर्ध्वाधर अंतर _इनपुट और आउटपुट के बीच बनाए रखा जाना चाहिए।
• पहाड़ों में मोलिल को बदलने से प्रतिस्थापन के बाद, ऊर्ध्वाधर अंतर को बनाए रखने के लिए कुछ अन्य पात्रों को बदलने की आवश्यकता हो सकती है; लेकिन जो अक्षर बदले गए, उनमें से कोई भी ऐसा पात्र नहीं होना चाहिए, जो पहाड़ों का हिस्सा हो, जो तिलों से बना हो।
• और इन परिवर्तनों को पूरा करते समय, परिवर्तित अतिरिक्त वर्णों की संख्या न्यूनतम होनी चाहिए।

अघोषित एल्गोरिथम:

def f(s):
    s = ''.join(map(max,*s.split('\n'))) # flatten into a single line
    t = re.sub(r'..((./\\[^\\])|([^/]/\\.))..',r'////\\\\\\\\',s) # replace molehills with mountains
    d = s.count('/')-t.count('/')+t.count('\\')-s.count('\\') # are the two strings equally balanced?
    m=[{'_':'/','\\':'_'},{'_':'\\','/':'_'}][d<0] # make an appropriate mapping...
    d=abs(d);i=1 # skip over leading '_'...
    while d: # while still unbalanced...
        if s[i]!=t[i]:i+=7 # skip over any created mountains (7+1==8)
        elif t[i] in m:d-=1;t = t[:i]+m[t[i]]+t[i+1:] # if can replace, do replace
        i += 1 # next char
    t = reduce(lambda (a,p),c:(a+[' '*[p,p-1][c=='\\']+c],p+[[0,-1][c=='\\'],1][c=='/']),t,([],len(t)))[0]  # pad spaces at left side
    t = map(''.join,zip(*[u.ljust(max(map(len,t))) for u in t])) # rotate
    return '\n'.join(u for u in t[::-1] if u.strip()) # reverse and join into lines.
import re

Answer 2

लाल , 855, 845 833 बाइट्स

func[s][r: split s"^/"c: charset"\_/"m: copy #()repeat n l: length? r[parse r/:n[any[i:
c(put m 1 + offset? r/:n i reduce[first i n])| skip]]]m: extract next sort/skip to-block m
2 2 e: copy[]parse b: rejoin collect[foreach c m[keep c/1]][any[c:["/\_"|"/\/"](alter
e 1 + offset? b c)| c:["_/\"|"\/\"](alter e 2 + offset? b c)| skip]]y: 0 foreach a e[q: p:
d: -3 + min m/(a - 4)/2 m/(a + 5)/2 if d < y[y: d]j: i: a until[m/:i/1: #"/"m/:i/2: p k: i
- 2 if all[k > 0 #"_"= m/:k/1 p = m/:k/2][m/(k + 1)/1: #"_"m/(k + 1)/2: p break]i: i - 1
m/:i/2 < p: p + 1]j: j + 1 until[m/:j/1: #"\"m/:j/2: q k: i + 2 if all[#"_"= m/:k/1
p = m/:k/2][m/(k - 1)/1: #"_"m/(k - 1)/2: p break]j: j + 1 m/:j/2 < q: q + 1]]y: y - 1 q:
collect[loop l - y[k: copy""keep pad k p: length? m]]repeat n p[w: m/1/2 - y
q/:w/:n: m/1/1 m: next m]foreach d q[print d]]

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

दूर, एक गोल्फ समाधान से दूर ... यह परीक्षण के मामलों से गुजरता है लेकिन सबसे अधिक शायद कुछ अन्य, अधिक अजीब पैटर्न पर विफल होगा।

अधिक पठनीय:

f: func [ s ] [
    r: split s "^/"
    c: charset "\_/"
    m: copy #()
    repeat n l: length? r[
        parse r/:n[ any [ i: c(put m 1 + offset? r/:n i reduce[ first i n ])
        | skip]]
    ]
    m: sort/skip to-block m 2
    m: extract next m 2
    b: rejoin collect [ foreach c m [ keep c/1 ] ]
    e: copy []
    parse b [ any [ c: [ "/\_" | "/\/" ]
                (alter e 1 + offset? b c)
            | c: [ "_/\" | "\/\" ]
                (alter e 2 + offset? b c)
            | skip
        ]
    ]
    y: 0
    foreach a e [
        q: p: d: -3 + min m/(a - 4)/2 m/(a + 5)/2
        if d < y [ y: d ]
        j: i: a
        until [
            m/:i/1: #"/"
            m/:i/2: p
            k: i - 2
            if all [ k > 0
                     #"_" = m/:k/1
                     p = m/:k/2
            ] [ 
                m/(k + 1)/1: #"_"
                m/(k + 1)/2: p
                break
            ]
            i: i - 1
            p: p + 1 
            m/:i/2 < p
        ]
        j: j + 1
        until[
            m/:j/1: #"\"
            m/:j/2: q
            k: i + 2
            if all [ #"_" = m/:k/1 
                     p = m/:k/2
            ] [
                m/(k - 1)/1: #"_"
                m/(k - 1)/2: p
                break
            ]
            j: j + 1
            q: q + 1 
            m/:j/2 < q
        ]
    ]
    y: y - 1
    q: collect [
        loop l - y [
            k: copy ""
            keep pad k p: length? m
        ]
    ]
    repeat n p [ w: m/1/2 - y
                 q/:w/:n: m/1/1
                 m: next m ]
    foreach d q [ print d ]
]