Lý lịch

Kỷ niệm ngày phát hành Dyalog APL 16.0 , trong đó giải pháp cho vấn đề này là {⊢⌺(≢⍵)⊢⍵}^{Giải thích}

Bài tập

Cho một chuỗi ASCII in có độ dài lẻ n , làm cho một n × n vuông với chuỗi trung tâm theo chiều ngang, nhân đôi để được tập trung theo chiều dọc, và với acrostics của chuỗi giống nhau trong mỗi hàng và cột. Lưu ý rằng tất cả trừ các chuỗi trung tâm sẽ bị cắt để giữ kích thước của hình vuông n × n .

Giải thích về mã của bạn sẽ được nhiều đánh giá cao.

Quy tắc

1. Bạn có thể có khoảng trắng ở cuối và dòng mới (bao gồm cả tam giác phía dưới bên phải)
2. Bạn có thể trả về một danh sách các chuỗi

Ví dụ sử dụng chuỗi ABXCD:

• n là 5. Đầu tiên chúng ta vẽ hai chuỗi trung tâm, một ngang và một dọc:

  ┌─────┐
  A
  │ B
  │ABXCD│
  C
  │ D
  └─────┘
  

  ^{(Hộp giới hạn 5 × 5 được thêm vào cho rõ ràng)}

• Sau đó, chúng tôi đặt tất cả các động tác có thể, theo chiều ngang và chiều dọc:

         Một
        AB
    ┌─────┐
    │ ABX│CD
    ABXC│D
    │ABXCD│
   A│BXCD
  AB│XCD
    └─────┘
     CD
     D
  

• Cuối cùng, chúng tôi chỉ trả lại những gì bên trong hộp giới hạn:

    ABX
   ABXC
  ABXCD
  BXCD 
  XCD  
  

Các trường hợp thử nghiệm

World:

  Wor
 Worl
World
orld
rld

mississippi:

     missis
    mississ
   mississi
  mississip
 mississipp
mississippi
ississippi
ssissippi
sissippi
issippi
ssippi

Pneumonoultramicroscopicsilicovolcanoconiosis:

                      Pneumonoultramicroscopi
                     Pneumonoultramicroscopic
                    Pneumonoultramicroscopics
                   Pneumonoultramicroscopicsi
                  Pneumonoultramicroscopicsil
                 Pneumonoultramicroscopicsili
                Pneumonoultramicroscopicsilic
               Pneumonoultramicroscopicsilico
              Pneumonoultramicroscopicsilicov
             Pneumonoultramicroscopicsilicovo
            Pneumonoultramicroscopicsilicovol
           Pneumonoultramicroscopicsilicovolc
          Pneumonoultramicroscopicsilicovolca
         Pneumonoultramicroscopicsilicovolcan
        Pneumonoultramicroscopicsilicovolcano
       Pneumonoultramicroscopicsilicovolcanoc
      Pneumonoultramicroscopicsilicovolcanoco
     Pneumonoultramicroscopicsilicovolcanocon
    Pneumonoultramicroscopicsilicovolcanoconi
   Pneumonoultramicroscopicsilicovolcanoconio
  Pneumonoultramicroscopicsilicovolcanoconios
 Pneumonoultramicroscopicsilicovolcanoconiosi
Pneumonoultramicroscopicsilicovolcanoconiosis
neumonoultramicroscopicsilicovolcanoconiosis
eumonoultramicroscopicsilicovolcanoconiosis
umonoultramicroscopicsilicovolcanoconiosis
monoultramicroscopicsilicovolcanoconiosis
onoultramicroscopicsilicovolcanoconiosis
noultramicroscopicsilicovolcanoconiosis
oultramicroscopicsilicovolcanoconiosis
ultramicroscopicsilicovolcanoconiosis
ltramicroscopicsilicovolcanoconiosis
tramicroscopicsilicovolcanoconiosis
ramicroscopicsilicovolcanoconiosis
amicroscopicsilicovolcanoconiosis
microscopicsilicovolcanoconiosis
icroscopicsilicovolcanoconiosis
croscopicsilicovolcanoconiosis
roscopicsilicovolcanoconiosis
oscopicsilicovolcanoconiosis
scopicsilicovolcanoconiosis
copicsilicovolcanoconiosis
opicsilicovolcanoconiosis
picsilicovolcanoconiosis
icsilicovolcanoconiosis

