24

मैंने पहले ही इसे पायथन में बनाया है, लेकिन ऐसा लगता है कि इसे बहुत छोटा किया जा सकता है:

txt = input("Type something.. ")
c = "#"
b = " "
print(c * (len(txt) + 4))
print(c, b * len(txt), c)
print(c, txt, c)
print(c, b * len(txt), c)
print(c * (len(txt) + 4))

तो अगर उपयोगकर्ता प्रकार:

Hello World

कार्यक्रम प्रिंट:

###############
#             #
# Hello World #
#             #
###############

सबसे कम बाइट्स जीतती हैं - और निश्चित रूप से, इसका उत्तर किसी भी भाषा में लिखा जा सकता है।

code-golf string

— Jacob_
स्रोत

संपादक गोल्फ के रूप में एक ही चुनौती।

— मार्टिन एंडर

1

इतना अलग नहीं है: codegolf.stackexchange.com/questions/57442/show-tree-rings-age/…

— edc65

1

इनपुट स्ट्रिंग में लाइनब्रेक नहीं होगा, है ना?

— फ्लोडेल

2

@ edc65 मैं असहमत हूं, यह चुनौती बेहद अलग है

— बीटा

10

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

— मार्टिन एंडर

17

CJam, 22 20 बाइट्स

qa{4/3*' +f+W%z}8/N*

इसका परीक्षण यहां करें।

व्याख्या

आप रिक्त स्थान (या किसी अन्य वर्ण) की एक परत में वर्णों के 2D ग्रिड को कैसे लपेटते हैं? सही: चार बार, आप प्रत्येक पंक्ति में एक स्थान जोड़ते हैं और फिर 90 डिग्री से ग्रिड को घुमाते हैं। ठीक यही मैं यहां आठ चक्कर लगा रहा हूं: रिक्त स्थान के लिए चार, चार के लिए #:

qa      e# Read the input and wrap it in an array, to make it a 2D grid.
{       e# Execute this block for each value from 0 to 7.
  4/3*  e#   Divide by 4, multiply by 3. Gives 0 for the first four iterations and
        e#   and 3 for the other four.
  ' +   e#   Add the result to a space character (space + 3 == #).
  f+    e#   Append this to each line of the grid.
  W%z   e#   Reverse the lines, then transpose the grid - together these rotate it.
}8/
N*      e# Join the lines of the grid by newlines.

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

1

क्या एक साफ समाधान!

— जोशपब्रॉन

1

मुझे स्पष्टीकरण पसंद है :-D

— जॉन ड्वोरक

13

vim, 28 27 कीस्ट्रोक्स

I# <esc>A #<esc>Y4PVr#G.kwv$3hr kk.

मान लेते हैं कि वर्तमान में खुली फ़ाइल में टेक्स्ट की एक पंक्ति के रूप में इनपुट प्रदान किया गया है।

स्पष्टीकरण:

I# <esc>        put a "#" and space at the beginning of the line
A #<esc>        put a space and "#" at the end of the line
Y4P             copy the line 4 times
Vr#             replace the entirety of the first line with "#"s
G.              do the same for the last line
kwv$3hr<space>  replace middle of the fourth line with spaces
kk.             do the same for the second line

इसे भी "प्रोग्राम" के रूप में चलाया जा सकता है:

echo 'Hello World' | vim - '+exe "norm I# \<esc>A #\<esc>Y4PVr#G.kwv$3hr kk."'

जो थोड़ा सा जटिल है, लेकिन यह काम करता है।

— Doorknob
स्रोत

1

यह सबसे अच्छा जवाब है, क्योंकि यह मेरे दिमाग की तरह काम करता है।

— tchrist

12

pb - 89 बाइट्स

v[4]w[Y!-1]{b[35]^}w[B!0]{t[B]vvv>>b[T]^^^<}v>>>w[Y!4]{b[35]v}w[X!0]{b[35]^[Y]b[35]v[4]<}

यह उसी तरह की चुनौती है, जिसके लिए pb बनाया गया था! ऐसा नहीं है कि यह इस तरह की चुनौती या किसी भी चीज के लिए प्रतिस्पर्धी है। यह अभी भी एक भयानक गोल्फ भाषा है। हालाँकि, इस तरह की चुनौतियाँ एक दर्द में दूसरों की तुलना में पीबी में हल करने के लिए बहुत कम हैं। चूँकि pb अपने आउटपुट को 2D कैनवास के रूप में मानता है और किसी भी कोर्डर्स को लिखने में सक्षम होता है, इसमें टेक्स्ट के आसपास पोजिशनिंग / ड्रॉइंग (यानी यह चैलेंज) को शामिल करने की कोई भी चीज़ होती है, बल्कि उसे सहज रूप से हैंडल किया जाता है।

इसे देखें:

यह दृश्य pbi के इन-डेवलपमेंट संस्करण, pb दुभाषिया के साथ बनाया गया था। ब्लू बैकग्राउंड वाली लाइन वह है Y=-1, जहां प्रोग्राम शुरू होने पर इनपुट स्टोर किया जाता है। लाल पृष्ठभूमि के साथ आयत ब्रश का वर्तमान स्थान है। पीले रंग की पृष्ठभूमि के साथ आयताकार कहीं भी हैं एससीआई चरित्र 32 (एक स्थान) स्पष्ट रूप से कैनवास पर लिखा गया है। इस पृष्ठभूमि के बिना किसी भी रिक्त स्थान का वास्तव में मूल्य होता है 0, जिसे एक स्थान पर परिवर्तित किया जाता है।

यहाँ कुछ टिप्पणी के साथ कोड का उपयोग किया गया है, जो इसे कुछ प्रासंगिक प्रासंगिक हेडर के साथ लिखते हैं;)

