60

एक प्रोग्रामर के रूप में, आपने शायद आगे की स्लैश और बैकवर्ड स्लैश के बारे में सुना है। लेकिन क्या आपने चढ़ाव के बारे में सुना है? जब आप स्लैश का एक गुच्छा लेते हैं, तो उनके सिरों को जोड़ते हैं और उन्हें नीचे की ओर खींचते हैं।

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

\
 \
  \
  /
 /
 \
 /
 \
  \

यहाँ कुछ स्पष्टीकरण दिए गए हैं:

प्रति पंक्ति एक स्लैश होना चाहिए।
पहली पंक्ति में 0 अग्रणी स्थान होंगे।
स्लैश के प्रत्येक जोड़े के लिए:
- यदि वे एक-दूसरे से अलग हैं, तो उन्हें एक ही कॉलम में खींचा जाएगा। उदाहरण के लिए, \/देंगे:
```
\
/
```
- यदि वे समान वर्ण हैं, तो निचला भाग उस दिशा में बताया गया है, जो बैकस्लैश के दाईं ओर घूम रहा है, और आगे की स्लैश के लिए बाईं ओर जा रहा है। तो \\//देंगे
```
\
 \
 /
/
```
प्रत्येक पंक्ति में अतिरिक्त अनुगामी व्हाट्सएप हो सकता है क्योंकि यह आउटपुट के दृश्य स्वरूप को नहीं बदलता है। एक अनुगामी और अग्रणी न्यूलाइन तक भी स्वीकार्य है। अतिरिक्त अग्रणी स्थान की अनुमति नहीं है !

इस सरल को बनाए रखने के लिए, आप यह मान सकते हैं कि स्ट्रिंग में बहुत अधिक फ़ॉरवर्ड स्लैश नहीं होंगे। दूसरे शब्दों में, इनपुट के किसी भी उपसर्ग में बैकस्लैश की तुलना में अधिक फ़ॉरवर्ड स्लैश नहीं होंगे, इसलिए ऐसा इनपुट \\////या //कभी नहीं दिया जाएगा। इसका मतलब यह भी है कि हर इनपुट एक बैकस्लैश के साथ शुरू होगा।

यदि आपका इनपुट एक स्ट्रिंग शाब्दिक के रूप में लिया गया है, तो यदि आवश्यक हो तो आप बैकस्लैश से बच सकते हैं। आपको किसी ऐसे इनपुट को संभालने की आवश्यकता नहीं होगी जो खाली है, या जिसमें स्लैश के अलावा अन्य वर्ण हैं।

आप किसी भी उचित प्रारूप द्वारा आउटपुट कर सकते हैं ।

हमेशा की तरह, यह एक कोड-गोल्फ चुनौती है, इसलिए कम से कम समाधान संभव बनाने की कोशिश करें, भले ही आप ऐसी भाषा चुनें जहां यह मुश्किल है। बाइट्स लेने के लिए आपके द्वारा इस्तेमाल की जाने वाली किसी भी दिलचस्प तकनीक की व्याख्या करने के लिए बोनस अंक!

उदाहरण

#Input
\\\\\\\\\\\

#Output
\
 \
  \
   \
    \
     \
      \
       \
        \
         \
          \

#Input
\\\//\\/\//\\///

#Output
\
 \
  \
  /
 /
 \
  \
  /
  \
  /
 /
 \
  \
  /
 /
/


#Input
\/\/\/

#Output
\
/
\
/
\
/

code-golf string ascii-art

— DJMcMayhem
स्रोत

9

बैकस्लैश

— भागती हुई

क्या इस प्रश्न के लिए मेरे उत्तर में दिए गए कर्सर को घूमने की फॉर्मफीड / बैकस्लैश विधि दी गई है ?

— डिजिटल ट्रॉमा

20

जीएनयू सैड, 20

s|\\|&^L|g
s|/|^H/^L^H|g

ध्यान दें कि ^Lऔर ^Hशाब्दिक फॉर्मफीड और बैकस्पेस वर्ण (0x12 और 0x8) हैं।

यह उत्तर कर्सर को बैकस्पेस का उपयोग करके चारों ओर ले जाकर काम करता है और वर्णों को प्रारूपित करता है। स्लैश / बैकस्लैश रिक्त स्थान के साथ बाएं-गद्देदार नहीं हैं - इस पर यकीन नहीं है कि यह उत्तर अयोग्य है। यह TIO में काम नहीं करता है, लेकिन यह सामान्य टर्मिनलों जैसे xtermऔर के तहत ठीक दिखता है gnome-terminal।

इस सेड स्क्रिप्ट को इस प्रकार बनाएँ:

base64 -d <<< c3xcXHwmDHxnCnN8L3wILwwIfGc= > downslash.sed

इसे निम्नानुसार चलाएं:

$ echo '\\\//\/\\' | sed -f downslash.sed
\ 
 \ 
  \ 
  /
 /
 \ 
 /
 \ 
  \ 

$

व्याख्या:

s|\\|&^L|g     # move cursor down after every "\"
s|/|^H/^L^H|g  # move cursor left before every "/", then after, down and left again

— डिजिटल आघात
स्रोत

14

चारकोल , 13 12 11 बाइट्स

ＦＳ¿⁼ι/↓¶/↘ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। अतिरिक्त //s का समर्थन करता है । स्पष्टीकरण:

 Ｓ              Input string
Ｆ               Loop over each character
  ¿             If
    ι           Current character
   ⁼            Equals
     /          Literal /
      ↓¶        Move left
      ↓ /       Print a / downwards
         ↘ι     Else it's a \ so print that down and right

— नील
स्रोत

मुझे लगता ↓¶है कि विवरण में "लेफ्ट लेफ्ट" सही नहीं है।

— जोनाथन एलन

@JonathanAllan यह सही है (newline प्रिंट डाउन = लेफ्ट लेफ्ट), हालांकि यह "प्रिंट \n/डाउन" कहना शायद स्पष्ट होगा

— केवल

मैंने यह नहीं कहा print \n/ downक्योंकि मुझे लगा कि इसके शाब्दिक अनुवाद के बजाय कोड के प्रभाव का वर्णन करना अधिक सहायक था।

— नील

1

(गाल में जीभ: प्रभाव का वर्णन = MyCode - Do the spec)। मैं इसे अभी प्राप्त करता हूं हालांकि प्रभाव बाईं ओर बढ़ना है; यह कहने के लायक हो सकता है "बाईं ओर ले जाएं (एक डाउनलाइन प्रिंटिंग दिशा के साथ एक नई लाइन प्रिंट करके)"।

— जोनाथन एलन

