पाठ का आयत

Question

आपके प्रोग्राम को इनपुट के रूप में एक पाठ मिलता है, कम से कम 8 वर्ण लंबा, और हमेशा वर्णों की संख्या से मिलकर। (इनपुट की शुद्धता का मूल्यांकन करने की आवश्यकता नहीं है)।

आपका लक्ष्य उस पाठ को एक आयत के रूप में प्रदर्शित करना है। उदाहरण के लिए, HelloWorldइनपुट के रूप में दिया गया, प्रदर्शन

Hell
d  o
lroW

नियम:

• पाठ दक्षिणावर्त चारों ओर चला जाता है (आपकी जैसी स्थिति शुरू होती है)
• यह एक बंद आयत बनाएगा, जिसकी भुजाएँ 1 वर्ण चौड़ी होंगी।
• आयत को अंदर के अधिकांश क्षेत्र को घेरना होगा। (केवल पाठ को दो पंक्तियों में प्रदर्शित करने के तुच्छ उत्तर का उल्लेख करने के लिए)
• पाठ के अलावा और आवश्यक पैडिंग स्पेस और लाइन फीड के अलावा कोई अन्य वर्ण मुद्रित नहीं किया जाता है।

कोड-गोल्फ के रूप में, सबसे छोटा कोड जीतता है।

_{पहले वैध जवाब के 10 दिन बाद विजेता का चयन नहीं किया जाता है।}

Answer 1

GolfScript, 56 53 40 38 अक्षर

1/..,4/):l<n@l>{)" "l*2>@(n@.,l-}do-1%

आप स्क्रिप्ट का परीक्षण ऑनलाइन कर सकते हैं ।

Answer 2

पोस्टस्क्रिप्ट 50 बाइनरी, 113 एएससीआईआई

यह ग्राफिकल आउटपुट का उपयोग करता है। बाइनरी टोकन का उपयोग करके कार्यक्रम का हेक्सडंप:

$ hexdump -C textRect_binary.ps 
00000000  74 5b 30 20 39 5b 74 92  62 34 92 36 92 38 92 10  |t[0 9[t.b4.6.8..|
00000010  32 92 19 5d 7b 92 2c 7b  32 92 19 7d 92 83 92 3e  |2..]{.,{2..}...>|
00000020  92 6e 7d 92 49 5d 39 20  39 92 6b 91 c7 39 92 8e  |.n}.I]9 9.k..9..|
00000030  92 c3                                             |..|
00000032

इसे आज़माने के लिए डाउनलोड करें । घोस्टस्क्रिप्ट का उपयोग करते हुए, इस प्रकार प्रस्तुत किए जाने वाले पाठ को कार्यक्रम में पास किया जा सकता है:

gs -st=helloworld textRect_binary.ps 

आलेखीय आउटपुट इस तरह दिखता है:

ASCII टोकन का उपयोग करने वाला समान कोड इस तरह दिखता है:

t[0 9[t length
4 div dup
ceiling
2 copy]{cvi{2 copy}repeat
exch neg}forall]9 9 moveto/Courier 9 selectfont
xyshow

रणनीति का उपयोग xyshowपरिभाषित करने के लिए किया जाता है जहां हम अगले चरित्र को दिखाने से पहले प्रत्येक चरित्र को दिखाने के बाद आगे बढ़ते हैं। हम निचले बाएं कोने में शुरू कर रहे हैं, घड़ी की दिशा में, यानी पहले ऊपर, फिर दाएं, फिर नीचे फिर बाएं। हम हमेशा 9 इकाइयों जा रहे हैं, इसलिए पहले हम की एक सापेक्ष गतिविधि होती है 0 9तो, 9 0है, तो 0 -9, तो -9 0। हम अनुक्रम के साथ इन संख्याओं के एक जोड़े से अगले तक प्राप्त कर सकते हैं exch neg।

