स्ट्रिंग गो राउंड और राउंड में वर्ण

23

( PhiNotPi की फ्रैक्टल लाइन चुनौती के शुरुआती मसौदे से प्रेरित है ।)

आपको मुद्रण योग्य ASCII वर्णों की चौड़ाई W > 1, ऊँचाई H > 1और स्ट्रिंग दी जाती है 2(W+H-2)। यह कार्य दी गई चौड़ाई और ऊंचाई के आयत के चारों ओर लिपटे हुए इस तार को प्रिंट करने के लिए होता है, जो शीर्ष बाएँ कोने में शुरू होता है, दक्षिणावर्त अर्थ में। आयत के अंदर का स्थान रिक्त स्थान से भरा है। परीक्षण मामलों को उम्मीद है कि यह बहुत स्पष्ट होना चाहिए।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेते हुए, एक प्रोग्राम या फ़ंक्शन लिख सकते हैं, और परिणाम को STDOUT (या निकटतम विकल्प) पर प्रिंट कर सकते हैं या इसे एक स्ट्रिंग के रूप में वापस कर सकते हैं।

कोई अग्रणी या अनुगामी स्थान नहीं होना चाहिए (उन लोगों के अलावा जो इनपुट स्ट्रिंग में हो सकते हैं)। आप वैकल्पिक रूप से एक एकल अनुगामी न्यूलाइन का उत्पादन कर सकते हैं।

यह कोड गोल्फ है, इसलिए सबसे छोटा सबमिशन (बाइट्स में) जीतता है।

परीक्षण के मामलों

प्रत्येक परीक्षण मामले के "String" W Hबाद अपेक्षित आउटपुट होता है।

"Hello, World! "
5 4
Hello
    ,
!    
dlroW

"+--+|||+--+|||"
4 5
+--+
|  |
|  |
|  |
+--+

">v<^"
2 2
>v
^<

"rock beats scissors beats paper beats "
11 10
rock beats 
          s
s         c
t         i
a         s
e         s
b         o
          r
r         s
epap staeb 

Note that the following string contains an escaped '"'.
"!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
46 3
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN
~                                            O
}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQP

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

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

code-golf  ascii-art  string 
— मार्टिन एंडर
स्रोत
8
आपके लीडरबोर्ड कितने कूल हैं।
— एलेक्स ए।
2
क्या आपने अपने लीडरबोर्ड की स्क्रिप्ट को गोल्फ किया है?
— mbomb007 21
2
@ mbomb007 नहीं, मैंने मिनीफ़ायर के माध्यम से कोड चलाया, इसलिए इसे विस्तारित होने पर अधिक स्थान नहीं मिलेगा। (मुझे लगता है कि लाइन ब्रेक को हटाना पर्याप्त होगा।) मुझे अभी भी अपनी हार्ड ड्राइव पर एक unminified संस्करण मिला है।
— मार्टिन एंडर
2
यदि आपने इसका नाम बदलकर "स्ट्रिंग इन गो राउंड एंड राउंड" रखा है, तो यह गीत की लय को बेहतर बनाता है।
— जस्टिन

जवाबों:

9

सीजेएम, 27 बाइट्स

Nl~:L/(os\2-{)L2-S*@(N@}*W%

मैं वास्तव में CJam नहीं है, लेकिन मुझे लगता है कि यह मार्टिन को हरा देता है। मुख्य अंतर यह है कि हम इनपुट पढ़ने से पहले एक नई रेखा को धक्का देते हैं और ऊंचाई को स्टोर करने की आवश्यकता को नकारते हुए, तुरंत पहली पंक्ति को प्रिंट करते हैं।

आदेश में इनपुट लेता है

H "String" W

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

— Sp3000
स्रोत
10

पायथन 2, 95 बाइट्स

s,m,n=input()
print s[:n]
for i in range(m-2):print s[~i]+' '*(n-2)+s[n+i]
print s[1-m::-1][:n]

पहली पंक्ति को प्रिंट करता है, फिर दो ऊर्ध्वाधर लाइनों को, फिर आखिरी लाइन को।

वहाँ printतीन बार लिखने की तुलना में कुछ कम हो गया है , लेकिन सब कुछ मैंने एक चर को बचाने के साथ अब तक कोशिश की है और '\n'.joinलंबे समय तक रहा है।

— XNOR
स्रोत
आप पायथन 3 पर स्विच कर सकते हैं और एक चर में प्रिंट स्टोर कर सकते हैं ...
— ओमर
1
@ उमर अधिक लंबी होने के कारण आपको evalइनपुट पर उपयोग करना होगा और प्रिंट स्टेटमेंट्स को ब्रैकेट करना होगा।
— FryAmTheEggman
ओह, मैंने ध्यान नहीं evalदिया! printपाइथन 2 के बाद से कोष्ठक को बहुत अधिक समस्या नहीं होनी चाहिए । से जा रहे हैं print blahकरने के लिए p(blah)अभी भी 3 अक्षरों की बचत होती है।
— उमर
9

सीजेएम, 31 30 बाइट्स

ऑप्टिमाइज़र के आग्रह पर, यहाँ मेरा अपना प्रयास है। मैं अपनी खुद की चुनौतियों को जीतने का प्रशंसक नहीं हूं, इसलिए मैं इसे हरा देने के लिए एपीएल परिवार (या सीजेएम में कोई बेहतर) की गिनती कर रहा हूं। ;)