Lời cảm ơn

Cảm ơn dzaima , Leaky Nun , ông Xcoder cho tất cả mọi thứ trừ chính ý tưởng của thử thách này.

Python 2 , 60 byte

n=input();l=len(n)
for i in range(l):print(l/2*' '+n)[i:l+i]

Hãy thử trực tuyến!

MATL , 8 byte

nXyPGZ+c

Hãy thử trực tuyến!

Giải trình

n    % Implicit input. Number of elements
Xy   % Identity matrix of that size
P    % Flip vertically
G    % Push input again
Z+   % 2D convolution, maintaining size
c    % Convert to char (char 0 is displayed as space). Implicitly display

Võng mạc , 70 59 byte

.
$.'$* $_$.`$* ¶
(?=((....))+)(?<-1>.)+(.*?)(?<-2>.)+¶
$3¶

Hãy thử trực tuyến! Chỉnh sửa: Đã lưu 11 byte với một số trợ giúp từ @MartinEnder. Giải thích: Giai đoạn đầu tiên lặp lại đầu vào một lần cho mỗi ký tự, đệm nó một cách thích hợp trên mỗi dòng để có được sự cắt. Giai đoạn cuối cùng sau đó loại bỏ 25% từ mỗi bên để tạo ra kết quả mong muốn.

Java 8, 120 103 byte

s->{int l=s.length(),i=l/2;for(;i-->0;s=" "+s+" ");for(;++i<l;System.out.println(s.substring(i,l+i)));}

-17 byte nhờ @ OlivierGrégoire .

Giải trình:

Hãy thử nó ở đây.

s->{                      // Method with String parameter and no return-type
  int l=s.length(),       //  Length of the input-String
      i=l/2;              //  Temp index-integer (starting at halve the length floored)
  for(;i-->0;             //  Loop (1) from `l/2` to 0 (exclusive)
    s=" "+s+" "           //   Add spaces before and after the input-String
  );                      //  End of loop (1)
                          //  (If the input was "World", it is now "  World  ")
  for(;++i<l;             //  Loop (2) from 0 to `l` (exclusive)
    System.out.println(   //   Print:
      s.substring(i,      //    Substring of the modified input from `i`
                    l+i)  //    to `l+i` (exclusive)
    )                     //   End of print
  );                      //  End of loop (2)
}                         // End of method

Haskell, 64 62 byte

f s|l<-length s=take l$take l<$>scanr(:)""(([2,4..l]>>" ")++s)

Hãy thử trực tuyến! Làm thế nào nó hoạt động:

l<-length s               -- let l be the length of the input string

      ([2,4..l]>>" ")     -- take l/2 spaces and
                     ++s  -- append s
    scanr(:)""            -- make a list of the inits of the above string, e.g.
                          -- "  world" -> ["  world"," world","world","orld"...]
  take l <$>              -- take the first l chars of each string
take l                    -- and the first l strings

SWI Prolog, 234 byte

h(_,0,_,_,[]).
h(T,N,S,L,[H|U]):-sub_string(T,S,L,_,H),M is N-1,A is S+1,h(T,M,A,L,U).
s(T,R):-string_length(T,L),findall('_',between(1,L,_),A),string_chars(B,A),
                   string_concat(B,T,C),string_concat(C,B,D),S is L-((L-1)/2),h(D,L,S,L,R).

Có thể thử trực tuyến tại đây: http://swish.swi-prolog.org/p/hEKigfEl.pl

Lưu ý

