Ich hatte erwartet, als mein erstes Rätsel in PCG etwas Komplexeres zu veröffentlichen, aber eine bestimmte, ähm ... Hausaufgabenfrage zu Stack Overflow hat mich dazu inspiriert, dies zu veröffentlichen. Sie möchten:

Gib das folgende Muster für ein bestimmtes Wort aus, das eine ungerade Anzahl von Buchstaben enthält:

P           M
  R       A   
    O   R    
      G       
    O   R      
  R       A   
P           M 

c ++

Beachten Sie, dass Buchstaben in dem Muster, das Sie drucken möchten, nur einen Springer voneinander entfernt sind. Jede zweite Spalte ist also leer. - (Danke xnor für den Hinweis.)

Regeln

1. Die Verwendung von C ++ ist verboten. Da darf ich diese Frage da verlinken.
2. Sie können stdouteine Zeichenfolge verwenden oder auf beliebige Weise schnell ausgeben (z alert(). B. in JavaScript).
3. Wie immer gewinnt der kürzeste Code.

Pyth , 22

Vzjdm?@zd}N,dt-lzd\ Uz

Prüfung:

$ pyth -c 'Vzjdm?@zd}N,dt-lzd\ Uz' <<< "CODE-GOLF"
C               F
  O           L  
    D       O    
      E   G      
        -        
      E   G      
    D       O    
  O           L  
C               F

Erläuterung:

(Implicit)                  z = input()
(Implicit)                  d = ' '
Vz                          for N in range(len(z)):
  jd                            print(d.join(
    m                               map(lambda d:
     ?@zd                                        z[d] if
         }N                                      N in
           ,dt-lzd                                    (d,len(z)-d-1) else
      \                                          " ",
     Uz                                          range(len(z)))))

APL ( 37 35 34 27)

↑{∊2↑¨⍵↑¨I}¨↓(+∨⌽)∘.=⍨⍳⍴I←⍞

Es nimmt Eingaben von der Tastatur entgegen, wie folgt:

      ↑{∊2↑¨⍵↑¨I}¨↓(+∨⌽)∘.=⍨⍳⍴I←⍞
CODE-GOLF
C               F 
  O           L   
    D       O     
      E   G       
        -         
      E   G       
    D       O     
  O           L   
C               F 

Python 2 - 94 90 89 88

s=input()
L=len(s)
R=range(L)
for i in R:print" ".join([s[j]," "][j!=i!=L+~j]for j in R)

Eingang:

"CODE-GOLF"

Ausgabe:

C               F
  O           L  
    D       O    
      E   G      
        -        
      E   G      
    D       O    
  O           L  
C               F

Python 3: 75 Zeichen

s=input()
i=n=len(s)
while i:i-=1;a=[" "]*n;a[i]=s[i];a[~i]=s[~i];print(*a)

Für line ibeginnen wir mit einer Liste von Leerzeichen und setzen die Einträge ivon vorne und hinten so, dass sie den Buchstaben der Eingabezeichenfolge entsprechen. Dann drucken wir das Ergebnis.

Python-Strings sind unveränderlich, daher amuss es sich stattdessen um eine Liste von Zeichen handeln. Die Liste amuss innerhalb der Schleife initialisiert werden, sonst werden die Änderungen zwischen den Schleifen übertragen. Wir verwenden print(*a), um jedes Zeichen in der Liste mit Leerzeichen zu drucken, was Python 3 erfordert.

Die Ausgangsleitungen sind symmetrisch, so dass wir imit einer while-Schleife eher abwärts als aufwärts zählen können .

>>> CODE-GOLF
C               F
  O           L  
    D       O    
      E   G      
        -        
      E   G      
    D       O    
  O           L  
C               F

Es funktioniert auch für eine gerade Anzahl von Buchstaben.

>>> CODEGOLF
C             F
  O         L  
    D     O    
      E G      
      E G      
    D     O    
  O         L  
C             F