################################
#                              #
# Handle first column oddities #
#                              #
################################
v[4]           # Start from Y=4 and go up (so we land on input afterwords)
w[Y!-1]{       # While we're on the visible part of the canvas
    b[35]^         # Write "#", then go up
}

#########################
#                       #
# Insert text of output #
#                       #
#########################

w[B!0]{        # For each character of input
    t[B]           # Save input char in T
    vvv>>          # Down 3 + right 2 = where text part of output goes
    b[T]^^^<       # Write T and go to next char
}

###############################
#                             #
# Handle last column oddities #
#                             #
###############################

v>>>           # Go to Y=0, X=(X of last text output's location + 2)
w[Y!4]{        # Until we reach the last line of output
    b[35]v         # Draw "#", then go down
}

###########################
#                         #
# Loop to finish Y=0, Y=4 #
#                         #
###########################

w[X!0]{        # Until we've gone all the way left
    b[35]^[Y]      # Print "#" at Y=4, go to Y=0
    b[35]v[4]      # Print "#" at Y=0, go to Y=4
    <              # Move left, printing until output is complete
}

— undergroundmonorail
स्रोत

3

Not that it's competitive... It's still a horrible golf language.मैं कहता हूं कि, लेकिन अभी मैं केवल आखिरी के लिए बंधा हूं । मैं एकमुश्त आखिरी होने की उम्मीद कर रहा था। : डी

— अंडरग्राउंडोरेल

9

brainfuck - 156 बाइट्स

++++++++++>,[>>+++++[<+++++++>-],]<....[.---<<]>>+++>>+++.---.[.>>]<<.+++.[<]>.>>+++.---.<[.>>]<<<.>>.---[<]>.--->>+++.---[.>>]<<..+++.---[<]>[+++.>>]<<....

यह शायद गोल्फ है। कुछ ऐसे स्थान हैं जहाँ मुझे नहीं पता था कि पुन: उपयोग के लिए किसी मूल्य को स्टोर करना बेहतर होगा या इसे रीमेक करने के लिए / टेप पर कहीं और से प्राप्त करने के लिए। यह पता लगाने के लिए काम करने के बजाय, मैंने ऐसा नहीं किया। : डी

टिप्पणियों के साथ:

++++++++++>              Place a 10 (\n) at the beginning of the tape