1. Dòng cuối cùng là một dòng dài, tôi đã thêm một dòng ngắt và khoảng trắng ở đây chỉ để tránh thanh cuộn ngang trong câu trả lời này.
2. Câu hỏi liên quan đến không gian để đệm, nhưng Swish trực tuyến không hiển thị chúng rõ ràng vì các tương tác kết xuất HTML, bạn phải xem nguồn trong các công cụ phát triển trình duyệt để kiểm tra xem chúng có mặt không (chúng có). Tôi đã thay đổi phần đệm _ở đây, vì nó cho thấy nó hoạt động và không ảnh hưởng đến số byte.

Ví dụ chạy trong Swish:

Cách tiếp cận, về cơ bản là điều đầu tiên tôi có thể làm cho công việc, và chắc chắn một người dùng Prolog có kỹ năng có thể rút ngắn nó rất nhiều:

• Cho một chuỗi có độ dài L, đầu ra sẽ có các dòng L và mỗi dòng sẽ dài L ký tự, vì vậy 'L' hiển thị rất nhiều. Đếm ngược từ L đến 0 cho số dòng, L cho chiều dài chuỗi con cho mỗi dòng.
• Tạo một chuỗi đệm của các khoảng trắng L (dấu gạch dưới) dài, thêm nó vào cả hai đầu của chuỗi đầu vào, bởi vì đó là một độ dài đơn giản mà chắc chắn sẽ đủ đệm.
• Tính toán phần bù bắt đầu vào chuỗi có độ dài gấp ba lần này và lặp lại, tạo ra một chuỗi con mỗi lần, vào một danh sách kết quả.

Mã giải thích và nhận xét (có thể không chạy), đọc từ superacrostic()dưới lên, sau đó helper()là thân chính, sau đó là helper()trường hợp cơ sở:

% helper function recursive base case, 
% matches when counter is 0, other input has any values, and empty list 'output'.
helper(_,0,_,_,[]). 



% helper function recursively generates substrings
% matching a padded input Text, a line Counter
% a substring starting Offset, a line Length,
% and an output list with a Head and a Tail
helper(Text, Counter, Offset, LineLength, [Head|Tail]):-

    sub_string(Text, Offset, LineLength, _, Head),    % The list Head matches
                                                      % a substring of Text starting 
                                                      % from Offset, of LineLength chars 
                                                      % and

    NextCounter is Counter-1,                         % decrement the Counter

    NextOffset is Offset+1,                           % increment the offset

    helper(Text, NextCounter, NextOffset, LineLength, Tail).  % Recurse for list Tail



% Result is a superacrostic for an input string Text, if
superacrostic(Text, Result):-
    string_length(Text, Length),                   % Length is length of input, 
                                                   % Text = 'ABXCD', Length = 5
                                                   % and

    findall('_',between(1,Length,_),PaddingList),  % PaddingList is a list of padding
                                                   % chars Length items long, 
                                                   % ['_', '_', '_', '_', '_']
                                                   % and

    string_chars(PaddingString, PaddingChars),     % PaddingString is the string from 
                                                   % joining up that list of chars
                                                   % '_____'
                                                   % and

    string_concat(PaddingString, Text, Temp),      % Temp is Text input with a
                                                   % padding prefix
                                                   % Temp = '_____ABXCD'
                                                   % and

    string_concat(Temp, PaddingString, PaddedText), % PaddedText is Temp with 
                                                    % a padded suffix
                                                    % Temp = '_____ABXCD_____'
                                                    % and


    S is Length - ((Length - 1) / 2),              % Starting offset S for the substring
                                                   % is just past the padding,
                                                   % then half the input length back
                                                   % '_____ABXCD_____'
                                                   %     |
                                                   % to start the first line,
                                                   % and


    helper(PaddedText, Length, S, Length, Result). % Result is the list generated from 
                                                   % the helper function, 

    % to recurse Length times for that many output rows, S starting offset, 
    % Length linelength, and Result 'output'.

05AB1E , 11 byte

g;úIvDIg£,À

Hãy thử trực tuyến!

Giải trình