l~:H;:V/(N@s{)V2-S*@(N@}H2-*W%

उसी क्रम में इनपुट लेता है जैसा कि प्रश्न में दिया गया है:

"Hello, World! " 5 4

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

एक बाइट ने ऑप्टिमाइज़र को धन्यवाद दिया।

व्याख्या

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

l~                             "Read and evaluate the input.";
  :H;                          "Store the height in H and discard it.";
     :V/                       "Store the width in V and split the input into chunks of size V.";
        (N                     "Slice off the first such chunk and push a newline.";
          @s                   "Pull up the other chunks and join them back together.";
            {          }H2-*   "Repeat this block H-2 times, printing the sides.";
             )                 "Slice off the last character of the string.";
              V2-S*            "Push V-2 spaces.";
                   @(          "Pull up the remaining string and slice off the first character.";
                     N@        "Push a newline and pull up the remaining string.";
                            W% "Reverse the remainder of the string, which is the bottom row.";
— मार्टिन एंडर
स्रोत
क्योंकि हम स्ट्रिंग की लंबाई प्राप्त कर सकते हैं और हमारे पास वी है, एच को बचाने की कोई आवश्यकता नहीं है। बस ब्लॉक को तब तक दोहराएं जब तक कि केवल वी अक्षर शेष न हों। l~;:V/(N@s{)V2-S*@(N@_,V-}gW%1 char बचाता है।
— डॉकमैक्स
@DocMax दुर्भाग्य से, यह ऊंचाई के लिए काम नहीं करता है। यह एक अच्छा विचार है, हालांकि, मैं इस बात पर ध्यान दूंगा कि क्या मैं किसी तरह से इसका उपयोग कर सकता हूं।
— मार्टिन एंडर
डी 'ओह! आपने H = 2 समस्या का भी उल्लेख किया है और मैं अभी भी इसके खिलाफ पहरा देना भूल गया हूं ।
— डॉकमैक्स
9

पायथ, 47 46 45 40 37 36 बाइट्स

यह पाइथ में लागू स्पष्ट दृष्टिकोण है। यह पहली पंक्ति को अनुक्रमणित करता है 0:widthऔर फिर मध्य, फिर अंत।

उपयोग करने के साथ zऔर Qदो इनपुट और उपयोग करने के लिए टिप के लिए @Jakube का धन्यवाद p।

AkYQ<zkV-Y2p*d-k2@zt_N@z+kN;<_<z-2Yk

स्टड से इनपुट को एक स्ट्रिंग के रूप में और आयामों के एक गुच्छे के रूप में ले जाता है, नई रेखा अलग हो जाती है:

Hello, World! 
5, 4

और stdout को लिखता है।

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

A              Double assignment
 kY            The vars k and Y
 Q             The dimension tuple
<zk            Prints out first line by doing z[:width]
V-Y2           For N in height-2
 p             Print out everything
  *d           Repeat " "
   -k2         Width-2 times
  @z           Index z
   -_N1        At index -N-1
  @z           Index z
   +kN         At index k+N
;              Close out loop
<_<z-2Yk       Print last line
— Maltysen
स्रोत
zस्ट्रिंग को पढ़ने के लिए उपयोग करने से वर्णों की काफी बचत होती है। साथ t_Nही जैसी है वैसी ही है -_N1।
— जकुबे
हमारे दृष्टिकोण से 37 वर्ण संभव हैं।
— जकुबे
@Jakube सुझावों के लिए धन्यवाद!
— माल्टीसेन
एक और चार बचत। इसके बजाय ++उपयोग pऔर स्विच के zt_Nसाथ *d-k2।
— जकुबे
5

जे, 61 बाइट्स

तरीका:

(height-2)*(width-2)रिक्त स्थान के ब्लॉक से शुरू करके हम स्ट्रिंग के अंत से आवश्यक मात्रा में अक्षर लेते हैं और इसे वर्तमान ब्लॉक में जोड़ते हैं। हम इसे 4 बार दोहराते हैं। उदाहरण के साथ बताए गए कुल 5 राज्य 'Hello, World! ' 5 4(रिक्त स्थान Xपठनीयता के लिए s के साथ प्रतिस्थापित ):

XXX   !_   orld   ,_W   Hello
XXX   XX   XXX!   XXo   _XXX,
      XX   XXX_   XXr   !XXX_
      XX          XXl   dlroW
                  _!d

कोड:

4 :'|:>{:((}.~{:@$);({.~{:@$)|.@|:@,])&>/^:4(|.x);'' ''$~y-2'

स्पष्ट फ़ंक्शन परिभाषा। दो-ऑपरेंड फ़ंक्शन बाएं तर्क के रूप में एक स्ट्रिंग लेता है और दो पूर्णांकों की सूची सही तर्क के रूप में।

उदाहरण का उपयोग:

   wrap_on=.4 :'|:>{:((}.~{:@$);({.~{:@$)|.@|:@,])&>/^:4(|.x);'' ''$~y-2'

   'Hello, World! ' wrap_on 5 4
Hello
    ,
!    
dlroW

   '>v<^' wrap_on 2 2
>v
^<

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

— randomra
स्रोत
वाह, मैं प्रभावित हूं कि यह जे। में चौड़ाई और ऊंचाई 2 के लिए काम करता है
— मार्टिन एंडर
4

अजगर, ३ 37 ३ 37

AGHQ<zGFNC,_>z_ttH>zGj*dttGN)<>_zttHG

मेरे पास मूल रूप से एक अलग 38 समाधान था, लेकिन यह मूल रूप से माल्टीसेन के जवाब का गोल्फ समाधान था। इसलिए मैंने थोड़ा अलग होने का फैसला किया।

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

              implicit: z=string from input, Q=pair of numbers from input
AGHQ          G=Q[0] (width), H=Q[1] (height)
<zG           print z[:G]
    _>z_ttH     last H-2 chars reversed
    >zG         all chars from the Gth position to end
  C,           zip these 2 strings to pairs
FN            for each pair N:
  j*dttGN       seperate the two chars by (G-2) spaces and print
)             end for
<>_zttHG     print last line z[::-1][H-2:][:G]
— Jakube
स्रोत
_>z_ttHके बराबर है <_zttH।
— isaacg
@isaacg धन्यवाद, पहले से ही माल्टीसेन के जवाब में कुछ ऐसा ही देखा गया है।
— जकुबे
4

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

3 मापदंडों के साथ फ़ंक्शन, एक स्ट्रिंग लौटाता है 

F=(s,w,h,q=h+(w-=2),t=b='')=>
[for(c of s)q?t+=q<h?c+'\n'+s[w+h+w+q--]+' '.repeat(q&&w):(b+=s[w+q--],c):q]
&&t+b

क्रोम संस्करण 119 : कार्यों के लिए कोई छोटा प्रारूप नहीं, कोई डिफ़ॉल्ट पैरामीटर नहीं। for(of)समर्थित होने पर भी उपयोग करने का कोई कारण नहीं

function F(s,w,h){
  for(q=h+(w-=2),t=b=i='';
      q;
      q<h?t+='\n'+s[w+h+w+q--]+' '.repeat(q&&w):b+=s[w+q--])
    t+=s[i++];
  return t+b
}

ES5 संस्करण 126 : नहीं (के लिए), कोई string.repeat

function F(s,w,h){
  for(q=h+(w-=2),t=b=i='';
      q;
      q<h?t+='\n'+s[w+h+w+q--]+Array(q&&-~w).join(' '):b+=s[w+q--])
    t+=s[i++];
  return t+b
}

Ungolfed

F=(s,w,h)=>
{
  var q = h+(w-=2), // middle length 
      t = '', // top and body
      b = ''; // bottom row
  for(c of s)
    if (q > 0)
    {
      if (q < h)
      {
        t += c+'\n'; // right side, straight
        t += s[w+h+w+q]; // left side, backwards 
        if (q > 1) // body fill, except for the last line
          t += ' '.repeat(w)
      }
      else
      {
        t+=c, // top, straight
        b+=s[w+q] // bottom, backwards
      }
      --q
    }
  return t+b

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

;[["Hello, World! ", 5, 4],["+--+|||+--+|||",4,5],[">v<^",2,2]
,["rock beats scissors beats paper beats ",11,10]
,["!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",46,3]]
.forEach(test => console.log(F(...test)))

उत्पादन

Hello
    ,
!    
dlroW

+--+
|  |
|  |
|  |
+--+

>v
^<

rock beats 
          s
s         c
t         i
a         s
e         s
b         o
          r
r         s
epap staeb 

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN
~                                            O
}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQP
— edc65
स्रोत
3

पायथन 2, 97 बाइट्स

def f(s,w,h):print s[:w];i=0;exec'print s[~i]+" "*(w-2)+s[w+i];i+=1;'*(h-2);print s[1-h:w+h-3:-1]

प्रत्यक्ष दृष्टिकोण लेना।

— Sp3000
स्रोत
3

हास्केल, 164 156 बाइट्स

import Data.List
r=replicate
p w h(s:t)=unlines$fst$n$n$n$n(r h$r w ' ',(w,h,s:t++[s]))
n(_:b,(w,h,s))=(transpose$map reverse$(take w s):b,(h,w,drop(w-1)s))

फ़ंक्शन pआउटपुट को प्रिंट नहीं करता है, लेकिन इसे एक स्ट्रिंग के रूप में लौटाता है, जैसे p 4 5 "+--+|||+--+|||"-> "+--+\n| |\n| |\n| |\n+--+\n"। बेहतर प्रदर्शन के लिए putStr:

putStr $ p 4 5 "+--+|||+--+|||"

+--+
|  |
|  |
|  |
+--+

यह कैसे काम करता है: मैं रिक्त स्थान का एक wएक्स hब्लॉक बनाता हूं और इनपुट स्ट्रिंग की शुरुआत के साथ पहली पंक्ति को प्रतिस्थापित करता हूं । फिर मैं ब्लॉक वामावर्त घुमाता हूं और पहली पंक्ति को दूसरी तीन बार प्रतिस्थापित करता हूं।

# 4 के बाद फिर से पहले चरित्र को काटने से रोकने के लिए, मैं इसे शुरू करने से पहले इनपुट स्ट्रिंग पर जोड़ता हूं।

"Hello World" example, 5 x 4


         |  Start               Turn #1          Turn #2     Turn #3   Turn #4
---------+--------------------------------------------------------------------
String   |  "Hello, World! H"   "o, World! H"    "World! H"  "d! H"    ""
left     | 
         |
Block    |  <empty>             Hello            o, W        World     d! H
before   |                                       l                     l  e
rotating |                                       l           ,         r  l
         |                                       e           olleH     o  l
         |                                       H                     W ,o

संपादित करें: कट-ऑफ-पहले-चरित्र-ऑन-टर्न- # 4 समस्या को हल करने का एक बेहतर तरीका मिला।

— nimi
स्रोत
आह अच्छा ... यह सीजेएम में मेरे द्वारा किए गए प्रयास के समान है, सिवाय इसके कि यह काम करता है। ;)
— मार्टिन एंडर
3