,[>>+++++[<+++++++>-],]  Place a byte of input; place a 35 (#); repeat until end of input

<....                    Print the last cell (35; #) 4 times

[.---<<]                 Print every noninput cell on the tape in reverse (one # for each byte of input; then \n)
                         After printing each cell; decrease it by 32

>>+++                    Increase the 7 back up to 10

>>+++.---.               Increase a 32 (space) back up to 35 (#); print it; put it back to 32 and print again

[.>>]                    Print every 32 on the tape (one for each byte of input)

<<.+++.                  Print the last space again; increase it by 3 and print the resulting #

[<]>.                    Go to the beginning of the tape and print the \n

>>+++.---.               Increase a 32 (space) back up to 35 (#); print it; put it back to 32 and print again

<[.>>]                   Print every byte of input

<<<.>>.---               Print a space; then print a 35 (#} that was left behind earlier; Set it back to 32 after

[<]>.---                 Go to the beginning of the tape and print the \n; decrease by 3

>>+++.---                Set a space to #; print it; set it back to space

[.>>]                    Print all spaces

<<..+++.---              Print a space twice more; set it to #; print it again; set it back to space

[<]>                     Go to the "newline" (currently a 7 instead of 10)

[+++.>>]                 Increase by 3; print; do the same for all spaces (to set them to # before printing)

<<....                   Print the last # 4 more times

— undergroundmonorail
स्रोत

5

के, 21 बाइट्स

4(|+"#",)/4(|+" ",)/,

स्ट्रिंग को सूचीबद्ध करें, एक स्ट्रिंग के सभी चार पक्षों के लिए एक स्थान जोड़ें, फिर स्ट्रिंग के प्रत्येक पक्ष में एक ऑक्टोथोरपे जोड़ें। कार्रवाई में:

  4(|+"#",)/4(|+" ",)/,"Hello."
("##########"
 "#        #"
 "# Hello. #"
 "#        #"
 "##########")

ओके, कोना और के 5 में काम करता है।

लंबाई के एक चरित्र के भीतर काफी भिन्नताएं हैं जो उपरोक्त में अतिरेक को दूर करती हैं, लेकिन कोई भी तब भी नहीं लगता है जब हमें केवल "रैप" ऑपरेशन दो बार करना पड़ता है:

{x{|+x," #"y}/&4 4},:
{x{|+x,y}/,/4#'" #"},:
{x{|+x,y}/" #"@&4 4},:
{|+x,y}/[;" #"@&4 4],:

— JohnE
स्रोत

3

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

Js[K\#*d+2lzKb*K+4lz)_Jjd[KzK)J

आगे कैसे गोल्फ के बारे में संकेत देने वाली टिप्पणियों में लोगों को धन्यवाद, मैं वास्तव में अच्छी तरह से भाषा नहीं जानता जैसा कि आप (शायद) बता सकते हैं।

— नीला
स्रोत

2

संकेत के जोड़े: "#"के बराबर है \#। यदि आपको बहुत सी वस्तुओं को समाप्‍त करना है तो आप उन वस्तुओं की j""[सूची का उपयोग कर सकते हैं, जो इसके बराबर है jk[।

— orlp

1

कुछ और संकेत। तार के सरणियों के लिए s[बराबर है jk[। इसके अलावा, आप Kमक्खी पर भी असाइन कर सकते हैं, जैसे jk[K\#, और बस प्रारंभिक असाइनमेंट को छोड़ दें। नियत lzकरने के लिए Jमदद करता है, तो केवल दो बार इस्तेमाल किया है, तो बचाने नहीं है Jकुछ और के लिए। यहाँ, आप स्वैप करता है, तो Zके लिए Jआप निकाल सकते हैं =। अंत में, आप Jमक्खी पर असाइन कर सकते हैं । फिर कोड इस तरह दिखता है:_Js[K\#*d+2lzKb*K+4lz)jd[KzK)J

— PurkkaKoodari

3

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

धन्यवाद @WorldSEnder

s=" ";n=s+input()+s
b=len(n)
h="#";x=h*(b+2);y=h+s*b+h;z="\n"
print(x+z+y+z+h+n+h+z+y+z+x)

उदाहरण I / O:

This is a test
##################
#                #
# This is a test #
#                #
##################

— बीटा डिके
स्रोत

s=" "शुरुआत में मुझे लगता है कुल मिलाकर 1 बाइट बचाता है।

— वर्ल्डसेडर

;नई लाइनों के बजाय btw का उपयोग क्यों ? दोनों एक बाइट होनी चाहिए, है ना?

— जेरोमेज

3

@JeromeJ मुझे पता है कि इससे कोई फर्क नहीं पड़ता है, लेकिन अगर आप इसे एक पंक्ति में रखते हैं तो यह छोटा दिखता है;)

— बीटा डेके

3

पर्ल, 43 76 बाइट्स

निर्दिष्ट के रूप में प्रत्येक पाठ इनपुट लाइन रूपांतरण:

s/.*/($x=("#"x(4+($z=length))))."\n".($y="#"." "x(2+$z)."#\n")."# $& #\n$y$x"/e

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

echo surround a long string with pounds | 
perl -ple's/.*/($x=("#"x(4+($z=length))))."\n".($y="#"." "x(2+$z)."#\n")."# $& #\n$y$x"/e' 
######################################
#                                    #
# surround a long string with pounds #
#                                    #
######################################

यहाँ देखें कि यह वास्तव में क्या कर रहा है:

perl -MO=Deparse,-p,-q,-x9 -ple '($x=("#"x(4+($z=length))))."\n".($y="#"." "x(2+$z)."#\n")."# $& #\n$y$x";'
BEGIN { $/ = "\n"; $\ = "\n"; }
LINE: while (defined(($_ = <ARGV>))) {
    chomp($_);
    (((($x = ('#' x (4 + ($z = length($_))))) . "\n") . ($y = (('#' . (' ' x (2 + $z))) . "#\n"))) . (((('# ' . $&) . " #\n") . $y) . $x));
}
continue {
    (print($_) or die((('-p destination: ' . $!) . "\n")));
}
-e syntax OK

तो इस तरह कुछ और:

((  
      (($x =  ('#' x (4 + ($z = length($_))))) . "\n")
    .  ($y = (('#' . (' ' x (2 + $z))) . "#\n"))
  )  
    .  (((('# ' . $&) . " #\n") . $y) . $x)
)

— tchrist
स्रोत

स्ट्रिंग से पहले और बाद में सफेद अंतरिक्ष गद्दी की एक पंक्ति होनी चाहिए। प्रश्न से उदाहरण आउटपुट पर एक नज़र डालें .... लेकिन आपको सबमिट करते हुए देखकर अच्छा

— लगेगा

@rayryeng यह मुझे दुखी करता है कि कोई भी पर्ल में जमा नहीं हो रहा था।

— tchrist

सच कहूं तो मैं हैरान था। यह निश्चित रूप से इसके लिए उपयुक्त एक समस्या की तरह लगता है :)।

— रेयरेंग -

अगली रिलीज में @rayryeng फिक्स्ड। :)

— tchrist

1

वास्तव में, अब मैं इसके बारे में लगता है कि, यदि आप अलग बयान में सब कुछ अलग हो गए, आप बस उन्हें प्रतिस्थापन के बाहर ले जा सकते हैं और ड्रॉप eसंशोधक ... लेकिन अगर आप ऐसा करते हैं, आप के साथ-साथ बस प्रतिस्थापन पूरी तरह छोड़ सकता है: $x="#"x(4+($z=y!!!c));$y="#".$"x(2+$z)."#\n";$_="$x\n$y# $_ #\n$y$x"। इसके बजाय वास्तविक newlines का उपयोग करें \nऔर यह केवल 65 बाइट्स, प्लस 2 के लिए है -lp।

— ThisSuitIsBlackNot

2

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

टेम्प्लेट स्ट्रिंग का उपयोग करते हुए, 2 नईलाइन्स महत्वपूर्ण और गिनी जाती हैं।

किसी भी EcmaScript 6 अनुरूप ब्राउज़र (फ़ायरफ़ॉक्स और नवीनतम क्रोम, शायद सफारी) में नीचे स्निपेट चलाने का परीक्षण करें।

f=s=>(z=c=>`*${c[0].repeat(s.length+2)}*
`)`*`+z` `+`* ${s} *
`+z` `+z`*`

// Less golfed

U=s=>(
  z=c=>'*' + c.repeat(s.length+2) + '*\n',
  z('*') + z(' ') + '* ' + s + ' *\n' + z(' ') + z('*')
)

// TEST

O.innerHTML=f('Hello world!')

<pre id=O></pre>

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

यह मेरी पहली कोशिश से काफी छोटी है, जो इस अन्य चुनौती से ली गई है :

f=s=>(q=(c,b,z=c.repeat(b[0].length))=>[z,...b,z].map(r=>c+r+c))('*',q(' ',[s])).join`\n`

— edc65
स्रोत

मेरे (कैनरी) के लिए नहीं चलता है।

— mınxomaτ

@minxomat कैनरी क्या है?

— edc65

यह क्रोम 45.0.2454.85 मीटर, विंडोज 7

— edc65

कैनरी हमेशा नवीनतम Chrome बिल्ड है । मेरे Chrome Stable में भी काम नहीं करता है। संपादित करें: हालांकि फ़ायरफ़ॉक्स में काम करता है।

— mınxomaτ

(क्या zसाइड-इफ़ेक्ट के रूप में ग्लोबल को असाइन करना कानूनी है ?)

— नील

2

पायथन 2, 74

s='# %s #'%input()
n=len(s)
b='\n#'+' '*(n-2)+'#\n'
print'#'*n+b+s+b+'#'*n

जैसे कोट्स में इनपुट लेता है "Hello World" ।

तीसरी लाइन इनपुट है जो एनकोडेड है # _ #।
दूसरी और चौथी लाइन b# # रिक्त स्थान की सही संख्या के साथ होती हैं, जो चारों तरफ से चारों ओर से नई-नई से घिरी होती हैं।
पहली और पांचवीं पंक्तियों को #इनपुट की लंबाई से गुणा किया जाता है

लाइनों को समतल और मुद्रित किया जाता है।

— XNOR
स्रोत

2

MATLAB, 93 91 बाइट्स

सबसे सुंदर नहीं है, लेकिन यह काम हो जाता है।

t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])

कोड स्पष्टीकरण

चरण 1

t=[32 input('','s') 32];

STDIN से एक स्ट्रिंग में पढ़ें और इसके अंदर एक अग्रणी और पीछे एकल स्थान रखें। 32 एक स्थान के लिए ASCII कोड है और इनपुट में पढ़ना एक स्ट्रिंग प्रकार के रूप में 32s को रिक्त स्थान में ले जाता है।

चरण 2

m='#####'.';

एक स्तंभ वेक्टर में 5 हैश संकेतों के एक चरित्र सरणी की घोषणा करें।

चरण 3

n=repmat('# ',numel(t),1)'

एक 2 पंक्ति वर्ण मैट्रिक्स बनाएँ, जो पहले हैश संकेतों द्वारा भरा गया है उसके बाद सफेद स्थान द्वारा पीछा किया गया है। वर्णों की संख्या इनपुट स्ट्रिंग प्लस 2 की लंबाई है ताकि हम स्ट्रिंग से पहले और बाद में अंतरिक्ष के लिए समायोजित कर सकें।

चरण 4

disp([m [n;t;flipud(n)] m])

हम सब कुछ एक साथ करने जा रहे हैं। हम 5 हैश के पहले कॉलम को रखते हैं, उसके बाद केंद्र के हिस्से को और उसके बाद 5 हैश के दूसरे कॉलम को रखते हैं। केंद्र भाग में चरण # 3 में बनाए गए 2 पंक्ति वर्ण मैट्रिक्स के होते हैं, इनपुट स्ट्रिंग ही जिसमें एक अनुगामी और अग्रणी स्थान होता है, उसके बाद 2 पंक्ति वर्ण मैट्रिक्स होता है लेकिन उलट होता है।

उदाहरण रन

>> t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])
This is something special for you
#####################################
#                                   #
# This is something special for you #
#                                   #
#####################################
>> t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])
Hello World
###############
#             #
# Hello World #
#             #
###############
>> t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])
I <3 Code Golf StackExchange!
#################################
#                               #
# I <3 Code Golf StackExchange! #
#                               #
#################################

— रायरेंग - मोनिका को पुनः स्थापित करें
स्रोत

2

पर्ल 5.14+, 57 56 बाइट्स

perl -lpe '$_=join"#
#",($_=" $_ ",y// /cr,"#".y//#/cr)[2,1,0..2]'

54 बाइट्स + के लिए 2 बाइट्स -lp(यदि इनपुट एक नई पंक्ति में समाप्त नहीं होता है,-l एक बाइट को बचाने के लिए गिराया जा सकता है)।

STDIN पर इनपुट स्वीकार करता है:

$ echo Hello World | perl -lpe '$_=join"#
#",($_=" $_ ",y// /cr,"#".y//#/cr)[2,1,0..2]'
###############
#             #
# Hello World #
#             #
###############

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

कार्यक्रम का मूल एक सूची टुकड़ा है:

($_=" $_ ",y// /cr,"#".y//#/cr)[2,1,0..2]'

यह आउटपुट की तीन अनूठी पंक्तियों को संग्रहीत करने का एक कॉम्पैक्ट तरीका प्रदान करता है (बाउंडिंग बॉक्स की पहली दो पंक्तियां अंतिम दो के समान हैं, केवल प्रतिबिंबित)। इनपुट स्ट्रिंग के लिए foo, स्लाइस के परिणाम होंगे:

index   value
--------------
  2    "######"
  1    "     "
  0    " foo "
  1    "     "
  2    "######"

इन मूल्यों के साथ #\n#जुड़कर हमें हमारा बॉक्स मिलता है।

ध्यान दें कि पर्ल 5.14+ rट्रांसलिटरेशन ऑपरेटर को गैर-विनाशकारी संशोधक का उपयोग करने के लिए आवश्यक है y///।

— ThisSuitIsBlackNot
स्रोत

2

PHP, 95 93 बाइट्स

बिल्कुल शानदार या कुछ भी समान नहीं है, लेकिन यह वास्तव में मजेदार था!

$l=strlen($s=" $argv[1] ");printf("#%'#{$l}s#
#%1\${$l}s#
#$s#
#%1\${$l}s#
#%1\$'#{$l}s#",'');

बिल्कुल सुंदर या कुछ भी नहीं, लेकिन यह शानदार ढंग से काम करता है!

@ बाइट्स के लिए धन्यवाद 2 बाइट्स बचाने के लिए।

— इस्माइल मिगुएल
स्रोत

के $argvबजाय $_GETऔर का उपयोग करके आप दो बाइट्स बचा सकते हैं -r।

— टाइटस

1

सी ++, 198 बाइट्स

#include <iostream>
#include <string>
int i;int main(){std::string t,n,o;std::getline(std::cin,o);t="\n#";o="# "+o+" #";for(;i<o.size();i++){n+="#";if(i>1)t+=" ";}t+="#\n";std::cout<<n+t+o+t+n;}

कोडगुल्फ़ पर मेरा पहला छुरा, और जब मैंने सीखा सी ++ शायद गोल्फ के लिए सबसे अच्छी भाषा नहीं है, तो मुझे लगा कि मैं अपनी पहली कोशिश के लिए शालीनता से (!)।

Ungolfed

#include <iostream>
#include <string>

int i;                              //globals default to a value of 0

int main()
{
    std::string t, n, o;
    std::getline(std::cin, o);

    t = "\n#";                      // t needs hashes at start and end, places hash at start here
    o = "# " + o + " #";            // put hash at each end of input

    for(; i < o.size(); i++) {
        n += "#";                   // fills n with hashes
        if(i > 1) {
            t += " ";               // fill t with spaces between hashes, has two fewer spaces than n has hashes
        }
    }
    t += "#\n";                     // puts final hash at end of t

    std::cout << n + t + o + t + n; // final output
}

n, o और t पूरी तरह से हैशेड लाइनों का प्रतिनिधित्व करते हैं, इनपुट (प्रत्येक छोर पर हैश के साथ) और इनपुट और हैशेड लाइनों के बीच की लाइनें क्रमशः।

— Cyv
स्रोत

1

> <> , 106 104 बाइट्स

मुझे लग रहा है कि> <> इसके लिए सबसे अच्छी भाषा नहीं हो सकती है, लेकिन मैं इसे छोड़ने और इसे पोस्ट नहीं करने के लिए बहुत दूर आ गया हूं। *लाइन 4 के अंत में एक अंतरिक्ष माना जाता है। क्या आपको यह पसंद नहीं है कि यह कोड कितना अविश्वसनीय रूप से आकर्षक है? इसे ऑनलाइन आज़माएं ।

<v?(0:i
v>~" ## "}}l:::
>"#"o1-:?!v02.>~a"#"oo
"-2ooa"#"~<.31v!?:-1o" 
7v?=3loroo"#"a<.4
.>";^"e3pa2p093

यहां कुछ भी बिना दिशा के संस्करण है, लेकिन यह संकेत देने के लिए दिशा परिवर्तक है कि सूचक कैसे चलता है (ध्यान दें कि मैंने "टेलपोर्ट" स्टेटमेंट को छोड़ दिया है, अर्थात .)।

दिशा प्रवाह:

<v
v>
>         v   >
          <   v 
 v            <
 >

व्याख्या

स्टैक का मेरा विज़ुअलाइज़ेशन इनपुट के आधार पर होगा input। > <> एक दो आयामी भाषा है, इसलिए ध्यान दें कि सूचक लाइनों के बीच कहां जा रहा है, क्योंकि यह उसके नीचे कोड निष्पादित करता है (इस कोड <>v^में मुख्य रूप से दिशा बदलने के लिए उपयोग किया जाता है)। मैं अपना स्पष्टीकरण शुरू कर रहा हूँ जहाँ से सूचक शुरू होता है। ध्यान दें कि दो पंक्तियों को दोहराया जाएगा, क्योंकि पांचवीं पंक्ति के बाद सूचक पीछे की ओर बढ़ता है।

मैं हमेशा किस तरह शांत रहता हूं> <> अपने स्वयं के स्रोत कोड को संशोधित करने की क्षमता है, और मैं इस कार्यक्रम में इसका उपयोग करता हूं। पंक्तियों 3 और 4 का पुन: उपयोग किया जाता है, जिसमें प्रत्येक वर्ण के संशोधन के माध्यम से अंतिम दो पंक्तियों को मुद्रित किया जाता है।

पंक्ति 1: इनपुट लूप

<v?(0:i
<        change direction to left
   (0:i  checks if input is less than 0 (no input defaults to -1)
 v?      change direction to down if so

ढेर: [-1,t,u,p,n,i]

लाइन 2: आउटपुट की तीसरी लाइन उत्पन्न करता है

v>~" ## "}}l:::  
 >~" ## "}}      remove -1 (default input value) from stack and pads with # and spaces
           l:::  push 4 lengths of padded input

