Viết chương trình hoặc hàm có trong một chuỗi đơn không trống. Bạn có thể cho rằng nó chỉ chứa ASCII có thể in được, trừ không gian.

In hoặc trả lại hình dạng hình thoi nghệ thuật ASCII tương tự như một quả chanh hoặc vôi được làm từ các tiền tố của chuỗi.

Giả sử chuỗi đầu vào dài n chữ cái. Sau đó, một hình dạng như vậy bao gồm 2n - 1 cột nghệ thuật ASCII được khâu lại với nhau, mỗi cột gồm 2n - 1 dòng. Đếm từ 1, cột thứ k là f (k) = min (k, 2n - k) ký tự rộng và chứa f (k) bản sao của các ký tự f (k) đầu tiên, được căn giữa theo chiều dọc, với một khoảng trống dòng tách các bản sao.

Ví dụ: nếu đầu vào là Lemon, đầu ra phải là:

          Lemon
      Lemo     Lemo
   Lem    Lemon    Lem
 Le   Lemo     Lemo   Le
L  Lem    Lemon    Lem  L
 Le   Lemo     Lemo   Le
   Lem    Lemon    Lem
      Lemo     Lemo
          Lemon

Nếu đầu vào là limeđầu ra nên:

      lime
   lim    lim
 li   lime   li
l  lim    lim  l
 li   lime   li
   lim    lim
      lime

Và mô hình tương tự được theo sau cho các đầu vào khác:

a

a

Be

 Be
B  B
 Be

/\

 /\
/  /
 /\

cat

   cat
 ca   ca
c  cat  c
 ca   ca
   cat

|||

   |||
 ||   ||
|  |||  |
 ||   ||
   |||

.__.

      .__.
   .__    .__
 ._   .__.   ._
.  .__    .__  . 
 ._   .__.   ._
   .__    .__
      .__.

$tring

               $tring
          $trin      $trin
      $tri     $tring     $tri
   $tr    $trin      $trin    $tr
 $t   $tri     $tring     $tri   $t
$  $tr    $trin      $trin    $tr  $
 $t   $tri     $tring     $tri   $t
   $tr    $trin      $trin    $tr
      $tri     $tring     $tri
          $trin      $trin
               $tring

Các dòng trong đầu ra có thể có các khoảng trắng ở cuối và có thể có một dòng mới theo dõi tùy chọn.

Mã ngắn nhất tính bằng byte thắng.

Matlab, 140 136 128 124 byte

Về cơ bản đầu tiên bắt đầu với phần giữa, và sau đó thêm / thêm các phiên bản rút gọn / sửa đổi từng bước.

a=input('');v=ones(nnz(a)*2-1,1)*a;v(2:2:end,:)=0;b=v;for k=a;v=v(2:end,1:end-1);v(end+1,:)=0;b=[v,b,v,''];end;b(~flip(b))=0

Cảm ơn vì 8 byte @LuisMendo!

Ví dụ: MATLABchúng tôi nhận được:

               MATLAB               
          MATLA      MATLA          
      MATL     MATLAB     MATL      
   MAT    MATLA      MATLA    MAT   
 MA   MATL     MATLAB     MATL   MA 
M  MAT    MATLA      MATLA    MAT  M
 MA   MATL     MATLAB     MATL   MA 
   MAT    MATLA      MATLA    MAT   
      MATL     MATLAB     MATL      
          MATLA      MATLA          
               MATLAB                    

Con trăn 2 121 110 byte

s=input()
n=len(s)
r=range(1,n)+range(n,0,-1)
for y in r:print''.join(s[:(x+y-n&(x+y>n))*x]or' '*x for x in r)

116 byte nếu sử dụng raw_input. Chương trình về cơ bản thực hiện mặt nạ dựa trên khoảng cách L1-Norm / Manhattan từ trung tâm, cũng như tính chẵn lẻ của khoảng cách này so với tính chẵn lẻ của độ dài đầu vào.

(Cảm ơn @Lynn cho -9 byte và mở đường cho 2 người nữa)

MATL , 44 byte

Tôi lấy một số cảm hứng từ câu trả lời của @ flawr (mặc dù thuật toán không giống nhau)

GtnEq:!g*2Mo*XKG"K1YS3LZ)OX@:Y(PO5MY(XKwyhhc

Đầu vào là một chuỗi với dấu ngoặc đơn.

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

JavaScript (ES6), 132 byte

s=>{x=' '.repeat(l=s.length);for(n=r='';n++<l;r=r?t+`
${r}
`+t:t)for(i=l,t='';i;t=t?w+t+w:w)w=(i<n|n+i&1?x:s).slice(0,i--);return r}

