Escreva um programa ou função que utilize uma sequência de linhas simples não vazia. Você pode assumir que ele contém apenas ASCII imprimível, excluindo espaço.

Imprima ou retorne uma forma de losango de arte ASCII semelhante a um limão ou lima feita a partir dos prefixos da sequência.

Suponha que a sequência de entrada tenha n letras. Então, essa forma consiste em 2n - 1 colunas de arte ASCII costuradas, cada uma consistindo em 2n - 1 linhas. Contando de 1, a k- ésima coluna tem f (k) = min (k, 2n - k) caracteres de largura e contém cópias f (k) dos primeiros f (k) caracteres de entrada, centralizados verticalmente, com um único espaço em branco linhas que separam as cópias.

Por exemplo, se a entrada for Lemon, a saída deve ser:

          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

Se a entrada for limea saída deve ser:

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

E o mesmo padrão é seguido para outras entradas:

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

As linhas na saída podem ter espaços à direita e pode haver uma nova linha à direita opcional.

O código mais curto em bytes vence.

Matlab, 140 136 128 124 bytes

Basicamente, primeiro começa com a seção do meio e, em seguida, acrescenta / acrescenta as versões reduzidas / modificadas passo a passo.

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

Obrigado por 8 bytes @LuisMendo!

Por exemplo, para MATLABobtermos:

               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                    

Python 2, 121 110 bytes

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 bytes se estiver usando raw_input. O programa basicamente faz uma máscara com base na distância L1 / norma Manhattan / centro, bem como a paridade dessa distância em comparação com a paridade do comprimento da entrada.

(Graças a @Lynn por -9 bytes e abrindo caminho para mais 2)

MATL , 44 bytes

Tomei alguma inspiração da resposta de @ flawr (embora o algoritmo não seja o mesmo)

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

Entrada é uma string com aspas simples.

Experimente online!

JavaScript (ES6), 132 bytes

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}

Teste

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>

Pitão, 32 bytes

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

Demonstração

Geléia, 32. 26 bytes

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

Experimente online!

EDIT: Dennis salvou 6 bytes. Obrigado!

JavaScript, 187 178 bytes

Uma abordagem bit a bit. A função mdefine uma máscara iniciando em 2 ** length, por exemplo, 00100em binário e definindo m(n) = m(n-1) << 1 | m(n-1) >> 1para a primeira metade. Curiosamente, a segunda metade pode ser definida como m(n) = m(n-1) << 1 & m(n-1) >> 1. (embora o programa opte por definir m(n) = m(2 * length - 1)para a segunda metade) A partir daqui, essas máscaras podem ser usadas para determinar se uma palavra ou espaço deve aparecer marcando 2 ** column & m(row). Claro que em JavaScript é mais curto escrever 2 ** somethingcom 1 << something...

nota: escrito enquanto estiver cansado. Pode quase certamente cometer erros.

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 bytes

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]

Braquilog , 46 bytes

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

Experimente online!

Contagem de bytes terrível e abordagem provavelmente pior (para não mencionar o Brachylog não é exatamente projetado para a arte ASCII), mas eu perdi tempo suficiente para publicá-lo de qualquer maneira.

              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.

Quase a única parte inteligente disso é o uso de a₁para gerar os espaços verticais maior-primeiro, enquanto a₀gera a palavra prefixos menor-primeiro e zzexpandir espaços únicos em blocos de espaço correspondentes às larguras dos prefixos.

TSQL, 259 bytes

Golfe:

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

Ungolfed:

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

Violino

C, 167 bytes

Este programa espera que o texto de entrada seja passado como o primeiro parâmetro para o programa (via linha de comando ou outro modo) e gravará a saída em stdout.

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));}

Esta é a minha primeira tentativa de código de golfe aqui, pois parecia um desafio razoável, por isso provavelmente pode ser jogado mais do que eu era capaz devido apenas ao modo como o fiz.

Explicação

/* 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) */
        );
}

É significativo o suficiente observar o uso de (n < m) ? n : (m * 2) - nno programa pelo menos duas vezes para obter a distância invertida a partir de uma posição central mem um intervalo m * 2com a entrada n. Se houver uma maneira mais curta de fazer isso, isso poderá ser resolvido com mais facilidade, pois esse algoritmo é importante para o funcionamento deste programa.

C, 137 bytes

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);}

Demolir:

Isso desenha todos os elementos da grade 2n-1 x 2n-1, com uma função de máscara que decide se o elemento atual deve ser um espaço em branco ou a palavra de entrada (a máscara verifica a forma de um diamante e o padrão quadriculado).

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
}