मैंने सुना है कि यदि आप इसे रिवर्स में इंडेंट करते हैं तो आपका कोड तेजी से चल सकता है, ताकि कंपाइलर इसे "शाखाओं" के बहुत ऊपर से ट्री डिजाइन पैटर्न की तरह प्रोसेस कर सके। यह मदद करता है क्योंकि गुरुत्वाकर्षण आपके कोड को संकलित करने में लगने वाले समय को गति देगा, और डेटा संरचना दक्षता में सुधार होता है। यहाँ एक उदाहरण है, जावा स्क्रिप्टिंग में:

            function fib(n) {
        var a = 1, b = 1;
        while (--n > 0) {
    var tmp = a;
    a = b;
    b += tmp;
    if (a === Infinity) {
return "Error!";
    }
        }
        return a;
            }

लेकिन किसी कारणवश नोटपैड के पास स्वचालित रूप से ऐसा करने के लिए कोई सेटिंग नहीं है, इसलिए मुझे इसे करने के लिए एक कार्यक्रम की आवश्यकता है।

विवरण

सबमिशन को इनपुट के रूप में एक कोड स्निपेट लेना होगा, इंडेंटेशन को उल्टा करना होगा और परिणामी कोड को आउटपुट करना होगा।

यह निम्नलिखित प्रक्रिया द्वारा किया जाता है:

कोड को लाइनों में विभाजित करें। प्रत्येक पंक्ति शून्य या अधिक रिक्त स्थान के साथ शुरू होगी (कोई टैब नहीं होगा)।
कोड में सभी अद्वितीय इंडेंटेशन स्तर का पता लगाएं। उदाहरण के लिए, उपरोक्त उदाहरण के लिए, यह होगा
```
0
4
8
12
```
इंडेंटेशन स्तरों की इस सूची के क्रम को उल्टा करें, और उलटी सूची को मूल सूची में मैप करें। यह शब्दों में व्याख्या करना कठिन है, लेकिन उदाहरण के लिए, यह ऐसा लगेगा
```
0  — 12
4  — 8
8  — 4
12 — 0
```
इस मैपिंग को मूल कोड पर लागू करें। उदाहरण में, 0-स्पेस-इंडेंटेशन वाली एक पंक्ति 12 स्थानों से इंडेंट हो जाएगी, 4 स्पेस 8 स्पेस बन जाएंगे, आदि।

इनपुट आउटपुट

इनपुट और आउटपुट तब भी प्रदान किया जा सकता है जब आप चाहें (STDIN / STDOUT, फ़ंक्शन पैरामीटर / रिटर्न वैल्यू, आदि); यदि आपकी भाषा मल्टीलाइन इनपुट का समर्थन नहीं करती है (या आप बस नहीं करना चाहते हैं), तो आप |इसके बजाय लाइनों को अलग करने के लिए चरित्र का उपयोग कर सकते हैं ।

इनपुट में केवल मुद्रण योग्य ASCII + newlines शामिल होंगे, और इसमें खाली लाइनें नहीं होंगी।

परीक्षण के मामलों

इनपुट:

function fib(n) {
    var a = 1, b = 1;
        while (--n > 0) {
            var tmp = a;
            a = b;
            b += tmp;
            if (a === Infinity) {
                return "Error!";
            }
        }
    return a;
}

आउटपुट: ऊपर उदाहरण कोड।

इनपुट:

a
  b
  c
d
   e
        f
  g
   h

आउटपुट:

इनपुट:

आउटपुट:

इनपुट:

foo

आउटपुट:

foo

code-golf string whitespace

— Doorknob
स्रोत

21

इसका "जावास्क्रिप्ट" नहीं "जावा स्क्रिप्टिंग": /

— ऑप्टिमाइज़र

75

@ ऑप्टिमाइज़र मैं देखता हूं कि पहले दो पैराग्राफ के साथ अधिक से अधिक लोगों को संक्रमित करने का मेरा लक्ष्य हासिल किया गया है। ;)