ढेर: [9,9,9,9,#, ,t,u,p,n,i, ,#]

लाइन 3: आउटपुट की पहली लाइन प्रिंट करता है

>"#"o1-:?!v02.>~a"#"oo
>"#"o                   print "#"
     1-                 subtract 1 from length (it's at the top of the stack)
       :?!v             move down if top of stack is 0

ढेर: [0,9,9,9,#, ,t,u,p,n,i, ,#]

आउटपुट:

#########

लाइन 4: आउटपुट की दूसरी लाइन प्रिंट करता है

"-2ooa"#"~<.31v!?:-1o"*
 -2ooa"#"~<              pops 0, prints newline, "#", then decrements length by 2
"                   o"*  prints space (* is supposed to be space char)
                  -1     decrements top of stack
           .31v!?:       changes direction to down if top of stack is 0, else jumps back to "

ढेर: [0,9,9,#, ,t,u,p,n,i, ,#]

आउटपुट ( *अंतरिक्ष का प्रतिनिधित्व करता है):

#########
#*******

लाइन 5: आउटपुट की तीसरी लाइन प्रिंट करता है

7v?=3loroo"#"a<.4
        oo"#"a<    prints "#",newline
       r           reverses stack
7v?=3lo        .4  outputs until stack has 3 values, then changes direction to down

ढेर: [9,9,0]

आउटपुट:

#########
#       #
# input #

लाइन 6: आउटपुट की चौथी और पांचवीं पंक्तियों को प्रिंट करने के लिए खुद को सेट करता है

.>";^"e3pa2p093
 >";^"           push ";",then "^"
      e3p        place "^" as the fifteenth character on line 4
         a2p     place ";" as the eleventh character on line 3
            0    push a value (value doesn't matter -- it will be deleted)
.            93  jump to the tenth character on line 4

ढेर: [0,9,9,0]

पंक्ति 4: आउटपुट की चौथी पंक्ति प्रिंट करें

"-2ooa"#"~<.31^!?:-1o"*
   ooa"#"~<              delete 0 (unnecessary value pushed), then print newline,"#"
 -2                      subtract two from value on top of stack (length)
"          .31^!?:-1o"*  print space until top of stack is 0, then change direction to up

ढेर: [0,9,0]

आउटपुट ( *अंतरिक्ष का प्रतिनिधित्व करता है):

#########
#       #
# input #
#*******

पंक्ति 3: आउटपुट की अंतिम पंक्ति प्रिंट करें

"#"o1-:?!;02.>~a"#"oo
             >~a"#"oo  pop top of stack, print "#", newline
"#"o1-:?!;02.          print "#" until top of stack is 0, then terminate

ढेर: [0,0]

आउटपुट:

#########
#       #
# input #
#       #
#########

— गोभी
स्रोत

1

PHP, 93 91 बाइट्स

$b=str_pad("",$e=strlen($s=" $argv[1] "));echo$h=str_pad("",2+$e,"#"),"
#$b#
#$s#
#$b#
$h";

कमांड लाइन तर्क से इनपुट लेता है; रिक्त स्थान से बचने या एकल उद्धरण का उपयोग करें। साथ चलाना -r।

— टाइटस
स्रोत

1

पाइके (नॉनकमेटिटिव), 6 बाइट्स

.X".X#

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

पाइके को चुनौती के बाद लिखा गया था और इसलिए वह अयोग्य है।

.X"    - surround string in spaces
   .X# - surround string in hashes

.Xएक स्ट्रिंग और एक स्ट्रिंग निरंतर आर्ग लेता है और वर्णों के समूह के साथ एक स्ट्रिंग को घेरता है। निरंतर आर्गन 8 वर्णों तक हो सकता है और स्ट्रिंग को घेरने के विभिन्न प्रभाव हैं।

— नीला
स्रोत

1

05AB1E, 26 बाइट्स , प्रतिस्पर्धा नहीं

g4+'#×©,¹' .ø'#.ø,®,

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

संपादित करें: वाह! ध्यान नहीं दिया कि यह एक पुराना चालान है! माफ़ कीजिये!

— ल्यूक
स्रोत

1

सी # - 142 बाइट्स (विधि शरीर 104 है)

class P{static void Main(string[]a){for(int i=0;++i<6;)System.Console.Write("#{0}#\n",i==3?$" {a[0]} ":new string(" #"[i%2],a[0].Length+2));}}

Ungolfed:

class P
{
    static void Main(string[] a)
    {
        for (int i = 0; ++i < 6;)
            System.Console.Write("#{0}#\n", i == 3 ? $" {a[0]} " : new string(" #"[i%2], a[0].Length + 2));
    }
}

— Ozziereturnz
स्रोत

0

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

$l=$input.length+4;$p='#'*$l;$s=' '*$l;$p,$s,"  $input  ",$s,$p-replace'^ | $','#'

— briantist
स्रोत

0

लुआ, 90 बाइट्स

a=arg[1]h="#"s=" "t="\n"..h c=h:rep(#a+4)..t..s:rep(#a+2)..h..t..s print(c..a..c:reverse())

— Trebuchette
स्रोत

0

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

मुझे लगता है कि इसे आगे बढ़ाया जा सकता है, लेकिन चूंकि अभी तक कोई रूबी का जवाब नहीं है, यहाँ यह है:

s=ARGV[0]
n=s.size
r="#"*(n+4)
t="\n#"+" "*(n+2)+"#\n"
puts r+t+"\n# "+s+" #\n"+t+r

— झामुमो
स्रोत

0

रैकेट 172 बाइट्स

(λ(s)(let((n(string-length s))(p #\space)(g(λ(l c)(make-string l c))))(display(string-append
(g(+ 4 n)#\#)"\n#"(g(+ 2 n)p)"#\n# "s" #\n#"(g(+ 2 n)p)"#\n"(g(+ 4 n)#\#)))))

Ungolfed:

(define (f s)
  (let ((n (string-length s))
        (p #\space)
        (g (λ (l c) (make-string l c))))
    (display (string-append (g (+ 4 n) #\#)
                            "\n#"
                            (g (+ 2 n) p)
                            "#\n# "
                            s
                            " #\n#"
                            (g (+ 2 n) p)
                            "#\n"
                            (g (+ 4 n) #\#)
                            ))))

परिक्षण:

(f "This is a test" )

आउटपुट:

##################
#                #
# This is a test #
#                #
##################

— rnso
स्रोत

0

सी #, 116 110 बाइट्स

s=>{string r="\n".PadLeft(s.Length+5,'#'),p="#".PadRight(s.Length+3,' ')+"#\n";return r+p+"# "+s+" #\n"+p+r;};

Ungolfed:

s=>
{
    string r = "\n".PadLeft(s.Length + 5, '#'),         //the first line, made of '#'s
        p = "#".PadRight(s.Length + 3, ' ') + "#\n";    //the second line
    return r + p + "# " + s + " #\n" + p + r;           //output is simmetrical
};

प्रारंभिक संस्करण:

s=>{int l=s.Length;string r=new string('#',l+4)+"\n",p="#"+new string(' ',l+2)+"#\n";return r+p+"# "+s+" #\n"+p+r;};

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;

namespace SurroundStringWithHashes
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,string>f= s=>{int l=s.Length;string r=new string('#',l+4)+"\n",p="#"+new string(' ',l+2)+"#\n";return r+p+"# "+s+" #\n"+p+r;};

            Console.WriteLine(f("Hello World"));
            Console.WriteLine(f("Programming Puzzles & Code Golf"));
        }
    }
}

— adrianmp
स्रोत

के varबजाय का उपयोग करें string।

— 22

इस मामले में मदद नहीं करेगा, क्योंकि मेरे पास 2 तार हैं और प्रत्येक varकीवर्ड केवल एक घोषणा की अनुमति देता है।

— एड्रिएम्प

उफ़, दूसरा नहीं देखा: डी

— यति

0

सी (जीसीसी) 165 बाइट्स

f(*s){i,j;c='#';for(j=0;j<5;j++){if(j==0||j==4){for(i=0;i<strlen(s)+2;i++)printf("#");}else if(j==2) printf("#%s#",s);else printf("#%*c",(strlen(s)+1),c);puts("");

अनप्लग्ड संस्करण

void  f(char *s)
{
    int i,j;
    char c='#';

    for(j=0;j<5;j++)
    { 
       if(j==0||j==4)
       { 
         for(i=0;i<strlen(s)+2;i++)
           printf("#");
       }
       else
        if(j==2)
         printf("#%s#",s);
      else
        printf("#%*c",(int)(strlen(s)+1),c);

   puts("");
}

— हाबिल टॉम
स्रोत

0

स्माइलबासिक, 73 बाइट्स

LINPUT S$L=LEN(S$)+2O$="#"+" "*L+"#
T$="#"*(L+2)?T$?O$?"# ";S$;" #
?O$?T$

— 12Me21
स्रोत

एक स्ट्रिंग हैश के साथ चारों ओर

CJam, 22 20 बाइट्स

व्याख्या

vim, 28 27 कीस्ट्रोक्स

pb - 89 बाइट्स

brainfuck - 156 बाइट्स

के, 21 बाइट्स

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

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

उदाहरण I / O:

पर्ल, 43 76 बाइट्स

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

पायथन 2, 74

MATLAB, 93 91 बाइट्स

कोड स्पष्टीकरण

चरण 1

चरण 2

चरण 3

चरण 4

उदाहरण रन

पर्ल 5.14+, 57 56 बाइट्स

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

PHP, 95 93 बाइट्स

सी ++, 198 बाइट्स

> <> , 106 104 बाइट्स

व्याख्या

PHP, 93 91 बाइट्स

पाइके (नॉनकमेटिटिव), 6 बाइट्स

05AB1E, 26 बाइट्स , प्रतिस्पर्धा नहीं

सी # - 142 बाइट्स (विधि शरीर 104 है)

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

लुआ, 90 बाइट्स

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

रैकेट 172 बाइट्स

सी #, 116 110 बाइट्स

सी (जीसीसी) 165 बाइट्स

स्माइलबासिक, 73 बाइट्स