सबसे संक्षिप्त और सभी का आत्म-स्पष्टीकरण!

— j4hangir

14

पायथन 2 , 55 54 51 57 53 बाइट्स

^{-3 बाइट्स (और एक बग फिक्स) फेलिप नारदी बतिस्ता के लिए धन्यवाद}

i=0
for c in input():i-=c<'<'*i;print' '*i+c;i+=c>'<'

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

— छड़ी
स्रोत

56 बाइट्स

— श्री एक्सकोडर

10

/// , 119 बाइट्स

/// में कोई इनपुट कमांड नहीं है, इसलिए इनपुट को प्रोग्राम में एम्बेड किया जाना चाहिए। इस के लिए, इनपुट स्ट्रिंग बस संलग्न है, जिसमें कोई भागने की आवश्यकता नहीं है।

/=/\/\///M/
|%%=N/%|||=C/BA=\/\\/\/C\\=C\\/CbC=B\A\=CfC=AB=/A/%Mxy=B/|z%N|x|y% %N%x|y%%% |fzN%M%b|zN|M|%
=|/AB\\=%/|=AC

इसे ऑनलाइन आज़माएं!
-dविकल्प के साथ (प्रत्येक कमांड चलाने से पहले कोष्ठक में दिखाया गया कार्यक्रम स्थिति)।

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

निम्नलिखित में, \\/\//प्रदर्शन के लिए कार्यक्रम के लिए एक इनपुट जोड़ा जाएगा।
␤ इनलाइन कोड में newlines का प्रतिनिधित्व करने के लिए उपयोग किया जाता है।

लघुरूप

/=/\/\///M/␤|%%=N/%|||=C/BA=कार्यक्रम की शुरुआत में गोल्फिंग संक्षिप्तीकरण के विकल्प होते हैं।

=करने के लिए //, Mकरने के लिए ␤|%%, Nकरने के लिए %|||और Cकरने के लिए फैलता है BA।

इसके बाद वर्तमान कार्यक्रम बन जाता है

/\/\\/\/BA\\//BA\\/BAbBA//B\A\//BAfBA//AB///A/%
|%%xy//B/|z%%||||x|y% %%|||%x|y%%% |fz%|||%
|%%%b|z%||||
|%%|%
//|/AB\\//%/|//ABA\\/\//

इनपुट रीकोडिंग

अगला चरण एपेंडेड इनपुट स्ट्रिंग को अधिक प्रयोग करने योग्य रूप में बदल देता है। चूँकि इसमें पूरी तरह से /// के दो कमांड कैरेक्टर होते हैं, इसलिए बेस प्रोग्राम को मेनटेन करने से बचने के लिए यह कुछ ध्यान रखता है।

पहला पर्याप्त प्रतिस्थापन, /\/\\/\/BA\\/स्ट्रिंग /\को प्रतिस्थापित करता है /BA\।
- इस समय आधार कार्यक्रम शामिल नहीं है /\, इसलिए यह प्रतिस्थापन इसे प्रभावित नहीं करता है।
- हालांकि, यह \एस के अनुक्रमों के बाद एस के अनुक्रमों में संलग्न इनपुट स्ट्रिंग को विभाजित करता है /, जो ABAकि आधार कार्यक्रम के अंत में एक साथ निम्नलिखित प्रतिस्थापन के साथ इसके माध्यम से पुनरावृति करना संभव बनाता है।
- ABAइससे पहले उपसर्ग को शामिल करते हुए , उदाहरण इनपुट स्ट्रिंग अब बन गया है ABA\\/BA\//।
अगले प्रतिस्थापन, द्वारा /BA\\/BAbBA/प्रतिस्थापित करता BA\है BAbBA।
- क्योंकि /// प्रतिस्थापन को तब तक दोहराया जाता है जब तक वे मेल नहीं खाते, यह \इनपुट स्ट्रिंग के सभी s के माध्यम से पुनरावृत्त करता है, जो कि उपसर्ग के साथ बन जाता हैABAbBAbBA/BAbBA//
इसी तरह, /B\A\//BAfBA/परिवर्तन BA/करने के लिए BAfBA, के माध्यम से पुनरावृत्ति /रों।
- \इस प्रतिस्थापन में भागने की जरूरत है क्योंकि यह पिछले एक द्वारा मंगाई जाएगी।
- इनपुट अब बदल गया है ABAbBAbBAfBABAbBAfBAfBA।
इसके /AB//बाद एन्कोडिंग के कुछ शानदार हिस्सों को हटाकर इसे मोड़ दिया जाता है AbBAbBAfBAbBAfBAfBA।
- यह कार्यक्रम में बाद में प्रतिस्थापन ABसे भी हटाता है /|/AB\\/, जिसे उपरोक्त /\हेरफेर से बचाने के लिए आवश्यक था ।
- इस बिंदु पर हर \मूल इनपुट स्ट्रिंग बन गया है AbB, और हर /बन गया है AfB। ( bऔर fपिछड़े और आगे के लिए खड़े हैं।) Aअंत में एक भटका है ।
अगले दो प्रतिस्थापन सब की जगह Aहै और Bअंतिम चरण में चलाने के लिए कार्यक्रम के टुकड़े के साथ। प्रतिस्थापन तार में, %और |रों एनकोड क्या बन जाएगा /और \क्रमशः है। इसके दो लाभ हैं:
- इसके विपरीत /और \, %एस और |एस को नकल करने के लिए भागने की जरूरत नहीं है।
- प्रतिस्थापन के तार प्रतिस्थापन से बचते हैं /\, जो अन्यथा पिछले जोड़तोड़ से प्रभावित होते हैं।
इसके बाद, प्रतिस्थापन /|/\\/(पूर्व में /|/AB\\/) अब |s को डिकोड करता है , जिसके बाद निम्नलिखित /%/|//बन गया है /%/\//और %s को डिकोड करता है ।

अंतिम चरण में कार्यक्रम की संरचना

इस बिंदु पर, बेस प्रोग्राम ने अपने सभी प्रतिस्थापन चलाए हैं, और जो भी शेष है वह इनपुट स्ट्रिंग का प्रोग्राम-एन्कोडिंग है।

प्रत्येक इनपुट चरित्र एक उपप्रोग्राम बन गया है
```
/
\//xy*\z//\\\\x\y/ //\\\/x\y/// \fz/\\\/
\///b\z/\\\\
\//\/
```
(अनुगामी न्यू लाइन), जहां *का प्रतिनिधित्व करता है या तो fएक मूल के लिए /, या bएक मूल के लिए \।
/␤\//xyकार्यक्रम के अंत में एक अधूरा प्रतिस्थापन कमांड भी है , जिसका /पिछले उपप्रोग्राम के प्रतिस्थापन के लिए आवश्यक प्रदान करने के अलावा कोई प्रभाव नहीं होगा ।