g;ú           # prepend len(input)/2 spaces to input
   Iv         # for each char of input do
     D        # duplicate current string
      Ig£     # take the first len(input) chars
         ,    # print
          À   # rotate the string to the left

JavaScript (ES6), 75 byte

f=(s,k=1,l=s.length)=>k>l?'':(' '.repeat(l)+s).substr(l/2+k,l)+`
`+f(s,k+1)

console.log(f("World"))

APL (Dyalog Unicode) , 10 ký tự = 22 byte

{⊢⌺(≢⍵)⊢⍵}

Hãy thử trực tuyến!

{... } chức năng ẩn danh mà lập luận được đại diện bởi ⍵

 ⊢ cung cấp khu vực được bảo hiểm khi

 ⌺(... ) trượt một stencil kích thước

  ≢ độ dài của

  ⍵ tranh luận

 ⊢ trên

 ⍵ tranh luận

Cách thức hoạt động này là bằng cách cho phép mỗi ký tự tạo thành giữa một chuỗi có cùng độ dài với đầu vào, đệm sang trái hoặc phải khi cần. Lấy ví dụABXCD :

Chuỗi có năm ký tự, do đó, stprint sẽ có một "mở" rộng năm ký tự.

┌──↓──┐     mở stprint với điểm đánh dấu ở giữa
│ ABX│CD   hãy Aở giữa
 │ ABXC│D   sau đó, B
  │ABXCD|   vv
  A|BXCD | 
  AB|XCD  |
    └──↑──┘ vị trí stprint cuối cùng

PHP , 98 byte

for(;~($a=$argn)[$i++];)$i&1?$t.=substr($a,$i/2)."
":$t=($s.=" ").substr($a,0,-$i/2)."
$t";echo$t;

Hãy thử trực tuyến!

JavaScript (ES8), 66 63 62 byte

Trả về một mảng.

s=>[...s].map((_,x)=>s.padStart(l*1.5).substr(x,l),l=s.length)

Thử nó

o.innerText=(f=
s=>[...s].map((_,x)=>s.padStart(l*1.5).substr(x,l),l=s.length)
)(i.value="Pneumonoultramicroscopicsilicovolcanoconiosis").join`\n`;oninput=_=>o.innerText=f(i.value).join`\n`

<input id=i><pre id=o>

Giải trình

s=>

Hàm ẩn danh lấy chuỗi làm đối số thông qua tham số s.

[...s]

Chia chuỗi thành một mảng các ký tự riêng lẻ.

l=s.length

Lấy độ dài của chuỗi và gán nó cho biến l.

.map((_,x)=>                                        )

Ánh xạ qua mảng, chuyển từng phần tử qua một hàm, trong đó xchỉ mục của phần tử hiện tại.

s.padStart(l*1.5)

Đối với mỗi phần tử, trả về chuỗi gốc có khoảng trắng được đặt trước cho đến khi độ dài của nó gấp 1,5 lần chiều dài ban đầu.

.substr(x,l)

Lấy chuỗi con có độ dài lbắt đầu từ chỉ mục của phần tử hiện tại.

V , 14 , 11 byte

òlÙxHÄ$x>>ê

Hãy thử trực tuyến!

3 byte được lưu nhờ @nmjmcman!

Hexdump:

00000000: f26c d978 48c4 2478 3e3e ea              .l.xH.$x>>.

Cách tiếp cận ban đầu (18 byte):

ø..
Duu@"ñLÙxHÄ$x>

Giải trình:

ò           " Recursively:
 l          "   Move one char to the right (this will break the loop if we move too far
  Ù         "   Duplicate this line down
   x        "   Delete the first character on this line
    H       "   Move to the first line
     Ä      "   Duplicate this line up
      $     "   Move to the end of this line
       x    "   And delete a character
        >>  "   Put one space at the beginning of this line
          ê "   And move to this column on the last line
            " (implicit) ò, end the loop.

Lõi PowerShell , 68 byte

0..($L=($a="$args").Length-1)|%{-join(' '*($L/2)+$a)[($_..($_+$L))]}

Hãy thử trực tuyến!

