Đưa ra một đầu vào của một chuỗi đại diện cho một định nghĩa hàm, xuất ra chuỗi có dòng mới và khoảng trắng được chèn để các đối số của hàm được phân tách và căn chỉnh dòng mới.

Chuỗi đầu vào sẽ theo mẫu sau:

• Đầu tiên, nó sẽ bắt đầu bằng một tiền tố, luôn dài ít nhất một ký tự và không chứa bất kỳ ký tự nào ,().

• Dấu ngoặc đơn mở ( () sau đó sẽ đánh dấu phần đầu của danh sách đối số.

• Một danh sách gồm 0 hoặc nhiều đối số sau đó sẽ theo sau. Chúng được phân tách bằng chuỗi ", "(dấu phẩy và sau đó là khoảng trắng). Không có đối số sẽ chứa bất kỳ ký tự nào ,().

• Dấu ngoặc đơn đóng ( )) sẽ đánh dấu kết thúc danh sách đối số.

• Cuối cùng, một hậu tố có thể được tìm thấy, có độ dài bằng 0 hoặc nhiều ký tự và có thể chứa các ký tự ,().

Chuỗi đầu vào sẽ chỉ bao gồm ASCII có thể in được (có nghĩa là nó sẽ không bao giờ chứa một dòng mới).

Đầu ra phải là:

• Tiền tố, sao chép nguyên văn và dấu ngoặc đơn mở.

• Danh sách đối số, lần này được phân tách không phải bởi ", "dấu phẩy, dòng mới và càng nhiều khoảng trắng cần thiết để sắp xếp theo chiều dọc ký tự đầu tiên của mỗi đối số.

• Paren gần và postfix (nếu nó tồn tại) nguyên văn.

Vì đây là môn đánh gôn , mã ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm (định dạng: đầu vào một dòng theo sau là đầu ra theo sau là hai dòng mới):

def foo(bar, baz, quux):
def foo(bar,
        baz,
        quux):