स्थानापन्न साझा किया

उपप्रोग्राम के माध्यम से अंतिम पुनरावृत्ति शुरू होने से पहले, प्रपत्र के प्रत्येक चरित्र के उपप्रोग्राम के बाद सीमा पार करने वाला एक विकल्प है \/␤/।

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

एक चरित्र उपप्रोग्राम चलाना

निम्नलिखित प्रतिस्थापन में से कई में \एक दूसरे से मेल खाने और मंगवाने से रोकने के लिए अतिरिक्त एस होते हैं (अन्य उपप्रोग्राम में अन्य प्रतियां सहित)। इस लक्ष्य को प्राप्त भी कारण है कि दोनों है xऔर yजरूरत है।

एक चरित्र उपप्रोग्राम में पहला प्रतिस्थापन, /␤\//xyf\z/या /␤\//xyb\z/, ␤/साझा प्रतिस्थापन के अंत में xyfzया xybz, तुरंत \/या उसके बाद का कारण बनता है \\।
प्रतिस्थापन एक स्थान से /\\\\x\y/ /बदलता \\xyहै, और प्रतिस्थापन कुछ भी नहीं द्वारा /\\\/x\y//प्रतिस्थापित करता \/xyहै।
- वे लागू होते हैं जब पिछले इनपुट चरित्र मुद्रित एक था \या /, क्रमशः।
- साझा किए गए सबस्ट्रिंग में एक \अगला प्रिंट करने के लिए उपयुक्त स्थान हैं , उसके बाद fzया bz।
प्रतिस्थापन / \fz/\\\/␤\//की जगह fzसे \/␤/, और /b\z/\\\\␤\//की जगह bzसे \\␤/।
- वे तब लागू होते हैं जब वर्तमान इनपुट वर्ण क्रमशः होता है /या होता \है।
- पहले वाला /सही जगह पर एक अतिरिक्त जगह खाता है।
  - यदि यह स्थान अनुपलब्ध है (यानी इनपुट उपसर्ग स्थिति का उल्लंघन करता है), तो निम्न प्रतिस्थापन गलत तरीके से प्राप्त होते हैं, बहुत सारे कबाड़ को प्रिंट करते हैं और आमतौर पर एक को मारते हैं ///, जो एक अनंत लूप है।
- प्रत्येक अपने चरित्र को मुद्रित करने के लिए सही कमांड जोड़ता है, और ␤/साझा किए गए प्रतिस्थापन के अंत में मूल को बहाल करता है ।
चरित्र उपप्रोग्राम अब साझा प्रतिस्थापन की अपनी प्रतिलिपि तक पहुंच गया है, जो अपनी लाइन को प्रिंट करने के लिए तैयार है।

अंतिम चरित्र सबप्रोग्राम चलने के बाद, प्रोग्राम का अवशेष क्या है /␤\//xy। चूंकि यह अंतिम रूप से गायब होने के साथ एक अधूरा प्रतिस्थापन है /, इसलिए कार्यक्रम इसे बंद कर देता है और सामान्य रूप से रुकता है।

— अर्जन जोहान्सन
स्रोत

1

नौकरी के लिए सही भाषा! Lol

— DJMcMayhem

6

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

=”\ðḤ’+\_⁸⁶ẋżY

एक पूर्ण कार्यक्रम परिणाम को प्रिंट करता है।

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

कैसे?

=”\ðḤ’+\_⁸⁶ẋżY - Link: list of characters, s    e.g. "\\\//\\/"
 ”\            - literal '\'                         '\'
=              - equal? (call this e)                [1, 1, 1, 0, 0, 1, 1, 0]
   ð           - new dyadic chain f(e, s)
    Ḥ          - double                              [2, 2, 2, 0, 0, 2, 2, 0]
     ’         - decrement                           [1, 1, 1,-1,-1, 1, 1,-1]
      +\       - cumulative reduce with addition     [1, 2, 3, 2, 1, 2, 3, 2]
         ⁸     - chain's left argument, e            [1, 1, 1, 0, 0, 1, 1, 0]
        _      - subtract (# of leading spaces)      [0, 1, 2, 2, 1, 1, 2, 2]
          ⁶    - literal ' '                         ''
           ẋ   - repeat                              [""," ","  "," "," "," ","  ","  "]
            ż  - zip with s                          [["",'\'],[" ",'\'],["  ",'\'],["  ",'/'],[" ",'/'],[" ",'\'],["  ",'\'],["  ",'/']]
             Y - join with newlines                  ["",'\','\n'," ",'\','\n',"  ",'\','\n',"  ",'/','\n'," ",'/','\n'," ",'\','\n',"  ",'\','\n',"  ",'/']
               - implicit print - this smashes the lists (shown as "..." above) and the characters (shown as '...' above) together.

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

6

हास्केल , 49 बाइट्स

scanl(\x c->drop(sum[1|'/'<-c:x])(' '<$x)++[c])[]

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

— डायने
स्रोत

5

पर्ल 5 , 44 बाइट्स

-Fध्वज के लिए कोड + 2 के 42 बाइट्स

say$"x($s+=$\eq$_&&$#i**m|/|).($\=$_)for@F

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

— Xcali
स्रोत

5

जावास्क्रिप्ट (ईएस 8), 66 59 63 बाइट्स

7 बाइट्स को बचाने के लिए जस्टिन मेरिनर
+4 बाइट्स को धन्यवाद दिया /\\/\\/( नील द्वारा देखा गया )

f=([a,...z],b=a<'0')=>a?a.padStart(b+=k=a>'/')+`
`+f(z,b-!k):''

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

5

MATL , 23 19 18 बाइट्स

1 बाइट @Sanchises की बदौलत

fGqoEq1yd~h*YsGZ?c

इनपुट एकल उद्धरण में संलग्न एक स्ट्रिंग है।

इसे ऑनलाइन आज़माएं! या परीक्षण मामलों को सत्यापित करें: 1 , 2 , 3 ।

व्याख्या

'\\\//\/\\'उदाहरण के रूप में इनपुट पर विचार करें ।

f      % Implicit input. Array of indices of nonzeros. Since all chars in the input
       % have nonzero code point, this gives [1 2 ... n] where n is input length
       % STACK: [1 2 3 4 5 6 7 8 9]
G      % Push input again
       % STACK: [1 2 3 4 5 6 7 8 9], '\\\//\/\\'
qo     % Subtract 1 from (the code-point) of each char and then compute modulo 2.
       % This transforms '\' into 1 and '/' into 0
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 0 0 1 0 1 1]
Eq     % Double, subtract 1. This transforms 0 into -1
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1]
1y     % Push 1 and duplicate from below
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], 1, [1 1 1 -1 -1 1 -1 1 1]
d~     % Consecutive differences, logical negation: gives 1 if consecutive entries
       % are equal, 0 otherwise
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], 1, [1 1 0 1 0 0 0 1]
h      % Horizontally concatenate
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], [1 1 1 0 1 0 0 0 1]
*      % Element-wise multiplication
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 0 -1 0 0 0 1]
Ys     % Cumulative sum
       % STACK: [1 2 3 4 5 6 7 8 9], [1 2 3 3 2 2 2 2 3]
