बॉक्स खोलने में मेरी मदद करें

33

मेरे पास एक ASCII- कला बॉक्स है और मुझे इसे खोलने के लिए एक कार्यक्रम की आवश्यकता है।

उदाहरण

इनपुट:

-------
|     |
|_____|

आउटपुट:

      /
     /
    /
   /
  /
 /
/
|     |
|_____|

विशिष्टता

  • पहली पंक्ति में केवल -उनमें से कम से कम 3 शामिल होंगे
  • बीच की पंक्तियों के साथ |रिक्त स्थान शुरू होगा , और इसके साथ समाप्त होगा|
    • सभी मध्य पंक्तियाँ समान होंगी
  • अंतिम पंक्ति के साथ शुरू होगा | है _और एक के साथ समाप्त|
  • सभी पंक्तियों की लंबाई समान होगी

बॉक्स खोलना:

  • प्रत्येक -को /आरोही लाइनों और स्थिति में प्रतिस्थापित किया जाना चाहिए ।
code-golf  string  ascii-art 
— Downgoat
स्रोत
2
खेल "शट द बॉक्स" के विपरीत?
— एडिसन क्रम्प
1
— Addison Crump
28
खोला जाने पर ढक्कन दो गुना हो जाता है? ओह ठीक है, ASCII कला को दोष दें।
— डारेल हॉफमैन
8
बॉक्स में क्या है?
— विलीह टोटलैंड
2
कोई काम करने वाला दुभाषिया नहीं है, इसलिए मुझे लगता है कि तब नहीं। कोई बात नहीं; जब मैं दुभाषिया (जल्द ही, उम्मीद से) बनाऊंगा, तो मैं जवाब पोस्ट करूंगा।
— ETHproductions

जवाबों:

7

CJam, 14 बाइट्स

