Je m'attendais à publier quelque chose de plus complexe comme mon premier casse-tête dans PCG, mais une question particulière, euh ... sur les devoirs sur Stack Overflow m'a inspiré à poster ceci. Ils veulent:

imprimez le modèle suivant pour tout mot donné contenant un nombre impair de lettres:

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

c ++

Notez que les lettres sont un écart de chevalier dans le motif que vous devez imprimer. Ainsi, toutes les autres colonnes sont vides. - (Merci xnor de l' avoir signalé.)

Règles

1. L'utilisation de C ++ est interdite. Comme je peux y lier cette question.
2. Vous pouvez utiliser stdout, ou tout moyen de sortie rapide d'une chaîne (par exemple alert()en JavaScript).
3. Comme toujours, le code le plus court l'emporte.

Pyth , 22

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

Tester:

$ 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

Explication:

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

Il prend la saisie du clavier, comme ceci:

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

Contribution:

"CODE-GOLF"

Sortie:

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

Python 3:75 caractères

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

Pour la ligne i, nous commençons par une liste d'espaces et définissons les entrées ide l'avant et de l'arrière pour qu'elles soient égales aux lettres de la chaîne d'entrée. Ensuite, nous imprimons le résultat.

Les chaînes Python sont immuables, il adoit donc s'agir d'une liste de caractères à la place. La liste adoit être initialisée à l'intérieur de la boucle ou les modifications seront reportées entre les boucles. Nous utilisons print(*a)pour imprimer chaque caractère de la liste, séparés par des espaces, ce qui nécessite Python 3.

Les lignes de sortie sont symétriques, donc nous pouvons avoir un icompte à rebours plutôt que vers le haut en utilisant une boucle while.

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

Il fonctionne également pour un nombre pair de lettres.

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

CJam, 27 25 octets

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

Essayez-le en ligne.

Exemple d'exécution

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

Comme l'exemple dans la réponse, chaque ligne a un espace de fin.

Comment ça marche

                             " 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

Une simple boucle imbriquée, il n'y a rien de vraiment spécial ici.

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

Avec des sauts de ligne:

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 octets

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

Rubis, 64

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

Explication

• L'entrée est considérée comme l'argument d'un lambda. Il attend a String.
• Dans une boucle qui traverse tous les caractères du mot ( nau total):
  • Créez une chaîne composée d' nespaces.
  • Remplacez les espaces ith et n-ith ( ~i, merci xnor) par les caractères ith et n-ith de l'entrée.
  • Imprimer la ligne

JavaScript (E6) 101 95129136

modifier espacement des lettres incorrect. Fixé.
Édition Plus simple et plus courte en utilisant des boucles classiques
Pour une fonction, sortie via 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)
}

Version précédente utilisant .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 dans la console FireFox / FireBug

F('Java-Script')

Sortie

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

Vous pouvez le tester ici . Il y aura une boîte de dialogue d'entrée à chaque passage ~; entrez votre mot un caractère à la fois (cela dit que l'entrée est «klunky» après tout), en terminant par un espace.

Il n'imprimera pas sur la console; ce ne serait pas Befunge sans un soupçon d'auto-modification, après tout! Au lieu de cela, il modifiera sa propre grille pour afficher le message. Une fois terminé, la grille ressemblera à ceci:

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