G      % Push input again
       % STACK: [1 2 3 4 5 6 7 8 9], [1 2 3 3 2 2 2 2 3], '\\\//\/\\'
Z?     % Build sparse matrix with those row indices, column indices, and values
       % STACK: [92  0  0;
                  0 92  0;
                  0  0 92;
                  0  0 47;
                  0 47  0;
                  0 92  0;
                  0 47  0;
                  0 92  0;
                  0  0 92]
c      % Convert to char. Char 0 is shown as space. Implicitly display
       % STACK: ['\  ';
                 ' \ ';
                 '  \';
                 '  /';
                 ' / ';
                 ' \ ';
                 ' / ';
                 ' \ ';
                 '  \']

— लुइस मेंडो
स्रोत

अपने सूचकांकों को प्राप्त करने के लिए थोड़ा अलग एल्गोरिथम द्वारा एक बाइट करें

— Sanchises

@Schchises आपके बहुत ही उपयुक्त संपादन के लिए धन्यवाद!

— लुइस मेंडो

5

सी # (.NET कोर) , 74 88 82 78 77 76 + 18 बाइट्स

केविन क्रूज़सेन के लिए धन्यवाद

s=>s.Select((x,i)=>$"{x}".PadLeft((x-s[0])/45-~s.Take(i).Sum(y=>y<92?-1:1)))

स्ट्रिंग्स का एक संग्रह आउटपुट करता है, प्रत्येक पंक्ति के लिए एक। बाइट काउंट में ये भी शामिल हैं:

using System.Linq;

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

77 बाइट उत्तर के लिए स्पष्टीकरण:

s =>                              // Take input, a string
    s.Select((x, i) =>            // Replace every character with:
        $"{x}"                    //     The character as string
        .PadLeft(                 //     Pad with this many spaces:
            s.Take(i)             //         Take characters, in the input string, preceding current one
            .Sum(y =>             //         Sum them by:
                y < 92 ? -1 : 1   //             If it's a \ add 1, if / subtract 1
            )
            + (x - s[0]) / 45 + 1 //         If first slash is a / add one more space, if current slash is a \ add one more space (I got this through power of MATHS!)
                                  //         How I arrived at this function:
                                  //         + x / 48        If current slash is a \ add one more space
                                  //         - s[0] / 48 + 1 If the first slash is a / add one more space
        )
    )

— ग्रेज़गोरज़ पुलावस्की
स्रोत

3

के लिए काम नहीं करता है /\\/\\/।

— नील

@ नील आपको इस ओर इशारा करने के लिए धन्यवाद! फिक्स्ड।

— ग्रेजगोरज पूलावस्की

1

मैं जानता हूँ कि यह एक समय हो गया है, लेकिन आप को बदलने के द्वारा एक बाइट बचा सकते हैं s.Take(i).Sum(y=>y<92?-1:1)+(x-s[0])/45+1करने के लिए(x-s[0])/45-~s.Take(i).Sum(y=>y<92?-1:1)

— केविन Cruijssen

एक अच्छा @KevinCruijssen!

— ग्रेज़गोरज़ पुलावस्की

4

05AB1E , 14 बाइट्स

ÇÈx<ηOs-W-ISú»

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

व्याख्या

Ç                # convert input string to a list of ascii codes
 È               # check each for evenness
  x              # push a doubled copy
   <             # decrement
    η            # compute prefixes
     O           # sum each prefix
      s          # swap the unaltered copy of evenness to the top
       -         # subtract from the prefix-sum list
        W-       # subtract the minimum value
          IS     # push input split to a list of chars
            ú    # pad each with the number of spaces computed
             »   # join on newline

— Emigna
स्रोत

1

के लिए काम नहीं करता है /\\/\\/।

— नील

Ç¥.¥0<.SηOv¹Nèy<ú, बाइनरी में sobbing

— मैजिक ऑक्टोपस Urn

3

आर , 122 121 बाइट्स

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

x=el(strsplit(scan(,""),""));n=seq(x);y=x>"/";for(i in n)cat(rep(" ",diffinv(y[n[-1]-1]+y[n[-1]]-1)[i]),x[i],"\n",sep="")

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

अतिरिक्त व्हाट्सएप के साथ:

x = el(strsplit(scan(,""),""))
n = seq(x)
y = x>"/"
for(i in n) {
  cat(rep(" ", diffinv(y[n[-1]-1]+y[n[-1]]-1)[i]), x[i], "\n", sep="")
}

स्पष्टीकरण: यह उत्तर इस अवलोकन पर आधारित है कि प्रमुख स्थानों की संख्या प्रत्येक रेखा को -1 से बदल देती है, साथ /ही पिछली और वर्तमान लाइनों की संख्या।

यदि हमारे पास एन स्लैश है, तो चर yलंबाई एन का एक वेक्टर है, जिसमें प्रत्येक स्थिति के लिए 1 है \, 0 के साथ । इसलिए, प्रति पंक्ति अग्रणी स्थान की संख्या में परिवर्तन प्राप्त करने के लिए, हम गणना करते हैं y[1:(N-1)] + y[2:N] - 1। फ़ंक्शन diffinvइन अंतरों को एक अनुक्रम में परिवर्तित करता है, 0. के साथ शुरू होता है। बाकी बस प्रत्येक पंक्ति को अनुगामी रिक्त स्थान की आवश्यक संख्या के रूप में इकट्ठा करने का मामला है, इसके बाद प्रासंगिक स्लैश और एक नई रेखा है।

— user2390246
स्रोत

1

हुह। मैंने 119 बाइट्स के लिए एक बहुत अलग दृष्टिकोण लिया, जो मुझे आश्चर्यचकित करता है कि क्या हम अपने दृष्टिकोणों को जोड़ सकते हैं। (का अच्छा उपयोग diffinv;) इसके अलावा आप y=x>")"-1 बाइट के लिए सेट कर सकते हैं

— Giuseppe

@Giuseppe आपको एक अलग उत्तर के रूप में पोस्ट करना चाहिए, यह एक अलग पर्याप्त दृष्टिकोण है। तुम्हारा करने से बचने का एक अच्छा तरीका है strsplit, जो हमेशा एक हत्यारा है। आप प्रसिद्ध का उपयोग भी कर सकते हैं diffinv!

— user2390246

1

इसके अलावा, मुझे लगता है कि अगर आप library(methods)हेडर में डालते हैं (जो ठीक होना चाहिए w / o पेनल्टी क्योंकि उस पैकेज का आधार आर है), तो आप उपयोग कर सकते हैं el। इसके अलावा, diffinvबस के रूप में लंबे समय के रूप में निकला cumsum! :)

