함수 정의를 나타내는 문자열이 입력되면, 함수의 인수가 개행으로 구분되고 정렬되도록 줄 바꿈과 공백이 삽입 된 문자열을 출력하십시오.

입력 문자열은 다음 패턴을 따릅니다.

• 먼저 접두사로 시작합니다. 접두사는 항상 1 자 이상이며 문자를 포함하지 않습니다 ,().

• 열린 괄호 ( ()는 인수 목록의 시작을 표시합니다.

• 그런 다음 0 개 이상의 인수 목록이 이어집니다. 문자열 ", "(쉼표와 공백)로 구분됩니다. 어떤 인수도 문자를 포함하지 않습니다 ,().

• 닫는 괄호 ( ))는 인수 목록의 끝을 표시합니다.

• 마지막으로 접미사가 발견 될 수 있으며, 길이는 0 자 이상이며 문자를 포함 할 수 있습니다 ,().

입력 문자열은 인쇄 가능한 ASCII로만 구성됩니다 (즉, 줄 바꿈이 포함되지 않음).

출력은 다음과 같아야합니다.

• 그대로 복사 된 접두사와 열린 괄호.

• 이번에는 인수 목록이 ", "아니라 쉼표, 개행 및 각 인수의 첫 문자를 수직으로 정렬하는 데 필요한만큼의 공백으로 구분됩니다.

• 닫는 paren 및 postfix (있는 경우) 그대로.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 승리합니다.

테스트 사례 (형식 : 단일 행 입력, 출력 및 이중 줄 바꿈) :

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)

하스켈, 115 바이트

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

사용 예 :

*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>) {

작동 방식 :

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

apt, 23 바이트

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

온라인으로 테스트하십시오!

작동 원리

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

펄, 62 52 + 2 = 54 바이트

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

필요 -p플래그가 :

$ 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>) {

작동 방식 :

# '-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

망막, 31 바이트

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

두 줄의 끝에 공백이 있습니다.

우리는 정규 표현식이있는 모든 공간을 대체 ^([^(])*\([^)]*,합니다. 교체 문자열은 줄 바꿈이되며 캡처 횟수는([^(])* 공백이 하나 .

더 일관된 설명이 나중에 나옵니다.

여기에서 온라인으로 사용해보십시오.

ES6, 68 67 바이트

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

이것은 원래 문자열에서 인수 목록을 추출하고 각 인수 구분 기호를 원래 문자열 내 인수 목록의 위치에서 계산 된 들여 쓰기로 대체하여 작동합니다.

편집 : @ETHproductions 덕분에 1 바이트가 절약되었습니다.

Pyth, 35 30 바이트

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

여기 사용해보십시오!

설명:

+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

그루비, 137 89 95 바이트

Groovy는 "Right Tool for the Job"™ 이 아닙니다 . 편집 : 그것을 사용하는 두뇌를 가진 사람이있을 때 잘 작동합니다 ...

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

테스트 :

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)")

언 골프 :

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

레티 나 , 47 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 85

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

테스트

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>

젤리 , 39 바이트

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

온라인으로 사용해보십시오!