tło

Świętujemy wydanie Dyalog APL 16.0 , w którym rozwiązaniem tego problemu jest {⊢⌺(≢⍵)⊢⍵}^wyjaśnienie

Zadanie

Biorąc pod uwagę drukowalny ciąg ASCII o nieparzystej długości n , utwórz kwadrat n × n ze sznurkiem wyśrodkowanym poziomo, zduplikowanym, aby wyśrodkować go w pionie, oraz z akrostykami tego samego ciągu w każdym rzędzie i kolumnie. Zauważ, że wszystkie oprócz wyśrodkowanych łańcuchów zostaną odcięte, aby zachować rozmiar kwadratu n × n .

Wyjaśnienie twojego kodu będzie mile widziane.

Zasady

1. Możesz mieć końcowe białe znaki i znaki nowej linii (dotyczy to również trójkąta w prawym dolnym rogu)
2. Możesz zwrócić listę ciągów znaków

Przykład przy użyciu ciągu ABXCD:

• n wynosi 5. Najpierw narysujemy dwa wyśrodkowane ciągi, jeden poziomy i jeden pionowy:

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

  ^{(Dodano ramkę ograniczającą 5 × 5 dla przejrzystości)}

• Następnie umieszczamy wszystkie możliwe akrostyki, poziomo i pionowo:

         ZA
        AB
    ┌─────┐
    │ ABX│CD
    │ ABXC│D
    │ABXCD│
   A│BXCD │
  AB│XCD │
    └─────┘
     Płyta CD
     re
  

• Na koniec zwracamy tylko to, co znajduje się w obwiedni:

    ABX
   ABXC
  ABXCD
  BXCD 
  XCD  
  

Przypadki testowe

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

Podziękowanie

Dzięki dzaima , Leaky Nun , Mr. Xcoder za wszystko oprócz samej idei tego wyzwania.

Python 2 , 60 bajtów

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

Wypróbuj online!

MATL , 8 bajtów

nXyPGZ+c

Wypróbuj online!

Wyjaśnienie

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

Siatkówka , 70 59 bajtów

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

Wypróbuj online! Edycja: Zapisano 11 bajtów przy pewnej pomocy @MartinEnder. Objaśnienie: Pierwszy etap powtarza dane wejściowe dla każdego znaku, wypełniając je odpowiednio w każdej linii, aby uzyskać ścinanie. Ostatni etap usuwa następnie 25% z każdej strony, aby uzyskać pożądany rezultat.

Java 8, 120 103 bajtów

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 bajtów dzięki @ OlivierGrégoire .

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

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

Wypróbuj online! Jak to działa:

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 bajty

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).

Może spróbuj online tutaj: http://swish.swi-prolog.org/p/hEKigfEl.pl

NB.

1. Ostatnia linia to jedna długa linia, dodałem tutaj podział linii i spacje, aby uniknąć poziomego paska przewijania w tej odpowiedzi.
2. Pytanie dotyczy spacji do wypełnienia, ale Swish online nie pokazuje ich czysto z powodu interakcji renderowania HTML, musisz zobaczyć źródło w narzędziach programistycznych przeglądarki, aby sprawdzić, czy są obecne (są). Zmieniłem padding _tutaj, ponieważ pokazuje, że działa i nie wpływa na liczbę bajtów.

Przykłady uruchomione w Swish:

Podejdź, w zasadzie pierwszą rzeczą, którą w ogóle mógłbym zrobić, a niewątpliwie wykwalifikowany użytkownik Prologu mógłby go znacznie skrócić:

• Biorąc pod uwagę ciąg długości L, dane wyjściowe będą miały L linii, a każda linia będzie miała długość L znaków, więc „L” często się pojawia. Odliczanie od L do 0 dla liczby linii, L dla długości podciągu dla każdej linii.
• Utwórz łańcuch dopełniania o długości L spacji (podkreślenia), dodaj go do obu końców łańcucha wejściowego, ponieważ jest to prosta długość, która z pewnością będzie wystarczająca do wypełnienia.
• Obliczyć początkowe przesunięcie na ten ciąg o trzech długościach i powtórzyć, generując podciąg za każdym razem, na listę wyników.

Wyjaśniony i skomentowany kod (może się nie uruchomić), odczytany z superacrostic()dołu, następnie helper()główny korpus, a następnie helper()przypadek podstawowy:

% 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 bajtów

g;úIvDIg£,À

Wypróbuj online!

Wyjaśnienie

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 bajtów

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 znaków = 22 bajty

{⊢⌺(≢⍵)⊢⍵}

Wypróbuj online!

{… } Anonimowa funkcja, w której argument jest reprezentowany przez ⍵

 ⊢ podać objęty obszar, kiedy

 ⌺(… ) Przesuwając szablon wielkości

  ≢ długość

  ⍵ argument

 ⊢ na

 ⍵ argument