CJam, 27 25 Bytes

l_,S*:Sf{W):W2$tW~@tS}zN*

Probieren Sie es online aus.

Beispiellauf

$ cjam <(echo 'l_,S*:Sf{W):W2$tW~@tS}zN*') <<< CROSS; echo
C       S 
  R   S   
    O     
  R   S   
C       S 

Als Beispiel in der Antwort weist jede Zeile ein nachgestelltes Leerzeichen auf.

Wie es funktioniert

                             " N := '\n'; R := []; S = ' '; W := -1 ";
l                            " Q := input()                         ";
 _,S*:S                      " S := len(Q) * S                      ";
       f{            }       " for each C in Q:                     ";
                             "   T := S                             ";
         W):W                "   W += 1                             ";
             2$t             "   T[W] := C                          ";
                W~@t         "   T[~W] := C                         ";
                             "   R += [T]                           ";
                    S        "   R += [S]                           ";
                      z      " R := zip(R)                          ";
                       N*    " R := N.join(R)                       ";
                             " print R                              ";

Java - 168

Eine einfache verschachtelte Schleife, hier ist nichts wirklich Besonderes los.

class C{public static void main(String[]a){int b=-1,c=a[0].length()-1,d;for(;b++<c;)for(d=-1;d++<c;)System.out.print((b==d|b==c-d?a[0].charAt(d):" ")+(c==d?"\n":""));}}

Mit Zeilenumbrüchen:

class C{
    public static void main(String[]a){
        int b=-1,c=a[0].length()-1,d;
        for(;b++<c;)
            for(d=-1;d++<c;)
                System.out.print(
                    (b==d|b==c-d?a[0].charAt(d):" ")+
                    (c==d?"\n":""));
    }
}

Pure Bash, 94 Bytes

