एक कोडब्लॉक टूल बनाएं

18

मार्क नेटवर्क का उपयोग करते समय, एसई नेटवर्क की तरह, पाठ की एक पंक्ति से पहले चार रिक्त स्थान का एक इंडेंटेशन इसे कोड ब्लॉक के हिस्से के रूप में दर्शाता है, जैसा कि मुझे आशा है कि आप जानते हैं। यदि आप नहीं करते हैं, तो यहां एक उदाहरण है ( .एक स्थान का प्रतिनिधित्व करने के साथ ):

.... कोड
.... अधिक कोड

का परिणाम

Code
More code

समस्या यह है कि जब आप एक उत्तर में कोड-पेस्ट करते हैं, तो आपको प्रत्येक पंक्ति को मैन्युअल रूप से इंडेंट करना होगा। जब यह पहले से ही इंडेंट हो तो भ्रम की स्थिति पैदा हो सकती है, क्योंकि यह अनलॉक्ड कोड के साथ काम करते समय विशेष रूप से मुश्किल है। आप बस अपना कोड चुन सकते हैं और हिट कर सकते हैं Ctrl + K, यह पता चला है। मेरे जीवन के कुछ घंटे बिना किसी कारण के बर्बाद हो गए ...

तो, आपका लक्ष्य एक इनपुट दिया गया है, इसे प्रत्येक पंक्ति से पहले चार स्थानों के साथ लौटाएं। समय कॉपी-पेस्टिंग को बचाने की भावना में, आपको पूरे इनपुट को एक स्ट्रिंग के रूप में संसाधित करना है (इसलिए जब तक आपकी भाषा पार्स कर सकती है)। यदि आपकी भाषा तार में किसी वर्ण (जैसे कि नई भूमिका) को संसाधित करने में असमर्थ है, तो आप यह मान सकते हैं कि भाषा द्वारा समर्थित किसी अन्य विधि के माध्यम से इसे निरूपित / छोड़ दिया गया है; हालांकि, आउटपुट को प्रत्येक लाइन को अपनी लाइन पर आउटपुट करना होगा (ताकि कोई पासिंग न हो ....foo\n....bar)।

मानक खामियों की अनुमति नहीं है। जैसा कि यह कोड-गोल्फ है , बाइट्स में सबसे कम जवाब जीतता है। सौभाग्य!

code-golf  string  whitespace 
— Papayaman1000
स्रोत
3
"आपको प्रत्येक पंक्ति को मैन्युअल रूप से इंडेंट करने की आवश्यकता है" (या टेक्स्ट का चयन करें और बटन पर क्लिक करें :))
— जोनाथन एलन
11
@JonathanAllan "बटन"? निश्चित रूप से आपका मतलब "कीबोर्ड शॉर्टकट" है। (Ctrl + K)
— मार्टिन एंडर
31
@ जोनाथनअलन ... मैं ... मैं बहुत परेशान हूं। बहुत अधिक समय। व्यर्थ।
— पापायमान 1000
6
हालांकि मुझे पूरा विश्वास है कि कृति के वी उत्तर को पीटा नहीं जाएगा, मैं आम तौर पर एक उत्तर को स्वीकार करने से पहले थोड़ी प्रतीक्षा करने की सलाह दूंगा, क्योंकि इतनी जल्दी स्वीकार करने से उन लोगों को नुकसान होता है, जो कम जवाब के साथ जवाब दे सकते थे, लेकिन नहीं थे समय पर साइट (टाइमज़ोन या हमेशा पीपीसीजी 24/7 पर नहीं)
— हायपरनीट्रीनो
2
+1 लोगों को सूचित करने के लिएCtrl + K
— कोइशोर रॉय

जवाबों:

17

वी , 4 बाइट्स

Î4É

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

(अनुगामी स्थान नोट करें)

V को लैटिन 1 में एन्कोड किया गया है, जहां यह एनकोडेड है जैसे:

00000000: ce34 c920                                .4.

व्याख्या