पोस्टस्क्रिप्ट, 62 बाइट्स

यह निश्चित रूप से बाइनरी टोकन का उपयोग करता है, लेकिन यह इसके बराबर है:

/Courier findfont setfont

0 h moveto

s [
    w {1 0} repeat pop pop
    h {0 -1} repeat pop pop
    w {-1 0} repeat pop pop
    h {0 1} repeat
] xyshow

यहाँ फ़ाइल का हेक्सडंप है ( xxd round.ps):

0000000: 91c7 9243 9295 3020 6892 6b73 5b77 7b31  ...C..0 h.ks[w{1
0000010: 2030 7d92 8392 7592 7568 7b30 202d 317d   0}...u.uh{0 -1}
0000020: 9283 9275 9275 777b 2d31 2030 7d92 8392  ...u.uw{-1 0}...
0000030: 7592 7568 7b30 2031 7d92 835d 92c3       u.uh{0 1}..]..

ऐसे दोड़ो:

gs -dw=11 -dh=10 -ss="rock beats scissors beats paper beats " round.ps

आउटपुट वास्तव में छोटा है (फ़ॉन्ट को स्केलिंग नहीं करने के परिणामस्वरूप), इसलिए आपको इसे देखने के लिए एक निष्पक्ष बिट में ज़ूम करने की आवश्यकता है।