l,{N'/@S*}%W%q

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

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

l               Read the first line from STDIN.
 ,              Compute the line's length. Result: L
  {      }%     Map; for each I in [0 ... L-1]:
                  (implicit) Push I.
   N              Push a linefeed.
    '/            Push a slash.
      @           Rotate I on top of the stack.
       S*         Turn I into a string of I spaces.
           W%   Reverse the resulting array of strings and characters.
             q  Read the remaining input from STDIN.
— डेनिस
स्रोत
12

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

s=>s[r="replace"](/-+/,s=>s[r](/-/g,`
$'/`))[r](/-/g,' ')

एक प्रमुख न्यूलाइन को आउटपुट करता है। की पंक्ति लेकर काम करता है-S और उन्हें एक त्रिभुज में परिवर्तित करता है, फिर -s को स्थान के साथ प्रतिस्थापित करता है ।

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

— नील
स्रोत
1
+1 मैंने कुछ नया ($ ') सीखा। इसके बजाय यह पुरानी चाल आपके लिए 4 बाइट बचा सकती है:f=s=>s[R='replace'](/-+/,s=>s[R](/-/g,"\n$'/"))[R](/-/g,' ')
— edc65
@ edc65 धन्यवाद, मैं वास्तव में इसे 5 बाइट्स बनाता हूं; मेरे टाइपो को ठीक करने के लिए भी धन्यवाद (जैसा कि आपने अनुमान लगाया होगा कि मैं \nइसके साथ विकसित होता हूं और बाद में परिवर्तित होता हूं )।
— नील
9

pb (NONCOMPETING), 125 बाइट्स

^w[B!0]{>}w[B!45]{<w[B=10]{t[T+1]b[0]}}v[X]vw[T!0]{vb[124]<[X]b[124]>w[B=0]{>}t[T-1]}w[X!1]{<b[95]}<w[B!0]{^}w[Y!-1]{b[47]>^}

Pbi का संस्करण जिसे आपको इस उत्तर को चलाने की आवश्यकता है वह प्रश्न की तुलना में नया है। इसने पुराने संस्करणों में काम किया होगा, सिवाय इसके कि मुझे इनपुट में नए सिरे से अनुमति देने के लिए कभी नहीं मिला। ओह अच्छा।

सबसे पहले, यह इनपुट में newlines की गिनती करके बॉक्स की ऊंचाई निर्धारित करता है। एक बार जब यह पता चल जाता है कि, यह बॉक्स के दाईं ओर के Y स्थान पर जाता है, नीचे जाता है जहाँ इसे होना चाहिए और ढक्कन के साथ दीवारों और फर्श को खींचता है।

इस मजेदार एनीमेशन की जाँच करें!

लंबा पोज इनपुट पर जा रहा ब्रश है।

Ungolfed:

^w[B!0]{>}                # Go to the end of the input
w[B!45]{<                 # Head left until hitting a hyphen
    w[B=10]{                # For each newline on the way:
            t[T+1]                # Count it
            b[0]                  # Delete it
    }
}

v[X]                      # Move down as far as it is right + the number of \n
v                         # ...plus one

w[T!0]{                   # While the counting variable is nonzero:
    vb[124]                 # Go down and draw a pipe
    <[X]b[124]              # Draw a pipe on the left as well
    >w[B=0]{>}              # Go back to the right side
    t[T-1]                  # Decrement variable
}

w[X!1]{<b[95]}            # Draw the bottom of the box
<w[B!0]{^}                # Go up the left wall
w[Y!-1]{b[47]>^}          # Go up and right, drawing the lid
— undergroundmonorail
स्रोत
2
शांत एनीमेशन के लिए +1। आपने इसे कैसे बनाया?
— गौतम
@ गौतम मुझे लगता है कि आप अपनी स्क्रीन रिकॉर्ड करेंगे और वीडियो को क्रॉप करेंगे। फिर, इसे लें और इसे GIF में परिवर्तित करें। बेशक, सिर्फ अनुमान लगाते हुए, मैं वास्तविक विधि नहीं जानता
— स्पॉटलाइट
@ भयानक 1 आपको मिल गया
— भूमिगत
8

रेटिना, ३४ 20 बाइट्स

- (= (- *)) ¶?
$ 1 / ¶
-

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

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

— randomra
स्रोत
2
बस इसके मज़े के लिए, यह एक चरण में भी संभव है: retina.tryitonline.net/… (वैसे बाइट्स हालांकि)
— मार्टिन
यदि आप पहली नई लाइन अलग से खाते हैं तो आप $%'ट्रेलिंग -एस को पकड़ने के लिए उपयोग कर सकते हैं जो आपको 5 बाइट्स बचाता है: इसे ऑनलाइन आज़माएं!
— नील
7

MATL , 14 15 बाइट्स

' /'jnXyPQ)`jt

इनपुट में एक अनुगामी न्यूलाइन होनी चाहिए।

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

व्याख्या

' /'       % push string (will be indexed into to generate the open lid)
jn         % read first line of input and push its length
Xy         % identity matrix with that size
P          % flip vertically
Q          % add 1. Now the matrix contains 1 and 2, to be used as indices
)          % index into string. Produces a 2D char array for the lid
`          % do-while loop
  j        %   push input line
  t        %   duplicate. Truthy if nonempty
           % implicitly end loop. The loop condition is the top of the stack,
           % that is, the input line that has just been read.
           % This is truthy if non-empty; and in that case another line will
           % be read in the next iteration.
           % implicitly display stack contents, bottom to top
— लुइस मेंडो
स्रोत
5

जाप, 28 26 25 22 18 17 बाइट्स

Ur-@"
{SpUa- -Y}/

इसे ऑनलाइन टेस्ट करें!

एक प्रमुख न्यूलाइन को आउटपुट करता है, जो ओपी के अनुसार स्वीकार्य है।

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

Ur-@       // Replace each hyphen X in the input and its index Y with this function:
"          //  Start a string that contains a newline.
{        } //  Insert here:  
   Ua- -Y  //   Take the index of the last hyphen in the input, subtract Y,
 Sp        //   and return that many spaces.
/          //  Finish off the string with a slash.

यदि बॉक्स के दाहिने किनारे पर टिका होने की अनुमति है तो यह 4 बाइट्स छोटा होगा:

Ur-@"
{SpY}\\
— ETHproductions
स्रोत
4

जावास्क्रिप्ट (ईएस 6), 66

b=>([a,t]=b.split`-
`,[...a+0].map(_=>(t=l+`/
`+t,l+=' '),l=''),t)

परीक्षा

f=b=>([a,t]=b.split`-\n`,[...a+0].map(_=>(t=l+`/\n`+t,l+=' '),l=''),t)

var box = `-------
|     |
|_____|`

console.log=x=>O.textContent=x

console.log(f(box))
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
3

जावा 8, 158 118 बाइट्स

यह सिर्फ एक शुरुआत है, लेकिन हे, FGITWFTW। 

n->{String o="";int z=n.lastIndexOf("-"),i=z;for(;i-->0;o+="/\n")for(int y=i;y-->0;o+=" ");return o+n.substring(z+2);}

एक स्ट्रिंग के रूप में इनपुट की अपेक्षा करता है, बॉक्स लौटाता है।

— एडिसन क्रम्प
स्रोत
3

पायथन 3, 1̶7̶0̶ 88 बाइट्स

यहाँ मेरा शॉर्ट (एर) कोड है: EDIT: अब 82 बाइट्स शॉर्टर विथ @ डेनिस कोड एडिट!

f=open('f.txt')
d=len(f.readline())-1
a=f.read()
while d:d-=1;print(' '*d+'/')
print(a)

पायथन 3, 421 बाइट्स

वैकल्पिक रूप से, केवल मनोरंजन के लिए, आप इसे धीरे-धीरे खोलने वाले एक का उपयोग कर सकते हैं:

import time
import os
f = open('f.txt', 'r')
e = f.readline()
a = f.read()
d = len(e)
c = 0
t = e + a
g = ''
clear = lambda: os.system('cls')
while c <= d - 1:
    clear()
    print(("\n" * ((d - 1) - (c))) + t)
    c += 1
    e1 = e[0:(d - c)  -1]
    e2 = e[(d - c):len(e)]
    e1 += '/'
    e2 = ' ' * len(e2)
    y = (' ' * len(e1)) + '/' + '\n'
    g += y
    t = (g + e1 + e2 + '\n' + a)[d:len(g + e1 + e2 + '\n' + a)]
    time.sleep(0.2)
f.close()

या तो उपयोग करने के लिए, आपको एक ही डायरेक्टरी में एक टेक्स्ट फाइल बनानी होगी जिसमें किसी भी चौड़ाई या गहराई का एससी बॉक्स हो, जिसे 'f.txt' कहा जाता है। इसके बाद वह बॉक्स खुल जाएगा।

— राक्षस
स्रोत
1
आप इसे एक अक्षर के लिए चर को छोटा करके और ऑपरेटरों के बीच कई व्हाट्सएप को हटाकर छोटा कर सकते हैं। पायथन में गोल्फ के लिए सामान्य सुझावों के लिए, यहां देखें ।
— एलेक्स ए।
पृथ्वी पर आपको समय की आवश्यकता क्यों है ? यह सवाल केवल एक आउटपुट के लिए पूछता है।
— Addison Crump
जैसा कि मैंने कहा, इस पहेली की मेरी व्याख्या थोड़ी बंद थी और यदि आप इसका उत्पादन करते हैं तो यह आपके द्वारा पूछे गए प्रश्न से अधिक दिखाएगा।
— मॉन्सटर
ठीक है, मैंने एक सरल उत्तर जोड़ा है जो वास्तव में वही कहता है जो अब मैं समझता हूं। यह सुंदर नहीं है, लेकिन यह काम करता है। मेरा वैकल्पिक कोड किसी के लिए भी बहुत बढ़िया है जो इसे खुला देखना चाहता है
— मॉन्स्टर
2
कुछ मामूली बदलाव आपके बाइट काउंट को 81 (STDIN से पढ़ना) तक लाते हैं।
— डेनिस
3

बैश, 85 84 79 वर्ण

(शुद्ध बैश संस्करण, कोई बाहरी कमांड का उपयोग नहीं किया गया।)

r(){
a="${a/-
/
$s/
}"
s+=\ 
[[ $a = -* ]]&&r
}
mapfile a
r
IFS=
echo "${a[*]}"