Działa to tak, że każdy znak tworzy środek łańcucha o tej samej długości co dane wejściowe, dopełniając w lewo lub w prawo w razie potrzeby. Weź np . ABXCD:

Ciąg ma pięć znaków, więc szablon będzie miał „otwór” o szerokości pięciu znaków.

┌──↓──┐     Wzornik z otworu środkowego znacznika
│ ABX│CD   puszczeniu Asię w środku
 │ ABXC│D   , a następnie B
  │ABXCD|   itp
  A|BXCD | 
  AB|XCD  |
    └──↑──┘ pozycji końcowej wzornik

PHP , 98 bajtów

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

Wypróbuj online!

JavaScript (ES8), 66 63 62 bajtów

Zwraca tablicę.

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

Spróbuj

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>

Wyjaśnienie

s=>

Anonimowa funkcja przyjmująca ciąg jako argument za pomocą parametru s.

[...s]

Podziel ciąg na tablicę pojedynczych znaków.

l=s.length

Uzyskaj długość ciągu i przypisz go do zmiennej l.

.map((_,x)=>                                        )

Odwzoruj tablicę, przepuszczając każdy element przez funkcję, gdzie xjest indeks bieżącego elementu.

s.padStart(l*1.5)

Dla każdego elementu zwróć oryginalny ciąg znaków z odstępami poprzedzonymi, aż jego długość będzie 1,5 raza większa niż jego pierwotna długość.

.substr(x,l)

Uzyskaj podciąg długości lzaczynający się od indeksu bieżącego elementu.

V , 14 , 11 bajtów

òlÙxHÄ$x>>ê

Wypróbuj online!

3 bajty zapisane dzięki @nmjmcman!

Hexdump:

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

Oryginalne podejście (18 bajtów):

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

Wyjaśnienie:

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

PowerShell Core , 68 bajtów

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

Wypróbuj online!

Wyjaśnienie bez golfa

# 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 bajtów

Zaoszczędź 5 bajtów dzięki @ETHproductions i @Shaggy

¬£iSp½*Ul¹tYUl

Przetestuj online! -Rdodano flagę, aby dołączyć do nowej linii (cele widoczności)

Wyjaśnienie

¬£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) 

Węgiel drzewny , 26 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu.

Galaretka , 11 bajtów

LH⁶ẋ;ṫJḣ€LY

Wypróbuj online!

Jak to działa

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 bajty

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

Człowieku, nadszedł czas, abym dodał space$do QBIC ...

Wyjaśnienie

  ;             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

Przykładowy przebieg

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

Mathematica, 88 bajtów

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

Haskell , 86 70 bajtów

To (wciąż) jest o wiele za długie, ale dziękuję @bartavelle za przypomnienie mi, że generowanie listy ciągów jest również dopuszczalne!

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

Wypróbuj online!

Python 3 , 68 bajtów

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

Wypróbuj online!

PowerShell , 133 119 bajtów

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

Wypróbuj online!

Bez golfa

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

Python 2 ,76 74 73 bajty

-1 dzięki @FelipeNardiBatista

Oczywiście nie tak krótki jak druga odpowiedź w Pythonie, ale warto wypróbować zupełnie inną metodę:

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

Wypróbuj online! (z wersją 74-bajtową)

Najpierw generuje pełny ciąg, a następnie kroi go tak, aby pasował do kwadratu.

Wyjaśnienie

n = input (); - pobiera dane wejściowe i przypisuje je do zmiennej n
          x = len (n) - przypisuje długość wejścia do zmiennej x
dla i w zakresie (x): - iteruje w zakresie 0 ... x, ze zmienną i
                   print - wyświetla wynik
                         ((2 * xi-1) * '' + n) - tworzy ciąg „diamentowy”
                                          [x + x / 2: 2 * x + x / 2] - przycina ciąg pasujący do pudełka

J , 19 bajtów

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

Wypróbuj online!

Wyjaśnienie

|.!.' '"{~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 bajtów

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

Zasadniczo odpowiedź @ KevinCruijssen. Zapisuje 2 bajty, ponieważ string.Lengthnie potrzebuje () i kolejne 2 bajty, ponieważ drugim argumentem string.Substring()jest długość zamiast końca indeksu, ale następnie traci 2 bajty, ponieważ Console.WriteLine()jest dłuższy. Miałem bardziej naiwne wdrożenie, ale trwało to około dwa razy dłużej, więc ...

Excel VBA, 68 bajtów

Grał w golfa

Anonimowa funkcja bezpośredniego okna VBE, która przenosi dane wejściowe z komórki [A1]i dane wyjściowe do bezpośredniego okna VBE

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

Bez golfa

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 bajtów

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

Wypróbuj online!