মোলিহিলের বাইরে পাহাড় তৈরি করা

Question

আপনাকে মোলহিল এবং পর্বতমালা সহ একটি ভূখণ্ডের স্ট্রিং দেওয়া হবে:

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

আপনার কাজটি হ'ল স্ট্রিংয়ের প্রতিটি মোলিহিলকে একই কলামে কেন্দ্র করে সমতুল্য পর্বত দিয়ে প্রতিস্থাপন করা। স্ট্রিংয়ের বাকি অংশগুলি অবশ্যই প্রভাবিত হবে না। স্ট্রিংয়ের শুরুতে এটি অতিরিক্ত রেখার প্রয়োজন হতে পারে।

একটি মোলহিল সংলগ্ন কলামগুলি নিয়ে গঠিত যেখানে ভূখণ্ডটি উপরে উঠে যায়, তত্ক্ষণাত সংলগ্ন কলামগুলি অনুসরণ করে যেখানে অঞ্চলটি নীচে নামবে। সংক্ষিপ্ত দিকটি অবশ্যই এক কলাম প্রশস্ত হতে হবে।

এগুলি সমস্ত মোলহিল:

_____/\______

   /\________
__/

________/\
          \__

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

এগুলি মোলহিল নয় :

    /\
___/  \______

      ___
_____/   \___

____  _______
    \/

একটি পাহাড় মোলিহিলের মতো, তবে সংক্ষিপ্ততম দিকটি একটিটির পরিবর্তে চার লাইন উঁচু।

উদাহরণ

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

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

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

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

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

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

অতিরিক্ত বিধি

• স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।
• ইনপুট এবং আউটপুট যে কোনও যুক্তিসঙ্গত বিন্যাসে হতে পারে।
• আপনি ইনপুট স্ট্রিংয়ে পূর্ববর্তী সাদা স্থানের উপস্থিতি বা অনুপস্থিতি ধরে নিতে পারেন।
• আপনার প্রয়োজন হতে পারে যে কোনও পর্বতের জন্য স্ট্রিংয়ের পাশ এবং মোলহিলের মধ্যে সর্বদা পর্যাপ্ত জায়গা থাকবে।
• যদি মোলহিলগুলি পর্বতমালার সাথে প্রতিস্থাপন করে অতিরিক্ত মোলহিল তৈরি করে, আপনার সেই মোলহিলগুলিকে পর্বতে পরিণত করার দরকার নেই।
• অঞ্চলটি একই কলামে উপরে এবং নীচে উভয়দিকে যেতে পারে না। যদি এটি হয় তবে ভূখণ্ডটি সরবে না।
• কোনও নির্দিষ্ট কলাম যদি কোনও পর্বতের অংশ না হয়ে যায় তবে এর উচ্চতা অবশ্যই অপরিবর্তিত থাকবে।

এটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর ins

Comments

এটি একটি দুর্দান্ত চ্যালেঞ্জ!

— গ্যালেন ইভানভ 8

আমি মনে করি দ্বিতীয়-শেষ উদাহরণটি সাত not এবং একটি _ দিয়ে নয় four এবং চার _ দিয়ে শেষ হওয়া উচিত।

— এনজিএম

আপনার উদ্দেশ্য কি প্রথম এবং শেষের অক্ষরগুলি উল্লম্ব অবস্থান পরিবর্তন করতে হবে না এবং এটিও যে যতটা সম্ভব কম অক্ষর পরিবর্তন করা উচিত ? উদাহরণস্বরূপ যা বোঝায় এটি হ'ল, বিশেষত যদি দ্বিতীয় সর্বশেষের একমাত্র সঠিক উত্তর।

— এনজিএম

এই পয়েন্টগুলি স্পষ্ট করতে চ্যালেঞ্জের বিশদটি সম্পাদনা করা ভাল ধারণা হবে।

— এনজিএম

তদ্ব্যতীত, সর্বশেষ বিধি "অঞ্চলগুলি একই কলামে উপরে এবং নীচে উভয় যেতে পারে না" - এর অর্থ কী? অবশ্যই "ভূখণ্ড" তিনটি চরিত্রের মধ্যে একটি /, \, _, সুতরাং কীভাবে এটি একই সাথে সম্ভবত উপরে এবং নীচে যেতে পারে?

— চ্যাস ব্রাউন 21

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

এটি অনলাইন চেষ্টা করুন!

প্রকৃত বিধিগুলি কী তা এখনও পরিষ্কার নয়; তবে এখানে অতিরিক্ত সীমাবদ্ধতাগুলি যা মোলহিলকে পর্বতে পরিণত করা হবে তার উপরে এবং নিয়মের বাইরে প্রয়োগ করা হয়েছে:

• আউটপুটটির প্রথম এবং শেষ ভূখণ্ডের অক্ষরগুলি _অবশ্যই বৈধ ইনপুটগুলির জন্য হওয়া উচিত।
• প্রথম _এবং শেষের মধ্যে উল্লম্ব পার্থক্য _অবশ্যই ইনপুট এবং আউটপুট বজায় রাখতে হবে।
• মোলহিলকে পর্বতে পরিণত করা থেকে প্রতিস্থাপনের পরে, উল্লম্ব পার্থক্য বজায় রাখার জন্য আরও কিছু চরিত্র পরিবর্তন করার প্রয়োজন হতে পারে; তবে পরিবর্তিত চরিত্রগুলি অবশ্যই মোলহিল থেকে নির্মিত পাহাড়ের অংশের কোনও অক্ষর নয় not
• এবং এই পরিবর্তনগুলি সম্পাদন করার সময় পরিবর্তিত অতিরিক্ত অক্ষরের সংখ্যা অবশ্যই ন্যূনতম হতে হবে।

অগল্ফড অ্যালগরিদম:

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 ]
]