Lời giải thích

# Input string ABXCD
# -> indexes  0,1,2,3,4  string indexing and num of output lines.
# -> Pad with half-len of spaces __ABXCD.
# -> sliding window array of chars:
# __ABXCD
# |    |       0..4
#  |    |      1..5
#   |    |     2..6
#    |    |    3..7   (selecting indexes past the end returns $nulls, no error)
#     |    |   4..8

# joining those chars into a line


$Text = "$args"                            # script args array to string.
$L    = $Text.Length - 1                   # useful number

$Offsets = 0..$L                           # range array 0,1,2,3,.. to last offset

$Offsets | ForEach-Object {                # Offsets doubles as number of output lines

    $LinePadding = ' ' * ($L / 2)          # lead padding string __
    $PaddedText  = $LinePadding + $Text    # -> __ABXCD

    $Chars = $_..($_+$L)                   # windows 0..4, then 1..5, then 2..6, etc.
    $Line  = $PaddedText[$Chars]           #_,_,A,B,X then _,A,B,X,C then A,B,X,C,D etc.

    -join $Line                            # __ABX  then _ABXC then ABXCD etc.

}

Japt , 19 17 14 byte

Đã lưu 5 byte nhờ @ETHproductions và @Shaggy

¬£iSp½*Ul¹tYUl

Kiểm tra nó trực tuyến! -Rcờ được thêm vào để tham gia với dòng mới (mục đích hiển thị)

Giải trình

¬£iSp½*Ul¹tYUl
                U = Implicit input
¬               Split the input into an array of chars
 £              Map; At each char:
  i               Insert:
   S                Space " "
    p               repeated(
     ½*Ul           .5 * U.length times 
         ¹          )
          t        Substring(
           Y         Index,
            Ul       U.length) 

Than , 26 byte

Ａ⁺¹÷Ｌθ²δＦδ⟦✂θι⁺ιδ⟧Ｆ∕θ²Ｃ¹±¹

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

Thạch , 11 byte

LH⁶ẋ;ṫJḣ€LY

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

