Bir işlev tanımını temsil eden bir dizenin girdisi verildiğinde, işlevin bağımsız değişkenlerinin yeni satırla ayrılması ve hizalanması için dizeyi yeni satırlar ve boşluklar eklenmiş olarak çıktılar.

Giriş dizesi aşağıdaki deseni izler:

• İlk olarak, her zaman en az bir karakter uzunluğunda ve karakterlerden hiçbirini içermeyen bir önekle başlar ,().

• (Ardından açık bir parantez ( ) argüman listesinin başlangıcını işaretler.

• Ardından sıfır veya daha fazla argümanın bir listesi gelecektir. Bunlar dizeyle ", "(virgül ve sonra boşluk) ayrılır . Bağımsız değişkenlerin hiçbiri hiçbir karakteri içermeyecektir ,().

• Yakın bir parantez ( )) argüman listesinin sonunu işaretler.

• Son olarak, bir sonek uzun sıfır veya daha fazla karakter ve hangi bulunabilir olabilir karakterler içeriyor ,().

Giriş dizesi yalnızca yazdırılabilir ASCII'den oluşur (yani hiçbir zaman yeni satır içermeyecektir).

Çıktı şöyle olmalıdır:

• Aynen kopyalanan önek ve açık parantez.

• Bağımsız değişken listesi, bu sefer birbirinden değil, ", "virgül, yeni satır ve her bağımsız değişkenin ilk karakterini dikey olarak hizalamak için gereken sayıda boşlukla ayrılmıştır .

• Close paren ve postfix (varsa) kelimesi kelimesine.

Bu kod golf olduğundan , bayt cinsinden en kısa kod kazanacaktır.

Test senaryoları (format: tek satır giriş, ardından çıkış ve ardından çift yeni satır):

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 bayt

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

Kullanım örneği:

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

Nasıl çalışır:

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 bayt

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

Çevrimiçi test edin!

Nasıl çalışır

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

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

-pBayrağı gerektirir :

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

Nasıl çalışır:

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

Retina, 31 bayt

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

Her iki satırın sonundaki boşluklara dikkat edin.

^([^(])*\([^)]*,Öncesinde düzenli ifadeye sahip her alanı değiştiriyoruz . Değiştirilen dize bir satırsonu olacak ve yakalamaların sayısı ([^(])*artı bir boşluk olacak.

Daha tutarlı bir açıklama daha sonra gelir.

Burada çevrimiçi deneyin.

ES6, 68 67 bayt

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

Bu, bağımsız değişken listesini orijinal dizeden ayıklayarak ve her bağımsız değişken ayırıcısını, orijinal dize içindeki bağımsız değişken listesinin konumundan hesaplanan girintiyle değiştirerek çalışır.

Düzenleme: @ETHproductions sayesinde 1 bayt kaydedildi.

Pyth, 35 30 bayt

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

Burada deneyin!

Açıklama:

+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 bayt

Groovy olduğu değil ™ "İşe Doğru Aracı". Düzenleme: Beynini kullanan biri olduğunda gayet iyi çalışıyor ...

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

Testler:

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

Biraz soluksuz:

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

Retina , 47 bayt

Bayt sayımı ISO 8859-1 kodlamasını varsayar.

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

Çevrimiçi deneyin!

JavaScript (ES6), 85

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

Ölçek

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>

Jöle , 39 bayt

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

Çevrimiçi deneyin!