कन्वर्ट ब्रेसिज़ को राइट हैंड ब्रेस (उदास ब्रेस)


26

राइट हैंड ब्रेस कोड ब्रैकेटिंग की एक शैली है जिसमें घुंघराले ब्रेस और अर्धविराम सभी को आ फाइल के दाईं ओर एक बिंदु पर संरेखित किया जाता है।

उदाहरण छवि यहां जाएं

आमतौर पर, यह कई कारणों से, बुरा अभ्यास माना जाता है।

चुनौती

किसी भी विधि के माध्यम से एक बहुस्तरीय स्ट्रिंग लें, और इसे ब्रेस स्टाइल को राइट हैंड ब्रेस में परिवर्तित करें।

इस चुनौती के लिए, आपको केवल जावा कोड पर काम करने की आवश्यकता है, हालांकि, यह सैद्धांतिक रूप से किसी भी कोड पर काम करना चाहिए जो ब्रेसिज़ और सेमरोलोन का उपयोग करता है।

आप सभी {};वर्णों को एक पंक्ति में पकड़ सकते हैं , उनके बीच किसी भी राशि के व्हाट्सएप के साथ। ईजी। }}, ; } }\n\t\t}और व्हॉट्सएप के उपयोग के माध्यम से फ़ाइल के दाईं ओर उन्हें पंक्तिबद्ध करें।

उदाहरण के लिए:

a {
b;
{c

बन जाना चाहिए

a {
b ;{
c

या, अधिक अमूर्त, किसी भी और सभी व्हाट्सएप को सभी {};वर्णों के बाईं ओर से दाईं ओर धकेलें ।

लाइनों का इंडेंटेशन अन्यथा संरक्षित किया जाना चाहिए। {};वर्णों की गति के बाद केवल व्हाट्सएप वाली लाइनें वैकल्पिक रूप से हटाई जा सकती हैं।

उदाहरण के लिए:

a{
    b{
        c;
    }
}
d;

या तो बन सकता है

a        {
    b    {
        c;}}
d        ;

या

a        {
    b    {
        c;}}


d        ;

दाईं ओर धकेलने से तात्पर्य उन सभी {};वर्णों से है जिन्हें सबसे लंबी पंक्ति से कम बिंदु पर संरेखित किया जा रहा है। उसके बाद की कोई भी जगह स्वीकार्य है।

तो सभी नीचे स्वीकार्य है:

a {
bc;

a  {
bc ;

a   {
bc  ;

आदि...

किसी भी कोड की पंक्तियों में {};अन्य गैर-व्हाट्सएप पात्रों के बीच वर्ण हो सकते हैं , इस मामले को संभालना आवश्यक नहीं है, हालांकि यदि आप इच्छुक हैं, तो आपको उन्हें जगह में छोड़ देना चाहिए। लाइनों में कोई भी {};वर्ण नहीं हो सकता है , और इसे सही तरीके से संभाला जाना चाहिए। जैसा कि नीचे दिखाया गया है।

a {
b ;
c
d }

क्योंकि हम नहीं चाहते हैं कि हम जो भयानक काम कर रहे हैं, उसे देखने के लिए आपको कोड की समीक्षा करनी पड़े, आपको अपना कोड यथासंभव छोटा बनाना होगा।

उदाहरण / टेस्टकेस

जेनेरिक जावा

public class HelloWorld{
       public static void main(String[] args){
           System.out.println("Hello, World!");
       }
}

हो जाता है ...

public class HelloWorld                        {
    public static void main(String[] args)     {
        System.out.println("Hello, World!")    ;}}

छवि ही

public class Permuter{
    private static void permute(int n, char[] a){
        if (n == 0){
            System.out.println(String.valueOf(a));
        }else{
            for (int i=0; i<= n; i++){
                permute(n-1, a);
                swap(a, n % 2 == 0 ? i : 0, n);
            }
        }
    }
    private static void swap(char[] a, int i, int j){
        char saved = a[i];
        a[i] = a[j];
        a[j] = saved;
    }
}

हो जाता है ...

public class Permuter                                {
    private static void permute(int n, char[] a)     {
        if (n == 0)                                  {
            System.out.println(String.valueOf(a))    ;}
        else                                         {
            for (int i=0; i<= n; i++)                {
                permute(n-1, a)                      ;
                swap(a, n % 2 == 0 ? i : 0, n)       ;}}}
    private static void swap(char[] a, int i, int j) {
        char saved = a[i]                            ;
        a[i] = a[j]                                  ;
        a[j] = saved                                 ;}}

बिल्कुल परफेक्ट नहीं जेनेरिक पायथन

इसके विपरीत

def Main():
    print("Hello, World!");

Main();

हो जाता है ...

def Main():
    print("Hello, World!")    ;
Main()                        ;

टिप्पणियाँ

  • स्टैंडर्ड लोफॉल्स लागू होते हैं
  • स्टैंडर्ड IO लागू होता है
  • यह , इसलिए बाइट्स जीत में सबसे छोटा कार्यक्रम है!
  • मैं राइट हैंड ब्रेस स्टाइल में प्रोग्रामिंग से संबंधित नुकसान के लिए उत्तरदायी नहीं हूं
  • मज़े करो!

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

मैंने चुनौती का विवरण दिया, उम्मीद है कि मैंने नियमों के बारे में किसी के विचार को नहीं तोड़ा, मैं आपको विश्वास दिलाता हूं कि यह अनजाने में था। यह बहुत अधिक स्पष्ट और कम आत्म-विरोधी युक्ति होना चाहिए।


एकाधिक अर्धविराम वाली पंक्तियों पर क्या निर्णय है? कुछ इस तरहint a=0;System.out.println(a);
वैल्यू इंक

2
यह चुनौती के लिए सबसे अच्छी छवि नहीं हो सकती है यदि हमें नमूना छवि में छोरों के लिए संभाल करने की आवश्यकता नहीं है?
डेनिस

1
लगता है कि प्रश्न में छवि इस उदाहरण से आई थी, जिसका अनुसरण इस अनुवर्ती द्वारा किया गया था , जिसके अधिक जटिल उदाहरण हैं
रे तोल

2
यह स्पष्ट किया जा सकता है कि आप चाहते हैं ;{}वर्ण इकट्ठा अगर वे अलग पंक्ति में रहे हैं (यह उदाहरण से ही स्पष्ट है, नियम नहीं है, और वास्तव में अगर एक लाइन के होते हैं में \t}मतलब होगा खरोज संरक्षण नहीं चलती }अंत तक पिछली पंक्ति में)
क्रिस एच

2
अच्छा भगवान, कृपया मुझे बताएं कि कोई भी वास्तव में जावा जैसी क्रियात्मक भाषा के लिए ऐसा नहीं करता है ।_।
मैजिक ऑक्टोपस Urn

जवाबों:


5

वी + बैश उपयोगिताओं, 64 62 61 60 62 बाइट्स

1 बाइट पूर्व कमांड को एक साथ रखने के लिए @DJMcMayhem के लिए धन्यवाद सहेजा गया

:se ve=all|%!wc -L
y$uò/^ *<93>[{};]
xk$pòò/<84> {};][{};]«$
lDî^R0|p

^Rके लिए चरित्र शाब्दिक है <C-r>( 0x12) और <84>है 0x84और <94>है 0x94

wc -Lअधिकांश * निक्स आधारित प्रणालियों पर काम करता है, लेकिन macOS पर नहीं। MacOS के लिए, आपको gwc -L पहले से ही नहीं, तो काढ़ा का उपयोग करके कोरुटिल प्राप्त करने के बाद करना होगा ।

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

इसे ऑनलाइन आज़माएं! (अजगर)

इसे ऑनलाइन आज़माएं! (जावा फिर से)

यह सभी रिक्त लाइनों को संरक्षित करता है और केवल रिक्त स्थान टैब को हैंडल नहीं करता है।

Hexdump:

00000000: 3a73 6520 7665 3d61 6c6c 7c25 2177 6320  :se ve=all|%!wc 
00000010: 2d4c 0a79 2475 f22f 5e20 2a93 5b7b 7d3b  -L.y$u./^ *.[{};
00000020: 5d0a 786b 2470 f2f2 2f84 207b 7d3b 5d5b  ].xk$p../. {};][
00000030: 7b7d 3b5d ab24 0a6c 44ee 1230 7c70       {};].$.lD..0|p

व्याख्या

पहले हमें बफर में कहीं भी कर्सर ले जाने में सक्षम होना चाहिए, इसलिए हम उपयोग करते हैं

:se ve=all|...

और हम एक और पूर्व कमांड का उपयोग करके इसे चेन करते हैं |

हमें इनपुट में सबसे लंबी लाइन की लंबाई प्राप्त करने की आवश्यकता है। यह शेल कमांड के साथ किया जा सकता है wc -L

       ...|%!wc -L

यह परिणाम के साथ वर्तमान बफर (इनपुट युक्त) को अधिलेखित करता है wc -L। यह कुछ का आउटपुट देता है जैसे:

            42

और कर्सर पर भूमि 4में 42। फिर हम इस संख्या को कॉपी करके उपयोग करते हैं y$: कर्सर की स्थिति से लाइन के अंत तक यैंक टेक्स्ट। यह आसानी से रजिस्टर में इस संख्या को संग्रहीत करता है 0। लेकिन उस पर बाद में। इनपुट को इस संख्या से बदल दिया जाता है, इसलिए वापस लौटने के लिए, हम uनादो।

अब कहते हैं इनपुट कुछ इस तरह देखा गया:

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("Hello, World!");
    }
}

हमें बयान के }बाद ब्रेसरों को बफ़र के अंत से स्थानांतरित करने की आवश्यकता है println