l=${#1}
for((;t<l*l;t++));{
((x=t%l))||echo
((x-t/l&&x+t/l+1-l))&&printf \ ||printf ${1:x:1}
}

Rubin, 64

f=->w{x=w.size
x.times{|i|y=" "*x
y[i],y[~i]=w[i],w[~i]
puts y}}

Erläuterung

• Die Eingabe wird als Argument für ein Lambda verwendet. Es erwartet a String.
• In einer Schleife, die alle Zeichen des Wortes durchläuft ( ninsgesamt):
  • Erstellen Sie eine Zeichenfolge, die aus nLeerzeichen besteht.
  • Ersetzen Sie das ith und n-ith ( ~i, danke xnor) Leerzeichen durch das ith und n-ith Zeichen der Eingabe.
  • Drucken Sie die Zeile

JavaScript (E6) 101 95 129 136

Bearbeiten Sie den falschen Buchstabenabstand. Fest.
Bearbeiten Einfacher und kürzer mit classic for-Schleifen
. Ausgabe über Popup.

F=a=>{
  for(l=a.length+1,i=s=o='';++i<l;s='\n')
    for(j=0;++j<l;)
      o+=s+((s=' ')+a)[j==i|i+j==l&&j]
  alert(o)
}

Vorherige Version mit .map

F=a=>alert([...a].map((c,p)=>
  --q<p
  ?B(q)+a[q]+B(p-q-1)+c 
  :B(p)+c+(p-q?B(q-p-1)+a[q]:'')
,B=n=>' '.repeat(n),q=a.length).join('\n'))

Test In FireFox / Firebug - Konsole

F('Java-Script')

Ausgabe

J                   t
  a               p  
    v           i    
      a       r      
        -   c        
          S          
        -   c        
      a       r      
    v           i    
  a               p  
J                   t

Befunge-93, 68 71

:~:84*-!#@#v_\:2*\4+p1+
::+\4+g:!| >$1+0:>p1-::
00+4\*2:\<>0p#:- ^#2g

Sie können es hier testen . Bei jedem Durchlauf wird ein Eingabedialogfeld angezeigt ~. Geben Sie Ihr Wort zeichenweise ein (es besagt, dass die Eingabe doch "klunky" ist) und schließen Sie mit einem Leerzeichen ab.

Es wird nicht auf der Konsole gedruckt. das wäre doch keine Befunge ohne einen Hauch von Selbstveränderung! Stattdessen ändert es sein eigenes Raster, um die Nachricht anzuzeigen. Nachdem es fertig ist, sieht das Gitter ungefähr so ​​aus:

 ~:84*-!#@#v_\:2*\4+p1+
::+\4+g:!| >$1+0:>p1-::
00+4\*2:\<>0p#:- ^#2g

c               f      
  o           l        
    d       o          
      e   g            
        -              
      e   g            
    d       o          
  o           l        
c               f

(Beachten Sie das edle Opfer der Zelle bei (0,0), nachdem wir wissen, dass der Zeiger nicht mehr dorthin geht, um ein Datenelement zu speichern.)

Es funktioniert auch mit Eingaben von gerader Länge. Beachten Sie, dass die Eingabegröße auf 21 Zeichen beschränkt ist, wenn Sie Befunge-93 in einem Befunge-93-Interpreter ausführen, da Befunge-93 auf ein Raster von 80 x 25 beschränkt ist. Wenn Sie es als Befunge-98 ausführen, sollte diese Beschränkung aufgehoben werden.

Bearbeiten - Jetzt funktioniert es mehr in Richtung der beabsichtigten Ausgabe, auf Kosten von nur drei Zeichen Länge.

Javascript 102 84 85

Bearbeiten: Musste Abstand zu beheben. Nicht mehr so ​​klein.

function p(s){for(i in s){o='';for(n in s)o+=(n==i?s[n]:n==s.length-1-i?s[n]:' ')+' ';console.log(o)}}

p('Thanks-Dennis')

T                       s
  h                   i
    a               n
      n           n
        k       e
          s   D
            -
          s   D
        k       e
      n           n
    a               n
  h                   i
T                       s

CJam, 38 36 35 34 32 Bytes

l:I,,_f{f{_2$=@2$+I,(=|\I=S?S}N}

Teste es hier. Dies liest das Eingangswort von STDIN. Es funktioniert auch für eine gerade Anzahl von Zeichen. Dies gibt eine nachfolgende Spalte mit Leerzeichen aus, aber ich sehe nichts in den Regeln dagegen.

Erläuterung

l:I,,_f{f{_2$=@2$+I,(=|\I=S?S}N}
l:I                              "Read input and store it in I.";
   ,                             "Get string length.";
    ,_                           "Turn into range and duplicate.";
      f{                       } "Map block onto first range, with second range on the stack.";
        f{                   }   "Map block onto second range, with first iterator in stack.
                                  Each invocation of this block will start with grid coordinates
                                  y and x on the stack (x on top).";
          _2$=                   "Duplicate x, duplicate y, check for equality.";
              @2$+               "Pull up y, duplucate x, add,";
                  I,(=           "Check if that's one less than the string length.";
                      |          "Bitwise or between conditions.";
                       \         "Swap condition and x.";
                        I=       "Take x'th character from the string.";
                          S?     "Push a space and select character depending on condition.";
                            S    "Push another space.";
                              N  "Push a line feed.";

Der Inhalt des Stapels wird am Ende des Programms automatisch ausgedruckt.

C 105

zwei leicht unterschiedliche Arten, es zu tun.

c,i,j;main(int l,char**v){for(l=strlen(v[1]);j-l;)putchar((c=v[1][i++])?i-1-j&&l-i-j?32:c:(i=0,j++,10));}

i,j;main(int l,char**v){for(l=strlen(v[1]);j-l;i++)putchar((l-i)?i-j&&l-i-j-1?32:v[1][i]:(i=-1,j++,10));}

Wenn Sie zusätzliche Leerzeichen einfügen möchten, ersetzen Sie diese putchar(durch printf(" %c",5 zusätzliche Zeichen.

J - 36 30 Bytes:

Bearbeiten: 6 Zeichen kürzer, Credits gehen an @algorithmshark .

(1j1#"1' '&,({~](*>.*&|.)=)#\)

z.B:

   (1j1#"1' '&,({~](*>.*&|.)=)#\) 'Code-Golf'
C               f
  o           l  
    d       o    
      e   G      
        -        
      e   G      
    d       o    
  o           l  
C               f

Bonus: Funktioniert auch mit Saiten mit gerader Länge:

   (1j1#"1' '&,({~](*>.*&|.)=)#\) 'CodeGolf'
C             f
  o         l  
    d     o    
      e G      
      e G      
    d     o    
  o         l  
C             f

Prolog - 240 Bytes

:-initialization m.
+[]. +[H|T]:-(H=' ';!),+T.
+[H|T]+I+X:-0=:=I,X=H;+T+(I-1)+X.
+L+I+C+S:-L=:=I;S=[D|E],+C+I+B,+C+(L-I-1)+B,+B+2*I+D,+L+(I+1)+C+E,+B,writef('%s\n',[B]).
-X:-get_char(C),(C='\n',X=[];X=[C|Y],-Y).
m:- -X,length(X,L),+L+0+_+X.

Aufruf:

$ echo "Code-Golf" | swipl -qf c.pl
C               f
  o           l
    d       o
      e   G
        -
      e   G
    d       o
  o           l
C               f

Lesbar:

:- initialization(main).

vars_to_spaces([]).
vars_to_spaces([' '|T]) :- vars_to_spaces(T).
vars_to_spaces([_|T]) :- vars_to_spaces(T).

get_index([Head|_], Index, Result) :-
    0 =:= Index,
    Result = Head.
get_index([_|Tail], Index, Result) :-
    get_index(Tail, Index-1, Result).

print_loop(Length, Index, Board, String) :-
    Length =:= Index;
    String = [FirstChar|RestString],
    get_index(Board, Index, Line),
    get_index(Board, Length-Index-1, Line),
    get_index(Line, 2*Index, FirstChar),
    print_loop(Length, Index+1, Board, RestString),
    vars_to_spaces(Line),
    writef('%s\n', [Line]).

get_line(Line) :-
    get_char(C),
    (   C = '\n', Line = [];
        Line = [C|More], get_line(More)).

main :-
    get_line(String),
    length(String, Length),
    print_loop(Length, 0, _, String).

Canvas , 5 Bytes

＼＼：⇵ｎ

Probieren Sie es hier aus!

Erläuterung:

\      create a diagonal of the input
 \     create an even steeper diagonal of that
  :⇵   reverse a copy of it vertically
    n  overlap the two

R , 99 98 93 89 Bytes

m=ifelse(diag(l<-length(w<-el(strsplit(scan(,''),'')))),w,' ')
write(pmax(m,m[,l:1]),1,l)

Probieren Sie es online!

Zeile 1 liest die Eingabezeichenfolge, teilt sie in Zeichen auf, speichert ihre Länge und erstellt eine Matrix mit dem Wort in der Hauptdiagonale. Die Buchstaben des Wortes werden in einer Identitätsmatrix überlagert (und standardmäßig wiederholt, um der Länge zu entsprechen) und nur die übereinstimmenden Einsen bleiben erhalten, andere werden durch Leerzeichen ersetzt.

Zeile 2 gibt eine Matrix aus, die aus Elementen der Diagonalmatrix oder ihrer horizontal gespiegelten Version besteht, je nachdem, welche größer sind.

−2 + 1 = −1 Byte dank JayCe

−4 Bytes dank Giuseppe

C # ( 214 212)

(Sicherlich schlecht) Golf Version:

using System;class A{static void Main(){char[]a,w=Console.ReadLine().ToCharArray();int l=w.Length,i=0;for(;i<l;i++){a=new string(' ',2*l-1).ToCharArray();a[2*i]=w[i];a[2*l-2*i-2]=w[l-i-1];Console.WriteLine(a);}}}

Ungolfed-Version:

using System;

class A
{
  static void Main()
  {
    char[] a, w = Console.ReadLine().ToCharArray();
    int l = w.Length, i = 0;
    for (; i < l; i++)
    {
      a = new string(' ', 2 * l - 1).ToCharArray();
      a[2 * i] = w[i];
      a[2 * l - 2 * i - 2] = w[l - i - 1];
      Console.WriteLine(a);
    }
  }
}

Hinweise, Tipps, Tricks oder Bemerkungen sind sehr willkommen, da dies mein erster Versuch bei CodeGolf ist. Ich wollte es einfach mal ausprobieren, obwohl ich weiß, dass meine C # -Byte-Länge die besten Lösungen nicht annähernd verdoppelt;)

Und wie zählt ihr eure Bytes? Ich habe gerade das oben Genannte in ein Quick Watch-Fenster gepostet und habe es getan .Length. Ich könnte ein kleines Programm schreiben, um Bytes für mich zu zählen, aber ich wette, es gibt einen einfacheren Weg, den ich noch nicht kenne.

JavaScript (ES6) - 185 177 175 170 Bytes

f=n=>{return s='  ',r='repeat',n=[...n],l=n.length,j=l/2-.5,[...h=n.slice(0,j).map((c,i)=>s[r](i)+c+s[r](l-2-(i*2))+' '+n[l-i-1]),s[r](j)+n[j],...h.reverse()].join('\n')}

Fügen Sie dies in die Firefox-Konsole ein und führen Sie es aus als f('PROGRAM'):

P           M
  R       A
    O   R
      G
    O   R
  R       A
P           M

f("CODE-GOLF"):

C               F
  O           L
    D       O
      E   G
        -
      E   G
    D       O
  O           L
C               F

Mathematica, 149 Bytes

FromCharacterCode@Flatten[Append[Riffle[#,32],10]&/@MapThread[Max,{#,Reverse@#,ConstantArray[32,Dimensions@#]},2]&@DiagonalMatrix@ToCharacterCode@#]&

Eingabe als Parameter an die Funktion übergeben; Funktion gibt die Ausgabezeichenfolge zurück. Am Ende der Ausgabe befindet sich eine nachgestellte Zeile.

Erläuterung: Wir erstellen eine diagonale Matrix mit der Zeichenfolge und erstellen dann eine Kopie davon, die vertikal gespiegelt ist, indem wir Reverse@#die Zeilen umkehren. Dann haben wir eine dritte Matrix mit den gleichen Dimensionen, die nur 32 enthält (ASCII-Raum). Wir verwenden MapThread, um das elementweise Maximum dieser 3 Matrizen zu nehmen. Schließlich setzen wir Rifflein jede Zeile Appendein Leerzeichen , eine neue Zeile am Ende und Flattendas Ergebnis.

C 119

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

Dies könnte nicht als C ++ kompiliert werden, daher hoffe ich, dass ich nicht gegen Regeln verstoßen habe :)

Perl - 90

Es könnte möglich sein, einige weitere Zeichen daraus herauszuholen:

($j=$i++%8)==7?++$k&&print"\n":print$j+1==$k||7-$j==$k?"$_ ":"  "for split//,($_ x y///c)

89+ 1für -n.

Laufen mit:

echo "program" | perl -nE'($j=$i++%8)==7?++$k&&print"\n":print$j+1==$k||7-$j==$k?"$_ ":"  "for split//,($_ x y///c)'

Ausgabe:

p           m
  r       a
    o   r
      g
    o   r
  r       a
p           m

T-SQL: 180

Übernahme der Eingabe von der Variablen @i

DECLARE @s VARCHAR(MAX)=REPLICATE('  ',LEN(@i)),@ INT=1a:PRINT STUFF(STUFF(@s,@*2-1,1,SUBSTRING(@i,@,1)),LEN(@i)*2-(@*2)+1,1,SUBSTRING(@i,LEN(@i)-@+1,1))SET @+=1IF @<=LEN(@i)GOTO A

Dadurch werden einzelne Zeichen vom Anfang bis zum Ende in eine Folge von Leerzeichen eingefügt bzw. dekrementiert.

Testergebnis

DECLARE @i VARCHAR(MAX)='Super Large'
DECLARE @s VARCHAR(MAX)=REPLICATE('  ',LEN(@i)),@ INT=1a:PRINT STUFF(STUFF(@s,@*2-1,1,SUBSTRING(@i,@,1)),LEN(@i)*2-(@*2)+1,1,SUBSTRING(@i,LEN(@i)-@+1,1))SET @+=1IF @<=LEN(@i)GOTO A
S                   e 
  u               g   
    p           r     
      e       a       
        r   L         

        r   L         
      e       a       
    p           r     
  u               g   
S                   e 

PowerShell 118 102 97

($x=[char[]]"$args")|%{$i++;$y=[char[]]" "*$x.Count;$y[$i-1]=$x[$i-1];$y[-$i]=$x[-$i];$y-join' '}

Ausgänge:

PS C:\PowerShell> .\cross.ps1 SWORD
S       D
  W   R
    O
  W   R
S       D

Jelly , 11 Bytes

LḶḤ⁶ẋ;"µ»ṚY

Probieren Sie es online!

JavaScript (Node.js) , 81 Byte

f=s=>[...s].map((_,i,a)=>a.map((c,j)=>j==i|j==s.length+~i?c:' ').join` `).join`
`

EDIT : -1 Danke Joe King. Ich habe nicht gesehen, dass TIO eine vorformatierte Direktpaste für CG enthält.

Probieren Sie es online!

C # 208

static void Main()
{
string s=Console.ReadLine(),t="";
int n=s.Length;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(i==j)t+=s[i];
else if(i==n-j-1)t+=s[n-i-1];
t+=" ";
}
t+="\n";
}
Console.WriteLine(t);
}

GolfScript 46 ( DEMO )

:w,:l,{l,{.[.l(\-]2$?)!w@[=32]=}%\;''+' '*}%n*

Egal wie lange, es muss immer eine Antwort geben ...

Java - 289 234 Bytes

public static void main(String[]a){int l=a.length-1,i=0,j;for(;i<=l;i++){for(j=0;j<=l;j++){if(j==i)System.out.print(a[i]);else if(i==l-j)System.out.print(a[j]);else System.out.print(" ");System.out.print(" ");}System.out.println();}}}

Ungolfed:

    class A {

    public static void main(String[] a) {
        int l = a.length - 1, i = 0, j;
        for (; i <= l; i++) {
            for (j=0; j <= l;j++) {
                if (j == i)
                    System.out.print(a[i]);
                else if (i == l-j)
                    System.out.print(a[j]);
                else
                    System.out.print(" ");
                System.out.print(" ");
                }            
            System.out.println();
        }
    }
}

Die Ausgabe, mies gemacht, ist:

P           M 
  R       A   
    O   R     
      G       
    O   R     
  R       A   
P           M 

Fügte das import java.util.ScannerInnere des Codes hinzu, weil ich mich nie daran erinnere, ob die Importe für die Byteanzahl zählen ... Verdammt, ich bin echt beschissen.

C # (192/170)

using System;class P{static void Main(){var s=Console.ReadLine();int x,y,l=s.Length;for(x=0;x<l;x++){for(y=0;y<l;y++)Console.Write(x==y||l-x==y+1?s.Substring(x,1):" ");Console.Write("\n");};}}

Oder als "Main () only":

static void Main(){var s=Console.ReadLine();int x,y,l=s.Length;for(x=0;x<l;x++){for(y=0;y<l;y++)Console.Write(x==y||l-x==y+1?s.Substring(x,1):" ");Console.Write("\n");};}