Ecrivez un programme ou une fonction qui prend une chaîne non vide à une seule ligne. Vous pouvez supposer qu'il ne contient que de l' espace ASCII imprimable .

Imprimez ou renvoyez une forme de losange art ASCII semblable à un citron ou à une lime fabriquée à partir des préfixes de la chaîne.

Supposons que la chaîne d'entrée soit longue de n lettres. Ensuite, une telle forme consiste en 2n - 1 colonnes d’art ASCII cousues ensemble, chacune consistant en 2n - 1 lignes. En partant de 1, la k- ième colonne a une largeur de f (k) = min (k, 2n - k) et contient les copies f (k) des premiers caractères f (k) de l’entrée, centrées verticalement, avec un seul blanc lignes séparant les copies.

Par exemple, si l'entrée est Lemon, le résultat devrait être:

          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 l'entrée est limela sortie devrait être:

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

Et le même schéma est suivi pour les autres entrées:

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

Les lignes dans la sortie peuvent avoir des espaces de fin et il peut y avoir une nouvelle ligne de fin optionnelle.

Le code le plus court en octets gagne.

Matlab, 140 136 128 124 octets

Fondamentalement, commence par la section du milieu, puis ajoute / ajoute les versions abrégées / modifiées, étape par étape.

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

Merci pour 8 octets @LuisMendo!

Par exemple, MATLABnous obtenons:

               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 octets

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 octets si vous utilisez raw_input. Le programme utilise essentiellement un masque basé sur la distance L1-norm / Manhattan du centre, ainsi que sur la parité de cette distance par rapport à la parité de la longueur entrée.

(Merci à @Lynn pour -9 octets et ouvrant la voie à 2 autres)

MATL , 44 octets

Je me suis inspiré de la réponse de @ flawr (bien que l'algorithme ne soit pas le même)

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

L'entrée est une chaîne avec des guillemets simples.

Essayez-le en ligne!

JavaScript (ES6), 132 octets

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}

Tester

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 octets

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

Manifestation

Gelée, 32 26 octets

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

Essayez-le en ligne!

EDIT: Dennis a enregistré 6 octets. Merci!

JavaScript, 187 178 octets

Une approche de bitwise. Function mdéfinit un masque en partant de 2 ** length, par exemple 00100en binaire, et en définissant m(n) = m(n-1) << 1 | m(n-1) >> 1pour la première moitié. Fait intéressant, la seconde moitié peut être définie comme m(n) = m(n-1) << 1 & m(n-1) >> 1. (Bien que le programme choisisse plutôt de définir m(n) = m(2 * length - 1)pour la seconde moitié) À partir de là, ces masques peuvent être utilisés pour déterminer si un mot ou un espace doit apparaître en cochant 2 ** column & m(row). Bien sûr, en JavaScript, il est plus court d'écrire 2 ** somethingavec 1 << something...

note: écrit en étant fatigué. Peut presque sûrement avoir des erreurs.

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 octets

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 octets

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

Essayez-le en ligne!

Un nombre d'octets épouvantable et une approche probablement pire (pour ne pas dire que Brachylog n'est pas exactement conçu pour l'art ASCII), mais j'ai perdu assez de temps pour le publier de toute façon.

              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.

La seule partie intelligente de tout cela est l’utilisation de a₁pour générer les espaces verticaux les plus grands en premier tout en a₀générant les préfixes de mots les plus petits en premier, et zzpour développer des espaces simples en blocs d’espace correspondant aux largeurs des préfixes.

TSQL, 259 octets

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+=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

Violon

C, 167 octets

Ce programme s'attend à ce que le texte d'entrée soit transmis en tant que premier paramètre au programme (via la ligne de commande ou autrement) et écrira la sortie sur 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));}

C’est la première fois que je tente de jouer au code-golf ici, car c’était un défi raisonnable. Je peux donc probablement jouer au golf plus que je n’ai pu le faire à cause de la façon dont j’ai fait.

Explication

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

Il est assez important de noter l'utilisation de (n < m) ? n : (m * 2) - ndans le programme au moins deux fois pour obtenir la distance inversée à partir d'une position centrale msur une plage de m * 2avec l'entrée n. S'il existe un moyen plus court de le faire, il pourrait être plus facile de jouer au golf car cet algorithme est important pour le fonctionnement de ce programme.

C, 137 octets

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

Panne:

Cela dessine chaque élément de la grille 2n-1 x 2n-1, avec une fonction de masque déterminant si l’élément actuel doit être un espace ou le mot saisi (le masque vérifie la forme en losange et le motif en damier).

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
}