एक प्रमुख न्यूलाइन को आउटपुट करता है।

नमूना रन:

bash-4.3$ bash open-the-box.sh <<< $'-------\n|     |\n|_____|'

      /
     /
    /
   /
  /
 /
/
|     |
|_____|
— आदमी काम पर है
स्रोत
echoएक बाहरी आदेश है /usr/bin/echo;);
— लेवी
echoनिष्पादन मानकों के साथ ऑपरेटिंग सिस्टम के अनुरूपता के लिए मौजूद है। आजकल उस एक का उपयोग केवल तभी किया जाता है यदि पोर्टेबिलिटी महत्वपूर्ण है, क्योंकि वह मानक पर निर्भर है , लेकिन अधिकांश आधुनिक गोले का अपना बिलिन होता है, echoजिसका उपयोग डिफ़ॉल्ट रूप से किया जाता है: pastebin.com/RnxhweBv @Levi, यदि आपका नाम बदला / स्थानांतरित हुआ /usr/bin/echo, तो मेरा कोड अभी भी काम करेगा।
— मैनटवर्क
(यह एक मजाक था ....)
— लेवी
1
ओह। ठीक है। क्षमा करें, मैं पहले ही ऐसे लोगों से मिल चुका हूं जो समान दावा करते हैं, लेकिन गंभीरता से।
— मैनेटवर्क
3

