Esperaba publicar algo más complejo como mi primer acertijo en PCG, pero una pregunta de tarea particular, eh ... sobre Stack Overflow me inspiró a publicar esto. Ellos quieren:

imprima el siguiente patrón para cualquier palabra que contenga un número impar de letras:

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

c ++

Observe que las letras se separan de un caballero en el patrón que necesita imprimir. Entonces, cada otra columna está vacía. - (Gracias xnor por señalar esto).

Reglas

1. El uso de C ++ está prohibido. Como puedo vincular esta pregunta allí.
2. Puede usar stdout, o cualquier medio de salida rápida de una cadena (por ejemplo, alert()en JavaScript).
3. Como siempre, el código más corto gana.

Pyth , 22

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

Prueba:

$ 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

Explicación:

(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←⍞

Toma entrada del teclado, así:

      ↑{∊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)

Entrada:

"CODE-GOLF"

Salida:

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

Python 3: 75 caracteres

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

Para la línea i, comenzamos con una lista de espacios y configuramos las entradas idesde el frente y hacia atrás para que sean iguales a las letras de la cadena de entrada. Luego, imprimimos el resultado.

Las cadenas de Python son inmutables, por lo que adebe ser una lista de caracteres. La lista adebe inicializarse dentro del ciclo o las modificaciones se transferirán entre ciclos. Usamos print(*a)para imprimir cada carácter en la lista, separados por espacios, lo que requiere Python 3.

Las líneas de salida son simétricas, por lo que podemos tener una icuenta atrás en lugar de arriba usando un ciclo while.

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

También funciona para un número par de letras.

>>> 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*

Pruébalo en línea.

Ejecución de ejemplo

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

Como el ejemplo en la respuesta, cada línea tiene espacios en blanco al final.

Cómo funciona

                             " 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

Un bucle anidado simple, no hay nada realmente especial aquí.

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

Con saltos de línea:

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

Rubí, 64

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

Explicación

• La entrada se toma como argumento para una lambda. Espera a String.
• En un bucle que recorre todos los caracteres de la palabra ( nen total):
  • Crear una cadena que consta de nespacios.
  • Reemplace el espacio ith y n-ith ( ~i, gracias xnor) con el carácter ith y n-ith de la entrada.
  • Imprime la linea

JavaScript (E6) 101 95129136

Editar espaciado de letras incorrecto. Fijo.
Edición más simple y más corta usando clásicos para bucles
Como una función, salida a través de una ventana emergente.

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

Versión anterior usando .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'))

Prueba en la consola FireFox / FireBug

F('Java-Script')

Salida

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

Puedes probarlo aquí . Aparecerá un cuadro de diálogo de entrada en cada paso ~; ingrese su palabra un carácter a la vez (después de todo, dice que la entrada es 'klunky'), terminando con un espacio.

No se imprimirá en la consola; ¡Esto no sería Befunge sin un toque de auto-modificación, después de todo! En su lugar, modificará su propia cuadrícula para mostrar el mensaje. Una vez hecho esto, la cuadrícula se verá así:

 ~: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

(Tenga en cuenta el noble sacrificio de la celda en (0,0), después de que sepamos que el puntero ya no irá allí, con el fin de almacenar un dato).

También funciona con entradas de longitud uniforme. Tenga en cuenta que, dado que Befunge-93 está limitado a una cuadrícula de 80x25, el tamaño de entrada está limitado a 21 caracteres si lo ejecuta en un intérprete Befunge-93. Ejecutarlo como Befunge-98 debería eliminar este límite.

Editar : ahora funciona más en la línea de la salida prevista, a expensas de solo tres caracteres de longitud.

Javascript 102 84 85

Editar: Tuve que arreglar el espacio. Ya no es tan pequeño.

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}

Pruébalo aquí. Esto lee la palabra de entrada de STDIN. También funciona para un número par de caracteres. Esto imprime una columna final de espacios, pero no veo nada en las reglas en contra de eso.

Explicación

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.";

El contenido de la pila se imprime automáticamente al final del programa.

C, 105

dos formas ligeramente diferentes de hacerlo.

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

Si desea agregar espacios adicionales, reemplace putchar(con printf(" %c",un extra de 5 caracteres.

J - 36 30 bytes:

Editar: 6 caracteres más cortos, los créditos van a @algorithmshark .

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

p.ej:

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

Bonificación: también funciona con cadenas de longitud uniforme:

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

Prólogo - 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.

Invocación:

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

Legible:

:- 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).

Lienzo , 5 bytes.

＼＼：⇵ｎ

Pruébalo aquí!

Explicación:

\      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)

Pruébalo en línea!

La línea 1 lee la cadena de entrada, la divide en caracteres, almacena su longitud y crea una matriz con la palabra en su diagonal principal: las letras de la palabra se superponen en una matriz de identidad (y se repiten de manera predeterminada para que coincida con su longitud) y solo las que coinciden Los 1 se retienen, otros se reemplazan por espacios.

La línea 2 imprime una matriz formada por elementos de la matriz diagonal o su versión espejada horizontalmente, la que sea mayor.

−2 + 1 = −1 byte gracias a JayCe

−4 bytes gracias a Giuseppe

C # ( 214 212)

(Ciertamente mal) Versión golfizada:

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

Versión sin golf:

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

Cualquier sugerencia, consejo, truco o comentario es muy bienvenido, ya que este es mi primer intento en CodeGolf. Solo quería probarlo, aunque sé que la longitud de mi byte C # ni siquiera se acercará al doble de las mejores soluciones;)

¿Y cómo cuentan ustedes sus bytes? Acabo de publicar lo anterior en una ventana de Quick Watch y lo hice .Length. Podría escribir un pequeño programa para contar bytes por mí, pero apuesto a que hay una manera más fácil que aún no conozco.

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

Pon esto en la consola de Firefox y ejecútalo como 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@#]&

Entrada pasada como parámetro a la función; La función devuelve la cadena de salida. Hay una nueva línea al final de la salida.

Explicación: Creamos una matriz diagonal con la cadena, luego creamos una copia volteada verticalmente Reverse@#para invertir las filas. Luego tenemos una tercera matriz de las mismas dimensiones que contiene solo 32 (espacio ascii). Usamos MapThreadpara tomar el elemento máximo sabio de estas 3 matrices. Finalmente, Riffleespacios en cada fila, Appenduna nueva línea al final y Flattenel resultado.

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

Es posible que esto no se compile como C ++, por lo que espero no haber violado las reglas :)

Perl - 90

Podría ser posible exprimir algunos caracteres más de esto:

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

89+ 1para -n.

Corre con:

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

Salida:

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

T-SQL: 180

Tomando la entrada de la variable @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

Esto introduce caracteres individuales en / decrementando desde el principio y termina en una cadena de espacios.

Resultado de la prueba

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' '}

Salidas:

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

Jalea , 11 bytes

LḶḤ⁶ẋ;"µ»ṚY

Pruébalo en línea!

JavaScript (Node.js) , 81 bytes

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

EDITAR : -1 Gracias Joe King. No vi que el TIO proporciona una pasta directa preformateada para CG.

Pruébalo en línea!

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*

No importa cuánto tiempo, siempre debe haber una respuesta en ...

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

Sin golf:

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

La producción, mal hecha, es:

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

Agregué el import java.util.Scannercódigo interno porque nunca recuerdo si las importaciones cuentan para el conteo de bytes ... Maldición, realmente apesta.

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

O, como "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");};}