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

এতটা আলাদা নয়: কোডগলফ.স্ট্যাকেক্সেঞ্জারওয়েজ

— সেকশনস

1

ইনপুট স্ট্রিংটিতে লাইনব্রেক থাকবে না, তাই না?

— ফ্লোডেল

2

@ edc65 আমি অসম্মতি, এই চ্যালেঞ্জ অতিশয় ভিন্ন

— বিটা ক্ষয়

10

আমি উত্তর গ্রহণের আগে কমপক্ষে এক সপ্তাহ অপেক্ষা করার পরামর্শ দেব। সংক্ষিপ্ত জমা দেওয়ার পরে আপনি গৃহীত উত্তরটি আপডেট করার পরিকল্পনা করছেন কিনা তা আসলেই বিবেচ্য নয়, এমন লোকেরা প্রাথমিক গ্রহণযোগ্য উত্তর সম্পর্কে অভিযোগ করবে, বা এমনকি এটি ডাউনওয়েট করবে। এমন কিছু লোক আছেন যারা ইতিমধ্যে গৃহীত কোনও উত্তর থাকলে উত্তর পোস্ট করতে আগ্রহী হবেন না।

— মার্টিন এন্ডার

17

সিজেম, 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

আমি ব্যাখ্যাটি পছন্দ করি :-ড

— জন ডিভোরাক

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."'

যা কিছুটা বিশৃঙ্খলাযুক্ত, তবে এটি কার্যকর হয়।

— ডোরকনব
সূত্র

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]<}

এই ধরণের চ্যালেঞ্জের জন্য পিবি তৈরি করা হয়েছিল! এই জাতীয় চ্যালেঞ্জ বা যে কোনও কিছুর জন্য এটি প্রতিযোগিতামূলক নয় । এটি এখনও একটি ভয়াবহ গল্ফ ভাষা। যাইহোক, এই জাতীয় চ্যালেঞ্জগুলি অন্যগুলির তুলনায় পিবিতে সমাধানের জন্য অনেক কম ব্যথা। যেহেতু পিবি তার আউটপুটটিকে 2 ডি ক্যানভাস হিসাবে বিবেচনা করে এবং যে কোনও স্থায়িত্বগুলিতে লিখতে সক্ষম হয়, তাই পাঠ্য / পাঠ্যের আশেপাশে অঙ্কন সম্পর্কিত কোনও কিছুই (যেমন এই চ্যালেঞ্জ) বরং স্বজ্ঞাতভাবে পরিচালনা করা হয়।

এটি চালান দেখুন:

এই ভিজ্যুয়ালাইজেশনটি পিবিআই এর অর্থ-উন্নয়ন সংস্করণ, পিবি ইন্টারপ্রেটার দিয়ে তৈরি করা হয়েছিল। নীল পটভূমির সাথে লাইনটি 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

ব্রেনফাক - 156 বাইট

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

এটি সম্ভবত গল্ফযোগ্য। এমন কিছু জায়গা রয়েছে যেখানে আমি জানতাম না যে পুনরায় ব্যবহারের জন্য কোথাও কোনও মান সংরক্ষণ করা বা এটি পুনর্নির্মাণ করা / টেপের অন্য কোথাও থেকে পাওয়া ভাল if এটি বের করার জন্য কাজটি করার পরিবর্তে আমি এটি করিনি। : ডি

মন্তব্য সহ:

++++++++++>              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

আরও গল্ফ কীভাবে করা যায় সে সম্পর্কে ইঙ্গিত দেওয়ার মন্তব্যে লোকদের ধন্যবাদ, আপনি যে ভাষায় বলতে পারবেন তা আমি সত্যিই জানি না probably

— নীল
সূত্র

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 বাইট

ধন্যবাদ @ ওয়ার্ল্ড এসেন্ডার

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)

আই / ও উদাহরণ:

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

— বেটা ক্ষয়
সূত্র

s=" "শুরুতে আমি মনে করি 1 বাইট সাশ্রয় করে।

— ওয়ার্ল্ডসেন্ডার

;নতুন লাইনের পরিবর্তে বিটিডব্লিউ কেন ব্যবহার করবেন ? দুজনেরই এক বাইট হওয়া উচিত, তাই না?

— জেরোজেজে

3

@ জেরোজেজে আমি জানি এটি কোনও পার্থক্য করে না, তবে আপনি যদি এটি এক লাইনে রেখে দেন তবে এটি সংক্ষিপ্ত দেখাচ্ছে;)

— বিটা ডেসে

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
সূত্র

স্ট্রিংয়ের আগে এবং পরে সাদা স্পেস প্যাডিংয়ের একটি সারি থাকতে হবে। প্রশ্ন থেকে উদাহরণস্বরূপ আউটপুটটি একবার দেখুন ... তবে আপনাকে জমা দেওয়ার বিষয়টি দেখে ভাল

— লাগল

@ রাইরিং আমাকে দুঃখ দিয়েছে যে পার্লে কেউ জমা দিচ্ছে না।

— tchrist

সত্যি কথা বলতে আমি অবাক হয়েছি। এটি অবশ্যই এটির জন্য উপযুক্ত সমস্যার মতো বলে মনে হচ্ছে :)।

— রায়রিং - মনিকা

পরবর্তী প্রকাশে @rayryeng ঠিক করা হয়েছে। :)

— tchrist

1

