字符串中的字符不断旋转

23

（灵感来自PhiNotPi的分形线挑战的初稿。）

您会得到一个width W > 1，height H > 1和一个由2(W+H-2)可打印ASCII字符组成的字符串。任务是从左上角开始按顺时针方向打印此字符串，该字符串缠绕在给定宽度和高度的矩形周围。矩形的内部充满空格。测试用例有望使这一点很清楚。

您可以编写程序或函数，通过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

排行榜

这是一个堆栈片段，用于按语言生成常规排行榜和获胜者概述。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

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

显示代码段

code-golf  ascii-art  string 
— 马丁·恩德
source
8
您的排行榜太酷了。
— Alex A.
2
您打高尔夫排行榜脚本了吗？
— mbomb007'3
2
@ mbomb007不，我通过缩小器运行了代码，因此扩展时不会占用太多空间。（我想删除换行符就足够了。）我的硬盘上仍然有未缩小的版本。
— 马丁·恩德
2
如果您将其重命名为“字符串中的字符进行循环播放”，则它更适合歌曲的节奏。
— 贾斯汀

Answers:

9

CJam，27个字节

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

我并不是真正的CJam，但我认为这胜过Martin。主要区别在于我们在读取输入内容之前先插入换行符，然后立即打印第一行，而无需存储高度。

按顺序接受输入

H "String" W

在线尝试。

— Sp3000
source
10

Python 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时间更长。

— 异或
source
您可以切换到Python 3并将打印内容存储在一个变量中……
— Omar
1
@Omar这样会更长一些，因为您必须eval在输入上使用并在打印语句中加上括号。
— FryAmTheEggman 2015年
哦，我没有考虑eval！括号应该不是太大的问题，因为print在Python 2中，它后面需要一个空格。从print blah到p(blah)仍会保存3个字符。
— 奥马尔（Omar）2015年
9

CJam，31岁 30字节

在Optimizer的坚持下，这是我自己的尝试。我不喜欢赢得挑战，所以我指望APL家族（或CJam更好的人）要战胜这一挑战。;）

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.";
— 马丁·恩德
source
因为我们可以得到字符串的长度并且我们有V，所以不需要保存H。只需重复执行该程序块，直到仅剩下V个字符即可。l~;:V/(N@s{)V2-S*@(N@_,V-}gW%节省1个字符。
— DocMax
@DocMax不幸的是，这不适用于高度2。但是，这是个好主意，我将研究是否可以以其他方式使用它。
— 马丁·恩德
天哪！您甚至提到了H = 2问题，但我仍然忘记提防它。
— DocMax
9

Pyth，47 46 45 40 37 36字节

这是在Pyth中实现的明显方法。它通过索引打印第一行0:width，然后在中间打印，然后在结尾打印。

感谢@Jakube提供了使用z和Q用于两个输入以及使用的技巧p。

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

将来自stdin的输入作为字符串和维度元组（换行符分隔）：

Hello, World! 
5, 4

并写入标准输出。

在这里尝试。

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
— 马尔蒂森
source
使用z读取字符串可以节省很多字符。也是t_N一样-_N1。
— 雅库布
使用我们的方法可能会出现37个字符。
— 雅库布
@Jakube感谢您的提示！
— Maltysen
再节省一个字符。取而代之的++使用p和开关zt_N用*d-k2。
— 2015年
5

J，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
source
哇，我印象深刻的是这个工程的宽度和高度2 J.
— 马丁安德
4

佩斯38 37

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

我最初有一个不同的38解决方案，但基本上是Maltysen回答的高尔夫球解决方案。所以我决定走一点不同。

在线尝试。

              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]
— 雅库比
source
_>z_ttH等同于<_zttH。
— isaacg 2015年
@isaacg谢谢，已经在Maltysen的回答中看到了类似的内容。
— 雅库布
4

的JavaScript（ES6），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

Chrome版本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
}

不打高尔夫球

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

在Firefox / FireBug控制台中 测试

;[["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
source
3

Python 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
source
3

Haskell，164156字节

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

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

工作原理：创建一个wx 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

编辑：找到了一种更好的方法来解决第一个转弯后第四个字符的问题。

— 妮米
source
很好，这与我在CJam中尝试过的类似，除了它可以工作。;）
— Martin Ender 2015年
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操作员使用自定义字符间距写出字符串的优势。在这种情况下，我使用负的垂直间隔向下书写，然后使用负的水平间隔向后书写，然后使用正垂直的间隔向上书写。因此，我不需要使用任何类型的字符串处理。

— AJ曼斯菲尔德
source
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
source
2

Bash + coreutils，124

一个让您开始的shell脚本：

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
$
— 数字创伤
source
2

JavaScript中，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
source
slice短于substr，它并不完全相同，但是在这种情况下，您可以使用它
— edc65
2

Groovy，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
— 卡米尔（Kamil Mikolajczyk）
source
2

K，55 54字节

使用与randomra的J实现相同的方法；从一个空格开始，然后从字符串的尾部添加到边缘，同时旋转四次：

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)

使用transpose（+）和反向每个（|:'）旋转90度：

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

因此，如果我们有一个空格块t和一个字符串s，则可以在sto 的尾部前面加上一片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}

如果有更好的方法来计算这些分割点，我欢迎您提出建议。

编辑2：

稍微重新排列就可以删除一对括号。54个字节！

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

K，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
source
您可以通过使用“接受”（矢＃）和一个明确的参数列表完善这个有点：f:{[s;y;n]`0:(,n#s),({s[(#s)-x+2],((n-2)#" "),s@n+x}'!y-2),,n#|-4!s}。以我的数量计算，共68个字符。
— JohnE
@JohnE谢谢！我知道明确的论点清单，但它以某种方式让我忘了。不过，我对二进位数字一无所知。
— kirbyfan64sos
2

R，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='')}

不打高尔夫球

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
>
— 米奇
source
2

T-SQL，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次重复。首先递归从字符串中截断@W字符。中间递归从剩余的字符串中获取最后一个和第一个，并在其间进行填充。最后一次递归会反转剩余的内容。SQL Server处理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)
— 米奇
source
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])
— 克内德尔谢普
source
1

C ++，398字节

使用的编译器- 带标志的GCC 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;
    }

}
— 安莫尔·辛格·贾吉（Anmol Singh Jaggi）
source
您不能使用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]();
— Anmol辛格Jaggi
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";

我相信这可以大大改善。我是菜鸟 >，<

— 斯蒂芬·芒顿
source
0

Java 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)相同的字节数，因为Java 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
— 凯文·克鲁伊森
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.