— Giuseppe

हां, मैं सिर्फ यह महसूस कर रहा था कि यह उस संदर्भ में काफी काम नहीं करता है

— user2390246

ठीक है, मैं वर्कअराउंड के साथ आया था , लेकिन हां, यह *Sचीजें खराब कर रही हैं।

— Giuseppe

3

ब्रेन-फ्लैक , 175 बाइट्स (174 चार्ट + 1 ध्वज)

-cझंडे के साथ दौड़ो ।

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

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

व्याख्या

{ for each char in the input...
  (({})<(())>){({}[()]<([{}])>)}{} push 1/-1 for backslash/slash
  ((
   {}<>{}<> add the 1/-1 to a running total
   <
    ({}<>) move slash/backslash to other stack
    ((()()()()()){}) newline
   >
  )<{({}[()]<((((()()()()){}){}){})>)}>{}) spaces
  <>
}<>{} end for
reverse data order, removing one space before backslash
{({}<>)(({})(())){({}[()]<([{}]())>)}{}{<>{}<>(<{}>)}{}<>}<>

— MegaTom
स्रोत

मैं हमेशा ब्रेन-फ्लैक को बढ़ाता हूं। : डी

— DJMcMayhem

3

रूबी , 80 76 बाइट्स

-4 बाइट्स मैनटवर्क की बदौलत

puts"\\";$*[i=0].chars.each_cons 2{|b,c|puts" "*(b==c ?b==?/?i-=1:i+=1:i)+c}

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

व्याख्या:

puts "\\"           # Output the first backslash
$*[i=0].            # Get the first argument and set i to 0
chars.              # Go through every individual character,
each_cons 2 { |b,c| # In pairs to compare easily
                    #
    puts " " *      # Decide how many padding spaces to use based on the value
                    # of i. The expression inside the parenthesis will return
                    # i but before that, it will increment/decrement i based
                    # on what the previous character was.
                        #
    ( b==c ?            # if b == c
        b==?/ ?         #   if b == "/" (Going to the left)
            i-=1        #       return decremented i
            :           #   else        (Going to the right)
            i+=1        #       return incremented i
        :               # else
        i) +            #   return i
                    #
                c   # Finally, write the second of the characters that we're
}                   # iterating through.

— Pazzaz
स्रोत

1

कौन सा रूबी संस्करण? जब मैंने कोड ब्लॉक का अनुसरण किया है, तो 2.3.3 के पास पैरामीटर के आसपास कोष्ठक की मांग है .each_cons(2){…}:। परिवर्तन में आप .each_char→ प्रतिस्थापित करके बचा सकते हैं .chars।

— मैनटवर्क

@ मैनटवर्क मेरा माणिक संस्करण 2.4.1 है। आकर्षण के बारे में सुझाव के लिए धन्यवाद, मुझे उस बारे में नहीं पता था।

— पज्जाज़

आप i+=नेस्टेड टर्नरी एक्सप्रेशन की शुरुआत करने और इसे समाप्त करने के लिए एक और दो बाइट्स बचा सकते हैं -1:1:0।

— बेंज़ 2240

3

जावा 8, 121 118 110 109 102 बाइट्स

a->{String r="";int s=0,p=0,i;for(char c:a){for(i=s+=p+(p=c-63)>>5;i-->0;r+=" ");r+=c+"\n";}return r;}

-7 बाइट्स @ नोव्स बिट-बिट जादू के लिए धन्यवाद । :)

व्याख्या:

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

a->{                    // Method with char-array parameter and String return-type
  String r="";          //  Return-String
  int s=0,              //  Amount of spaces
      p=0,              //  Previous characters (starting at 0)
      i;                //  Index-integer
  for(char c:a){        //  Loop over the input
    for(i=s+=p+(p=c-63)>>5;
                        //   If the current does not equals the previous character
                        //    Leave `s` the same
                        //   Else-if it's a '\':
                        //    Increase `s` by 1
                        //   Else (it's a '/'):
                        //    Decrease `s` by 1
                        //   And set the previous character to the current in the process
        i-->0;r+=" ");  //   Append `r` with `s` amount of spaces               
    r+=c+"\n";          //   Append the character + a new-line to the result
  }                     //  End of loop
  return r;             //  Return result-String
}                       // End of method

— केविन क्रूज़सेन
स्रोत

1

102 बाइट्स:a->{String r="";int s=0,p=0,i;for(char c:a){for(i=s+=p+(p=c-63)>>5;i-->0;r+=" ");r+=c+"\n";}return r;}

— नेवे

@ नवीन धन्यवाद मुझे पता था कि इसे कुछ बिटवाइज़ ऑपरेशंस के साथ छोटा किया जा सकता है, लेकिन यह पता नहीं लगा सका। मुख्य रूप से, क्योंकि मैं के प्रभाव की कोशिश कर रहा बारे में भूल गया >>/ >>>/ <<... मैं केवल के साथ कुछ बातें की जाँच की थी &/ |/ ~/ ^। ..>>

— केविन Cruijssen

3

सी (जीसीसी), 137 134 97 बाइट्स

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

• 3 बाइट्स धन्यवाद ATaco

• डिजिटल ट्रॉमा और ThePirateBay के लिए 37 बाइट्स धन्यवाद

i,d;f(char*s){char c=s[i],n=s[++i];if(c){printf("%*c%c\n",d+1,c);(c-n)?d:(c==47)?--d:++d;f(s);}}

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

प्रयोग

f("\\\\\\//\\/\\\\",0,0);

Ungolfed

यह पुराने उत्तर के लिए है, इसे अपडेट करने के लिए ऑनलाइन लिंक की कोशिश देखें!

f(char *s, i, d) {
    char c=s[i], n=s[++i];
    if(!c) return;
    for(int j=0; j<d; j++) printf(" ");
    printf("%c\n",c);
    f(s, i, (c!=n)?d:(c=='/')?d-1:d+1);
}