यह xyshowकस्टम वर्ण spacings का उपयोग करके स्ट्रिंग को लिखने के लिए ऑपरेटर का लाभ उठाता है । इस मामले में, मैं लिखने के लिए नकारात्मक ऊर्ध्वाधर रिक्ति का उपयोग करता हूं, फिर पीछे की ओर लिखने के लिए नकारात्मक क्षैतिज स्थान, फिर ऊपर की ओर लिखने के लिए सकारात्मक ऊर्ध्वाधर स्थान। इस वजह से, मुझे किसी प्रकार के स्ट्रिंग हेरफेर का उपयोग करने की आवश्यकता नहीं है।

— AJMansfield
स्रोत
3

> <>, 82 80 + 3 = 83 बाइट्स

:2-&\
v!?:<oi-1
/?(0:i
\~ao{2-{~}
\{:?!v1-}o&:&
>:?v!~{{o}ao4.
^  >" "o1-
o;!?l<

Esolang पृष्ठ> <> (मछली) के लिए

यह मेरी अपेक्षा से कम निकला। यह पहली पंक्ति को प्रिंट करने के सीधे दृष्टिकोण का उपयोग करता है, फिर कॉलम केंद्रीय रिक्त स्थान, फिर अंतिम पंक्ति के साथ गद्देदार होता है।

STDIN के माध्यम से स्ट्रिंग इनपुट करें और -vध्वज के साथ कमांड लाइन के माध्यम से ऊंचाई और चौड़ाई , जैसे:

py -3 fish.py round.fish -v <height> <width>

व्याख्या

:2-&           Put W-2 in the register
:?!v1-io       Directly print the first W characters of the input
i:0(?/         Read the rest of the input
~ao{2-{~}      Pop a few leftovers 0s from above, decrement H by 2 and print a newline
               Stack now consists of H = H-2 at the bottom and the rest of the input reversed

[loop]

{:?!v          If H is 0...
  ~                Pop the 0
  l?!;o            Print the rest of the (reversed) input

               Otherwise...
  1-}              Decrement H
  o                Output the top of stack
  &:&              Copy I = W-2 from the register
  :?               If I is nonzero...
    " "o1-             Print a space and decrement I, then repeat from the previous line
  {{o}ao           Print the bottom input character and output a newline
  4.               Jump to the start of the loop (note that I = 0 is leftover from above)
— Sp3000
स्रोत
2

बैश + कोरुटिल्स, 124

आरंभ करने के लिए एक शेल स्क्रिप्ट:

echo "${3:0:$1}"
fold -1<<<"${3:$1*2+$2-2}"|tac|paste - <(fold -1<<<"${3:$1:$2-2}")|expand -t$[$1-1]
rev<<<"${3:$1+$2-2:$1}"

कमांड-लाइन आर्ग के रूप में इनपुट पास करें:

$ ./roundnround.sh 5 4 "Hello, World! "
Hello
    ,
!    
dlroW
$
— डिजिटल आघात
स्रोत
2

जावास्क्रिप्ट, 161 160 158 बाइट्स

मैं जिस विधि से आया हूं वह बहुत लंबा है, लेकिन ठीक है, यह अभ्यास है। (इसके अलावा, मुझे यह समझ से बाहर हो गया r+o[u]+'\n':d।)

function f(o,w,n){s=o.slice(0,w)+'\n';o=o.slice(w);n-=2;r='';for(u=w-2;u--;)r+=' ';for(u=d=0;d=o[2*n+w+~u],u<w+n;u++)s+=(u<n)?(d||' ')+r+o[u]+'\n':d;return s}

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

— vvye
स्रोत
sliceकी तुलना में कम है substr, यह बिल्कुल समान नहीं है, लेकिन इस मामले में आप इसका उपयोग कर सकते हैं
— edc65
2

ग्रूवी, 140

f={a,x,y->println a.substring(0,x);(1..y-2).each{println a[a.length()-it]+' '*(x-2)+a[it+x-1]}println a.substring(x+y-2,2*x+y-2).reverse()}

फोन:

f('rock beats scissors beats paper beats ',11,10)

उत्पादन:

rock beats 
          s
s         c
t         i
a         s
e         s
b         o
          r
r         s
epap staeb
— कामिल मिकोलाजस्की
स्रोत
2

के, 55 54 बाइट्स

रैंडम्रा के जे कार्यान्वयन के समान दृष्टिकोण का उपयोग करना; रिक्त स्थान के ब्लॉक से शुरू करें और चार बार घुमाते हुए स्ट्रिंग की पूंछ से किनारे तक जोड़ें:

f:{`0:*4{((,r#*|x),|:'+*x;(r:-#*x)_*|x)}/((y-2)#" ";x)}

और कुछ उदाहरण:

  f["Hello,_World!_";4 5]
Hello
_   ,
!   _
dlroW

  f[">v<^";2 2]
>v
^<

पठनीयता के लिए इसे थोड़ा तोड़कर,

NxM ब्लॉक बनाएं:

  t:2 3#!6
(0 1 2
 3 4 5)

ट्रांसपोज़ ( +) और रिवर्स-प्रत्येक ( |:') का उपयोग करके 90 डिग्री घुमाएँ :

  |:'+t
(3 0
 4 1
 5 2)

तो अगर हम रिक्त स्थान का एक ब्लॉक है tऔर एक स्ट्रिंग s, हम की पूंछ का एक टुकड़ा पहले जोड़ें कर सकते हैं sकरने के लिए t:

  s: 12 18 17 8 9
12 18 17 8 9
  (,(-#t)#s),|:'+t
(8 9
 3 0
 4 1
 5 2)

हम फॉर्म का उपयोग करते हैं 4 {[x] ... }/( ... ) फ़ंक्शन का बार-बार स्ट्रिंग और मैट्रिक्स के निर्माण से मिलकर एक कार्य करने के लिए करते हैं। हर बार जब हम यह रोटेट-एंड-कॉनेटेट करते हैं तो हम स्ट्रिंग को भी काट देते हैं।

संपादित करें:

एक अन्य विचार यह है कि इनपुट स्ट्रिंग को उन टुकड़ों में विभाजित किया जाए जो हम प्रत्येक घुमाव पर चाहते हैं, जो प्रोग्राम के मुख्य निकाय को सरल बनाता है। दुर्भाग्य से यह 56 बाइट्स से थोड़ा अधिक लंबा होता है:

f:{`0:((y-2)#" "){|:'(,y),+x}/(+\(0,y[0 1 0]-2 1 1))_|x}

अगर उन विभाजन बिंदुओं की गणना करने का एक बेहतर तरीका है जो मैं सुझावों के लिए खुला हूं।

EDIT2:

थोड़ा उलटने से मुझे कोष्ठक की एक जोड़ी निकालने की सुविधा मिलती है। 54 बाइट्स!

f:{`0:((y-2)#" "){|:'(,y),+x}/(0,+\y[0 1 0]-2 1 1)_|x}
— JohnE
स्रोत
2

के, 80 68 बाइट्स

f:{[s;y;n]`0:(,n#s),({s[(#s)-x+2],((n-2)#" "),s@n+x}'!y-2),,n#|-4!s}

@JohnE के लिए 80 धन्यवाद से छोटा।

मूल:

f:{s:x;n:z;`0:(,s@!n),({s[(#s)+-2-x],({" "}'!n-2),s@n+x}'!y-2),,(|s@!-4+#s)@!n}

मुझे बमुश्किल पता भी है कि यह चीज कैसे काम करती है।

उदाहरण का उपयोग:

f["Hello, world! ";5;4]

कुछ संभावित अनुकूलन हैं, लेकिन मैं बना रहा हूँ Kona segfault ...

— kirbyfan64sos
स्रोत
आप 'ले' (dyadic #) और एक स्पष्ट तर्क सूची का उपयोग करके यह थोड़ा सुधार कर सकते हैं: f:{[s;y;n]`0:(,n#s),({s[(#s)-x+2],((n-2)#" "),s@n+x}'!y-2),,n#|-4!s}। मेरी गिनती के 68 अक्षर।
— जॉनई
@ जॉन धन्यवाद! मुझे स्पष्ट तर्क सूची के बारे में पता था, लेकिन इसने किसी तरह मेरा दिमाग खिसका दिया; मुझे dyadic # के बारे में कोई सुराग नहीं था, हालांकि।
— kirbyfan64sos
2

आर, 178

यह s, w, hपैरामीटर के रूप में एक अनाम फ़ंक्शन है । काश स्ट्रिंग को विभाजित करने का एक अच्छा तरीका था।

function(s,w,h){W=w+h-1;H=w+W-1;S=strsplit(s,'')[[1]];O=array(" ",c(h,w+1));O[,w+1]="\n";O[1:h,c(w,1)]=c(S[w:W],S[(W+W-1):H]);O=t(O);O[1:w,c(1,h)]=c(S[1:w],S[H:W]);cat(O,sep='')}

Ungolfed

W=w+h-1;                                 # additional index points
H=w+W-1;                                 # additional index points
S=strsplit(s,'')[[1]];                   # vectorize the string
O=array(" ",c(h,w+1));                   # create an array of spaces
O[,w+1]="\n";                            # set newlines
O[1:h,c(w,1)]=c(S[w:W],S[(W+W-1):H]);    # build middles lines
O=t(O);                                  # transpose array
O[1:w,c(1,h)]=c(S[1:w],S[H:W]);          # build top and bottom lines
cat(O,sep='')                            # cat out results

परीक्षण चालन

> (function(s,w,h){W=w+h-1;H=w+W-1;S=strsplit(s,'')[[1]];O=array(" ",c(h,w+1));O[,w+1]="\n";O[1:h,c(w,1)]=c(S[w:W],S[(W+W-1):H]);O=t(O);O[1:w,c(1,h)]=c(S[1:w],S[H:W]);cat(O,sep='')})("Hello, World! ",5,4)
Hello
    ,
!    
dlroW
> (function(s,w,h){W=w+h-1;H=w+W-1;S=strsplit(s,'')[[1]];O=array(" ",c(h,w+1));O[,w+1]="\n";O[1:h,c(w,1)]=c(S[w:W],S[(W+W-1):H]);O=t(O);O[1:w,c(1,h)]=c(S[1:w],S[H:W]);cat(O,sep='')})("+--+|||+--+|||",4,5)
+--+
|  |
|  |
|  |
+--+
> (function(s,w,h){W=w+h-1;H=w+W-1;S=strsplit(s,'')[[1]];O=array(" ",c(h,w+1));O[,w+1]="\n";O[1:h,c(w,1)]=c(S[w:W],S[(W+W-1):H]);O=t(O);O[1:w,c(1,h)]=c(S[1:w],S[H:W]);cat(O,sep='')})(">v<^",2,2)
>v
^<
> (function(s,w,h){W=w+h-1;H=w+W-1;S=strsplit(s,'')[[1]];O=array(" ",c(h,w+1));O[,w+1]="\n";O[1:h,c(w,1)]=c(S[w:W],S[(W+W-1):H]);O=t(O);O[1:w,c(1,h)]=c(S[1:w],S[H:W]);cat(O,sep='')})("rock beats scissors beats paper beats ",11,10)
rock beats 
          s
s         c
t         i
a         s
e         s
b         o
          r
r         s
epap staeb
> # Escaped the \ as well 
> (function(s,w,h){W=w+h-1;H=w+W-1;S=strsplit(s,'')[[1]];O=array(" ",c(h,w+1));O[,w+1]="\n";O[1:h,c(w,1)]=c(S[w:W],S[(W+W-1):H]);O=t(O);O[1:w,c(1,h)]=c(S[1:w],S[H:W]);cat(O,sep='')})("!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",46,3)
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN
~                                            O
}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQP
>
— MickyT
स्रोत
2

टी-एसक्यूएल, 307

हालांकि अभी भी लंबे समय तक, यह एक क्वेरी में जितना मैंने सोचा था उससे काफी आसान (और कम) निकला। T-SQL के लिए एक इनलाइन टेबल वैल्यू फ़ंक्शन के रूप में लागू किया गया।

CREATE FUNCTION f(@S VARCHAR(MAX),@ INT,@H INT)RETURNS TABLE RETURN WITH R AS(SELECT 2i,LEFT(@S,@)S,STUFF(@S,1,@,'')+'|'R UNION ALL SELECT i+1,CASE WHEN i<@H THEN LEFT(RIGHT(R,2),1)+REPLICATE(' ',@-2)+LEFT(R,1)ELSE REVERSE(LEFT(R,@))END,STUFF(STUFF(R,LEN(R)-1,1,''),1,1,'')FROM R WHERE i<=@H)SELECT S FROM R

यह स्ट्रिंग @ h समय के माध्यम से पुनरावृत्ति करता है। पहली पुनरावृत्ति क्लिप @ स्ट्रिंग से वर्ण। बीच की स्ट्रिंग के बीच शेष पैडिंग के साथ मध्य पुनरावर्ती अंतिम और पहले लेती है। अंतिम पुनरावृत्ति पीछे छोड़ दिया जाता है। SQL सर्वर VARCHARS पर अनुगामी रिक्त स्थान का व्यवहार करने के तरीके से निपटने के लिए कुछ खोए हुए वर्ण हैं।

परीक्षण चालन

WITH TestSet AS (
    SELECT *
    FROM (VALUES
        ('Hello, World! ',5,4),
        ('+--+|||+--+|||',4,5),
        ('>v<^',2,2),
        ('rock beats scissors beats paper beats ',11,10),
        ('!"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~andfoure',50,3)
        ) Test(S,W,H)
)
SELECT x.S 
FROM TestSet 
    CROSS APPLY (
        SELECT S FROM dbo.F(S,W,H)
        )x

S
----------------------------
Hello
    ,
!    
dlroW
+--+
|  |
|  |
|  |
+--+
>v
^<
rock beats 
          s
s         c
t         i
a         s
e         s
b         o
          r
r         s
epap staeb 
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR
e                                                S
ruofdna~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUT

(24 row(s) affected)
— MickyT
स्रोत
2

MATLAB, 101

function f(H,W,S)
w=1:W;h=(0:H-3).';n=W+H-2;S(3*n)=' ';S([w;[2*n-h,3*n*ones(H-2,W-2),h+W+1];n-w+W+1])
— knedlsepp
स्रोत
1

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

संकलक का इस्तेमाल किया - ध्वज के साथ जीसीसी 4.9.2-std=c++14 

#include<bits/stdc++.h>
using namespace std;string s;vector<vector<char>> M;int w,h,p,i,j;void F(int x,int y){if(p<s.size()&&(((!y||y==h-1)&&x>=0&&x<w)||((!x||x==w-1)&&y>=0&&y<h))&&!M[y][x])M[y][x]=s[p++],F(x+1,y),F(x,y+1),F(x-1,y),F(x,y-1);}int main(){getline(cin,s);cin>>w>>h;M.resize(h,vector<char>(w,0));F(0,0);while(i<h){j=0;while(j<w){if(!M[i][j])M[i][j]=32;cout<<M[i][j++];}i++;cout<<endl;}}

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

व्याख्या

#include<bits/stdc++.h>
using namespace std;

string s; // input string
vector<vector<char>> M; // output matrix
int w, h, p, i, j;
// w = width
// h = height
// p = iterator over s
// i, j = iterators used later for printing answer

void F( int x, int y )
{
    // If the coordinates (x, y) are either on the first row/column or the last row/column and are not already populated with the input characters, populate them
    if ( p < s.size() && ( ( ( y == 0 || y == h - 1 ) && x >= 0 && x < w ) || ( ( x == 0 || x == w - 1 ) && y >= 0 && y < h ) ) && !M[y][x] )
    {
        M[y][x] = s[p++];
        F( x + 1, y );
        F( x, y + 1 );
        F( x - 1, y );
        F( x, y - 1 );
    }
}

int main()
{
    getline( cin, s );
    cin >> w >> h;
    // Input taken !!

    M.resize( h, vector<char>( w, 0 ) ); // Fill the matrix with null characters initially

    F( 0, 0 ); // This function does all the work

    // Now printing the matrix
    while ( i < h )
    {
        j = 0;
        while ( j < w )
        {
            if ( !M[i][j] )
            {
                M[i][j] = ' ';  // Replace '\0' with ' '
            }
            cout << M[i][j++];
        }
        i++;
        cout << endl;
    }

}
— अनमोल सिंह जग्गी
स्रोत
क्या आप char[][]इसके बजाय वर्णों को सहेज नहीं सकते थे ?
— corsiKa
नहीं, vector<vector<char>> M;M.resize(h,vector<char>(w,0));की तुलना में थोड़ा छोटा हैchar** M;M=new char*[h];while(i<h)M[i++]=new char[w]();
— अनमोल सिंह जग्गी
1

पर्ल, 193 195 बाइट्स

($s,$w,$h,$i,$y)=(@ARGV,0,2);
$o.=substr$s,$i,$w;
$i+=$w;
$o.=sprintf"\n%s%*s",substr($s,2*($w+$h)-$y++-3,1)||' ',$w-1,substr($s,$i++,1)while$y<$h;
print$o."\n".reverse(substr($s,$i,$w))."\n";

मुझे यकीन है कि इसमें बहुत सुधार किया जा सकता है। मैं एक noob हूँ। >, <

— स्टीफन मेंटन
स्रोत
0

जावा 11, 180 बाइट्स

(s,w,h)->{var r=s.substring(0,w)+"\n";int i=w;for(var S=s.split("");i<w+h-2;)r+=S[3*w+2*h-i-5]+" ".repeat(w-2)+S[i++]+"\n";return r+new StringBuffer(s.substring(i,i+w)).reverse();}

इसे ऑनलाइन आज़माएं (नोट: String.repeat(int)एक repeat(String,int)ही बाइट-काउंट के लिए अनुकरण किया जाता है , क्योंकि जावा 11 अभी तक TIO पर नहीं है।)

स्पष्टीकरण:

(s,w,h)->{               // Method with String & 2 int parameters and String return-type
  var r=s.substring(0,w)+"\n";
                         //  Result-String, starting at the the first row of output,
                         //  which is a substring in the range [0, `w`)
  int i=w;               //  Index-integer, starting at `w`
  for(var S=s.split(""); //  Split the input-String into a String-array of characters
      i<w+h-2;)          //  Loop `i` in the range [`w`, `w+h-2`)
    r+=                  //   Append the result-String with:
       S[3*w+2*h-i-5]    //    The character at index `2*w+2*h-4 - i+w-1`
       +" ".repeat(w-2)  //    Then append `w-2` amount of spaces
       +S[i++]           //    Then append the character at index `i`
       +"\n";            //    And a trailing new-line
  return r               //  After the loop, return `r` as result
         +new StringBuffer(s.substring(i,i+w)).reverse();
                         //  Appended with the last row of output,
                         //  which is a substring in the range [`i`, `i+w`) reversed
— केविन क्रूज़सेन
स्रोत
0

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

ＢＮＮＳ

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

स्पष्टीकरण:

मूल रूप से इस चुनौती के लिए एक निर्माण। चौड़ाई और ऊंचाई के रूप में पहले दो पूर्णांक-इनपुट लें, और बॉर्डर के रूप में तीसरे इनपुट-स्ट्रिंग के साथ एक बॉक्स प्रिंट करता है:

Box(InputNumber(), InputNumber(), InputString())
ＢＮＮＳ
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.