Î            " On every line
 4É<space>   " Prepend 4 spaces

यहाँ एक समाधान है जो UTF-8 में 4 बाइट्स भी है!

VG4>

VG          " Select everything
   >        " Indent
  4         " 4 times (with spaces)
— क्रिकटी लिथोस
स्रोत
2
आशा है कि किसी ने उस फोन को उठाया, क्योंकि वाह किसी ने फोन किया था।
— Papayaman1000
वैकल्पिक समाधान:4ñ>G
— DJMcMayhem
@DJMcMayhem लेकिन यह रिक्त स्थान के बजाय इंडेंट करने के लिए टैब का उपयोग करता है
— Kritii Lithos
विम में, हाँ। वी में, नहीं, यह 4 स्थानों है
— DJMcMayhem
@DJMcMayhem धन्यवाद, जिसने यूटीएफ -8 में केवल 4 बाइट्स के लिए एक और वैकल्पिक समाधान प्रेरित किया!
— कृतिका लिथोस
9

क्रेयॉन , 7 बाइट्स

`¤q;3xq

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

व्याख्या

क्रेयॉन एक स्टैक-आधारित भाषा है जिसे ASCII-art बनाने के लिए डिज़ाइन किया गया है। यह अभी भी विकास के शुरुआती चरण में है, लेकिन यह केवल कम बाइट की गिनती के साथ इस चुनौती को समाप्त करने के लिए पर्याप्त जानता है:

         Implicit: input string is on the stack
`¤       Push a non-breaking space to the stack.
  q;     Draw this at the cursor (0,0 by default) and pop it.
    3x   Move three more spaces to the right.
      q  Draw the input string here (at 4,0).
         Implicit: output the canvas, trimmed to a rectangle

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

— ETHproductions
स्रोत
क्या क्रेयॉन आपको इसके विपरीत करने देगा: स्ट्रिंग को आउटपुट करें, फिर चार स्थानों को बाईं ओर ले जाएं और एक आउटपुट दें? स्टैक हेरफेर में लागत कम होने की संभावना है, हालांकि मुझे नहीं पता कि क्या क्रेयॉन सही तरीके से कैनवास को सही स्थान पर ले जाएगा।
@ ais523 हम्म, यह वास्तव में एक अच्छा विचार है ... दुर्भाग्य से, इसे x = -4 में ले जाने की आवश्यकता होगी, जो इस समय एक आसान काम नहीं है। मुझे वास्तव में इन परिवर्तनों को धक्का देना चाहिए जो मैं एक महीने से काम कर रहा था ...: P
— ETHproductions
7

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

%`^

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

दूसरी पंक्ति में चार स्थान हैं। वैकल्पिक समाधान पहली पंक्ति पर या तो उपयोग करते हैं m`^या । ये सभी प्रत्येक पंक्ति की शुरुआत में स्थिति से मेल खाते हैं और इसे चार स्थानों से बदलते हैं।%1`1%`

— मार्टिन एंडर
स्रोत
मुझे संदेह था कि रेटिना का उत्तर पहले होगा।
— नील
खैर वो तेज था।
— Papayaman1000
@ नील मुझे आश्चर्य होगा अगर यह वी (या यहां तक ​​कि कच्चे विम) द्वारा पीटा नहीं जाता है। :)
— मार्टिन एंडर
1
@MartinEnder यहाँ फिर जाना (वी में 4 बाइट्स): codegolf.stackexchange.com/a/115870/41805 :)
— Kritixi lithos
7

चेडर, 31 बाइट्स

@.lines.map(("    ":+)).asLines

वास्तव में बस, लेकिन मैंने पोस्ट किया क्योंकि यह नए कार्यात्मक ऑपरेटरों को दिखाता है।

(" ":+)के रूप में ही है A -> " " + A। (यानी +एलएचएस के साथ एक फ़ंक्शन के रूप में ऑप " ")।

मुझे नहीं लगता कि स्पष्टीकरण की भी आवश्यकता है