Kiểm tra

var solution =

s=>{
  x=' '.repeat(l=s.length);
  for(n=r='';n++<l;r=r?t+`\n${r}\n`+t:t)
    for(i=l,t='';i;t=t?w+t+w:w)
      w=(i<n|n+i&1?x:s).slice(0,i--);
  return r
}

result.textContent = solution('Lemon');

<input type="text" id="input" value="Lemon" oninput="result.textContent=solution(this.value)" /><pre id="result"></pre>

Bình thường, 32 byte

jsMCm.[tylztsmC*\ dd*;ld+J._zt_J

Trình diễn

Thạch, 32 26 byte

³L_+«0ị“~ ”«³ḣ
JµṖ;Ṛç@þ`j⁷

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

EDIT: Dennis lưu 6 byte. Cảm ơn!

JavaScript, 187 178 byte

Một cách tiếp cận bitwise. Hàm mđịnh nghĩa một mặt nạ bằng cách bắt đầu tại 2 ** length, ví dụ như 00100trong nhị phân và xác định m(n) = m(n-1) << 1 | m(n-1) >> 1cho nửa đầu. Điều thú vị là nửa thứ hai có thể được định nghĩa là m(n) = m(n-1) << 1 & m(n-1) >> 1. (mặc dù chương trình thay vì chọn để xác định m(n) = m(2 * length - 1)cho nửa thứ hai) Từ đây, các mặt nạ này có thể được sử dụng để xác định xem một từ hoặc khoảng trắng sẽ xuất hiện bằng cách kiểm tra 2 ** column & m(row). Tất nhiên trong JavaScript, nó ngắn hơn để viết 2 ** somethingbằng 1 << something...

lưu ý: viết trong khi mệt mỏi. Có thể Hầu như chắc chắn không có những sai lầm.

s=>{m=n=>n?n>l?m(2*l-n):(p=m(n-1))>>1|p<<1:1<<l
for(r=0;r/2<=(l=s.length-1);r++){for(i=1,o="";i/2-1<l;i++)o+=(1<<i-1&m(r)?s:" ".repeat(i)).slice(0,i>l?2*l+2-i:i)
console.log(o)}}

Haskell, 109 byte

f s|n<-length s,r<-[1..n]++[n-1,n-2..1]=unlines[do x<-r;min(" ~"!!mod((x+y+n)*min(n-x-y)0)2)<$>take x s|y<-r]

Brachylog , 46 byte

{a₀⟨{;Ṣ}j₎l⟩}ᶠL&l;Ṣj₍ẹa₁ᶠ;Lz{czzcᵐ}ᵐ⟨kc↔⟩zcᵐ~ṇ

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

Số lượng byte khủng khiếp và cách tiếp cận có lẽ tồi tệ hơn (không đề cập đến Brachylog không được thiết kế chính xác cho nghệ thuật ASCII), nhưng tôi đã lãng phí đủ thời gian cho nó để đăng nó.

              L    The variable L
{           }ᶠ     is a list containing every possible
 a₀                prefix of
                   the input
    {;Ṣ}           paired with a space
        j          and concatenated with itself
   ⟨     ₎l⟩       a number of times equal to its length.

          ᶠ    A list containing every possible
        a₁     suffix of
   Ṣ           a space
    j          concatenated with itself
  ;  ₍         a number of times equal to
 l             the length of
&              the input
      ẹ        then split back up into its elements
               is an important list which doesn't actually get a name.

                         That list
;Lz                      zipped with L
   {     }ᵐ              with each pair being
    c                    concatenated,
     z                   zipped with cycling,
      z                  zipped back,
        ᵐ                and subjected to each of its elements being
       c                 concatenated itself,
           ⟨kc↔⟩         then palindromized
                z        and zipped yet again
                 cᵐ      with every line concatenated once more
                   ~ṇ    and finally joined on newlines
                         is the output.

Phần thông minh duy nhất của bất kỳ thứ gì trong số này là việc sử dụng a₁để tạo các không gian dọc lớn nhất trước tiên trong khi a₀tạo các tiền tố từ nhỏ nhất trước tiên và zzđể mở rộng các không gian đơn thành các khối không gian khớp với độ rộng của các tiền tố.

TSQL, 259 byte

Chơi gôn

DECLARE @ VARCHAR(30)='TSQL'

,@o VARCHAR(max),@i INT=0,@j INT,@t VARCHAR(max)SET @j=LEN(@)z:WHILE @i<LEN(@)SELECT @o=x+ISNULL(@o+x,''),@i+=1FROM(SELECT LEFT(IIF((@j-@i)%2=1,@,SPACE(99)),LEN(@)-@i)x)z SELECT @j-=1,@t=@o+ISNULL(CHAR(10)+@t+CHAR(10)+@o,''),@o=null,@i=0IF @j>0GOTO z PRINT @t

Ung dung:

DECLARE @ VARCHAR(30)='TSQL'

,@o VARCHAR(max),@i INT=0,@j INT,@t VARCHAR(max)SET @j=LEN(@)
z:
WHILE @i<LEN(@)
  SELECT @o=x+ISNULL(@o+x,''),@i+=1
  FROM(SELECT LEFT(IIF((@j-@i)%2=1,@,SPACE(99)),LEN(@)-@i)x)z
SELECT @j-=1,@t=@o+ISNULL(CHAR(10)+@t+CHAR(10)+@o,''),@o=null,@i=0
IF @j>0 GOTO z

PRINT @t

Vĩ cầm

C, 167 byte

Chương trình này hy vọng văn bản đầu vào sẽ được chuyển làm tham số đầu tiên cho chương trình (thông qua dòng lệnh hoặc tuy nhiên khác) và sẽ ghi đầu ra vào thiết bị xuất chuẩn.

int i,j,k,l,v;main(h,s)char**s;{h=strlen(s[1]);l=h*2;for(;++i<l;puts(""))for(j=0;++j<l,v=j<h?j:l-j;)for(k=0;k++<v;putchar((i+j+h%2)%2&&v>h-(i<h?i:l-i)?s[1][k-1]:32));}

Đây là nỗ lực đầu tiên của tôi tại môn đánh gôn ở đây vì nó có vẻ như là một thử thách hợp lý, vì vậy nó có thể được chơi golf nhiều hơn tôi có thể chỉ vì cách tôi đã làm nó.

Giải trình

/* Static variables
   i - "Row" number
   j - "Column" number
   k - String character counter
   l - Double length of the input string
   v - Inverted column distance from center */
int i,j,k,l,v;

/* Main parameters
   h - (argc) Input string length
   s - argv */
main(h, s)
char**s;
{
  /* Assign the input string length and double length */

  h = strlen(s[1]);
  l = h * 2;

  /* Display content */

    /* Loop over rows l - 1 times and put a newline after each */
  for (; ++i < l; puts(""))
      /* Loop over columns l - 1 times and set the inverted column
         distance each time */
    for (j = 0; ++j < l, v = ((j < h) ? j : l - j);)
        /* Loop over characters up to the inverted column distance from the
           center (this generates the pattern of output lengths needed) */
      for (k = 0; k++ < v;)
        putchar(
            /* Check for if the current row + column (with an offset based on
               the input parity) parity is even or odd, creating the needed
               checkerboard pattern */
          (i + j + h % 2) % 2 &&
            /* If the inverted column distance from the center is more than the
               row distance from the center, then the cell is inside the
               circular shape */
          v > (h - ((i < h) ? i : l - i)) ?
              /* Display the requested character (minus one for 0 based) */
            s[1][k-1] :
            32 /* Otherwise display a space (ASCII 32) */
        );
}

Nó đủ quan trọng để lưu ý việc sử dụng (n < m) ? n : (m * 2) - ntrong chương trình ít nhất hai lần để có được khoảng cách đảo ngược từ vị trí trung tâm mtrên một phạm vi m * 2với đầu vào n. Nếu có một cách ngắn hơn để làm điều đó thì nó có thể được đánh xuống dễ dàng hơn vì thuật toán đó rất quan trọng đối với cách thức hoạt động của chương trình này.

C, 137 byte

x,y,w;main(l,v)char**v;{for(y=l=strlen(v[1]);-l<--y;putchar(10))for(x=l;-l<--x;printf("%*.*s",w,w,x+y+l&1&&w>abs(y)?v[1]:""))w=l-abs(x);}

Phá vỡ:

Điều này rút ra mọi phần tử của lưới 2n-1 x 2n-1, với chức năng mặt nạ quyết định xem phần tử hiện tại có phải là khoảng trống hoặc từ đầu vào không (mặt nạ kiểm tra hình dạng kim cương và mẫu bàn cờ).

x,y,w;
main(l,v)char**v;{
    for(y=l=strlen(v[1]);-l<--y;/*...*/)    // row loop (count down to save bytes)
        for(x=l;-l<--x;/*...*/)             // column loop
            w=l-abs(x);                     // calculate current word's width
            printf("%*.*s",                 // print...
                w,w,                        // ...with min & max width...
                x+y+l&1&&w>abs(y)           // Check mask:
                    ?v[1]                   //  ...word
                    :"")                    //  ...or blank space
        putchar(10)                         // Newline
}