— दरवाज़े

7

1! = अधिक से अधिक लोग।

— ऑप्टिमाइज़र

23

@JDDvorak वही लोग जिन्होंने एमएलए शैली के उद्धरणों का आविष्कार किया, उन्हें लगता है कि यह एक अच्छा विचार है।

— रेनबोल्ट

6

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

— कॉनर ओ'ब्रायन

10

CJam, 43 39 36 35 बाइट्स

qN/_{_Sm0=#}%___&$_W%er]z{~S*@+>N}%

~~यह बहुत लंबा दिखता है। मुझे यकीन है कि मैं पर्याप्त अनुकूलन नहीं कर रहा हूँ !~~

यह काम किस प्रकार करता है:

मूल विचार नई लाइन पर इनपुट को विभाजित करना है, प्रत्येक पंक्ति में प्रमुख स्थानों की संख्या की गणना करें, सॉर्ट करें और अद्वितीय नंबर प्राप्त करें, उस सरणी को कॉपी करें और कॉपी को उल्टा करें, इस दो सरणियों के साथ मूल-क्रम संख्याओं का अनुवाद करें और फिर अंत में फॉर्म बनाएं। अंतिम स्ट्रिंग इस जानकारी का उपयोग करते हुए।

सबसे लंबा हिस्सा यह पता लगाना है कि प्रत्येक पंक्ति में कितने प्रमुख स्थान हैं क्योंकि सीजेएम के पास इसे करने का एक आसान तरीका नहीं है।

कोड विस्तार:

qN/_                                      "Split the string on newline and take copy";
    {_Sm0=#}%                             "Map this code block on the copy";
     _Sm                                  "Copy the string and remove spaces from the copy";
        0=                                "Get first non space character";
          #                               "Gets its index in original string";
             ___                          "Get 3 copies of the above array";
                &$_W%                     "Get unique elements, sort, copy and reverse";
                     er                   "Transliterate unique sorted elements with";
                                          "the unique reverse sorted in the copy";
                       ]z                 "Get array of [row,
                                          " original number of leading spaces,
                                          " required number of leading spaces]";
                         {~S*@+>N}%       "For each above combination";
                          ~S*             " unwrap and get leading space string";
                             @+           " prepend to the row";
                               >          " remove original spaces";
                                N         " put newline";

और प्रश्न की भावना में। कोड का वास्तविक विस्तार:

                                          qN/_                                      "Split the string on newline and take copy";
                                {_Sm0=#}%                             "Map this code block on the copy";
                               _Sm                                  "Copy the string and remove spaces from the copy";
                             0=                                "Get first non space character";
                          #                               "Gets its index in original string";
                         ___                          "Get 3 copies of the above array";
                       &$_W%                     "Get unique elements, sort, copy and reverse";
                     er                   "Transliterate unique sorted elements with";
"the unique reverse sorted in the copy";
                ]z                 "Get array of [row,
" original number of leading spaces,
" required number of leading spaces]";
             {~S*@+>N}%       "For each above combination";
          ~S*             " unwrap and get leading space string";
        @+           " prepend to the row";
     >          " remove original spaces";
    N         " put newline";

7 बाइट्स ने मार्टिन को धन्यवाद दिया और डेनिस को 1 बाइट दिया

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

— अनुकूलक
स्रोत

1. {}#एक बग है: यह एक पूर्णांक लौटाता है, लेकिन इसे एक लौटना चाहिए। विडंबना यह है कि, i(पूर्णांक तक कास्ट) इसे ठीक करता है। 2. चूंकि ""#एक ही बग नहीं है, _Sm0=#एक बाइट कम है।

— डेनिस

@ डेनिस हाँ, बग अजीब है। वर्कअराउंड के लिए धन्यवाद!

— ऑप्टिमाइज़र

2

विस्तार में यह इंडेंटेशन पढ़ना इतना आसान है! आपको इसका उल्टा करना चाहिए!

— DLEh

13

पायथन 2 - 137 131 बाइट्स

i=raw_input().split('|')
f=lambda s:len(s)-len(s.lstrip())
d=sorted(set(map(f,i)))
for l in i:print' '*d[~d.index(f(l))]+l.lstrip()

के |बजाय के साथ इनपुट लेता है \n।

व्याख्या

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

अंतिम पंक्ति रास्ता अधिक मजेदार है।

                                 l               # string with the line
                               f(l)              # amount of leading whitespace
                       d.index(f(l))             # where it is in list of whitespace amounts
                      ~d.index(f(l))             # bitwise NOT (~n == -(n+1))
                    d[~d.index(f(l))]            # index into the list (negative = from end)
           print' '*d[~d.index(f(l))]            # print that many spaces...
           print' '*d[~d.index(f(l))]+l.lstrip() # plus everything after leading whitespace
for l in i:print' '*d[~d.index(f(l))]+l.lstrip() # do the above for every line

— undergroundmonorail
स्रोत

पुष्टि 137 :)