— Downgoat
स्रोत
ओह, क्या आप बदलते हैं कि पार्सर कैसे काम करता है? मुझे जो याद है :उससे समस्याएं पैदा होंगी?:
— कॉनर ओ'ब्रायन
@ ConorO'Brien मैं यह भूल गया कि मैंने इसे कैसे तय किया है, लेकिन मेरा मानना ​​है कि क्योंकि :कोई मिलान नहीं है ?, तो पार्सर इसे एक कार्यात्मक ऑप के रूप में मानेंगे। इसके लिए अभी भी कार्यात्मक ऑप को
— पैरेंस
स्माइली के लिए +1:+)
— LarsW
क्या @मतलब है?
— लीक नून
6

पायथन ,  44  39 बाइट्स

पार किया & nbsp; 44 & nbsp; अब 44 नहीं है :)

-5 बाइट्स ओव्स के लिए धन्यवाद (प्रीपेन्ड के साथ डीक्यू से बचें)

lambda s:' '*4+s.replace('\n','\n    ')

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

— जोनाथन एलन
स्रोत
lambda s:' '*4+s.replace('\n','\n ')39 बाइट्स के लिए
— ovs
@ नोव्स - मैं इसे नहीं देखता ... क्या आपका मतलब lambda s:' '*4+s.replace('\n','\n ')[1:]40 (जो काम नहीं करता है) या कुछ और है?
— जोनाथन एलन
1
बस lambda s:' '*4+s.replace('\n','\n<4 spaces>') TIO
— ovs
@ हाँ, हाँ, निश्चित रूप से (टिप्पणी चार अंतरिक्ष markdown प्रतिपादन मुझे फेंक दिया और मैं इसे या तो मेरे जवाब में ध्यान नहीं दिया) बचत के लिए धन्यवाद!
— जोनाथन एलन
6

जावास्क्रिप्ट, 26 बाइट्स

धन्यवाद @Conor O'Brien 8 बाइट्स से गोल्फिंग के लिए

x=>x.replace(/^/gm,"    ")

सभी उदाहरणों को बदलकर / g के साथ regex के साथ बदलें। मीटर स्ट्रिंग की शुरुआत के लिए रेगेक्स को प्रत्येक पंक्ति को अलग से मानता है।

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

— fənɛtɪk
स्रोत
asdfबार-बार बार-बार इनपुट में गैर-व्हाट्सएप को जंप करना लगता है ।
— Papayaman1000
आपको ध्यान देना चाहिए कि मैंने TIO में इनपुट के रूप में क्या रखा था
— fəˈnɛtɪk
You can save a few bytes by doing x=>x.replace(/^|\n/g,"$&    ") to get the first line and the following lines all in one go
— ETHproductions
1
— कॉनर ओ'ब्रायन
1
या ^ काम करता है मुझे भी लगता है ;-)
— ETHproductions
4

पायथन 2, 87 45 बाइट्स

print' '*4+'\n    '.join(input().split('\n'))

इनपुट के रूप में लिया जाता है 'Line1\nLine2\nLine3...'(आवश्यक उद्धरण)

मुझे एक विचार देने के लिए @WheatWizard का धन्यवाद, जिसने मुझे गोल्फ में 42 बाइट करने में मदद की।

