16

फ़ंक्शन परिभाषा का प्रतिनिधित्व करने वाले स्ट्रिंग के इनपुट को देखते हुए, नई और रिक्त स्थान के साथ स्ट्रिंग को आउटपुट किया जाता है ताकि फ़ंक्शन के तर्क न्यूलाइन-अलग और संरेखित हों।

इनपुट स्ट्रिंग निम्नलिखित पैटर्न का पालन करेगी:

सबसे पहले, यह एक उपसर्ग के साथ शुरू होगा, जो हमेशा कम से कम एक वर्ण लंबा होता है और इसमें कोई भी वर्ण नहीं होता है ,()।
एक खुला कोष्ठक ( () तब तर्क सूची की शुरुआत को चिह्नित करेगा।
शून्य या अधिक तर्कों की एक सूची इसके बाद आएगी। इन्हें स्ट्रिंग ", "(एक अल्पविराम और फिर एक स्थान) द्वारा अलग किया जाता है । किसी भी तर्क में कोई भी वर्ण नहीं होगा ,()।
एक करीबी कोष्ठक ( )) तर्क सूची के अंत को चिह्नित करेगा।
अंत में, एक उपसर्ग पाया जा सकता है, जो शून्य या अधिक वर्ण लंबा है और इसमें वर्ण हो सकते हैं ,()।

इनपुट स्ट्रिंग में केवल मुद्रण योग्य ASCII शामिल होगा (जिसका अर्थ है कि इसमें एक नई पंक्ति कभी नहीं होगी)।

आउटपुट होना चाहिए:

उपसर्ग, कॉपी वर्बटीम, और खुले कोष्ठक।
तर्क सूची, इस बार अलग-अलग नहीं ", "बल्कि अल्पविराम, न्यूलाइन, और जितने रिक्त स्थान हैं, प्रत्येक तर्क के पहले वर्ण को संरेखित करने के लिए आवश्यक है।
नज़दीकी पैरेन्क और पोस्टफ़िक्स (यदि यह मौजूद है) शब्दशः।

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीत जाएगा।

परीक्षण के मामले (प्रारूप: सिंगल-लाइन इनपुट जिसके बाद आउटपुट के बाद डबल न्यूलाइन है):

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)

code-golf string

— Doorknob
स्रोत

7

हास्केल, 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

— nimi
स्रोत

a>>" "वास्तव में होशियार है ...

— एक्टरक्लविसिलिस

4

जाप, 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

— ETHproductions
स्रोत

3

पर्ल, 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

— andlrc
स्रोत

3

रेटिना, 31 बाइट्स

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

दोनों लाइनों के अंत में रिक्त स्थान पर ध्यान दें।

हम प्रत्येक स्थान को प्रतिस्थापित करते हैं, जिसके ^([^(])*\([^)]*,पहले रेगेक्स है। प्रतिस्थापन स्ट्रिंग एक नई रेखा होगी, और इसके साथ कैप्चर की संख्या([^(])* प्लस एक रिक्त स्थान के ।

अधिक सुसंगत स्पष्टीकरण बाद में आता है।

इसे यहाँ ऑनलाइन आज़माएँ।

— randomra
स्रोत

3

ईएस 6, 68 67 बाइट्स

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

यह मूल स्ट्रिंग से तर्क सूची निकालने के द्वारा काम करता है, और प्रत्येक तर्क विभाजक को मूल स्ट्रिंग के भीतर तर्क सूची की स्थिति से गणना की गई इंडेंटेशन के साथ प्रतिस्थापित करता है।

संपादित करें: 1 बाइट @ETHproductions के लिए धन्यवाद सहेजा गया।

— नील
स्रोत

मैं सोच रहा था कि आपने इसके .split`, `.join(...)बजाय क्यों किया .replace(...)। बाहर मुड़ता है एक बाइट कम है:s=>s.replace(/\(.*?\)/,(s,n)=>s.replace(/, /g,`,\n `+` `.repeat(n)))

— ETHproductions

2

पायथ, 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

— Denker
स्रोत

2

ग्रूवी, 137 89 95 बाइट्स

~~ग्रूवी है नहीं ™ "नौकरी के लिए सही उपकरण"।~~ संपादित करें: यह ठीक काम करता है जब आपके पास इसका उपयोग करने वाला मस्तिष्क है ...

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

— जे एटकिन
स्रोत

1

रेटिना , 47 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

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

इसे ऑनलाइन आज़माएं!

— मार्टिन एंडर
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 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>

स्निपेट का विस्तार करें

— edc65
स्रोत

मुझे क्षमा करें, मैं गलत कर रहा था, मेरे कंसोल में कोड चला रहा था और आउटपुट कुछ इस तरह था: "x y z(xजैसा कि आप देख सकते हैं "कि मैं यह क्यों सोच रहा था कि यह एक जगह से दूर था। इसलिए विलोपन

— andlrc

@ देव-नल जो मुझे हर समय होता है।

— edc65

0

जेली , 39 बाइट्स

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