उत्पादन

— Asleepace
स्रोत

आप एक ही प्रभाव के c=='\0'साथ बदल सकते हैं !c।

— अक्टूबर को ATaco

बहुत बढ़िया धन्यवाद बस समाधान अद्यतन!

— सोप्स

क्या आप printf("%*s%c", n, "", c)एन प्रमुख स्थानों के साथ चार सी को मुद्रित करने के लिए उपयोग कर सकते हैं ?

— डिजिटल ट्रामा

मुझे पूरा यकीन है कि आप टर्नरी एक्सप्रेशन के (c!=n)साथ c-nऔर फिर से व्यवस्थित करके कुछ बाइट्स बचा सकते हैं । उसी के साथ (c=='/')। इसके अलावा, आप '/'शाब्दिक संख्या के साथ बदल सकते हैं 47। मुझे लगता है कि यह कुल मिलाकर 7 बाइट्स है।

1

78 बाइट्स

— केवल

3

सी, 60 बाइट्स

i;f(char*s){for(i=1;*s;s++)printf("%*c\n",*s%2?--i:i++,*s);}

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

— orlp
स्रोत

-1 नो टीआईओ लिंक: पी

— एएससीआईआई-केवल

TIO

— केवल

@ ASCII- केवल आपका स्वागत है

— Stan Strum

3

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

^|\\
 $&
+m`^( *)( /|\\)(/| \\)
$1$2¶$1$3
m`^

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:

^|\\
 $&

प्रत्येक पंक्ति की शुरुआत में और प्रत्येक से पहले एक स्थान जोड़ें \।

+m`^( *)( /|\\)(/| \\)
$1$2¶$1$3

स्ट्रिंग के पहले दो वर्णों पर विचार करें। यदि पहले एक है, /तो इंडेंट को कम करने की आवश्यकता है; इसे कैप्चर में पूर्ववर्ती स्थान को शामिल करके प्राप्त किया जाता है (जो हमेशा मौजूद रहता है क्योंकि पहले चरण ने इसे जोड़ा); यदि दूसरा है \\तो इसे बढ़ाना होगा; यह उस स्थान को शामिल करके हासिल किया जाता है जिसे कैप्चर में पहला चरण जोड़ा गया था। दूसरे पात्र को सही इंडेंट देने के बाद, दूसरे और तीसरे चरित्र आदि के लिए स्टेज को दोहराया जाता है।

m`^

अतिरिक्त इंडेंट निकालें।

मैंने एक 94-बाइट संस्करण लिखा है जो (मेरे चारकोल जवाब की तरह) स्लैश के किसी भी संयोजन की अनुमति देता है: इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.$
¶$.`$* $&

अंतिम स्लैश लेकर गेंद को लुढ़काएं और उसे अपनी लाइन पर उसी स्थिति में लाएं।

/
 /

सभी फ़ॉरवर्ड स्लैश के लिए रिक्त स्थान प्रीफ़िक्स करें ताकि उन्हें कैप्चर किया जा सके।

+`^(.*)( /|\\)¶( *)( \\|/)
$1¶$3$2¶$3$4

बार-बार इनपुट का अंतिम स्लैश लें और इसे नीचे की लाइन पर स्लैश के साथ अपनी लाइन पर संरेखित करें।

+ms`^(?<!^[\\/].*) (?!.*^[\\/])

किसी भी बचे हुए इंडेंटेशन को हटा दें।

G`.

अब खाली इनपुट हटाएं।

— नील
स्रोत

2

लुआ , 96 बाइट्स

c=0 for s in(...):gmatch(".")do c=c+(p==s and(s=="/"and-1or 1)or 0)p=s print((" "):rep(c)..s)end

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

सबसे कम मैं लूआ में आ सकता था। इनपुट कमांड लाइन से लिया गया है।

यह कुछ तरकीबों का उपयोग करता है:

(...):gmatch(
कमांड लाइन से Lua प्रोग्राम में सिंगल स्ट्रिंग प्राप्त करने का यह सबसे छोटा रूप होना चाहिए। ...लुआ में अभिव्यक्ति है कि समारोह घोषणा में निर्दिष्ट नहीं हैं और varargs के लिए प्रयोग किया जाता है एक समारोह के लिए किसी भी अतिरिक्त पैरामीटर कैप्चर करता है। चूंकि लुआ कार्यक्रम का मुख्य निकाय कमांड लाइन के तर्कों के साथ एक फ़ंक्शन के रूप में कहा जाता है, इसलिए कमांड लाइन तर्क समाप्त हो जाएगा ...।
इसके चारों ओर के कोष्ठक संभावित बहु-मूल्यवान ...अभिव्यक्ति को एकल-मूल्यवान अभिव्यक्ति में बदल देते हैं। इस पर विचार करें (कुछ आश्चर्यजनक) उदाहरण:
```
function multipleReturnValues()
    return "abc", "def"
end
print(  multipleReturnValues()  ) --This prints: abc    def
print( (multipleReturnValues()) ) --This prints: abc
```
Lua parser को किसी भी लाइन टर्मिनेटर या बयानों के बीच भी व्हाट्सएप की आवश्यकता नहीं है, जब तक कि दो बयानों के टोकन स्पष्ट रूप से अलग हो सकते हैं और पाठ का केवल एक ही व्याख्या है जो मान्य Lua कोड है।
दुर्व्यवहार and/ के orलिए "यदि x तो मान 1 और मान 2" तर्क। अगर गलत है तो
Lua का andऑपरेटर अपना पहला तर्क देता है; अन्यथा, यह अपना दूसरा तर्क देता है। orऑपरेटर ने अपना पहला तर्क देता है अगर यह truthy है; अन्यथा, दूसरा तर्क।
pकिसी भी आरंभीकरण की आवश्यकता नहीं है।
p==sहमेशा इनपुट के बावजूद लूप के पहले भाग में गलत होना पड़ता है। pलूप में प्रवेश करने से पहले किसी भी मूल्य पर सेट नहीं करना (इसे छोड़ना nil) ऐसा होगा और बाइट्स को भी बचाएगा।

क्या कोई इसे (लुआ में) गोल्फ कर सकता है?

— जोनाथन एस।
स्रोत

मैं gmub का उपयोग करने के बजाय gsub का उपयोग करके दो बाइट्स को सहेजने में सक्षम था। c=0(...):gsub(".",function(s)c=c+(p==s and(s=="/"and-1or 1)or 0)p=s print((" "):rep(c)..s)end)

— QuertyKeyboard

ठीक है, नहीं कि यह मायने रखता है। आप आसानी से बदल कर दो बाइट्स सहेज कर रखा है सकता है gmatch(".")करने के लिए gmatch"."आप अपने अगले जवाब में किया था की तरह।

— QuertyKeyboard

@QuertyKeyboard यह अजीब है ... मैंने वास्तव में इस कोड के पहले संस्करण में बिल्कुल इस तरह से gsub का उपयोग किया था, लेकिन फिर इसके बजाय gmatch पर स्विच कर दिया क्योंकि यह किसी तरह छोटा हो गया। मुझे नहीं पता कि मैंने क्या किया हालांकि, फाइल दुर्भाग्य से ओवरराइट की गई है।

— जोनाथन एस।

2

पायथ , 28 बाइट्स

j.u+?qeNY?>Y\/+PNdPPNPNYtzhz

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

— लीक नयन
स्रोत

आप Qइसके बजाय का उपयोग करके एक बाइट बचा सकते हैं j.u+?qeNY?>Y\/+PNdPPNPNYtQh:।

— आउटगॉल्फ

26 बाइट्स

— स्टेन स्ट्रम

2

आर , 119 बाइट्स

function(s)for(i in 1:nchar(s))cat(rep(" ",cumsum(c(0,!diff(S<-(utf8ToInt(s)>48)*2-1))*S)[i]),substr(s,i,i),"
",sep="")

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

यह user2390246 के उत्तर से कुछ अलग है । वे स्ट्रिंग पर प्रत्येक पुनरावृति करते हैं, एक निश्चित संख्या में अंतरिक्ष वर्ण और फिर उपयुक्त /\वर्ण को प्रिंट करते हैं ।

हालांकि, मैंने स्ट्रिंग को विभाजित करने से परहेज किया, इसके बजाय वर्णों को उनके UTF-8 एन्कोडिंग मान से बदलने के लिए चुना, जो तब मुझे सीधे संख्याओं पर अंकगणित करने की अनुमति देता है, जिसने मुझे कुछ बाइट्स से बचा लिया।

— ग्यूसेप
स्रोत

बस यह कुछ और विचार कर रहा है, मुझे लगता है कि आपके एल्गोरिथ्म में एक त्रुटि है: TIO

— user2390246

@ user2390246 मैंने इसे ठीक किया! मेरे पास कुछ गलत कोष्ठक थे, लेकिन अब diffinvनिश्चित रूप से यहाँ काम नहीं करेगा।

— ग्यूसेप

क्या बारे में tio.run/##HYy7DsIwEAR/…

— JayCe

2

सी # (.NET कोर) , 60/65 बाइट्स

मैंने छोटा C # संस्करण आज़माया

s=>{int i=0;return s.Select(x=>"".PadLeft(x<92?--i:i++)+x);}

जैसा कि कहा गया था: "इसका अर्थ यह भी है कि हर इनपुट एक बैकस्लैश के साथ शुरू होगा।" या धीरे-धीरे लंबे समय तक जो शुरू "/" हल

s=>{int i=s[0]&1;return s.Select(x=>"".PadLeft(x<92?--i:i++)+x);}

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

— सज्जन
स्रोत

साइट पर आपका स्वागत है! :)

— DJMcMayhem

2

लुआ , 88 84 बाइट्स

बेहतर संस्करण (-4 बाइट्स के लिए क्वेर्टीकेबोर्ड का धन्यवाद)

s=""g=s.gsub g(...,".",function(c)s=g(g(g(s,"\\"," "),"/?$",c)," /","/")print(s)end)

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

मूल संस्करण (88 बाइट्स)

लुआ में एक और प्रयास, इस बार काउंटर चर के बजाय स्ट्रिंग हेरफेर का उपयोग करके पूरी तरह से अलग दृष्टिकोण के साथ।

s=""for c in(...):gmatch"."do s=s:gsub("\\"," "):gsub("/?$",c):gsub(" /","/")print(s)end

Ungolfed:

s = ""
for c in string.gmatch((...), ".") do --for each character in the input
  --s contains the output from the previous iteration
  s = s:gsub("\\", " ") --Replace backslash with space -> indent by 1
  s = s:gsub("/?$", c) --Remove any / at the end of the string and append c to the string
  s = s:gsub(" /", "/") --Remove a single space in front of any / -> un-indent by 1
  print(s)
end

कोड में एक दिलचस्प बात है: (...):gmatch"."
यह लूआ पार्सर में कुछ क्विरक्स का उपयोग करता है। जब Lua फॉर्म में कोड का एक टुकड़ा होता है func "string", तो यह इसे रूपांतरित कर देगा func("string")। यह इतना है कि एक print "string"निरंतर स्ट्रिंग को प्रिंट करने के लिए लिख सकता है और यह केवल फ़ंक्शन के बाद एकल स्ट्रिंग शाब्दिक के साथ काम करता है। और कुछ भी एक वाक्यविन्यास त्रुटि देगा। हालाँकि, यह सिंटैक्टिक शुगर एक अभिव्यक्ति के बीच में फ़ंक्शन कॉल के साथ भी काम करता है, और अधिक आश्चर्य की बात है, यह :सिंटैक्टिक शुगर के साथ विधि कॉल के साथ मिलकर ठीक काम करता है । तो अंत में, Lua इस तरह कोड की व्याख्या करेगा:

(...):gmatch"."
-> (...):gmatch(".")
-> string.gmatch((...), ".")

~~अगर कोई तीन gsub कॉल में से एक को हटाने का तरीका सोच सकता है, तो कृपया मुझे बताएं।~~

— जोनाथन एस।
स्रोत

1

मुझे यह जानकर निराशा हुई कि मेरे gsub चाल मैंने आपके अन्य उत्तर में टिप्पणी की थी, इस के लिए काफी काम नहीं किया। यह वास्तव में एक बाइट जोड़कर समाप्त हो गया। हालाँकि, मैं इतनी आसानी से हार नहीं मानूंगा। पहले, मैंने कोड को छोटा करने के लिए एक चर के रूप में gsub को संग्रहीत करने का प्रयास किया। मेरे आश्चर्य करने के लिए, मेरा कोड बाइट्स की समान मात्रा थी - 88. हालांकि, मुझे एहसास हुआ कि gsub को सहेजे जाने के साथ, मेरी gsub चाल अब काम कर सकती है! यहाँ मेरा कोड है कि 4 बाइट्स मुंडा है:s=""g=s.gsub g(...,".",function(c)s=g(g(g(s,"\\"," "),"/?$",c)," /","/")print(s)end)

— QuertyKeyboard

@QuertyKeyboard Yup, मैंने लूप से पहले एक वेरिएबल में gsub को स्टोर करने की कोशिश की और फिर तीन बार gsub लिखने के बजाय इसका उपयोग किया, और मैं इसे देखकर बिल्कुल हैरान रह गया, क्योंकि यह बिल्कुल कोई अंतर नहीं था। "लूप के बजाय गसुब" और "स्टोर ग्सब" ट्रिक को मिलाना वाकई बहुत साफ-सुथरा है, ऐसा किसी ने नहीं सोचा था! धन्यवाद! :)