(Notez le noble sacrifice de la cellule à (0,0), une fois que nous savons que le pointeur n'y ira plus, dans le but de stocker une donnée.)

Il fonctionne également avec des entrées de même longueur. Notez que, puisque Befunge-93 est limité à une grille 80x25, la taille d'entrée est limitée à 21 caractères si vous l'exécutez dans un interpréteur Befunge-93. L'exécuter en tant que Befunge-98 devrait supprimer cette limite.

Modifier - Maintenant, cela fonctionne plus dans le sens de la sortie prévue, au détriment de seulement trois caractères de longueur.

Javascript 102 84 85

Edit: a dû fixer l'espacement. Plus si petit.

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 octets

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

Testez-le ici.Ceci lit le mot d'entrée de STDIN. Il fonctionne également pour un nombre pair de caractères. Cela imprime une colonne d'espaces de fin, mais je ne vois rien dans les règles contre cela.

Explication

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

Le contenu de la pile est imprimé automatiquement à la fin du programme.

C, 105

deux façons légèrement différentes de le faire.

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 vous souhaitez ajouter des espaces supplémentaires, remplacez-les putchar(par printf(" %c",5 caractères supplémentaires.

J - 36 30 octets:

Edit: 6 caractères plus courts, les crédits vont à @algorithmshark .

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

par exemple:

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

Bonus: fonctionne également avec des chaînes de longueur égale:

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

Prolog - 240 octets

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

Invocation:

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

Lisible:

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

Canevas , 5 octets

＼＼：⇵ｎ

Essayez-le ici!

Explication:

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

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

Essayez-le en ligne!

La ligne 1 lit la chaîne d'entrée, la divise en caractères, stocke sa longueur et crée une matrice avec le mot sur sa diagonale principale - les lettres du mot sont superposées sur une matrice d'identité (et répétées par défaut pour correspondre à sa longueur) et uniquement celles qui correspondent Les 1 sont conservés, les autres étant remplacés par des espaces.

La ligne 2 imprime une matrice formée d'éléments de la matrice diagonale ou de sa version à miroir horizontal, selon la valeur la plus élevée.

−2 + 1 = −1 octet grâce à JayCe

−4 octets grâce à Giuseppe

C # ( 214 212)

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

Version non-golfée:

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

Tous les conseils, astuces, astuces ou remarques sont les bienvenus, car c'est ma première tentative chez CodeGolf. Je voulais juste l'essayer, même si je sais que ma longueur d'octet C # ne sera même pas proche de doubler les meilleures solutions;)

Et comment comptez-vous vos octets? Je viens de publier ce qui précède dans une fenêtre de surveillance rapide et je l'ai fait .Length. Je pourrais écrire un petit programme pour compter les octets pour moi, mais je parie qu'il existe un moyen plus simple que je ne connais pas encore.

JavaScript (ES6) - 185 177 175 170 octets

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

Mettez ceci dans la console Firefox et exécutez comme 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 octets

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

Entrée passée en paramètre à la fonction; renvoie la chaîne de sortie. Il y a une nouvelle ligne à la fin de la sortie.

Explication: Nous créons une matrice diagonale avec la chaîne, puis nous en créons une copie retournée verticalement en utilisant Reverse@#pour inverser les lignes. Ensuite, nous avons une troisième matrice de mêmes dimensions contenant seulement 32 (espace ascii). Nous utilisons MapThreadpour prendre le max élément par élément de ces 3 matrices. Enfin, nous avons des Riffleespaces dans chaque ligne, Appendune nouvelle ligne à la fin et Flattenle résultat.

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

Cela pourrait ne pas être compilé en C ++, donc j'espère que je n'ai pas violé les règles :)

Perl - 90

Il pourrait être possible d'en extraire d'autres caractères:

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

89 + 1 pour-n .

Courir avec:

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

Sortie:

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

T-SQL: 180

Prendre l'entrée 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

Cela place des caractères simples dans / décrémentant du début et de la fin dans une chaîne d'espaces.

Résultat du test

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

Les sorties:

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

Gelée , 11 octets

LḶḤ⁶ẋ;"µ»ṚY

Essayez-le en ligne!

JavaScript (Node.js) , 81 octets

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

EDIT : -1 Merci Joe King. Je n'ai pas vu que le TIO donne de la pâte directe préformatée pour CG.

Essayez-le en ligne!

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*

Peu importe combien de temps, il doit toujours y avoir une réponse dans ...

Java - 289 234 octets

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

Le résultat, mal fait, est:

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

Ajout de l' import java.util.Scannerintérieur du code parce que je ne me souviens jamais si les importations comptent pour le nombre d'octets ... Merde, je suis vraiment nul.

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

Ou, en tant que "Main () uniquement":

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