Arka fon

Kutlayan Dyalog APL 16.0 serbest bırakılmasını Bu sorunun çözümü ise, {⊢⌺(≢⍵)⊢⍵}^{açıklanması}

Görev

Bir ASCII bir dizge tek uzunlukta , n , bir hale n x n dize kare, yatay merkezli dikey olarak ortalanmış çoğaltılmış ve her satır ve sütun, aynı sıranın acrostics ile. Karenin boyutunu n × n tutmak için ortalanmış dizelerin dışındaki herkesin kesileceğini unutmayın .

Kodunuzun açıklaması çok takdir edilecektir.

kurallar

1. Sonunda boşluk ve satırsonları olabilir (bu, sağ alt üçgeni içerir)
2. Dizelerin bir listesini döndürebilirsiniz

Dizeyi kullanarak örnek ABXCD:

• n , 5'tir. İlk önce, biri orta diğeri dikey olan iki merkezlenmiş ipi çiziyoruz:

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

  ^{(Netlik için 5 × 5 sınırlayıcı kutu eklendi)}

• O zaman mümkün olan tüm akrostikleri yatay ve dikey olarak yerleştiririz:

         bir
        AB
    ┌─────┐
    │ ABX│CD
    X ABXC│D
    │ABXCD│
   A│BXCD │
  AB│XCD │
    └─────┘
     CD
     D
  

• Son olarak, sadece sınırlayıcı kutunun içindekileri döndürürüz:

    ABX
   ABXC
  ABXCD
  BXCD 
  XCD  
  

Test durumları

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

Teşekkür

Dzaima , Leaky Nun , Bay Xcoder , bu meydan okuma fikri dışında her şey için teşekkürler .

Python 2,60 bayt

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

Çevrimiçi deneyin!

MATL , 8 bayt

nXyPGZ+c

Çevrimiçi deneyin!

açıklama

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

Retina , 70 59 bayt

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

Çevrimiçi deneyin! Düzenleme: @ Martininder'den yardım alarak 11 bayt kaydedildi. Açıklama: İlk aşamada girdi, her karakter için bir kez tekrarlanır ve kaymayı elde etmek için her satıra uygun şekilde doldurulur. Son aşama daha sonra istenen sonucu elde etmek için her taraftan% 25'i uzaklaştırır.

Java 8, 120 103 bayt

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

@ OlivierGrégoire sayesinde -17 bayt .

Açıklama:

Burada dene.

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 bayt

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

Çevrimiçi deneyin! Nasıl çalışır:

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 bayt

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

Belki burada çevrimiçi deneyin: http://swish.swi-prolog.org/p/hEKigfEl.pl

NB.

1. Son satır uzun bir satır, bu cevapta yatay kaydırma çubuğunu önlemek için buraya bir satır sonu ve boşluk ekledim.
2. Soru, doldurma boşluklarını içerir, ancak çevrimiçi Swish, HTML oluşturma etkileşimleri nedeniyle bunları net olarak göstermez, mevcut olduklarını kontrol etmek için tarayıcı araçlarında kaynağı görüntülemek zorundasınız. _Çalışmayı gösterdiği ve bayt sayısını etkilemediğini gösterdiği için, doldurmayı burada değiştirdim .

Swish'te çalışan örnekler:

Yaklaşım, temel olarak çalışabileceğim ilk şey ve şüphesiz yetenekli bir Prolog kullanıcısı onu çok kısaltabilir:

• L uzunluğunda bir dizge verildiğinde, çıkışın L çizgileri olur ve her satır L karakter uzunluğunda olur, bu nedenle 'L' çok fazla gösterir. Satır sayısı için L ile 0 arasında geri sayım, her satır için alt uzunluk için L.
• L boşluklu (alt çizgi) uzun bir doldurma dizisi oluşturun, onu giriş dizesinin her iki ucuna ekleyin, çünkü bu kesinlikle yeterli bir dolum olacak basit bir uzunluktur.
• Bu üçlü uzunluğa dize bir başlangıç ​​ofseti hesaplayın ve sonuç listesine her seferinde bir alt dize oluşturarak tekrarlayın.

Açıklanan ve yorumlanan kod (çalışmayabilir), superacrostic()aşağıdan sonra helper()ana gövdeye, sonra helper()temel duruma okunur :

% 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 bayt

g;úIvDIg£,À

Çevrimiçi deneyin!

açıklama

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 bayt

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 karakter = 22 bayt

{⊢⌺(≢⍵)⊢⍵}

Çevrimiçi deneyin!

{… } Argümanın ⍵ ile temsil edildiği anonim işlev

 ⊢ kapalı alanı ne zaman

 ⌺(… ) Boyutta bir kalıbı kaydırmak

  ≢ uzunluğu

  ⍵ argüman

 ⊢ üzerinde

 ⍵ argüman