हमें इसके लिए एक सरणी बनाने की आवश्यकता है xyshowजो इन नंबरों की संख्या को रखता है, प्रत्येक वर्ण के लिए एक जोड़ी। इसका मतलब है, अगर हमारे पास helloworldउदाहरण स्ट्रिंग है, जिसमें 10 वर्ण हैं, तो हम दो बार ऊपर जाना चाहते हैं, फिर दाएं तीन बार, फिर दो बार और बाएं तीन बार। हम इन मूल्यों (दो और तीन) को स्ट्रिंग की लंबाई 8 से विभाजित करके, एक बार फर्श पर, एक बार छत तक ले जाते हैं।

इसलिए, हम 0 9दो बार कॉपी करते हैं , फिर सापेक्ष x / y निर्देशांक का उपयोग करके स्विच करते हैं exch neg, उन तीनों को कॉपी करें और इसी तरह।

यह टिप्पणी कोड दिखाता है कि स्टैक पर क्या होता है:

t[0 9                % t [ 0 9
[t length            % t [ 0 9 [ length
4 div dup            % t [ 0 9 [ length/4 length/4
ceiling              % t [ 0 9 [ length/4=height width
2 copy]              % t [ 0 9 [height width height width]
{%forall             % t [ 0 9 ... x y height_or_width
  cvi                % t [ 0 9 ... x y height_or_width_integer
  {2 copy}           % t [ 0 9 ... x y height_or_width_integer {2 copy}
  repeat             % t [ 0 9 ... x y .. x y
  exch neg           % t [ 0 9 ... x y .. y -x
}forall]             % t [0 9 ... -9 0]
9 9 moveto/Courier 9 selectfont
xyshow

Comments

+1 पवित्र बाज़ीज़। मैं स्तर -2 और उससे आगे के अपने ज्ञान में गंभीर रूप से कमी हूँ।

— लूसर डॉग

तुम्हारा मतलब है xyshow? आपको इस एक से kshowपरिचित कराने में प्रसन्नता है - कुछ समय पहले आपने मेरा परिचय कराया , जिसके बारे में मुझे वास्तव में जानकारी नहीं थी; ;-)

— थॉमस डब्ल्यू।

@luserdroog: BTW: मुझे बहुत गर्व है कि वर्तमान गोल्फस्क्रिप्ट प्रविष्टि में मेरी द्विआधारी प्रविष्टि की तुलना में 10% अधिक वर्ण हैं, लेकिन यह मुझे बताता है कि मेरा ASCII संस्करण रूबी के साथ एक ड्रॉ से दूर एक चरित्र है (वास्तव में, यहां तक ​​कि तीन, क्योंकि रूबी कोड को आगे बढ़ाया जा सकता है)। क्या आपके पास आगे के अनुकूलन के लिए कोई विचार है?

— थॉमस डब्ल्यू।

@ThomasW। अब मेरी गोल्फस्क्रिप्ट प्रविष्टि आपके बाइनरी की तुलना में 24% कम है ;-) और मुझे अभी भी लगता है कि अभी भी इसे एक या दो वर्णों से आगे छोटा करने का मौका है।

— हॉवर्ड

@ हावर्ड: अर्घ !!! क्या कोई भी गोल्फ गोल्फ को कभी हरा सकता है?

— थॉमस डब्ल्यू।

Answer 3

रूबी 112 100

मैं रूबी के लिए नया हूं और यह मेरा पहला कोड गोल्फ है। मैं मेमो के पर्ल कार्यान्वयन पर आकर्षित हुआ और इसका रूबी संस्करण बनाने की कोशिश की। यह 112 100 अक्षर है और मान लें कि आप x को एक स्ट्रिंग प्रदान करते हैं। दूसरों को देखने के लिए उत्सुक।

l=x.size
puts x[0..w=l/2-h=l/4]
1.upto(h-1){|i|puts x[-i]+' '*(w-1)+x[w+i]}
puts x[w+h..l-h].reverse

सुझावों को लागू करने के लिए संपादित किया गया। मुझे लगता है कि अब यह 100 अक्षर है। धन्यवाद दोस्तों!

Comments

अच्छा! आप 5 वीं पंक्ति (रिक्त स्थान हटाएं) में दो वर्णों को बचा सकते हैं।

— थॉमस डब्ल्यू।

मुझें यह पसंद है। धन्यवाद। अच्छा लग रहा है कि रूबी तार को एक सरणी की तरह एक्सेस किया जा सकता है, मुझे खुद से एक बनाना होगा। :)

— मेमोव

आप के x.lengthसाथ प्रतिस्थापित कर सकते हैं x.size(2 पात्रों बचाता है)

— 22:20

और 8 और का उपयोग कर puts x[0..w=l/2-h=l/4]।

— हॉवर्ड

Answer 4

पर्ल (124 118 109 + 3 = 112)

यह पहले बहुत सीधा था। 1 वर्ण प्रत्येक के रूप में सभी कमांड लाइन विकल्प गिना।

-nlE
$w=(@s=split//)/2-($h=int@s/4);say@s[0..$w--];say$s[1-$_].$"x$w.$s[$w+$_]for+2..$h;say+reverse@s[@s/2..@s-$h]

उदाहरण:

$ perl -nlE '$w=(@s=split//)/2-($h=int@s/4);say@s[0..$w--];say$s[1-$_].$"x$w.$s[$w+$_]for+2..$h;say+reverse@s[@s/2..@s-$h]'
abcdefghijklmnopqrstuvwxyz
abcdefgh
z      i
y      j
x      k
w      l
v      m
utsrqpon

Comments

इसे संकुचित किया जा सकता है: (1) (@s-$h*2)/2 == @s/2-$h(2) के $wरूप में प्रतिनिधित्व किया जा सकता है $w=(@s=split//)/2-($h=int@s/4);, इस प्रकार दो अर्धविरामों की बचत होती है

— amon

कोड अपडेट किया गया।

— मेमॉ

इससे भी दिलचस्प बात यह है: (1) अंतरिक्ष सरणी के प्रक्षेप मूल्य का डिफ़ॉल्ट मान है var $"–saves 1 char। (२) $w+$h == @s/2–सावधान १ चार। (३) यदि $wएक से छोटा है, तो हम सरल कर सकते हैं $"x($w-1)। इसके लिए, $_1 से बढ़ाना होगा। 3 चरों की तरह बचत करता है। (४) अंतिम अर्धविराम überflüssig है, 1 char बचाता है। यह कोड के टुकड़े की ओर जाता है say@s[0..$w--];say$s[1-$_].$"x$w.$s[$w+$_]for+2..$h;say+reverse@s[@s/2..@s-$h](थोड़े +से मनोरंजन के लिए, इसलिए एक भी जगह नहीं बची है)।

— आमोन

उत्कृष्ट गोल्फ, @ मान, क्या आप इसे मेरे पोस्ट में संपादित करेंगे? इस तरह दुनिया देख सकती है कि किसने क्या किया। :)

— मेमोव

Answer 5

ब्रेनफक - 194 187

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

Comments

अच्छी कोशिश है, लेकिन यह काम नहीं करता है। नीचे की रेखा गलत दिशा में है, नियम 1 के विपरीत है, और इसमें केवल एक निश्चित ऊंचाई है, नियम 3 के विपरीत

— 19

यकीन नहीं होता कि मैंने आखिरी पंक्ति क्यों झड़ी। मैं इसे लिखने के सही तरीके को पूरी तरह से ध्यान में रखता था। फिक्स वास्तव में 7 कमांड बचाता है। मैंने तय ऊंचाई की चीज़ पर पुलिस का सामना किया, लेकिन इसकी तुच्छ, 2 लाइन के मामले में आपने बात नहीं की। शायद मैं इसे भविष्य में बेहतर बनाऊंगा।

— captncraig

Answer 6

गणितज्ञ 156 199 344

संपादित करें : यह पहले के कोड का एक प्रमुख पुनर्लेखन है। यह अनिवार्य रूप से समान काम करता है, लेकिन अब इनपुट के रूप में लंबाई की एक स्ट्रिंग लेता है <120 वर्ण और स्वचालित रूप से वर्ग का आकार।

यह अभी भी थोड़ा गोल्फ हो सकता है लेकिन पहले के आकार, और बगियर, संस्करणों के लिए नीचे नहीं आएगा।

f@s_ := ({a, t, w, q} = {Automatic, Text, Quotient[StringLength@s, 2],
 Quotient[StringLength[s], 4] + 1};z = StringSplit[StringInsert[s <> ConstantArray[" ", 0],
 "*", {q, 2 q, 3 q}], "*"];
Graphics[{t[z[[1]], {0, q}],t[z[[2]], {q, 0}, a, {0, -1}],t[z[[3]], {0, -q}, a, {-1, 0}],
t[z[[4]], {-q, 0}, a, {0, 1}]},ImageSize -> 500,BaseStyle -> {FontFamily -> "Courier", 21},
PlotRange -> 34,ImagePadding -> 22])

उदाहरण

f["Hello Code Golf World!"]
f["January, February, March,April, May, June, July"]
f["This text is normal, this goes downwards,this is upside-down, and this is upwards"]

Comments

अरे, तार की एक सरणी? यह वास्तव में नियमों को झुका रहा है, है ना?

— थॉमस डब्ल्यू।

@ThomasW। उत्तर में टिप्पणियों से संकेत मिलता है कि यह अंतिम समाधान नहीं है।

— कोजिरो

ओह समझा! आश्चर्य है कि क्या मुझे चुनौती लेनी चाहिए और पोस्टस्क्रिप्ट में कुछ इसी तरह की कोशिश करनी चाहिए ...

— थॉमस डब्ल्यू।

मुझे पसंद है कि अब यह कैसा दिखता है!

— थॉमस डब्ल्यू।

@ थोमस डब्ल्यू। धन्यवाद। स्ट्रिंग की लंबाई की एक विस्तृत श्रृंखला के लिए सही देखने के लिए प्रारूप प्राप्त करना बहुत सारे बाइट्स का खर्च होता है।

— डेविड

Answer 7

पर्ल + रेगेक्स: 104 (101 + 3)

(कोड + स्विच की गिनती)

यहाँ अच्छा रेगेक्स, और पर्ल के एक बिट का उपयोग कर एक समाधान है:

perl -plE'$w=($l=length)/2-($h=int$l/4);s/..{$w}\K.*/"\n".reverse$&/e;$"x=--$w;s/.\K(.*)(.)$/$"$2\n$1/while--$h'

यह केवल एक इनपुट लाइन पर सही ढंग से काम करेगा ।

मेमो द्वारा प्रेरित, लेकिन अनिवार्य रूप से बिना किसी सरणियों के।

Comments

गूंगे प्रश्न के लिए क्षमा करें: मैं इसे कैसे आज़मा सकता हूँ? मैं आपका कोड कमांड लाइन में पेस्ट कर रहा हूं, फिर कुछ टाइप करें, एंटर दबाएं और कुछ सामने आए। लेकिन यह एक बॉक्स नहीं है। मैं क्या गलत कर रहा हूं?

— थॉमस डब्ल्यू।

@ThomasW। यह मेरे लिए काम करने के लिए लगता है, एक मनमाने ढंग से भी वर्णों की संख्या के लिए। उपरोक्त कोड बैश और पर्ल संस्करण 5.12+ के तहत काम करने की गारंटी है। इनपुट STDIN के माध्यम से स्वीकार किया जाता है, और केवल पहली पंक्ति को सही ढंग से संसाधित किया जाता है। मुझे नहीं पता कि cmd.exe के लिए कोड को सही तरीके से कैसे उद्धृत किया जाए।

— आमोन

आह, शायद मेरी गलती थी। मैंने शायद विषम लंबाई की एक स्ट्रिंग का उपयोग किया था। यह काम करता है:echo thisworksgreat | perl -plE'$w=($l=length)/2-($h=int$l/4);s/..{$w}\K.*/"\n".reverse$&/e;$"x=--$w;s/.\K(.*)(.)$/$"$2\n$1/while--$h'

— थॉमस डब्ल्यू।

Answer 8

पोस्टस्क्रिप्ट (106)

यह दोस्त के गणितज्ञ समाधान से प्रेरित है ।

0{= =
4 add dup
t length mod 4
lt{-90 rotate}if}0[0 3 -3 0 9 9]concat
0 moveto/Courier 5 selectfont
t kshow

घोस्टस्क्रिप्ट के साथ इसे कॉल करें

gs -st=hello! boxtext.ps

यह उत्पादन की तरह पैदा करता है।

यह kshowएक-एक करके ग्लिफ़ दिखाने के लिए उपयोग करता है। एक तरफ के लिए पर्याप्त ग्लिफ़ दिखाने के बाद, बचे हुए ग्लिफ़ को जारी रखने से पहले -90 डिग्री तक सब कुछ घुमाया जाता है।

यह जानने के लिए कि पक्ष में पर्याप्त ग्लिफ़ कब दिखाया गया है, हम हर बार एक ग्लिफ़ दिखाए जाने पर 4 से एक काउंटर बढ़ाते हैं। यदि काउंटर मान modulo स्ट्रिंग की लंबाई 4 से कम है, तो हमें पता है कि हमें घूमना होगा:

char  counter  mod 6  compared to 4
 h       4       4          =
 e       8       2          <   => rotate
 l      12       0          <   => rotate
 l      16       4          =
 o      20       2          <   => rotate
 !      24       0          <   => rotate

टिप्पणी की और गैर-गोल्फ स्रोत कोड:

0                      % n
{%kshow                % n char1 char2
  = =                  % n
  4 add dup            % n' n'
  t length mod         % n' (n' mod t_length)
  4 lt                 % n' bool
  {-90 rotate}if       % n'
}                      % n kshowProc
% First 0 for moveto. We add it here to take 
% advantage of the surrounding self delimiting tokens.
0                      % n kshowProc 0
% We change the graphics state so that the drawn
% text is at a nice size and not off screen.
[0 3 -3 0 9 9]concat   % n kshowProc 0
0                      % n kshowProc 0 0
moveto                 % n kshowProc
/Courier 5 selectfont  % n kshowProc
t                      % n kshowProc text
kshow                  % n

Answer 9

पायथन 2.x: 137

मैं कोड गोल्फिंग के लिए नया हूं और यह सुनिश्चित कर सकता हूं कि इसमें सुधार किया जा सके ...

def s(t):c=len(t);w=1+c/4;h=(c-w-w)/2;u=w+h;n='\n';print t[:w]+n+n.join(map(((w-2)*' ').join,zip(t[:w+u-1:-1],t[w:u])))+n+t[w+u-1:u-1:-1]

दृश्य परीक्षण कोड:

from itertools import chain
from string import letters
for i in range(8,101,2):
    t = ''.join(chain(letters))[:i]
    print '%d: %s' % (i, t)
    s(t)
    print '-----'

रुचि के कुछ: यह समाधान पूर्णांक गणित पर निर्भर करता है। यदि आप सिर्फ प्रतीकात्मक रूप से गणित करते हैं, तो आपको वह मिल जाएगा h=(c-w-w)/2 => h=w-2, लेकिन यदि आप उस परिणाम को प्रतिस्थापित करते हैं तो हर दूसरे परिणाम में दो निचले-बाएँ वर्ण गायब होंगे।

Answer 10

के, 84४

{-1'(*r;((|r 3),\:(w-2)#" "),'r 1;|(r:(0,+\(w;h;w;h:_(l-2*w:-_-(1+(l:#x)%4))%2))_x)2);}

।

k){-1'(*r;((|r 3),\:(w-2)#" "),'r 1;|(r:(0,+\(w;h;w;h:_(l-2*w:-_-(1+(l:#x)%4))%2))_x)2);}"HelloWorld"
Hell
d  o
lroW

k){-1'(*r;((|r 3),\:(w-2)#" "),'r 1;|(r:(0,+\(w;h;w;h:_(l-2*w:-_-(1+(l:#x)%4))%2))_x)2);}"Hellooooooooooooooo Worlddddd!"
Hellooooo
!       o
d       o
d       o
d       o
d       o
d       o
lroW oooo

Answer 11

स्काला (135)

निम्नलिखित स्निपेट मानता है कि xइसमें स्ट्रिंग को प्रारूपित किया गया है, और इसे स्कैल REPL में चिपकाया जाना चाहिए:

val (h,w)=((x.size+3)/4,println(_:Any));val s=x.grouped(h)toSeq;w(s(0));for((l,r)<-s(1)zip(s(3)reverse))w(r+" "*(h-2)+l);w(s(2)reverse)

यदि आपके पास स्केला स्थापित नहीं है, तो आप जल्दी से इस ऑनलाइन स्काला दुभाषिया का उपयोग करके जांच कर सकते हैं: http://www.simplyscala.com/ । बस निम्नलिखित पाठ अंत मूल्यांकन का पेस्ट करें:

val x="HelloWorld"
val (h,w)=((x.size+3)/4,println(_:Any));val s=x.grouped(h)toSeq;w(s(0));for((l,r)<-s(1)zip(s(3)reverse))w(r+" "*(h-2)+l);w(s(2)reverse)

Answer 12

पायथन 3 (120)

s=input()
n=len(s)
h=n//4
q=(n+2)//4-1
p=print
p(s[:q+2])
for i in range(1,h):p(s[n-i]+' '*q+s[q+1+i])
p(s[n-h:q+h:-1])

परीक्षा

इनपुट:

abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz

उत्पादन:

abcdefghijklmn
z            o
y            p
x            q
w            r
v            s
u            t
t            u
s            v
r            w
q            x
p            y
o            z
nmlkjihgfedcba

Answer 13

PHP (149)

मुद्रित करने के लिए पाठ नाम के एक चर में होना चाहिए $x।

@$s=substr;echo$s($x,-$w=($l=strlen($x)/2)-$h=$i=$l-2>>1).'
';while($i--)echo$x[$l+$i].str_repeat(' ',$w-2).$x[$h-$i-1].'
';echo$s(strrev($x),$l,$w);

Answer 14

पायथन 2.7 (99)

t=''.join(raw_input().split())
u=len(t)/2-1
print t[:u]+"\n"+t[-1]+" "*(u-2)+t[u]+"\n"+t[-2:u:-1]

संपादित करें: यह स्पष्ट रूप से अंदर अधिकतम क्षेत्र को शामिल करने के नियम का उल्लंघन करता है।

Answer 15

जावा - 320

public class A{
public static void main(String[] a){
String s=a[0];
int l=s.length(),h=l/2,f=h-1,i=0;       
for(i=0;i<f;i++)
System.out.print(s.charAt(i));
System.out.print("\n"+s.charAt(l-1));
for(i=0;i<f-2;i++)
System.out.print(" ");
System.out.println(s.charAt(h-1));
for(i=l-2;i>h-1;i--)
System.out.print(s.charAt(i));}}

नोट: - इनपुट कमांड लाइन से लिया गया है

इनपुट: - हैलोवर्ल्ड

आउटपुट: -

Hell
d  o
lroW

इनपुट: - abcdefghijklmnopqrstuvwxyz

आउटपुट: -

abcdefghijkl
z          m
yxwvutsrqpon

Comments

कृपया नियमों को अधिक ध्यान से पढ़ें, विशेष रूप से एनआर। 3.

— vsz