Bạn được cung cấp một chuỗi địa hình, với các nốt ruồi và núi:

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

Công việc của bạn là thay thế mọi nốt ruồi trong chuỗi bằng một ngọn núi tương đương tập trung trong cùng một cột. Phần còn lại của chuỗi phải không bị ảnh hưởng. Điều này có thể yêu cầu các dòng bổ sung ở đầu chuỗi.

Một nốt ruồi bao gồm các cột liền kề nơi địa hình đi lên, ngay sau đó là các cột liền kề nơi địa hình đi xuống. Mặt ngắn nhất phải chính xác là một cột rộng.

Đây là tất cả các nốt ruồi:

_____/\______

   /\________
__/

________/\
          \__

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

Đây không phải là nốt ruồi:

    /\
___/  \______

      ___
_____/   \___

____  _______
    \/

Một ngọn núi giống như một nốt ruồi, nhưng bên ngắn nhất cao bốn dòng thay vì một.

Ví dụ

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

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

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

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

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

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

Quy tắc bổ sung

• Sơ hở tiêu chuẩn bị cấm.
• Đầu vào và đầu ra có thể ở bất kỳ định dạng hợp lý.
• Bạn có thể giả sử sự hiện diện hoặc vắng mặt của khoảng trắng theo sau trong chuỗi đầu vào.
• Sẽ luôn có đủ không gian ở hai bên của chuỗi cũng như giữa các nốt ruồi cho bất kỳ ngọn núi nào bạn có thể cần.
• Nếu việc thay thế các nốt ruồi bằng núi tạo ra các nốt ruồi bổ sung, bạn không cần phải biến những nốt ruồi đó thành núi.
• Địa hình không thể đi lên và xuống trong cùng một cột. Nếu điều này xảy ra, địa hình không di chuyển.
• Nếu một cột cụ thể không trở thành một phần của ngọn núi, chiều cao của nó phải không thay đổi.

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Con trăn 2 , 509 495 480 byte

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

Hãy thử trực tuyến!

Vẫn chưa rõ các quy tắc thực tế là gì; nhưng đây là những ràng buộc bổ sung được thi hành ở trên và vượt ra ngoài quy tắc rằng các nốt ruồi sẽ bị biến thành núi:

• Các ký tự địa hình đầu tiên và cuối cùng của đầu ra phải _giống như chúng phải dành cho các đầu vào hợp lệ.
• Sự khác biệt dọc giữa đầu tiên _và cuối cùng _phải được duy trì giữa đầu vào và đầu ra.
• Sau khi thay thế từ việc biến nốt ruồi thành núi, một số nhân vật khác có thể cần phải được thay đổi để duy trì sự khác biệt theo chiều dọc đã nói; nhưng các nhân vật thay đổi không được là bất kỳ nhân vật nào là một phần của những ngọn núi được tạo ra từ molehills.
• Và khi hoàn thành những thay đổi này, số lượng ký tự bổ sung thay đổi phải ở mức tối thiểu.

Thuật toán 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 byte

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

Hãy thử trực tuyến!

Xa, rất xa với một giải pháp golf ... Nó vượt qua các trường hợp thử nghiệm nhưng hầu hết có thể sẽ thất bại trên một số mô hình khác lạ hơn.

Dễ đọc hơn:

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