— जोनाथन एस।

1

पायथ - 33 बाइट्स

पहला प्रयास, गोल्फ होगा।

jsMC,*L;+ZsM._*VqVtzztMxL"/ \\"zz

इसे यहाँ ऑनलाइन की कोशिश करो ।

— Maltysen
स्रोत

मेरा पहला प्रयास 32 बाइट्स

— स्टेन स्ट्रम

दूसरा प्रयास 28 बाइट्स

— स्टेन स्ट्रम

तीसरा प्रयास 26 बाइट्स

— स्टेन स्ट्रम

pinged @maltysen

— स्टेन

@StanStrum इस बिंदु पर, यू इसे सिर्फ अपने जवाब के रूप में पोस्ट कर सकता है

— माल्टीसेन

1

पर्ल, 40 + 2 बाइट्स

/\//&&$.--,say($"x$.,$_),/\\/&&$.++for@F

आपको -Fध्वज की आवश्यकता है ।

1

पर्ल, 34 38 + 1 बाइट्स

दो मामलों को संभालने के लिए

s,(/)|.,$"x($1?$c&&--$c:$c++).$&.$/,ge

-pविकल्प के साथ चलाया जाए

s,(/)|.,$"x($1?--$c:$c++).$&.$/,ge

संपादित करें: पहला वर्ण होने पर निम्न टिप्पणी काम नहीं करती है /

s,(/)|.,$"x($1?$c--:++$c).$&.$/,ge

हालाँकि आउटपुट पहले दाईं ओर एक वर्ण स्थानांतरित किया जाएगा \

— नहुएल फौलीउल
स्रोत

1

के लिए काम नहीं करता है /\\/\\/।

— नील

अपडेट किए गए प्रश्न के साथ आपका मूल 34समाधान अब पूरी तरह से मान्य है

— टन हास्पेल

1

VBA (एक्सेल), 181 बाइट्स

Sub q()
a = Cells(1, 1)
For x = 1 To Len(a)
c = Mid(a, x, 1)
If c = "\" Then: Debug.Print b & c: b = b + " "
If c = "/" Then: b = Left(b, Len(b) - 1): Debug.Print b & c
Next
End Sub

— remoel
स्रोत

1

आप एक्सेल VBA की स्वतः-स्वरूपित प्रकृति का लाभ उठाकर और [...]नोटेशन के उपयोग से अपने एल्गोरिथ्म को बदले बिना इसे काफी कम कर सकते हैं : मैंने इसे 128 बाइट्स तक प्राप्त किया Sub q For x=1To[Len(A1)] c=Mid([A1],x,1) If c="\"Then Debug.?b;c:b=b+" " If c="/"Then b=Left(b,Len(b)-1):Debug.?b;c Next End Sub

— टेलर स्कॉट

मेरी पटकथा को गढ़ने के लिए धन्यवाद। मैंने इससे कुछ सीखा और भविष्य में लागू होगा। :) मुझे नहीं पता था कि मैं इसका उपयोग कर सकता हूँ सीधे डेटा कोशिकाओं में लाने के लिए। धन्यवाद फिर से :)

— रेमोएल

1

पायथ , 24 21 बाइट्स

पोर्ट रॉड के जवाब से ।

VQ=-Z<N\<+*ZdN=+Z>N\<

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

— फेलिप नारदी बतिस्ता
स्रोत

अमान्य, प्रिंट [पहली पंक्ति पर अतिरिक्त अग्रणी स्थान अगर स्ट्रिंग के साथ शुरू होता है \। BTW आपका कोड कहां है?

— श्री Xcoder

@ Mr.Xcoder तय

— फेलिप

1

SOGL V0.12 , 16 13 बाइट्स

{└=-:↕PFoF┘=+

यह कोशिश करो! - स्टैक पर इनपुट की उम्मीद है, इसलिए आसानी से उपयोग के ,लिए जोड़ा जाता है

— dzaima
स्रोत

1

डायलाग एपीएल, 31 बाइट्स

{↑⍵,¨⍨' '/¨⍨{⍵-⍨+\¯1+2×⍵}⍵='\'}

यहाँ कोशिश करो!

— dzaima
स्रोत

{↑⍵↑¨⍨a-1-+\¯1*a←⍵='\'}

— ngn

मेरे अवगुणों को खींचो

उदाहरण

जीएनयू सैड, 20

व्याख्या:

चारकोल , 13 12 11 बाइट्स

पायथन 2 , 55 54 51 57 53 बाइट्स

/// , 119 बाइट्स

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

लघुरूप

इनपुट रीकोडिंग

अंतिम चरण में कार्यक्रम की संरचना

स्थानापन्न साझा किया

एक चरित्र उपप्रोग्राम चलाना

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

कैसे?

हास्केल , 49 बाइट्स

पर्ल 5 , 44 बाइट्स

जावास्क्रिप्ट (ईएस 8), 66 59 63 बाइट्स

MATL , 23 19 18 बाइट्स

व्याख्या

सी # (.NET कोर) , 74 88 82 78 77 76 + 18 बाइट्स

05AB1E , 14 बाइट्स

आर , 122 121 बाइट्स

ब्रेन-फ्लैक , 175 बाइट्स (174 चार्ट + 1 ध्वज)

व्याख्या

रूबी , 80 76 बाइट्स

जावा 8, 121 118 110 109 102 बाइट्स

सी (जीसीसी), 137 134 97 बाइट्स

प्रयोग

Ungolfed

उत्पादन

सी, 60 बाइट्स

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

लुआ , 96 बाइट्स

पायथ , 28 बाइट्स

आर , 119 बाइट्स

सी # (.NET कोर) , 60/65 बाइट्स

लुआ , 88 84 बाइट्स

मूल संस्करण (88 बाइट्स)

पायथ - 33 बाइट्स

पर्ल, 40 + 2 बाइट्स

पर्ल, 34 38 + 1 बाइट्स

पायथ , 24 21 बाइट्स

SOGL V0.12 , 16 13 बाइट्स

डायलाग एपीएल, 31 बाइट्स