আসলে, এখন আমি এটা সম্পর্কে কি মনে করে যে, আপনি যদি আলাদা বিবৃতি মধ্যে সবকিছু বিভক্ত, আপনি কেবল তাদের প্রতিস্থাপন বাহিরে স্থানান্তর করতে পারেন এবং ড্রপ eপরিবর্তক ... কিন্তু আপনি যদি তা করতে, আপনি হিসাবে ভাল শুধু প্রতিকল্পন পুরাপুরি ড্রপ করতে পারেন: $x="#"x(4+($z=y!!!c));$y="#".$"x(2+$z)."#\n";$_="$x\n$y# $_ #\n$y$x"। পরিবর্তে প্রকৃত নিউলাইনগুলি ব্যবহার করুন\n এবং এটি কেবল 65 বাইট, আরও 2 এর জন্য -lp।

— এইসুইটসআইবলাকনট

2

জাভাস্ক্রিপ্ট (ES6), 73

ভারীভাবে টেমপ্লেট স্ট্রিং ব্যবহার করে, দুটি নতুনলাইন উল্লেখযোগ্য এবং গণনা করা হয়।

যে কোনও ইকামাস্ক্রিপ্ট comp অনুবর্তী ব্রাউজারে (ফায়ারফক্স এবং সর্বশেষ Chrome, সম্ভবত সাফারি) নীচে স্নিপেট চালনা পরীক্ষা করুন Test

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

— এডক65

ক্যানারি সর্বদা সর্বশেষতম Chrome বিল্ড । আমার ক্রোম স্থিতিতেও কাজ করে না। সম্পাদনা: যদিও ফায়ারফক্সে কাজ করে।

— 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

ম্যাটল্যাব, 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];

এসটিডিআইএন থেকে একটি স্ট্রিং পড়ুন এবং এর ভিতরে একটি শীর্ষস্থানীয় এবং অনুসরণযোগ্য একক স্থান রাখুন। একটি স্থানের জন্য ইনপুটটিতে 32 টি ASCII কোড এবং স্ট্রিং টাইপের হিসাবে ইনপুটটিতে পড়া 32sকে ফাঁক করে স্থান দেয়।

ধাপ ২

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

কলাম ভেক্টরে 5 টি হ্যাশ চিহ্নের একটি চরিত্রের অ্যারে ঘোষণা করুন।

ধাপ 3

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

একটি 2 সারি অক্ষরের ম্যাট্রিক্স তৈরি করুন যা হ্যাশ লক্ষণ দ্বারা পূর্ণ হয় তার পরে সাদা স্থান পরে। অক্ষরের সংখ্যা হ'ল ইনপুট স্ট্রিং প্লাস 2 এর দৈর্ঘ্য যাতে আমরা স্ট্রিংয়ের আগে এবং পরে স্থানের জন্য জায়গা করতে পারি।

পদক্ষেপ # 4

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

আমরা একসাথে সবকিছু টুকরা করতে যাচ্ছি। আমরা 5 টি হ্যাশের প্রথম কলামটি রাখি, তারপরে কেন্দ্রের অংশ এবং তার পরে 5 টি হ্যাশের আরও একটি কলাম। কেন্দ্রের অংশটি ২ য় ধরণের অক্ষর ম্যাট্রিক্স নিয়ে গঠিত যা ধাপ # 3 তে তৈরি হয়েছে, ইনপুট স্ট্রিং নিজেই একটি পিছন এবং শীর্ষস্থানীয় স্থান রয়েছে, তারপরে 2 সারি অক্ষরের ম্যাট্রিক্স কিন্তু বিপরীত রয়েছে ed

উদাহরণ রান

>> 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! #
#                               #
#################################

— rayryeng - মনিকা পুনরায় স্থাপন করুন
সূত্র

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

পিএইচপি, 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
}

এন, ও এবং টি পুরোপুরি হ্যাশড লাইনগুলি, ইনপুট (প্রতিটি প্রান্তে হ্যাশ সহ) এবং ইনপুট এবং হ্যাশ লাইনের মধ্যবর্তী লাইনগুলি যথাক্রমে উপস্থাপন করে।

— 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 #

লাইন:: আউটপুটের চতুর্থ এবং পঞ্চম লাইনগুলি মুদ্রণের জন্য নিজেকে সেট করে

.>";^"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

পিএইচপি, 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

05 এ বি 1 ই, 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

— jmm
সূত্র

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 ।

— Yytsi

এই ক্ষেত্রে সাহায্য করবে না, যেহেতু আমার কাছে দুটি স্ট্রিং রয়েছে এবং প্রতিটি 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$

— #
সূত্র

হ্যাশ সহ একটি স্ট্রিং চারপাশে

সিজেম, 22 20 বাইট

ব্যাখ্যা

vim, 28 27 টি কীস্ট্রোক

pb - 89 বাইট

ব্রেনফাক - 156 বাইট

কে, 21 বাইট

পাইথ, 31 বাইট

পাইথন 3, 88 বাইট

আই / ও উদাহরণ:

পার্ল, 43 76 বাইট

জাভাস্ক্রিপ্ট (ES6), 73

পাইথন 2, 74

ম্যাটল্যাব, 93 91 বাইট

কোড ব্যাখ্যা

ধাপ 1

ধাপ ২

ধাপ 3

পদক্ষেপ # 4

উদাহরণ রান

পার্ল 5.14+, 57 56 বাইট

কিভাবে এটা কাজ করে

পিএইচপি, 95 93 বাইট

সি ++, 198 বাইটস

> <> , 106 104 বাইট

ব্যাখ্যা

পিএইচপি, 93 91 বাইট

পাইকে (অ-প্রতিযোগিতামূলক), 6 বাইট

05 এ বি 1 ই, 26 বাইট , প্রতিযোগিতা নয়

সি # - 142 বাইট (পদ্ধতির দেহটি 104)

পাওয়ারশেল, 84 82 বাইট

লুয়া, 90 বাইট

রুবি, 83 বাইট

র‌্যাকেট 172 বাইট

সি #, 116 110 বাইট

সি (জিসিসি) 165 বাইট

স্মাইলব্যাসিক, 73 বাইট