पर्ल, 61 54 33 + 3 = 36 वर्ण

s^-^" "x(length$')."/\n"^ge&chomp

इसे के रूप में चलाएँ

perl -ple 's^-^" "x(length${chr 39})."/\n"^ge&chomp' closed_box_file

-पहली पंक्ति में प्रत्येक को एक स्ट्रिंग से बदल दिया जाता है, जो कि कुछ संख्याओं के संघनन का परिणाम है , /और \n। ${chr 39}perl's (में) प्रसिद्ध $'उर्फ $POSTMATCHविशेष चर का मूल्यांकन करता है । अंत में, चॉम्पिंग को नए चरित्र के पीछे आने वाले चरित्र से छुटकारा मिल जाता है जिसे अंतिम -चरित्र के लिए जोड़ा गया था ।

7 + अधिक वर्ण सहेजने के लिए @manatwork का धन्यवाद।

बोनस - s^-^" "x$i++."\\\n"^ge&&chopदाईं ओर से बॉक्स को 29 + 3 अक्षरों में खोलता है :)। इसे इस रूप में चलाएं:

gowtham@ubuntu:~$ cat a
----
|  |
|__|
gowtham@ubuntu:~$ perl -plE 's^-^" "x$i++."\\\n"^ge&&chop' closed_box_file
\
 \
  \
   \