Bunun işleyiş şekli, her karakterin girişle aynı uzunlukta bir dizgenin ortasını oluşturmasına, gerektiği gibi sola veya sağa dolmasına izin vermektir. Örneğin al ABXCD:

Dize beş karakterden oluşur, bu nedenle şablonun beş karakter genişliğinde bir "açıklığı" olacaktır.

┌──↓──┐     orta işaretleyici ile şablon açılış
│ ABX│CD   bırakıldığında yukarı Aortasında olmak
 │ ABXC│D   sonra B
  │ABXCD|   vb
  A|BXCD | 
  AB|XCD  |
    └──↑──┘ nihai şablon pozisyonunda

PHP , 98 bayt

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

Çevrimiçi deneyin!

JavaScript (ES8), 66 63 62 bayt

Bir dizi döndürür.

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

Dene

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>

açıklama

s=>

Dizgiyi parametre ile argüman olarak alan isimsiz işlev s.

[...s]

Dize, tek tek karakter dizisine bölün.

l=s.length

Dizenin uzunluğunu alın ve değişkene atayın l.

.map((_,x)=>                                        )

Her öğeyi bir işlevden geçirerek x, geçerli öğenin dizini olan dizi üzerinde eşleyin.

s.padStart(l*1.5)

Her eleman için, orijinal dizginin uzunluğu, orijinal uzunluğunun 1,5 katı olana kadar boşluk bırakılarak hazırlanmış orijinal diziyi döndürün.

.substr(x,l)

lGeçerli öğenin dizininden başlayarak uzunluk alt dizesini alın .

V , 14 , 11 bayt

òlÙxHÄ$x>>ê

Çevrimiçi deneyin!

@Nmjmcman sayesinde 3 bayt kurtarıldı!

HexDump:

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

Orijinal yaklaşım (18 bayt):

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

Açıklama:

ò           " 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 Çekirdek , 68 bayt

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

Çevrimiçi deneyin!

Ungolfed açıklama

# 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 bayt

@ETHproductions ve @Shaggy sayesinde 5 bayt kurtarıldı

¬£iSp½*Ul¹tYUl

Çevrimiçi test edin! -Rnewlines'a katılmak için bayrak eklendi (görünürlük amaçlı)

açıklama

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

Kömür , 26 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur.

Jöle , 11 bayt

LH⁶ẋ;ṫJḣ€LY

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Dostum, benim space$QBIC’e ekleme zamanı ...

açıklama

  ;             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

Örnek çalışma

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

Mathematica, 88 bayt

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

Haskell , 86 70 bayt

Bu (hala) çok uzun, ama bana bir string listesinin çıktısının da kabul edilebilir olduğunu hatırlattığın için @ bartavelle!

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

Çevrimiçi deneyin!

Python 3 , 68 bayt

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

Çevrimiçi deneyin!

PowerShell , 133 119 bayt

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

Çevrimiçi deneyin!

Ungolfed

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

@FelipeNardiBatista sayesinde -1

Elbette, diğer Python cevapları kadar kısa değil, ama tamamen farklı bir yöntem denemeye değer:

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

Çevrimiçi deneyin! (74 byte versiyonu ile)

Bu ilk önce tam String'i üretir ve sonra onu kareye sığacak şekilde dilimler.

açıklama

n = girişi (); - girdi alır ve n değişkenine atar
          x = len (n) - girişin uzunluğunu x değişkenine atar
i için (x) aralığındaki: - 0 ... x aralığında, i değişkeniyle yinelenir
                   print - sonucu çıkarır
                         ((2 * xi-1) * '' + n) - "elmas" dizesini oluşturur
                                          [x + x / 2: 2 * x + x / 2] - dizeye kutuya sığacak şekilde keser

J , 19 bayt

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

Çevrimiçi deneyin!

açıklama

|.!.' '"{~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 Çekirdeği) , 101 bayt

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

Temelde @ KevinCruijssen'in cevabı. string.Lengthİhtiyaç duymadığı için 2 bayt kaydeder () ve başka bir 2 bayt çünkü ikinci argüman string.Substring()End Endeksinden ziyade uzunluktur, fakat daha sonra 2 bayt kaybeder çünkü Console.WriteLine()daha uzundur. Daha saf bir uygulamam vardı, fakat bu iki kat daha uzun sürdü.

Excel VBA, 68 Bayt

golfed

Hücreden girdi alan [A1]ve VBE acil durum penceresine çıkan anonim VBE acil pencere işlevi

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

Ungolfed

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 bayt

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

Çevrimiçi deneyin!