int main() {
int main() {

fn f(a: i32, b: f64, c: String) -> (String, Vec<i32>) {
fn f(a: i32,
     b: f64,
     c: String) -> (String, Vec<i32>) {

function g(h) {
function g(h) {

def abc(def, ghi, jkl, mno)
def abc(def,
        ghi,
        jkl,
        mno)

x y z(x, y, z) x, y, z)
x y z(x,
      y,
      z) x, y, z)

Haskell, 115 byte

import Data.Lists
f x|(a,b:c)<-span(/='(')x,(d,e)<-span(/=')')c=a++b:intercalate(",\n "++(a>>" "))(splitOn", "d)++e

Ví dụ sử dụng:

*Main> putStrLn $ f "fn f(a: i32, b: f64, c: String) -> (String, Vec<i32>) {"
fn f(a: i32,
     b: f64,
     c: String) -> (String, Vec<i32>) {

Làm thế nào nó hoạt động:

bind
  a: everything before the first (
  b: the first (
  c: everything after the first (
  d: everything of c before the first )
  e: everything of c from the first ) to the end

construct the output string by concatenating
  a
  b
  splitting d at the argument separator ", " and rejoining it with ",\n " followed by (length a) spaces    
  e

Japt, 23 byte

¡Y?X:Xr',",
"+SpUb'(}')

Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

               // Implicit: U = input string
¡        }')   // Map each item X and index Y in U.split(")") to:
Y?X            //  If Y is non-zero, X. This keeps e.g. "(String, Vec<i32>)" from being parsed.
:Xr',",\n"+    //  Otherwise, X with each comma replaced with ",\n" concatenated with
SpUb'(         //  U.indexOf("(") spaces.
               // Implicit: re-join with ")", output

Perl, 62 52 + 2 = 54 byte

s/\(.*?\)/$a=$"x length$`;$&=~s|(?<=,)[^,]+|\n$a$&|gr/e

Yêu cầu -pcờ:

$ echo "x y z(x, y, z) x, y, z)
fn f(a: i32, b: f64, c: String) -> (String, Vec<i32>) {" | \
perl -pe's/\(.*?\)/$a=$"x length$`;$&=~s|(?<=,)[^,]+|\n$a$&|gr/e'
x y z(x,
      y,
      z) x, y, z)
fn f(a: i32,
     b: f64,
     c: String) -> (String, Vec<i32>) {

Làm thế nào nó hoạt động:

# '-p' reads first line into $_ and will also auto print at the end
s/\(.*?\)/             # Match (...) and replace with the below
  $a=$"x length$`;     # $` contains all the content before the matched string
                       # And $" contains a literal space 
  $&=~s|               # Replace in previous match
    (?<=,)[^,]+        # Check for a , before the the string to match
                       # This will match ' b: f64', ' c: String'
  |\n$a$&|gr/e         # Replace with \n, [:spaces:] and all the matched text

Võng mạc, 31 byte

(?<=^([^(])*\([^)]*,) 
¶ $#1$* 

Lưu ý các khoảng trắng ở cuối của cả hai dòng.

Chúng tôi thay thế mọi không gian có regex ^([^(])*\([^)]*,trước nó. Chuỗi thay thế sẽ là một dòng mới và số lần chụp có ([^(])*cộng với một khoảng trắng.

Một lời giải thích mạch lạc hơn đến sau.

Hãy thử trực tuyến tại đây.

ES6, 68 67 byte

s=>s.replace(/\(.*?\)/,(s,n)=>s.replace/, /g, `,
 `+` `.repeat(n)))

Điều này hoạt động bằng cách trích xuất danh sách đối số từ chuỗi gốc và thay thế từng dấu tách đối số bằng cách thụt lề được tính từ vị trí của danh sách đối số trong chuỗi gốc.

Chỉnh sửa: Đã lưu 1 byte nhờ @ETHproductions.

Bình thường, 35 30 byte

+j++\,b*dhxz\(c<zKhxz\)", ">zK

Hãy thử nó ở đây!

Giải trình:

+j++\,b*dhxz\(c<zKhxz\)", ">zK    # z = input()

                 Khxz\)           # Get index of the first ")"
               <z                 # Take the string until there...
              c        ", "       # ...and split it on the arguments
 j                                # Join the splitted string on...
  ++                              # ...the concatenation of...
    \,b                           # ...a comma followed by a newline...
       *dhxz\(                    # ...followed by the right amount of spaces = index of the first "(" + 1
+                         >zK     # Concat the resulting string with the postfix

Groovy, 137 89 95 byte

Groovy không phải là "Công cụ phù hợp cho công việc" ™. Chỉnh sửa: Nó hoạt động tốt khi bạn có người có não sử dụng ...

f={s=(it+' ').split(/\0/)
s[0].replace(',',',\n'+(' '*it.indexOf('(')))+')'+s[1..-1].join(')')}

Các xét nghiệm:

println f("def foo(bar, baz, quux):")
println f("int main() {")
println f("fn f(a: i32, b: f64, c: String) -> (String, Vec<i32>) {")
println f("function g(h) {")
println f("def abc(def, ghi, jkl, mno)")
println f("x y z(x, y, z) x, y, z)")

Hơi vô dụng:

f = {String it ->
    def str = (it + ' ').split(/\)/)
    return (str[0].replace (',', ',\n'+(' ' * it.indexOf('('))) + ')' + str[1])
}

Võng mạc , 47 byte

Số lượng byte giả định mã hóa ISO 8859-1.

m+`^(([^(]+.)[^,)]+,) (.+)
$1¶$2$3
T`p` `¶.+?\(

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

JavaScript (ES6), 85

s=>s.replace(/^.*?\(|[^),]+, |.+/g,(x,p)=>[a+x,a=a||(p?`
`+' '.repeat(p):a)][0],a='')

Kiểm tra

f=s=>s.replace(/^.*?\(|[^),]+, |.+/g,(x,p)=>[a+x,a=a||(p?`
`+' '.repeat(p):a)][0],a='')

console.log=x=>O.textContent+=x+'\n'

;['def foo(bar, baz, quux):',
  'int main() {',
  'fn f(a: i32, b: f64, c: String) -> (String, Vec<i32>) {',
  'function g(h) {',
  'def abc(def, ghi, jkl, mno)',
  'x y z(x, y, z) x, y, z)']
.forEach(t=>console.log(t+'\n'+f(t)+'\n'))

<pre id=O></pre>

Thạch , 39 byte

ṣ”)Ḣṣ”(Ṫ©œṣ⁾, ji”(⁶ẋƊ⁾,¶;ƊḢ,j®${jʋ@œṣ®$

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