Escriba un programa o función que tome una cadena de una sola línea no vacía. Puede suponer que solo contiene ASCII imprimible, excluyendo el espacio.

Imprima o devuelva una forma de rombo ASCII similar a un limón o lima hecha de los prefijos de la cuerda.

Supongamos que la cadena de entrada tiene n letras de largo. Luego, dicha forma consta de 2n - 1 columnas de arte ASCII unidas, cada una de las cuales consta de 2n - 1 líneas. Contando desde 1, la columna k -ésima tiene f (k) = min (k, 2n - k) caracteres de ancho, y contiene copias f (k) de los primeros caracteres f (k) de entrada, centrados verticalmente, con un solo espacio en blanco líneas que separan las copias.

Por ejemplo, si la entrada es Lemon, la salida debería 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

Si la entrada es limela salida debe ser:

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

Y se sigue el mismo patrón para otras 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

Las líneas en la salida pueden tener espacios finales y puede haber una nueva línea final opcional.

El código más corto en bytes gana.

Matlab, 140 136 128 124 bytes

Básicamente, primero comienza con la sección central, y luego antepone / agrega las versiones acortadas / modificadas paso a paso.

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

Gracias por 8 bytes @LuisMendo!

Por ejemplo, para MATLABobtener:

               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 si se usa raw_input. El programa esencialmente hace una máscara basada en la norma L1 / distancia de Manhattan desde el centro, así como la paridad de esta distancia en comparación con la paridad de la longitud de entrada.

(Gracias a @Lynn por -9 bytes y allanando el camino para 2 más)

MATL , 44 bytes

Me inspiré en la respuesta de @ flawr (aunque el algoritmo no es el mismo)

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

La entrada es una cadena con comillas simples.

Pruébalo en línea!

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}

Prueba

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>

Pyth, 32 bytes

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

Demostración

Jalea, 32 26 bytes

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

Pruébalo en línea!

EDITAR: Dennis guardó 6 bytes. ¡Gracias!

JavaScript, 187 178 bytes

Un enfoque bit a bit. La función mdefine una máscara comenzando en 2 ** length, por ejemplo, 00100en binario, y definiendo m(n) = m(n-1) << 1 | m(n-1) >> 1para la primera mitad. Curiosamente, la segunda mitad se puede definir como m(n) = m(n-1) << 1 & m(n-1) >> 1. (aunque el programa opta por definir m(n) = m(2 * length - 1)para la segunda mitad) A partir de aquí, estas máscaras se pueden usar para determinar si una palabra o un espacio deben aparecer marcando 2 ** column & m(row). Por supuesto, en JavaScript es más corto escribir 2 ** somethingcon 1 << something...

nota: escrito mientras está cansado. Mayo casi seguramente tiene errores.

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]

Brachylog , 46 bytes

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

Pruébalo en línea!

Terrible recuento de bytes y probablemente peor enfoque (sin mencionar que Brachylog no está diseñado exactamente para el arte ASCII), pero perdí el tiempo suficiente para publicarlo de todos modos.

              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.

Casi la única parte inteligente de todo esto es el uso de a₁para generar los espacios verticales más grandes primero, mientras que a₀genera los prefijos de palabras más pequeños primero, y zzpara expandir espacios individuales en bloques de espacio que coinciden con los anchos de los prefijos.

TSQL, 259 bytes

Golfizado:

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

Sin golf:

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

Violín

C, 167 bytes

Este programa espera que el texto de entrada se pase como el primer parámetro al programa (a través de la línea de comando o de lo contrario) y escribirá la salida en 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));}

Este es mi primer intento de código de golf aquí, ya que parecía un desafío razonable, por lo que probablemente se pueda jugar más de lo que pude solo debido a cómo lo hice.

Explicación

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

Es lo suficientemente significativo como para tener en cuenta el uso de (n < m) ? n : (m * 2) - nen el programa al menos dos veces para obtener la distancia invertida desde una posición central men un rango de m * 2con la entrada n. Si hay una forma más corta de hacerlo, entonces podría reducirse un poco más fácilmente ya que ese algoritmo es importante para la forma en que funciona este 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);}

Descompostura:

Esto dibuja cada elemento de la cuadrícula 2n-1 x 2n-1, con una función de máscara que decide si el elemento actual debe ser un espacio en blanco o la palabra de entrada (la máscara verifica la forma de un diamante y el patrón de tablero de ajedrez).

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
}