ò                  " recursively do this until a breaking error:
 /^ *<93>[{};]     "   this compressed regex becomes /^ *\zs[{};]
                   "   this finds any character from `{};` after leading spaces
                   "   the cursor then goes to the `{};`

x                  "   delete character
 k$                "   go to the end of the line above
   p               "   and paste
    ò

यदि रेगेक्स नहीं मिल सकता है, तो एक ब्रेकिंग त्रुटि होती है और इसके कारण होने वाली पुनरावृत्ति से बाहर निकलता है ò

अब इस कार्यक्रम का मुख्य भाग आता है, सभी ब्रेसिज़ और सेमी-कॉलोन को स्थानांतरित करें और उन्हें संरेखित करें जैसा कि प्रश्न में कहा गया है।

ò                  " starts recursion
 /<84> {};][{};]«$ "   compressed form of [^ {};][{};]\+$
                   "   finds a sequence of `{};`s at the end of the line with a non-`{};` char to preceding it
 l                 "   move the cursor 1 to the right (since we were on the non-`{};` char now)
  D                "   delete everything from this position to the end of line
                   "   the deleted text contains `{};`
   î               "   execute as normal commands:
    ^R0            "   contains what's in register `0`, ie the length of the longest line
       |           "   now go to the column specified by that number
        p          "   and paste the contents 
                   " implicit ending `ò`

फिर, इस पुनरावृत्ति को एक ब्रेकिंग त्रुटि के कारण रोका जाएगा जब रेगेक्स बफर में नहीं मिल सकता है।

