คุณจะได้รับภูมิประเทศที่เต็มไปด้วยโมเลกุลและภูเขา:

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

งานของคุณคือแทนที่ทุกฮิลล์ในสตริงด้วยภูเขาที่เทียบเท่าโดยมีศูนย์กลางอยู่ที่คอลัมน์เดียวกัน ส่วนที่เหลือของสตริงจะต้องไม่ได้รับผลกระทบ สิ่งนี้อาจต้องการบรรทัดเพิ่มเติมที่จุดเริ่มต้นของสตริง

จอมปลวกประกอบด้วยคอลัมน์ที่อยู่ติดกันที่มีลักษณะภูมิประเทศขึ้นไปทันทีตามด้วยคอลัมน์ที่อยู่ติดกันที่มีลักษณะภูมิประเทศลงไป ด้านที่สั้นที่สุดจะต้องมีความกว้างหนึ่งคอลัมน์

นี่คืออณูทั้งหมด:

_____/\______

   /\________
__/

________/\
          \__

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

สิ่งเหล่านี้ไม่ใช่โมเลกุล:

    /\
___/  \______

      ___
_____/   \___

____  _______
    \/

ภูเขาเป็นเหมือนจอมปลวก แต่ด้านที่สั้นที่สุดคือสี่สายสูงแทนหนึ่ง

ตัวอย่าง

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

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

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

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

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

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

กฎเพิ่มเติม

• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• อินพุตและเอาต์พุตสามารถอยู่ในรูปแบบที่สมเหตุสมผล
• คุณอาจสมมติว่ามีหรือไม่มีช่องว่างต่อท้ายในสายป้อน
• จะมีพื้นที่เพียงพอในด้านข้างของเชือกตลอดจนระหว่างโมเลกุลสำหรับภูเขาใด ๆ ที่คุณอาจต้องการ
• หากแทนที่โมเลกุลด้วยภูเขาจะสร้างโมเลกุลขึ้นมาอีกคุณไม่จำเป็นต้องเปลี่ยนโมเลกุลเหล่านั้นเป็นภูเขา
• ภูมิประเทศไม่สามารถขึ้นและลงในคอลัมน์เดียวกันได้ หากสิ่งนี้เกิดขึ้นภูมิประเทศจะไม่เคลื่อนที่
• หากคอลัมน์ใดคอลัมน์หนึ่งไม่ได้เป็นส่วนหนึ่งของภูเขาความสูงของเสาจะต้องไม่เปลี่ยนแปลง

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ

Python 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

ลองออนไลน์!

ยังไม่ชัดเจนว่ากฎที่แท้จริงคืออะไร แต่นี่คือข้อ จำกัด เพิ่มเติมที่บังคับใช้เหนือกว่ากฎที่ว่าโมเลกุลจะกลายเป็นภูเขา:

• ต้องมีอักขระภูมิประเทศตัวแรกและตัวสุดท้ายของเอาต์พุต_เช่นเดียวกับที่ใช้สำหรับอินพุตที่ถูกต้อง
• ความแตกต่างในแนวดิ่งระหว่างตัวแรก_และตัวสุดท้าย_จะต้องได้รับการปรับปรุงระหว่างอินพุตและเอาต์พุต
• หลังจากเปลี่ยนจากการเปลี่ยนโมเลกุลเป็นภูเขาตัวละครอื่น ๆ อาจต้องเปลี่ยนเพื่อรักษาความแตกต่างในแนวดิ่งดังกล่าว; แต่ตัวละครที่เปลี่ยนไปจะต้องไม่เป็นตัวละครใด ๆ ที่เป็นส่วนหนึ่งของภูเขาที่สร้างขึ้นจากอนินทรีย์
• และเมื่อทำการเปลี่ยนแปลงเหล่านี้สำเร็จจำนวนของอักขระที่เปลี่ยนแปลงเพิ่มเติมจะต้องน้อยที่สุด

อัลกอริทึม Ungolfed:

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

สีแดง , 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 ]
]