— FryAmTheEggman

@ फ्राई धन्यवाद :)

— भूमिगत १२

1

यह सब अजगर 3 में ठीक लगता है, जिससे आपको 2 बाइट्स ()raw_

— बचानी

1

f(s)for s in iहोना चाहिए map(f,i)।

— feersum

1

जादू का एक टुकड़ा: d=[];d+=set(L)का एक छोटा संस्करण है d=sorted(set(L))।

— xnor

7

जावास्क्रिप्ट, ईएस 6, 113 103 101 बाइट्स

मुझे पूरा यकीन है कि इसे कम से कम थोड़ा आगे बढ़ाया जा सकता है, लेकिन यहाँ जाता है।

कभी नहीं सोचा होगा कि अजगर को पीटते हुए 101 बाइट जेएस समाधान होगा!

f=a=>(b=c=[...Set(a.match(r=/^ */gm).sort())],c.map((x,i)=>b[x]=c.slice(~i)[0]),a.replace(r,x=>b[x]))

यह एक विधि बनाता fहै जिसे इनपुट स्ट्रिंग के साथ बुलाया जा सकता है। यदि आप एक नवीनतम फ़ायरफ़ॉक्स में हैं, तो आपके पास टेम्पलेट स्ट्रिंग्स हैं और आप इस तरह की विधि को कॉल कर सकते हैं

f(`a
  b
  c
d
   e
        f
  g
   h`)

अन्यथा, आप इसे कॉल भी कर सकते हैं

f("a\n\
  b\n\
  c\n\
d\n\
   e\n\
        f\n\
  g\n\
   h")

या, नीचे स्निपेट आज़माएं:

g=_=>O.textContent=f(D.value)

f=a=>(b=c=[...Set(a.match(r=/^ */gm).sort())],c.map((x,i)=>b[x]=c.slice(~i)[0]),a.replace(r,x=>b[x]))

<textarea id=D></textarea><button id=B onclick=g()>Inverse!</button>
<pre id=O></pre>

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

— अनुकूलक
स्रोत

आप रेगेक्स को एक चर के रूप में संग्रहीत करके एक कूप बाइट्स को बचा सकते हैं, क्योंकि यह दो बार उपयोग किया जाता है (आपको \sएक अंतरिक्ष चरित्र के साथ बदलने में सक्षम होना चाहिए ), और xप्रतिस्थापित फ़ंक्शन में कोष्ठक को हटा दें ।

— NinjaBearMonkey

@ जीएसएल जी, धन्यवाद! मुझे यह भी नहीं पता कि मैंने क्यों लिखा (x): /

— ऑप्टिमाइज़र

आप दोनों की जरूरत नहीं है bऔर cआप करते हैं? वे वैसे भी उसी सरणी को संदर्भित करते हैं।

— नील

5

रूबी, 63 बाइट्स

->s{l=s.scan(r=/^ */).uniq.sort;s.gsub r,l.zip(l.reverse).to_h}