संपादित करता

  • के Dबजाय प्रयोग किया जाता है d$(मुझे यह भी नहीं पता कि मैं पहले स्थान पर क्यों चूक गया)
  • संपीड़ित [^(रेगेक्स में)<84>
  • का उपयोग करके बग को ठीक किया \zs(इसे में संपीड़ित करने <93>) और हटाने के द्वारा $में$xk$pò
  • बेकार की न्यूलाइन को हटा दिया
  • नए नियमों के साथ प्रस्तुत करने के लिए regex को बदला और 2 बाइट्स प्राप्त किए

यदि आपको अपने पूर्व आदेशों एक साथ शामिल एक बाइट को बचा सकता है:se ve=all|%!wc -L
DJMcMayhem

@DJMcMayhem धन्यवाद, टीआईएल
क्रिस्सी लिथोस

4

रूबी, 100 114 108 बाइट्स

कमांड लाइन तर्क के रूप में फ़ाइल नाम पढ़ता है। यदि कोई फ़ाइल नाम नहीं दिया गया है, तो यह STDIN से पढ़ेगा। टैब को हैंडल नहीं करता है।

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

f=$<.read.gsub(/[\s;{}]*$/){$&.tr"
 ",''}
$><<f.gsub(/(.*?)([;{}]+)$/){$1.ljust(f.lines.map(&:size).max)+$2}




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

क्या यह टैब है? मैंने सिर्फ एक खोज की और उस पर प्रतिस्थापित किया, और इसने 0 परिवर्तन किए।
पावेल

3

पर्ल , 90 बाइट्स

कोड + -p0झंडे के 88 बाइट्स ।

\@a[y///c]for/.*/g;s/(.*?)\K[{};]$/$"x(@a-$1=~y%%%c).$&/gme;1while s/ *
 *([{};]+)$/$1/m

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

लघु स्पष्टीकरण:
\@a[y///c]for/.*/g; सबसे लंबी रेखा की लंबाई को गिनता है: प्रत्येक पंक्ति के लिए, यह तत्व y///cको सरणी के सूचकांक (अर्थात लाइन के आकार) में परिभाषित करता है @a। सबसे अंत में, @a(यानी का आकार @a) का अधिकतम सूचकांक सबसे लंबी रेखा का आकार है। लाइनों के अंत में वर्ण
s/(.*?)\K[{};]$/$"x(@a-$1=~y%%%c).$&/gmeरखता है {};
1while s/ *\n *([{};]+)$/$1/mबनाता है खाली लाइनों पर ब्रेसिज़ ऊपर की रेखा पर चलते हैं।

धन्यवाद करने के लिए @primo जिसे मैं आंशिक रूप से से मेरी कोड की शुरुआत "चुरा लिया है" यहाँ सबसे लंबे समय तक लाइन की लंबाई गिनती करने के लिए।


ब्रेसिज़ को ऊपर की रेखा पर वापस जाना होगा यदि उनके सामने केवल
व्हाट्सएप है

@KritiiLithos वास्तव में, चुनौती के पुन: प्रकाशित होने से पहले यह ठीक लग रहा था (मैंने जो भी चुनौतियों और टिप्पणियों दोनों से समझा था)। वैसे भी, यह अब तय हो गया है (मेरे पास पहले से ही मेरे जवाब में लिखा कोड था जिसे आपने नोटिस नहीं किया था)।
दादा

1

पायथन 2: 228 बाइट्स

import re
g=re.search
def b(a):
    s,l="",a.split('\n')
    r=max([len(k)for k in l]) 
    for k in l:
        n,m=g('[;}{]',k),g('[\w]',k)
        if n:n=n.start()
        if m:m=m.start()
        if n>m and m!=None:s+="\n"+k[:n]+" "*(r-n)
        s+=k[n:]
    print s

भयंकर रूप से लंबा। मुझे शायद खरोंच से शुरू करना चाहिए था जब मुझे एहसास हुआ ;{}कि पिछली लाइनों के अंत में जाने के लिए अकेला होना आवश्यक है।
क्रिस एच।

1

स्टैक , 133 बाइट्स

'\s+([;{}])' '$1'repl lines{!n'[\s;{}]+$'match''join:n\'$'+del\,}"!tr:$size"!$MAXmap@k{e i:e[' 'k i#rpad]"!}map tr[' 'join]map'
'join

इसे ऑनलाइन आज़माएं! मैं इस पर भारी पड़ सकता है ... लेकिन क्या। मैं कल फिर से इसे देखूंगा। कुछ अच्छे सुझाव:

  1. "!अक्सर mapएक बाइट या दो को बचाने के स्थान पर उपयोग किया जा सकता है , इस पर निर्भर करता है कि अगला टोकन एक शब्द से शुरू होता है। हालाँकि, इसका उपयोग केवल तब किया जा सकता है जब सरणी के प्रत्येक परमाणु को मैप करना हो। यह एक गहरे मानचित्र के समान है।
  2. किसी उद्धृत फ़ंक्शन के बाद एक स्थान की आवश्यकता नहीं है, इसलिए $MAXmapइसके बराबर है $MAX map, जो बदले में इसके बराबर है [MAX] map। (प्रत्येक सरणी को उसके अधिकतम तत्व के लिए मैप करता है।)

1

जावास्क्रिप्ट (ईएस प्रस्ताव), 139 121 बाइट्स

f=
s=>s.replace(/^(.*?)\s*(([;{}]\s*)+)$/gm,(_,t,u)=>t.padEnd(Math.max(...s.split`
`.map(s=>s.length)))+u.replace(/\s/g,``))
<textarea rows=10 cols=40 oninput=o.textContent=f(this.value)></textarea><pre id=o>

फ़ायरफ़ॉक्स 48 / क्रोम 57 / ओपेरा 44 / सफारी 10 / एज 15 की आवश्यकता है padEnd। संपादित करें: @ValueInk के लिए धन्यवाद 18 बाइट्स सहेजे गए।


क्या आपको वास्तव s.replace(r,`$1`)में लाइन की लंबाई की गणना करते समय चलाने की आवश्यकता है ? उचित राइट-पेडिंग की कोई भी मात्रा पर्याप्त होनी चाहिए, इसलिए अर्धविराम और कोष्ठक के साथ लाइन की लंबाई ठीक होनी चाहिए।
मूल्य इंक

0

PHP, 201 194 185 172 167 बाइट्स

foreach($f=file(f)as$s)$x=max($x,strlen($a[]=rtrim($s,"{} ;
")));foreach($a as$i=>$c)echo str_pad($c,""<$c|!$i?$x:0),trim(substr($f[$i],strlen($c))),"
"[""==$a[$i+1]];

फ़ाइल f से इनपुट लेता है; सिंगल बाइट लाइनब्रीक्स और कोई टैब नहीं मानता है; रिक्त लाइनों को संरक्षित करता है।

  • व्हाट्सएप को परिसीमन के लिए +2 बाइट्स: +1दूसरे str_padपैरामीटर पर जोड़ें ।
  • -6 बाइट्स अगर यह गारंटी थी कि कोई कोड लाइन एक एकल नहीं है 0:
    निकालें ""<और ""==साथ बदलें !

टूट - फूट

foreach($f=file(f)as$s)             // loop through file
    $x=max($x,strlen(                   // 3. set $x to maximum code length
        $a[]=                           // 2. append to array $a
            rtrim($s,"{} ;\n")          // 1. strip trailing whitespace and braces
    ));
foreach($a as$i=>$c)echo            // loop through $a
    str_pad($c,                         // 1. print code:
        !$i|""<$c                       // if first line or not empty
        ?$x                             // then padded to length $x
        :0                              // else unpadded (= print nothing)
    ),
    trim(substr($f[$i],strlen($c))),    // 2. print braces
    "\n"[""==$a[$i+1]]                  // 3. if next line has code, print newline
;

क्या आप वाकई {}रेगेक्स में ब्रेसिज़ से बचने की ज़रूरत हैं ?
क्रिति लिथोस

@ कृतिलीथोस शायद नहीं; लेकिन मुझे वैसे भी एक छोटा दृष्टिकोण मिला।
टाइटस

0

जावा 8, 312 305 बाइट्स

s->{String t="([;{}]+)",z[],r="",a;s=s.replaceAll(t+"[\\s\\n]*","$1").replaceAll(t,"$1\n");int m=0,l;for(String q:s.split("\n"))m=m>(l=q.length())?m:l;for(String q:s.split("\n")){z=q.split("((?<="+t+")|(?="+t+"))",2);for(a="",l=0;l++<m-z[0].length();a+=" ");r+=z[0]+a+(z.length>1?z[1]:"")+"\n";}return r;}

स्पष्टीकरण:

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

s->{                                  // Method with String parameter and String return-type
  String t="([;{}]+)",                //  Temp regex-String we use multiple times
    z[],a,                            //  Temp String-array and temp String
    r="";                             //  Result-String
  s=s.replaceAll(t+"[\\s\\n]*","$1")  //  We replace all ;{} in the input with zero or more whitespaces/newlines to just ;{}
     .replaceAll(t,"$1\n");           //  and then add a single newline after each group of ;{}
  int m=0,l;                          //  Two temp integers
  for(String q:s.split("\n"))         //  Loop (1) over the lines
    m=m>(l=q.length())?m:l;           //   To determine the longest line
                                      //  End of loop (1)
  for(String q:s.split("\n")){        //  Loop (2) over the lines again
    z=q.split("((?<="+t+")|(?="+t+"))",2);
                                      //   Split on groups of ;{}, but keep them in the array
    for(a="",l=0;l++<m-z[0].length();a+=" "); 
                                      //   Amount of spaces we should add
    r+=z[0]+a+(z.length>1?z[1]:"")+"\n"; 
                                      //   Append this line to the result-String
  }                                   //  End of loop (2)
  return r;                           //  Return the result-String
}                                     // End of method

अरे, मैं इस जवाब पर टिप्पणी कर रहा हूं, लेकिन यह आपके कई अन्य लोगों पर लागू होता है। वर्तमान में हमें जावा में टाइप करने के लिए लैम्बडा पैरामीटर की आवश्यकता है
नाथन मेरिल

1
@NathanMerrill डर था कि फैसले का दिन आएगा। जे, अब से इसे जोड़ देगा और मैंने अपना जवाब संपादित किया है, धन्यवाद। ;)
केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.