|  |
|__|
— Gowtham
स्रोत
@ मैनटवर्क में केवल पहली पंक्ति शामिल है -, हां, मैं इसे और भी अधिक गोल्फ कर सकता हूं। धन्यवाद!
— गौतम
$.==1→ $.<2, &&chop→ &chop, चारों ओर कोष्ठक की अतिरिक्त जोड़ी को हटा दें length, {chr 39}1 के रूप में गिनें , क्योंकि यह केवल शेल के सिंटैक्स के कारण कमांड लाइन संस्करण द्वारा आवश्यक नहीं है: $.<2&&s^-^" "x(length$')."/\n"^ge&chopकमांड लाइन विकल्पों के लिए + 2 वर्ण मेरी गिनती के अनुसार = 40। pastebin.com/iDhUs9XX
— मैनटवर्क
@manatwork वास्तव में, $.==1या $.<2समाप्त किया जा सकता है क्योंकि केवल पहली पंक्ति में शामिल है-
— गौतम
हां, मैंने देखा कि आपने वहां क्या किया। और मैं अचंभित था। वैसे, आप इसके बजाय कोड में एक शाब्दिक लाइन रैप का उपयोग कर सकते हैं \n।
— मैनटवर्क
रवींद्र। एक छोटे से मिला:s^-^$'=~y/-/ /r."/\n"^ge&chomp
— manatwork
2

पायथ, 26 23 बाइट्स

jXK.z0jm+*\ t-lhKd\/lhK

छी। निश्चित रूप से कम हो सकता है; अभी तक उस पर कार्य कर रहा हूं।

— Doorknob
स्रोत
2

पायथन 3, 76 बाइट्स

f=open(0)
w=len(f.readline())
while w:w-=1;print(' '*w+'/')
print(f.read())
  1. पहली इनपुट लाइन की लंबाई प्राप्त करें।
  2. /स्थानों की घटती संख्या से पहले की प्रिंट लाइनें ।
  3. बाकी के stdinसीधे पुश करें stdout।

संपादित करें: मैंने अभी देखा है कि मेरा कोड @ मॉन्स्टर की छोटी पायथन 3 कोड की @Dennis की टिप्पणी के समान है, एकमात्र अंतर stdinयह है कि एक चर में इसे स्टोर करने के बजाय सीधे शेष को प्रिंट किया जा रहा है । महान दिमाग!

— josh2112
स्रोत
1

अजगर 2, 100 बाइट्स

def o(b):
 m=b.split('\n')[1:]
 print"\n".join(["/".rjust(i)for i in range(len(m[0]),0,-1)]+m)

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

— Scimonster
स्रोत
1

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

$d,$b=$args-split"`n";($d.length-1)..0|%{" "*$_+"/"};$b

$argsएक स्ट्रिंग के रूप में इनपुट लेता है , -splitnewlines `n ( संदर्भ लिंक ) पर है , पहली पंक्ति को $d(स्ट्रिंग के रूप में) और शेष को $b(स्ट्रिंग की एक सरणी के रूप में) संग्रहीत करता है । हम तो lengthपहली पंक्ति (शून्य 1) से लूप 0और प्रत्येक पुनरावृत्ति आउटपुट से रिक्त स्थान की संख्या प्लस a/ । अंत में, आउटपुट $b(इनपुट स्ट्रिंग के बाकी) जो डिफ़ॉल्ट रूप से प्रति पंक्ति एक आउटपुट होगा।

उदाहरण रन

PS C:\Tools\Scripts\golfing> .\help-me-open-the-box.ps1 "----`n|  |`n|__|"
   /
  /
 /
/
|  |
|__|
— AdmBorkBork
स्रोत
— Veskah
1

जावास्क्रिप्ट (Node.js) , 56 बाइट्स

a=>a[b="replace"](/-+/,c=>c[b](d=/-/g,`
$'/`))[b](d,' ')

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

@Neil के उत्तर की टिप्पणी के रूप में लिखा जाना चाहिए, लेकिन मैं अभी तक टिप्पणी नहीं बना सकता

— Any3nymous उपयोगकर्ता
स्रोत
नमस्कार और पीपीसीजी में आपका स्वागत है। मुझे लगता है कि आप नील के जवाब का मतलब है जिसे आपने आगे बढ़ाया है। आप उनके उत्तर के लिए एक कड़ी जोड़ना चाहते हैं और क्रेडिट देने के लिए लेखक का नाम सही कर सकते हैं।
— जोनाथन फ्रीच
@JonathanFrech धन्यवाद, किया गया
— Any3nymous उपयोगकर्ता
1

05AB1E (विरासत) , 9 बाइट्स

g'/1.Λ|»»

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

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

g'/1.Λ|»» – Full program. Takes input from STDIN.
g         - Length. Only takes the first line into account.
 '/       – Push a slash character, "/".
   1.Λ    – And diagonally up-right, draw a line of slashes of the given length.
      |»  – Push the remaining inputs (all other lines) joined on newlines.
        » – Then join the stack on newlines.
— मिस्टर एक्सकोडर
स्रोत
1

चारकोल , 14 बाइट्स

↙Ｌ§⪪θ¶⁰Ｍ→✂⪪θ¶¹

इसे ऑनलाइन (क्रिया) आज़माएँ या इसे ऑनलाइन (शुद्ध) आज़माएँ ।

स्पष्टीकरण:

इनपुट को न्यूलाइन्स द्वारा विभाजित करें, पहली पंक्ति की लंबाई लें, और उस लंबाई की एक पंक्ति को टॉप-राइट से डाउन-लेफ्ट तक प्रिंट करें:

Print(:DownLeft,Length(AtIndex(Split(q,"\n"),0)))
↙Ｌ§⪪θ¶⁰

एक बार दाईं ओर ले जाएं:

Move(:Right)
Ｍ→

इनपुट को नए सिरे से विभाजित करें, और पहले आइटम को हटा दें, और जो कुछ बचा है उसे प्रिंट करें:

Slice(Split(q,"\n"),1)
✂⪪θ¶¹

(नोट: इनपुट को विभाजित करके newlines द्वारा एक चर में (क्योंकि मैं इसे दो बार ऊपर करता हूं) 1 बाइट लंबी है और थोड़ी अलग विधि का उपयोग करके 14 बाइट्स भी है ( @Neil के लिए धन्यवाद ):
≔⮌⪪θ¶θ↙Ｌ⊟θＭ→⮌θ इसे ऑनलाइन आज़माएं ( क्रिया ) या ऑनलाइन प्रयास करें (शुद्ध )।

— केविन क्रूज़सेन
स्रोत
यदि आप नई विभाजन द्वारा इनपुट विभाजन को उलटते हैं तो आप पहली पंक्ति को पॉप कर सकते हैं जो आपको 14 बाइट्स में वापस लाती है: इसे ऑनलाइन आज़माएं!
— नील
0

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

q=>(q=q.split`
`,n=q[0].length,eval('for(i=0,r="";i<n;i++)r+=" ".repeat(n-i-1)+"/\\n"'),r+q.slice(1).join`
`)

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

इसका परीक्षण करो! (केवल ES6 :()

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

— कोनोर ओ ब्रायन
स्रोत
2
मैं देख रहा हूं कि आपने फॉर्मेटिंग का उपयोग करके XKCD समस्या को हल किया है । चतुर।
— क्रोल्टन
.repeat(n-i-1)=>.repeat(n+~i)
— डाउनगोट
0

पायथन 2.7, 120 122 चार्ट

fमूल / बंद बॉक्स के साथ एक फ़ाइल की आवश्यकता है , आउटपुट एक खोला गया है। विचार के लिए @Monster के लिए चीयर्स ... बाद में मल्टी-लाइन इनपुट का पता लगाने की कोशिश करेंगे और देखें कि क्या यह छोटा है।

for l in open('f').readlines():
 if l[1]==('-'):
  for x in range(1,len(l)):print(' '*(len(l)-x+1)+'/')
 else:print l[:-1]

संपादित करें

  • बस ध्यान दिया कि /सामने बाईं ओर एक स्थान है; +2 बाइट्स
— janrn
स्रोत
0

रूबी, 59 वर्ण

(57 वर्ण कोड + 2 वर्ण कमांड लाइन विकल्प।)

s=""
$_=$_.chars.map{(s<<" ")[1..-1]+?/}.reverse*$/if$.<2

नमूना रन:

bash-4.3$ ruby -ple 's="";$_=$_.chars.map{(s<<" ")[1..-1]+?/}.reverse*$/if$.<2' <<< $'-------\n|     |\n|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|
— आदमी काम पर है
स्रोत
0

बैश, 129 वर्ण

aबंद बॉक्स के साथ नामक एक फ़ाइल की आवश्यकता होती है , आउटपुट स्टडआउट के लिए।

for i in $(seq `cat a|awk 'NR==1{print length($1)-1}'` -1 1);{ for j in `seq 1 $i`;{ printf " ";};echo "/";};echo "/";tail -n2 a

sedस्टड और पाइपिंग का उपयोग करके इसे कम करना संभव हो सकता है ।

— डैनियल पीयूकेर्ट
स्रोत
अच्छा पहला गोल्फ जवाब। कुछ सरल वाक्यविन्यास परिवर्तन सुझाव:for i in $(seq `awk 'NR<2&&$0=length-1' a` -1 1);{ for j in `seq 1 $i`;{ printf \ ;};echo /;};echo /;tail -n2 a
— manatwork
0

PHP, 127 वर्ण

$s=$argv[1];$l=strlen(strtok($s,"\n"));for($i=0;$i<$l;$i++)$s=preg_replace("/-/","\n".str_repeat(" ",$l-$i-1)."/",$s,1);echo$s;

Ungolfed संस्करण:

$s=$argv[1];
$l=strlen(strtok($s,"\n"));

for($i=0;$i<$l;$i++){
    $v="\n".str_repeat(" ",$l-$i-1)."/";
    $s=preg_replace("/-/",$v,$s,1);
}
echo $s;
— kuldeep.kamboj
स्रोत
आपके कोड में एक टाइपो है: आप के सतर्क को याद किया $argv। आपके द्वारा लागू किए जा सकने वाले कुछ छोटे-छोटे $l=strlen(strtok($s=$argv[1],"↵"));while($l)$s=preg_replace("/-/","↵".str_repeat(" ",--$l-$i)."/",$s,1);echo$s;
— टोटके हैं
0

अजगर, 125 बाइट्स (110 बिना बॉक्स के)

i="\n---\n| |\n|_|"
l,b,r=i.count("-"),i.split('\n'),range
for x in r(1,l):print" "*(l-x)+"/"
for x in r(2,len(b)):print b[x]

अगर किसी को कोई आइडिया है तो उसे छोटा कैसे करें, कृपया मुझे बताएं!

— डेव लिन
स्रोत
0

Awk, 47 46 वर्ण

(44 वर्ण कोड + 2 वर्ण कमांड लाइन विकल्प।)

/-/{OFS=RS;for(i=NF;i;i--){$i=s"/";s=s" "}}1

नमूना रन:

bash-4.3$ awk -F '' '/-/{OFS=RS;for(i=NF;i;i--){$i=s"/";s=s" "}}1' <<< $'-------\n|     |\n|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|
— आदमी काम पर है
स्रोत
0

गेमा, ५१ ४ ९ ३१ अक्षर

-\P/-+/=@subst{-=\\ ;$1}/\n
-=/

नमूना रन:

bash-4.3$ gema -e '-\P/-+/=@subst{-=\\ ;$1}/\n;-=/' <<< $'-------\n|     |\n|_____|'
      /
     /
    /
   /
  /
 /
/
|     |
|_____|
— आदमी काम पर है
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.