Schreiben Sie ein Programm oder eine Funktion, die eine nicht leere einzeilige Zeichenfolge enthält. Sie können davon ausgehen, dass es nur druckbares ASCII ohne Leerzeichen enthält.

Drucken Sie oder geben Sie eine ASCII-Kunst-Raute zurück, die einer Zitrone oder einer Limette ähnlich ist, die von den Präfixen der Schnur gebildet wird.

Angenommen, die Eingabezeichenfolge besteht aus n Buchstaben. Dann besteht eine solche Form aus 2n - 1 zusammengenähten ASCII - Kunstspalten, die jeweils aus 2n - 1 Zeilen bestehen. Ab 1 gerechnet, ist die k- te Spalte f (k) = min (k, 2n - k) Zeichen breit und enthält f (k) Kopien der ersten f (k) Zeichen der Eingabe, vertikal zentriert, mit einem einzelnen Leerzeichen Zeilen, die die Kopien trennen.

Wenn die Eingabe beispielsweise lautet Lemon, sollte die Ausgabe wie folgt lauten:

          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

Wenn der Eingang limeder Ausgang ist, sollte sein:

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

Und das gleiche Muster wird für andere Eingaben befolgt:

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

Zeilen in der Ausgabe können abschließende Leerzeichen enthalten, und es kann eine optionale abschließende neue Zeile geben.

Der kürzeste Code in Bytes gewinnt.

Matlab, 140 136 128 124 Bytes

Grundsätzlich fängt man mit dem Mittelteil an und fügt dann die gekürzten / geänderten Fassungen schrittweise voran / an.

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

Danke für 8 Bytes @LuisMendo!

ZB für MATLABwir bekommen:

               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 bei Verwendung von raw_input. Das Programm erstellt im Wesentlichen eine Maske basierend auf der Entfernung L1-Norm / Manhattan vom Zentrum sowie der Parität dieser Entfernung im Vergleich zur Parität der eingegebenen Länge.

(Danke an @Lynn für -9 Bytes und ebnet den Weg für 2 weitere)

MATL , 44 Bytes

Ich habe mich von @ flawrs Antwort inspirieren lassen (obwohl der Algorithmus nicht derselbe ist)

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

Die Eingabe ist eine Zeichenfolge mit einfachen Anführungszeichen.

Probieren Sie es online!

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}

Prüfung

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

Demonstration

Gelee, 32 26 Bytes

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

Probieren Sie es online!

BEARBEITEN: Dennis sparte 6 Bytes. Vielen Dank!

JavaScript, 187 178 Bytes

Ein bitweiser Ansatz. Die Funktion mdefiniert eine Maske, indem sie bei beginnt 2 ** length, z. B. 00100in binärer Form, und m(n) = m(n-1) << 1 | m(n-1) >> 1für die erste Hälfte definiert. Interessanterweise kann die zweite Hälfte als definiert werden m(n) = m(n-1) << 1 & m(n-1) >> 1. (obwohl das Programm sich stattdessen dafür entscheidet, m(n) = m(2 * length - 1)für die zweite Hälfte zu definieren ) Von hier aus können diese Masken verwendet werden, um durch Überprüfen zu bestimmen, ob ein Wort oder ein Leerzeichen erscheinen soll 2 ** column & m(row). Natürlich ist es in JavaScript kürzer, 2 ** somethingmit 1 << something...

Anmerkung: geschrieben, während Sie müde sind. Mai hat mit ziemlicher Sicherheit Fehler.

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ᵐ~ṇ

Probieren Sie es online!

Schreckliche Byteanzahl und wahrscheinlich schlechtere Vorgehensweise (ganz zu schweigen davon, dass Brachylog nicht speziell für ASCII-Grafiken entwickelt wurde), aber ich habe genug Zeit darauf verschwendet, um es trotzdem zu veröffentlichen.

              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.

Der einzig clevere Teil davon ist die Verwendung von a₁ , um die vertikalen Räume mit der größten zuerst zu a₀erzeugen, während die Wortpräfixe mit der kleinsten zuerst erzeugt werden, und zzum einzelne Räume zu Raumblöcken zu erweitern, die der Breite der Präfixe entsprechen.

TSQL, 259 Bytes

Golf gespielt:

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

Geige

C 167 Bytes

Dieses Programm erwartet, dass der Eingabetext als erster Parameter an das Programm übergeben wird (über die Befehlszeile oder anderswo) und schreibt die Ausgabe nach 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));}

Dies ist mein erster Versuch, hier Codegolf zu spielen, da dies eine vernünftige Herausforderung zu sein schien. Es kann also wahrscheinlich mehr gespielt werden, als ich konnte, nur weil ich es getan habe.

Erläuterung

/* 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 ist wichtig genug, die Verwendung von (n < m) ? n : (m * 2) - nin dem Programm mindestens zweimal zu notieren , um den invertierten Abstand von einer Mittenposition min einem Bereich m * 2mit der Eingabe zu erhalten n. Wenn es einen kürzeren Weg dafür gibt, könnte man es einfacher machen, da dieser Algorithmus für die Funktionsweise dieses Programms wichtig ist.

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

Nervenzusammenbruch:

Dies zeichnet jedes Element des 2n-1 x 2n-1-Gitters, wobei eine Maskenfunktion entscheidet, ob das aktuelle Element ein Leerzeichen oder ein Eingabewort sein soll (die Maske prüft, ob eine Rautenform und ein Schachbrettmuster vorliegen).

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
}