— HyperNeutrino
स्रोत
मैं अजगर पर बड़ा हुआ। यही कारण है कि मुझे लगता है कि यह कठिन की तरह होगा। RegEx की अनदेखी करते हुए भी, मैं बहुत गलत था , यह पता चला।
— Papayaman1000
@ Papayaman1000 यह एक काफी तुच्छ चुनौती है, दोनों के साथ और RegEx के बिना, हालांकि मुझे यह बहुत दिलचस्प लगता है।
— हाइपरनेत्रिनो
2
I will admit, since I didn't know about Ctrl + K, the real reasons for this challenge being proposed were... less than for just pure puzzling.
— Papayaman1000
@Papayaman1000 Haha, yes, it was quite annoying having to press space 4 times in front of each line. Especially since I usually use Python and so I have multiple lines all the time (it's not so bad when I used to use Java). Eventually I just got lazy and used my text editor to replace ^ with ` `.
— HyperNeutrino
1
@WheatWizard Thanks for the suggestion, I golfed it down a bit. Is it a bit better now?
— HyperNeutrino
4

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

Ỵṭ€⁶ẋ4¤Y

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

कैसे?

Ỵṭ€⁶ẋ4¤Y - Main link: string
Ỵ        - split on newlines
      ¤  - nilad followed by ink(s) as a nilad:
   ⁶     -     a space character
    ẋ4   -     repeated four times
 ṭ€      - tack for €ach
       Y - join with newlines

कुछ अन्य 8 बाइट वैरिएंट हैं:
Ỵṭ€⁶Yµ4¡(नई कहानियों पर विभाजन के 4 दोहराव, एकल स्थान से निपटना);
⁶ḤḤ;ЀỴY(दो बार दोगुना करना 4 से गुणा करने के समान है, Ѐसही तर्क पर नक्शे, इसलिए हम निपटने के बजाय संक्षिप्त कर सकते हैं);
और इसके अलावा अन्य व्यवस्थाएं।

— जोनाथन एलन
स्रोत
4

Emacs, 5 की-बोर्ड, 5 बाइट्स

C-x h M-4 C-x tab

कीबोर्ड प्रविष्टि के लिए कम से कम आमतौर पर उपयोग किए जाने वाले एन्कोडिंग में, इनमें से प्रत्येक की-बोर्ड एक एकल बाइट है: 18 68 b4 18 09 :। Emacs प्रविष्टियाँ बहुत कीचर्ड-हेवी होती हैं, क्योंकि प्रत्येक मुद्रण योग्य ASCII चरित्र मल्टी-कैरेक्टर कमांड के बाद के चरित्र को छोड़कर खुद के लिए खड़ा होता है (जिसका अर्थ है कि केवल कमांडर का उपयोग वास्तविक कमांड देने के लिए किया जा सकता है)।

मुझे यकीन नहीं है कि यह विम (वी के विपरीत) की तुलना कैसे करता है। लेकिन विम का आमतौर पर पीपीसीजी पर उपयोग किया जाता है, और इसलिए मैंने सोचा कि संपादक युद्धों का दूसरा पक्ष सुर्खियों में भी अपना समय चाहता है।

यह मानता है कि I / O बफर के माध्यम से किया जाता है (vim के लिए सामान्य I / O सम्मेलनों के बराबर), या स्क्रीन पर एक फ़ाइल और आउटपुट से लिया जाता है (जो एक ही बात आती है)। यदि आप इसके बजाय क्षेत्र के माध्यम से I / O करते हैं, जो कि कार्यक्रम के कुछ रूपों के लिए स्वाभाविक है, तो आप 3 बाइट्स के स्कोर के लिए अग्रणी दो वर्णों को हटा सकते हैं; हालाँकि, मुझे नहीं लगता कि यह पीपीसीजी नियमों का अनुपालन करता है।

व्याख्या

C-x h M-4 C-x tab
C-x h               Specify the entire buffer as the region
      M-4           Give the argument 4 to the next command that runs
          C-x tab   Increase the indentation level of each line by a constant

यहाँ इस्तेमाल किया गया अंतिम बिलिन निश्चित रूप से इस चुनौती के लिए अविश्वसनीय रूप से उपयोगी है; बाकी सिर्फ संरचना है।

3

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

"$args"-split"
"|%{" "*4+$_}

-1 n के बजाय एक वास्तविक newline का उपयोग कर, फर्ग्यूस्क के लिए धन्यवाद

"$args"इनपुट को एक स्ट्रिंग के रूप में लेता है ("एस का उपयोग करके डाली जाती है) और -splitइसे एक नई रेखा पर रखता है , फिर %{}इसके माध्यम से लूप्स ( ), चार स्पेस ( " "*4) और लाइन ( $_) को जोड़ देता है और फिर इसे अनुमानित रूप से आउटपुट करता है।

— colsw
स्रोत
क्या आप `n के बजाय एक नई लाइन वर्ण का उपयोग कर सकते हैं?
— फर्ग्यूसक
@fergusq वास्तव में मैं अपडेट कर सकता हूं।
— कॉल्व्स
संभवत: नई पंक्ति वर्ण \ n \ n खिड़कियों पर है जो अभी भी दो बाइट्स है - या क्या नियम स्पष्ट कर रहे हैं कि एक नया वर्ण कितना बाइट लेता है?
— poizan42
@ poizan42 मुझे यकीन नहीं है कि इस पर एक मेटा पोस्ट है, लेकिन मैं इसे डिफ़ॉल्ट कंसोल में सिर्फ नई लाइन के साथ चला सकता हूं इसलिए इसे अमान्य मानने का कोई कारण नहीं है।
— कॉल्व्स
3

अजगर, 10 बाइट्स

jm+*4\ d.z

कोशिश करो!

यदि लाइनों की सूची के रूप में इनपुट की अनुमति होगी, तो मैं इसे 7 बाइट्स में कर सकता हूं:

jm+*4\

उसकी कोशिश करो

अब समाधान:

12 बाइट्स:

+*4d:Eb+b*4d

12 बाइट्स:

+*4dj+b*4d.z

13 बाइट्स:

t:E"^|
"+b*4d
— KarlKastor
स्रोत
इसे 9 तक ले गए: jbm*4\ .z
— ताली
— कार्लकास्टर
मैं भूल गया d, जो वूप्स। आपके 10 बाइट का जवाब है कि मैं क्या करने जा रहा था, वैसे भी
— क्लैप
2

रोदा , 21 बाइट्स

{(_/"
")|[`    $_
`]}

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

यह एक अनाम फ़ंक्शन है। इनपुट स्ट्रीम से खींचा गया है।

स्पष्टीकरण:

{
    (_/"\n") |        /* Splits the input at newlines */
    ["    ".._.."\n"] /* For each line, prints four spaces before the line */
}
— fergusq
स्रोत
क्या identity()सिर्फ एसटीडीआईएन से सभी मान खींचते हैं?
— कृतिका लिथोस 19
@ क्रिकटी लिथोस हां। identityइनपुट स्ट्रीम से मान खींचता है और उन्हें अपनी आउटपुट स्ट्रीम में धकेलता है। यह समान है push(x) for x।
— fergusq
2

पर्ल 5 , 11 + 1 = 12 बाइट्स

कोड + -pध्वज के 11 बाइट्स ।

s/^/    /mg

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

एक बार के लिए, स्पष्टीकरण छोटा होगा: रेगेक्स प्रत्येक पंक्ति की शुरुआत की जगह लेता है (^/m संशोधक के साथ संयुक्त ) को चार स्थानों द्वारा - अंत।

— बापू
स्रोत
यह एक समय में एक पंक्ति को इनपुट करता है, बजाय एक स्ट्रिंग के रूप में।
@ ais523 शीर्ष दो सहित उत्तर के आधे भाग, बिल्कुल उसी तरह से इनपुट पढ़ें।
— मैक्सिम मिखायलोव
@ ais523 मैं कहूंगा कि यह एक समय में एक पंक्ति को संसाधित करता है, लेकिन यह इसे पूरे स्ट्रिंग के रूप में पढ़ सकता है (यदि आप इसे <<< "..." उदाहरण के लिए) के साथ आपूर्ति करते हैं। क्या आप सहमत नहीं हैं?
— दादा
@ ais523 इसके बारे में थोड़ा और सोचने के बाद, मुझे लगता है कि आप सही हैं। (मैंने अपने कोड को तदनुसार अपडेट कर दिया है)
— दादा
2

सेड , १६ 10 9 बाइट्स

s/^/    /

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

संपादित करता

क्रिति लिथोस के लिए 16 से 10 बाइट्स से घोल के आकार को कम करें ।

-1 बाइट के लिए धन्यवाद seshoumara ।

— मैक्सिम मिखायलोव
स्रोत
आप -rध्वज (1 बाइट) का उपयोग करके 15 बाइट्स प्राप्त कर सकते हैं ताकि आप कोष्ठक से पहले बैकस्लैश निकाल सकें।
— कृति लीथोस
आप 13 का उपयोग करके प्राप्त कर सकते हैं s/.*/ &/(कोष्ठक को हटाएं और उसके \1साथ बदलें &)
— कृति लिथोस
@KritiiLithos धन्यवाद! यह बिना भी काम करता है *।
— मैक्सिम मिखायलोव
या बस s:^: :, 9 बाइट्स के लिए।
— शीशमारा
@ शीशमौरा मैंने कभी नहीं देखा है कि कॉलोन इस तरह से एक स्क्रिप्ट में इस्तेमाल करते हैं ... क्या आपको पता है कि मैनुअल का कौन सा हिस्सा इस वाक्यविन्यास का वर्णन करता है?
— मैक्सिम मिखायलोव
2

जावा 7, 58 बाइट्स

String c(String s){return"    "+s.replace("\n","\n    ");}

स्पष्टीकरण:

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

  • चार प्रमुख स्थानों के साथ संलग्न करें
  • हर नई-लाइन को एक नई-लाइन + चार स्थानों के लिए बदलें
— केविन क्रूज़सेन
स्रोत
मैं हमेशा के लिए दुखी हूं कि जावा के रेगेक्स तंत्र को अधिकांश भाग के लिए अन्य पुस्तकालयों की आवश्यकता है।
— पोक
मुझे लगता है कि आपको जरूरत हैreplaceAll
— खालिद
@ खालिद.के क्यों? दोनों .replaceऔर .replaceAllसभी घटनाओं की जगह के प्रतिस्थापन के साथ स्ट्रिंग की खोज करेंगे। .replaceशाब्दिक स्ट्रिंग्स के लिए प्रयोग किया जाता है, और .replaceAllregexes के लिए। चूंकि \nरेगेक्स नहीं है, इसलिए .replaceइसका उपयोग बिना किसी समस्या के सभी नईलाइनों को एक नई लाइन + चार रिक्त स्थान के साथ करने के लिए किया जा सकता है, जिसे आप मेरे द्वारा दिए गए "ट्राय इट लाइन" लिंक में भी देख सकते हैं।
— केविन क्रूज़सेन
2

ब्रेन-फ्लैक , 109 103 बाइट्स

-6 गेहूं जादूगर के लिए धन्यवाद

के लिए +1 शामिल है -c

((()()()()()){}){(({}<>)[()()((()()()()){})]<(((((({}){}){}))))>){(<{}{}{}{}{}>)}{}<>}<>{({}<>)<>}<>{}

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

((()()()()()){})        # Add a newline to the beginning
                        # This is needed to get spaces infront of the first line)
{                       # For every character (call it C)
  (({}<>)               #   Move C to the other stack
  [()()((()()()()){})]  #   Push 8 and subtract 10 (\n) from C
  <(((((({}){}){}))))>) #   Push 4 spaces using the 8 from earlier
  )                     #   Push C - 10
  {(<                   #   If C - 10 != 0...
    {}{}{}{}{}          #     Pop the 4 spaces that we added
  >)}{}                 #   End if
  <>                    #   Switch stacks to get the next character
}                       # End while
<>{({}<>)<>}<>          # Reverse the stack (back to the original order)
{}                      # Pop the newline that we added
— रिले
स्रोत
— पोस्ट रॉक गार्फ हंटर
— पोस्ट रॉक गार्फ हंटर
@WheatWizard नाइस। मुझे उस तरह की अतिरेक की तलाश शुरू करनी होगी। यह शायद मेरे लिए धक्का पॉप से ​​अधिक होता है। वे अभी स्वचालित हैं। धन्यवाद
— रिले
1

MATL , 12 बाइट्स

10&Yb"4Z"@gh

इनपुट न्यूलाइन्स के साथ एक स्ट्रिंग है। इसे दर्ज करने के लिए, आपको नई वर्णक का प्रतिनिधित्व करने के लिए सामान्य वर्णों के बीच वर्ण 10 को संक्षिप्त करने की आवश्यकता है (चौकोर कोष्ठक संघातक हैं):

['Code' 10 'More code']

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

10&Yb   % Implicit input. Split at char 10 (newline). Gives cell array of strings
"       % For each
  4Z"   %   Push string of 4 spaces
  @g    %   Push the contents of current cell array, i.e. a string with one of the
        %   original lines
  h     %   Concatenate the two strings horizontally
        % Implicit end. Implicit display
— लुइस मेंडो
स्रोत
1

PHP, 16

echo"    $argn";

साथ चलाना php -R <code>। -Rप्रत्येक इनपुट लाइन के लिए दिए गए कोड को चलाता है और $argnवर्तमान इनपुट लाइन को फीड किया जाता है। तो यह बस इसके सामने अतिरिक्त चार स्थानों के साथ प्रत्येक पंक्ति को प्रिंट करता है।

— क्रिस्टोफ
स्रोत
1

वी , 3 बाइट्स (गैर-प्रतिस्पर्धात्मक)

4>G

यह उत्तर एक सुविधा का उपयोग करता है जिसे मैं थोड़ी देर के लिए जोड़ने की योजना बना रहा हूं, लेकिन आज जोड़ने के लिए बस चारों ओर हो गया। जो इस जवाब को गैर-प्रतिस्पर्धी बनाता है और जीतने के लिए अमान्य है। लेकिन इस तरह की उपयोगी / प्रतिस्पर्धी सुविधा को दिखाना अभी भी अच्छा है!

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

स्पष्टीकरण:

4>   " Add an indent of 4 to...
  G  "   Every line from the current line (0 by default) to the end of the buffer
— DJMcMayhem
स्रोत
साफ! कम से कम इस बात पर गर्व करें कि आपकी भाषा पहले भी शीर्ष स्थान पर रही थी [भले ही वह गंदी गोल्फिंग भाषा हो ... नाह, जेके]!
— Papayaman1000
1

विम, 6 कीस्ट्रोक्स

<Ctrl-V>G4I <Esc>

मान लेता है कि कर्सर फ़ाइल की शुरुआत में है, जैसे कि आपने कमांड लाइन से फाइल को खोला है vim filename।

<Ctrl-V>            " Enter visual block move (enables rectangular selection)
        G           " Move to bottom line (selecting the entire first column)
         4          " Repeat the following action 4 times
          I         " Insert at start of (each selected) line
                    " [input a space]
            <Esc>   " Exit insert mode

इंडेंटेशन के लिए 4 रिक्त स्थान का उपयोग करने के लिए कॉन्फ़िगर एक विम के साथ यह 2 कीस्ट्रोक्स होगा >G:।

— daniero
स्रोत
मुझे पूरा यकीन है कि आप ZZअंत में हटा सकते हैं । आमतौर पर विम सबमिशन एक फाइल के बजाय बफर को आउटपुट देने के लिए ठीक है।
— DJMcMayhem
ठीक है धन्यवाद, मैंने ZZतब हटा दिया ।
— डेनियरो
1

Japt , 7 6 बाइट्स

सहेजे गए 1 बाइट @ETHproductions के लिए धन्यवाद

miS²²R

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

स्पष्टीकरण:

miS²²R
m       // At each char in the input:
 iS²²   //   Prepend " " repeated 4 times
     R  // Rejoin with newlines
— ओलिवर
स्रोत
अच्छी नौकरी। S²²के स्थान पर भी काम करेगा Sp4, न कि यह आपको इस मामले में कुछ भी बचाता है। जिसके बारे में बोलते हुए, मुझे लगता है कि आप केवल ध्वज miS²²Rको हटाने के लिए कर सकते हैं R(मूल रूप से miS²², लेकिन पहले से ही नई
— सुर्खियों में
1

UberGenes , 62 बाइट्स

मुझे UberGenes के साथ इस चुनौती में प्रवेश करना था, एक बहुत ही समान कार्यक्रम के रूप में (जो कि केवल एक स्थान डाला गया था) भाषा में लिखे गए पहले कार्यक्रमों में से एक था, और ऐसा लग रहा था कि इस उद्देश्य के लिए संशोधित करना आसान होगा।

=aA=p9=z4=cI=AC+a1-z1:pz=Ao:CA:Ii  =b5+b5-bA+a1=d3*d7:db=i0

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

=aA                                                         Set a to 61
                                                            (Begin main loop)
   =p9                                                      Set p to 9
      =z4                                                   z counts spaces
         =cI                                                Set c to 61
                                                            (Jumping to p jumps here)
            =AC                                             Put the space at position 61
                                                              at position a.
               +a1-z1                                       Move a right and decrement z
                     :pz                                    Jump to p if z is nonzero
                                                            (Jumping to d jumps here)
                        =Ao                                 Read a character to position a.
                           :CA                              Jump to position 32+3 if input
                                                              was nonzero.
                              :Ii                           Otherwise, jump to position 61,
                                                              causing the entire string
                                                              that begins there to be
                                                              printed before halting.
                                                            (This is position 32+3=35)
                                   =b5+b5                   Set b to 10 (newline).
                                         -bA                Subtract the input character to
                                                              compare it with newline.
                                            +a1             Move a right.
                                               =d3*d7       Set d to 21
                                                     :db    Jump to d if not newline.
                                                        =i0 Jump back to begin main loop.
(The 3 spaces at the end position a space character at position 61 so that, after =cI,
C refers to the space character--it will also be the first space printed.)
— quintopia
स्रोत
1

सीजेएम , 11 बाइट्स

एक सुधार के लिए @ चैलेंजर 5 को धन्यवाद

qN/{S4*\N}%

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

व्याख्या

q              e#  Read whole input as a string with newlines
 N/            e#  Split at newlines, keeping empty pieces. Gives an array of strings
   {     }%    e#  Map this function over the array of strings
               e#  The current string is automatically pushed
    S4*        e#  Push a string of four spaces
       \       e#  Swap. Moves the original string after the four spaces
        N      e#  Push a newline
               e#  Implicity display stack contents
— लुइस मेंडो
स्रोत
1
पर काम नहीं करता है abc\n\ndef। यह ....abc\n....defइसलिए लौटता है क्योंकि %खाली तत्वों को त्याग देता है। आप /इसके बजाय विभाजित करने के लिए उपयोग करना चाहते हैं , क्योंकि यह खाली तत्वों को रखता है।
— एगलैंगिंग फ्रूट
@ चैलेंजर 5 धन्यवाद, सही किया गया!
— लुइस मेंडो
1

जे-यूबी , 17 16 बाइट्स

~:gsub&' '*4&/^/

व्याख्या

~:gsub           # :gsub with reversed arguments: 
                 # (f)[regex,sub,str] == str.gsub(regex, sub)
      &' '*4     # replace with four spaces
            &/^/ # match the start of each line

यह सीधे (रूबी में) अनुवाद करता है:

->s{s.gsub(/^/,' '*4)}
— Cyoce
स्रोत
1

सी, 66 65 बाइट्स

p(){printf("    ");}f(char*s){for(p();*s;)putchar(*s++)-10||p();}

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

— Steadybox
स्रोत
नीट समाधान, लेकिन आप s;char*l;f(){while(getline(&l,&s,stdin)+1)printf("____%s",l);}62 बाइट्स के साथ जा सकते हैं
— खालिद.के
@ Khaled.K धन्यवाद, लेकिन वह <stdio.h>(क्योंकि stdin) के शामिल किए बिना काम नहीं करता है ।
— स्टेडीबॉक्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.