LH⁶ẋ;ṫJḣ€LY   "ABXCD"
L             5
 H            2.5
  ⁶ẋ          "  "
    ;         "  ABXCD"
     ṫJ       ["  ABXCD"
               " ABXCD"
               "ABXCD"
               "BXCD"
               "XCD]
        ḣ€L   ["  ABX"
               " ABXC"
               "ABXCD"
               "BXCD"
               "XCD]
           Y  "  ABX
                ABXC
               ABXCD
               BXCD
               XCD"

QBIC , 32 byte

_L;|A=space$(a'\`2)+A[a|?_sA,b,a    

Man, đã đến lúc tôi thêm space$vào QBIC ...

Giải trình

  ;             Read a cmd line parameter as A$
_L |            And take its length as 'a'
A=space$        Set A$ to a number of spaces
(a'\`2)           equal to its own length halved
+A                prepended to itself
[a|             FOR b= 1 to the length of A$
?_sA,b,a        Print a substring of our space-padded A$, starting at the b'th character, running for a chars

Chạy mẫu

Command line: acknowledgement
       acknowle
      acknowled
     acknowledg
    acknowledge
   acknowledgem
  acknowledgeme
 acknowledgemen
acknowledgement
cknowledgement
knowledgement
nowledgement
owledgement
wledgement
ledgement
edgement

Toán học, 88 byte

T=Table;Column@Reverse@T[T[" ",i]<>StringDrop[s=#,-i],{i,d=-⌊StringLength@s/2⌋,-d}]&

Haskell , 86 70 byte

Đây là (vẫn) quá dài, nhưng cảm ơn @bartavelle đã nhắc nhở tôi rằng việc đưa ra một danh sách các chuỗi cũng được chấp nhận!

f s|m<-div(length s)2=take(2*m+1).(`drop`((*>)s" "++s))<$>[m+1..3*m+1]

Hãy thử trực tuyến!

Python 3 , 68 byte

a=input()
c=len(a)
b=a.center(c*2)
for i in range(c):print(b[i:i+c])

Hãy thử trực tuyến!

PowerShell , 133 119 byte

$a="$args";$L=$a.Length;$m=($L+1)/2;$s=" "*($m-1)+$a+" "*($m-1);for($h=0;$h-lt$L;$h++){$r="";0..$L|%{$r+=$s[$_+$h]};$r}

Hãy thử trực tuyến!

Ung dung

$a="$args"
$L=$a.Length                        # the length of the input
$m=($L + 1) / 2                     # the midpoint of the input
$s=" " * ($m-1) + $a + " " * ($m-1) # create a string using the input and padded on both sides with spaces

for($h=0;$h -lt $L;$h++) {          # the height, matching the length of the input
    $r=""                           # init/reset the output string

    0..$L | % {                     # number range to represent each character in the string
        $r+=$s[$_+$h]               # append the output string with the next character
    }

    $r                              # write the output
}

Con trăn 2 ,76 74 73 byte

-1 cảm ơn @FelipeNardiBatista

Tất nhiên, không ngắn như câu trả lời Python khác, nhưng đáng để thử một phương pháp hoàn toàn khác:

n=input();x=len(n)
for i in range(x):print((2*x-~i)*' '+n)[x+x/2:2*x+x/2]

Hãy thử trực tuyến! (với phiên bản 74 byte)

Điều này đầu tiên tạo ra chuỗi đầy đủ, và sau đó cắt nó để phù hợp với hình vuông.

Giải trình

n = đầu vào (); - nhận đầu vào và gán nó cho một biến n
          x = len (n) - gán độ dài của đầu vào cho biến x
với i trong phạm vi (x): - lặp trên phạm vi 0 ... x, với biến i
                   in - đưa ra kết quả
                         ((2 * xi-1) * '' + n) - tạo chuỗi "kim cương"
                                          [x + x / 2: 2 * x + x / 2] - cắt chuỗi cho vừa với hộp

J , 19 byte

|.!.' '"{~2%~#\-#\.

Hãy thử trực tuyến!

Giải trình

|.!.' '"{~2%~#\-#\.  Input: string S
             #\      Length of each prefix of S, [1, 2, ..., len(S)]
                #\.  Length of each suffix of S, [len(s), ..., 2, 1]
               -     Subtract elementwise
          2%~        Divide by 2
                     We now have a range [(1-len(S))/2, ..., -1, 0, 1, ..., (len(S)-1)/2]
       "{~           Use each value to operate on S
|.!.' '                Perform a shift while replacing characters with ' '

C # (.NET Core) , 101 byte

(a)=>{int L=a.Length,l=L/2;for(;l-->0;)a=" "+a+" ";for(;++l<L;)Console.WriteLine(a.Substring(l,L));};

Về cơ bản câu trả lời của KevinCruijssen. Lưu 2 byte vì string.Lengthkhông cần () và 2 byte khác vì đối số thứ hai string.Substring()là độ dài thay vì chỉ mục kết thúc, nhưng sau đó mất 2 byte vì Console.WriteLine()dài hơn. Tôi đã có một triển khai ngây thơ hơn, nhưng nó dài gấp đôi nên ...

VBA Excel, 68 byte

Chơi gôn

Hàm cửa sổ tức thời VBE ẩn danh lấy đầu vào từ ô [A1]và xuất ra cửa sổ ngay lập tức VBE

l=[Len(A1)]:For i=Int(-l/2)+2To l/2+1:?Mid(Space(l-i)&[A1],l,l):Next

Ung dung

Sub C(ByVal s As String)
    Let l = Len(s)
    For i = Int(-l / 2) + 2 To l / 2 + 1 Step 1
        Debug.Print Mid(Space(l - i) & s, l, l)
    Next i
End Sub

Perl 5 , 53 + 1 ( -n) = 54 byte

$t=$"x(($\=y%%%c)/2).$_;say substr$t,$_,$\for 0..$\-1

Hãy thử trực tuyến!