यह एक अनाम फ़ंक्शन को परिभाषित करता है जो एक स्ट्रिंग लेता है और वापस करता है। आप इसे जोड़कर ["string here"]या किसी चर को निर्दिष्ट करके, और फिर उस चर को कॉल करके कह सकते हैं।

यह कैसे काम करता है: बाद में उपयोग के लिए s.scan(r=/^ */)regex कि सभी प्रमुख रिक्त स्थान और स्टोर की एक सूची देता है r। uniqडुप्लिकेट को समाप्त करता है। sort... तरह।

अब अंत तक छोड़ें, l.zip(l.reverse)एक जोड़ी जोड़े देता है जिसे हम स्थानापन्न करना चाहते हैं। to_hयह हैश में बदल जाता है, जोड़े को कुंजी-मूल्य जोड़े के रूप में व्याख्या करता है।

अब s.gsubरिप्लेक्स के सभी मैचों (सभी प्रमुख स्थानों) को प्रतिस्थापित करने के लिए लुक अप टेबल के रूप में उस हैश का उपयोग करके बदल दिया गया है।

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

3

अजगर 39

L-/bd/rb6dJcz\|KS{mydJFNJ+*d@_KxKyN>NyN

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

|सीमांकक विकल्प का उपयोग करता है ।

— FryAmTheEggman
स्रोत

2

जाप `-R` , 27 बाइट्स

·
mâ\S
Vâ n
Ëx2 iSpWg~WbVgE

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

अनपैक्ड और यह कैसे काम करता है

Input: U = multiline string

qR    Split by newline and implicit assign to U

mâ\S
m     Map over U...
 â\S    .search(/\S/); first index of non-whitespace char
      Implicit assign to V (V = array of indentations)

Vâ n  Take unique elements of V, sort, and implicit assign to W

mDEF{Dx2 iSpWg~WbVgE
mDEF{                 Map over U...
     Dx2                Trim left
         iSp            Indent by this many spaces...
                 VgE      Find the current indentation stored in V
               Wb         Find its index on W
            Wg~           Take the opposite element on W

-R    Join with newline

यह वास्तव में कैसे काम करता है

                 Input: U = multiline string

                 qR    Split by newline and implicit assign to U

                 mâ\S
                 m     Map over U...
               â\S    .search(/\S/); first index of non-whitespace char
         Implicit assign to V (V = array of indentations)

                 Vâ n  Take unique elements of V, sort, and implicit assign to W

                 mDEF{Dx2 iSpWg~WbVgE
                 mDEF{                 Map over U...
            Dx2                Trim left
      iSp            Indent by this many spaces...
VgE      Find the current indentation stored in V
 Wb         Find its index on W
     Wg~           Take the opposite element on W

                 -R    Join with newline

— bubbler
स्रोत

1

स्काला, 176 171

def g(n:String)={val a=n.split('|').map(a=>a.prefixLength(' '==)->a)
(""/:a){case(s,(l,p))=>val b=a.unzip._1.distinct.sorted
s+" "*b.reverse(b.indexOf(l))+p.drop(l)+'\n'}}

यह अंत में एक अतिरिक्त न्यूलाइन जोड़ देगा। यदि मुझे पंक्ति के अंत में रिक्त स्थान को संरक्षित करने की आवश्यकता नहीं है, तो मैं इसे 167 पर प्राप्त कर सकता हूं:

def t(n:String)={val a=n.split('|').map(a=>a.prefixLength(' '==)->a.trim)
(""/:a){(s,l)=>val b=a.unzip._1.distinct.sorted
s+" "*b.reverse(b.indexOf(l._1))+l._2+'\n'}}

Ungolfed:

      def reverseIndent(inString: String): String = {
    val lines = inString.split('\n')
    val linesByPrefixLength = lines.map { line =>
  line.prefixLength(char => char == ' ') -> line
    }
    val distinctSortedPrefixLengths = linesByPrefixLength.map(_._1).distinct.sorted
    val reversedPrefixes = distinctSortedPrefixLengths.reverse
    linesByPrefixLength.foldLeft("") { case (string, (prefixLength, line)) =>
  val newPrefixLength = reversedPrefixes(distinctSortedPrefixLengths.indexOf(prefixLength))
  val nextLinePrefix = " " * newPrefixLength
  string + nextLinePrefix + line.substring(prefixLength) + '\n'
    }
      }

— चाड Retz
स्रोत

1

पॉवरशेल , 112 बाइट्स

$x=@($args|sls '(?m)^ *'-a|% m*|% v*|sort -u)
[regex]::Replace($args,'(?m)^ *',{$x[-1-$x.IndexOf($args.Value)]})

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

कम गोल्फ वाला:

$xIdents=@($args|select-string '(?m)^ *'-AllMatches|% matches|% value|sort -unique) # get a sorted set of indentations
[regex]::Replace($args,'(?m)^ *',{$xIdents[-1-$xIdents.IndexOf($args.Value)]})    # replace each indentation with opposite one

— Mazzy
स्रोत

0

हास्केल, ११६

import Data.List
f s|l<-map(span(==' '))$lines s=unlines[k++b|(a,b)<-l,(k,r)<-reverse>>=zip$sort$nub$map fst l,r==a]

— गर्वित हेकलर
स्रोत

0

PHP - 173 बाइट्स

अकल्पित कोड को $vचर में संग्रहित किया जाना चाहिए :

<?php $f='preg_replace';$f($p='#^ *#me','$i[]='.$s='strlen("$0")',$v);$a=$b=array_unique($i);sort($a);rsort($b);echo$f($p,'str_repeat(" ",array_combine($a,$b)['.$s.'])',$v);

यहाँ ungolfed और टिप्पणी संस्करण है:

<?php
// Get the level of indentation for each line
$preg_replace = 'preg_replace';
$pattern = '#^ *#me';
$strlen = 'strlen("$0")';
$preg_replace($pattern, '$indentationLevelsOldList[] = '. $strlen, $value);

// Create an array associating the old level of indentation with the new expected one
$sortedArray = array_unique($indentationLevelsOldList);
$reverseSortedArray = $sortedArray;

sort($sortedArray);
rsort($reverseSortedArray);

$indentationLevelsNewList = array_combine($sortedArray, $reverseSortedArray);

// Print the correctly indented code
echo $preg_replace($pattern, 'str_repeat(" ", $indentationLevelsNewList['. $strlen .'])', $value);

मैंने शायद कभी इतना गंदा कुछ नहीं लिखा है। मैं शर्मिंदा हूँ।

— ब्लैक होल
स्रोत

0

जावास्क्रिप्ट, 351

var i=0;var a=$("#i").html().split("\n");var b=[];for(;i<a.length;i++){j=a[i].match(/\s*/)[0];if(b.indexOf(j)<0){b.push(j);}}b.sort(function(a,b){return a - b;});var c=b.slice().reverse();var d="";for(i=0;i<a.length;i++){d+=a[i].replace(/\s*/,c[b.indexOf(a[i].match(/\s*/)[0])])+"\n";j=a[i].search(/\S/);if(b.indexOf(j)<0){b.push(j);}}$("#i").html(d);

Ungolfed संस्करण:

var i = 0;
var a = $("#i").html().split("\n");
var b = [];
for (; i < a.length; i++) {
  j = a[i].match(/\s*/)[0];
  if (b.indexOf(j) < 0) {
    b.push(j);
  }
}
b.sort(function(a, b) {
  return a - b;
});
var c = b.slice().reverse();
var d = "";
for (i = 0; i < a.length; i++) {
  d += a[i].replace(/\s*/, c[b.indexOf(a[i].match(/\s*/)[0])]) + "\n";
  j = a[i].search(/\S/);
  if (b.indexOf(j) < 0) {
    b.push(j);
  }
}
$("#i").html(d);

परिक्षण

कोड स्निपेट दिखाएं

var i=0;var a=$("#i").html().split("\n");var b=[];for(;i<a.length;i++){j=a[i].match(/\s*/)[0];if(b.indexOf(j)<0){b.push(j);}}b.sort(function(a,b){return a - b;});var c=b.slice().reverse();var d="";for(i=0;i<a.length;i++){d+=a[i].replace(/\s*/,c[b.indexOf(a[i].match(/\s*/)[0])])+"\n";j=a[i].search(/\S/);if(b.indexOf(j)<0){b.push(j);}}$("#i").html(d);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<pre><code id="i">
function fib(n) {
    var a = 1, b = 1;
        while (--n > 0) {
            var tmp = a;
            a = b;
            b += tmp;
            if (a === Infinity) {
                return "Error!";
            }
        }
    return a;
}
</code></pre>

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

कोड स्निपेट दिखाएं

var i=0;var a=$("#i").html().split("\n");var b=[];for(;i<a.length;i++){j=a[i].match(/\s*/)[0];if(b.indexOf(j)<0){b.push(j);}}b.sort(function(a,b){return a - b;});var c=b.slice().reverse();var d="";for(i=0;i<a.length;i++){d+=a[i].replace(/\s*/,c[b.indexOf(a[i].match(/\s*/)[0])])+"\n";j=a[i].search(/\S/);if(b.indexOf(j)<0){b.push(j);}}$("#i").html(d);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<pre><code id="i">
a
  b
  c
d
   e
        f
  g
   h
</code></pre>

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

कोड स्निपेट दिखाएं

var i=0;var a=$("#i").html().split("\n");var b=[];for(;i<a.length;i++){j=a[i].match(/\s*/)[0];if(b.indexOf(j)<0){b.push(j);}}b.sort(function(a,b){return a - b;});var c=b.slice().reverse();var d="";for(i=0;i<a.length;i++){d+=a[i].replace(/\s*/,c[b.indexOf(a[i].match(/\s*/)[0])])+"\n";j=a[i].search(/\S/);if(b.indexOf(j)<0){b.push(j);}}$("#i").html(d);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<pre><code id="i">
1
 2
  3
 2
1
</code></pre>

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

कोड स्निपेट दिखाएं

var i=0;var a=$("#i").html().split("\n");var b=[];for(;i<a.length;i++){j=a[i].match(/\s*/)[0];if(b.indexOf(j)<0){b.push(j);}}b.sort(function(a,b){return a - b;});var c=b.slice().reverse();var d="";for(i=0;i<a.length;i++){d+=a[i].replace(/\s*/,c[b.indexOf(a[i].match(/\s*/)[0])])+"\n";j=a[i].search(/\S/);if(b.indexOf(j)<0){b.push(j);}}$("#i").html(d);

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<pre><code id="i">
  foo
</code></pre>

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

— द हैट विथ द हैट
स्रोत

0

पर्ल 5, 112

111 + 1 के लिए -n( -Eनि: शुल्क है)

@{$.[$.]}=/( *)(.*)/;++$_{$1}}{map$_{$_[$#_-$_]}=$_[$_],0..(@_=sort keys%_);say$_{$.[$_][0]}.$.[$_][1]for 0..$.

मुझे यकीन है कि यह कम स्ट्रोक में किया जा सकता है, लेकिन मैं इस समय नहीं देखता हूं।

— msh210
स्रोत

रिवर्स इंडेंटेशन

विवरण

इनपुट आउटपुट

परीक्षण के मामलों

CJam, 43 39 36 35 बाइट्स

पायथन 2 - 137 131 बाइट्स

जावास्क्रिप्ट, ईएस 6, 113 103 101 बाइट्स

रूबी, 63 बाइट्स

अजगर 39

जाप -R , 27 बाइट्स

अनपैक्ड और यह कैसे काम करता है

यह वास्तव में कैसे काम करता है

स्काला, 176 171

पॉवरशेल , 112 बाइट्स

हास्केल, ११६

PHP - 173 बाइट्स

जावास्क्रिप्ट, 351

परिक्षण

पर्ल 5, 112

जाप `-R` , 27 बाइट्स