我原本希望在PCG中发布更复杂的内容，这是我的第一个难题，但是一个特别的，嗯... Stack Overflow上的作业问题启发了我发布此内容。他们想要：

对于包含奇数个字母的任何给定单词，打印以下模式：
P           M
  R       A   
    O   R    
      G       
    O   R      
  R       A   
P           M 
C ++

请注意，字母是您需要打印的图案中骑士分开的部分。因此，每隔一列为空。-（感谢xnor指出这一点。）

规则

禁止使用C ++。正如我可能将这个问题联系到那里。
您可以使用stdout或任何快速输出字符串的方法（例如，alert()在JavaScript中）。
与往常一样，最短的代码获胜。

code-golf ascii-art

— 桑帕氏菌
source

2

这是有关堆栈溢出的相关文章：stackoverflow.com/q/5508110

— Level River St

2

@flawr我认为这表示奇数，而不是偶数。

— NinjaBearMonkey 2014年

31

天哪，我是愚蠢的，我认为它是一种晦涩的计算机科学家的缩写=）

— 虚伪的2014年

2

@jpjacobs：字节，除非问题明确说明。

— 丹尼斯

2

整个程序还是一个功能？（我真的很聪明，先回答，然后再提出这个问题...）

— Rodolfo Dias 2014年

13

珀斯 22

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

测试：

$ 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

说明：

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

— 伊萨格
source

Pyth中没有补码吗？

— xnor 2014年

@xnor否，但这无济于事。假设~不在Pyth中。然后，我们可以更改t-lzd为+lz~d-仍然是5个字符。

— isaacg 2014年

Vz这是一个巧妙的技巧：我不知道那U<string>给了range(len(<string>))。

— FryAmTheEggman 2014年

是的，这是一个不错的功能。也可以在列表上那样工作，但不一定要在元组上工作。编辑：糟糕，该文档中没有。我将其添加。抱歉。

— isaacg 2014年

20

APL（37 35 34 27）

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

它需要来自键盘的输入，如下所示：

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

— 马里纳斯
source

7

我所有的投票都属于APL。

— 2014年

13

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)

输入：

"CODE-GOLF"

输出：

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

— 法尔科
source

我只是在写同样的东西。我的一项改进是i in[j,L+~j]。

— xnor 2014年

@xnor：发现了一个更短的条件。;）

— Falko 2014年

聪明。您仍然可以做L+~j。

— xnor 2014年

@xnor：啊，你是对的。我总是忘了+~把戏……

— Falko 2014年

您for i in R:print" ".join([s[j]," "][j!=i!=L+~j]for j in R)可以保存一个字符吗？（我现在无法访问Python 2进行测试。）

— xnor 2014年

11

Python 3：75个字符

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

对于line i，我们从空格列表开始，i将前后的条目设置为等于输入字符串的字母。然后，我们打印结果。

Python字符串是不可变的，因此a必须是字符列表。该列表a必须在循环内部初始化，否则修改将在循环之间进行。我们print(*a)用来打印列表中的每个字符，并用空格隔开，这需要Python 3。

输出线是对称的，因此我们可以i使用while循环进行递减计数而不是递增计数。

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

它也适用于偶数个字母。

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

— 异或
source

将其转换为Pyth，我得到的VlzJ*]dlz=@JN@zN=@Jt_N@_zNjdJ是29个字节...我想我必须尝试其他方法才能击败APL。另外，+ 1表示Python 3可以超越Python 2（有时）的

— 证据

以我的经验，@ fry Python 3通常比高尔夫2高。即使其他任何地方都没有改变，大多数挑战也只能提供一个输入并期望一个输出，并且len("raw_input()") + len("print ") > len("input()") + len("print()")。

— 地下

@undergroundmonorail嗯，这样做的麻烦在于它input() 在python 2中同样有效（只是行为有所不同），因此，除非挑战的输入非常严格，否则python 2通常会获胜。

— FryAmTheEggman 2014年

哇，即使使用Python 2，print" ".join(a)您的代码也比我的短（82）。

— Falko 2014年

@FryAmTheEggman看到我的答案-它是另一个python答案的改编，比APL短得多。不幸的是，Pyth确实不喜欢分配索引。

— isaacg 2014年

8

CJam，27 25字节

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

在线尝试。

运行示例

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

作为答案中的示例，每行都有尾随空格。

怎么运行的

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

— 丹尼斯
source

1

抱歉，这基本上是一个“绝佳答案”！评论，但我只想说，我从来没有想过要按列而不是按行来构建框。

— FryAmTheEggman，2014年

4

Java-168

一个简单的嵌套循环，这里没有什么特别的事情。

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

带换行符：

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

— 地位
source

4

纯Bash，94个字节

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

— 数字创伤
source

1

t%l计算太多。首次使用时将其保存为变量，((x=t%l))然后使用该变量将其减少到94个字符。

— manatwork，2014年

嗯，是的，我这样做了x=t%l，y=t/l而且时间更长了……我只是为了使用x而没有想到

— Digital Trauma 2014年

4

Ruby，64岁

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

说明

输入作为lambda的参数。它期望一个String。
在一个循环中，循环遍历单词中的每个字符（n总计）：
- 创建一个由n空格组成的字符串。
- 用输入的th和th字符替换ith和n-ith（~i，感谢xnor）空格。in-i
- 打印线

— 英国茶
source

7

恭喜您发布了第25,000个答案！：）（实际上，由于缓存，我不是100％肯定的，但这是最新答案，当我第一次在网站统计信息中看到“ 25,000个答案”时。）

— Martin Ender 2014年

2

您可以做-i-1一点补充~i。

— xnor 2014年

太聪明了，谢谢！

— britishtea 2014年

2

通过这种方法，实际上使用stdin代替lambda似乎是有益的：（例如gets.size.times{|x|u=?\s*~/$/;u[x]=$_[x];u[~x]=$_[~x];puts u}，假设输入未由换行符终止echo -n CODE-GOLF）。然后，可以进一步利用它.chars来保存另一个角色：x=0;gets.chars{|r|u=?\s*~/$/;u[x]=r;u[~x]=$_[-x+=1];puts u}

— Ventero 2014年

4

JavaScript（E6）10195129136

编辑错误的字母间距。固定。使用经典for循环
编辑更简单，更简短
作为一个功能，通过弹出窗口输出。

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

使用.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'))

在FireFox / FireBug控制台中测试

F('Java-Script')

输出量

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

— edc65
source

2

这没有足够的水平间距-每列之间应有所有带有字母的空格。

— isaacg 2014年

4

Befunge-93，68 71

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

您可以在这里进行测试。每次通过都会出现一个输入对话框~; 一次输入一个单词（毕竟输入确实是“笨拙的”），并以空格结尾。

它不会打印到控制台。毕竟，如果没有自我修改的提示，这将不是Befunge！相反，它将修改自己的网格以显示消息。完成后，网格将如下所示：

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

（请注意，在我们知道指针不会再到那里了（0,0）时，该单元的崇高牺牲是为了存储一条数据。）

它也可用于偶数长度的输入。请注意，由于Befunge-93限于80x25网格，因此，如果您在Befunge-93解释器中运行它，则输入大小限制为21个字符。以Befunge-98的身份运行应该可以消除此限制。

编辑 -现在，它可以按照预期的输出效果工作，而只牺牲了三个字符的长度。

— 卡斯兰
source

请注意，字母用空白列分隔。字母相对呈L形。

— sampathsris 2014年

鸭！这使事情变得相当复杂。我想我可以解决这个问题，但这会增加最终的大小...哦，好。

— 卡斯兰2014年

4

Javascript 102 84 85

编辑：不得不修复间距。不再那么小了。

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

— 里普里布
source

这没有足够的水平间距。

— 丹尼斯

1

哇，比我的还短，甚至没有使用ES6。+1

— Scimonster 2014年

更好，但是间距仍然错误（请看X）。另外，除非问题另行说明，否则应编写程序或函数。带有硬编码变量的代码片段通常会被皱眉。

— 丹尼斯

1

而且function(s)因为不递归而不能做到吗？

— 扎卡里

3

CJam，38 36 35 34 32字节

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

在这里测试。这将从STDIN读取输入字。它也适用于偶数个字符。这将打印出一列空格，但是我在规则中看不到任何空格。

说明

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

堆栈的内容在程序末尾自动打印。

— 马丁·恩德
source

我亲爱的CJam，您刚刚被APL打败了。^ _ ^

— vaxquis 2014年

@vaxquis我很惊讶自己能够一举击败两次。这个问题似乎比基于堆栈的语言更适合APL和合作。

— 马丁·恩德2014年

2

好吧，至少l:I,,_f{f{_2$=@2$+I,(=|\I=S?S}N}在餐巾纸上写要比↑{∊2↑¨⍵↑¨I}¨↓(+∨⌽)∘.=⍨⍳⍴I←⍞... 轻笑

— vaxquis 2014年

好吧，有人设法使用CJam击败了我，我无法再缩短程序了，所以CJam最终击败了我。（但Pyth获得桂冠。）（这就是说，@vaxquis，APL是更容易比大多数在这里使用的其他语言的阅读，当然，一旦你知道的60个左右的字符，当然相比Pyth或CJam或当甚至J.）

— marinus，2014年

3

C，105

两种略有不同的方式。

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

如果你想添加额外的空格，替换putchar(用printf(" %c",一个额外的5个字符。

— Level River St
source

3

J- 36 30个字节：

编辑：短6个字符，积分转到 @algorithmshark。

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

例如：

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

奖励：甚至可以用于长度均匀的字符串：

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

— jpjacobs
source

3

Prolog-240字节

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

调用：

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

可读性：

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

— y
source

3

画布，5 个字节

＼＼：⇵ｎ

在这里尝试！

说明：

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

— 宰马
source

3

R，99 98 93 89字节

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

在线尝试！

第1行读取输入字符串，将其拆分为字符，存储其长度，并创建一个单词在其主要对角线上的矩阵-单词的字母叠加在一个单位矩阵上（默认情况下重复以匹配其长度），只有匹配的字符串1保留，其他用空格代替。

第2行打印由对角矩阵或其水平镜像版本（以较大者为准）的元素形成的矩阵。

− 2 + 1 = −1字节，归功于JayCe

−4个字节，感谢Giuseppe

— 罗伯特·哈肯
source

1

甜！很好的解释。您可以保存2个字节

— JayCe

1

看他其他的答案和问题-似乎矩阵应该更大（多余的空间）-输出不应该是方矩阵

— 。– JayCe

@JayCe感谢您提供2个字节！并且感谢您对格式的评论，您可能是对的（尽管规则可能对此更加清楚）。幸运的是，它所需要的只是在打印时在分隔器中放置一个空间。

— 罗伯特·哈肯

89个字节使用pmax并内联了更多分配。

— 朱塞佩

@Giuseppe谢谢！可悲的是，仍然不足以击败J.Doe的解决方案

— Robert

2

C＃（214212）

（肯定不好）高尔夫版本：

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

非高尔夫版本：

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

任何提示，技巧，窍门或备注都非常欢迎，因为这是我第一次尝试CodeGolf。我只是想尝试一下，尽管我知道我的C＃字节长度甚至都不是最佳解决方案的两倍；）

你们如何计算字节数？我只是将以上内容发布到“快速监视”窗口中并执行了.Length。我可以写一个小程序来为我计数字节，但是我敢打赌，还有一种我不知道的更简单的方法。

— 隐形熊猫
source

您可以通过删除中的空格来节省两个字节for(;i < l;i++)。

— Beta Decay

另外，我将其用于字节计数。

— Beta Decay

@BetaDecay啊，太好了，我一定忽略了那些。并感谢您的链接！

— 看不见的熊猫

2

JavaScript（ES6）- 185个 177 175 170字节

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

将其放入Firefox控制台并以以下方式运行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

— 西蒙斯特
source

codegolf.stackexchange.com/a/40594/26974

— sampathsris 2014年

我也看到了那个。

— Scimonster 2014年

2

Mathematica，149个字节

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

输入作为参数传递给函数；函数返回输出字符串。输出末尾有换行符。

说明：我们使用该字符串创建一个对角矩阵，然后创建一个垂直翻转的副本，Reverse@#用于反转行。然后，我们得到了具有相同维度的第三个矩阵，仅包含32个（ascii空间）。我们MapThread通常采用这3个矩阵的逐元素最大值。最后，我们Riffle将每一行，最后Append的换行符和Flatten结果隔开。

— ca
source

2

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

可能未将其编译为C ++，因此希望，我没有违反规则：）

— VX
source

1.当前输出错误。字母之间应该有一个空格。2. i=0并且j=0不需要，因为全局变量被初始化为零。3.您可以使用main(l,v)char**v;代替main(int l,char**v)。4.如果将更新i为i+=puts("")，则可以摆脱外循环的花括号。

— 丹尼斯2014年

2

Perl-90

可以从中挤出更多字符：

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

89+ 1为-n。

运行：

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

输出：

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

— hmatt1
source

2

T-SQL：180

从变量@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

这会将单个字符从头到尾的递增/递减填充为一串空格。

测试结果

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

— 米奇
source

2

PowerShell的118 102 97

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

输出：

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

— 黑暗阿贾克斯
source

2

果冻，11字节

LḶḤ⁶ẋ;"µ»ṚY

在线尝试！

— 暴民埃里克
source

2

JavaScript（Node.js），81字节

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

编辑：-1感谢乔·金。我没有看到TIO为CG提供了预先格式化的直接粘贴。

在线尝试！

顺便说一句，执行TIO中代码的多余代码可以放在程序页脚中。这有助于确定正确的字节数，并更流畅地使用自动PPCG答案格式。例如在线尝试！

— Jo King

-i-1可以+~i

— 乔·金

1

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

— 酒神
source

使用保存11个珍贵字符t+=i==j?s[i]:i==n-j-1?s[n-i-1]:"";。

— sampathsris，2014年

您可以删除这些换行符吗？

— 扎卡里

1

GolfScript 46（演示）

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

— 克里斯蒂安·卢帕斯库（Cristian Lupascu）
source

1

无论多久，总有一个答案……

Java- 289234字节

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

取消高尔夫：

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

大胆地完成的输出是：

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

~~在import java.util.Scanner内部添加了代码，因为我不记得导入次数是否计入字节数……~~该死，我真的很讨厌这一点。

— 鲁道夫·迪亚斯
source

2

进口确实算在内。这部分是由于Python的import-and-alias语法：from math import floor as f有点作弊

您应该能够System.out.print使用几个三元运算符将所有调用组合成一个字符，从而节省大量字符。

— DLosc 2014年

@DLosc您能举几个例子吗？

— Rodolfo Dias

1

是的，实际上Geobits的答案就是一个完美的例子-请System.out.print在最后查看通话内容。

— DLosc 2014年

1

@RodolfoDias别这样。我最初在Java参加的几次高尔夫比赛都非常糟糕，如果我足够努力的话，我仍然可以在“第一次修订”中剃掉相当大的一块；）

— Geobits 2014年

1

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

或者，作为“仅Main（）”：

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

— 罗比三世
source

角色交叉

规则

珀斯 22

APL（37 35 34 27）

Python 2-94 90 89 88

Python 3：75个字符

CJam，27 25字节

运行示例

怎么运行的

Java-168

纯Bash，94个字节

Ruby，64岁

说明

JavaScript（E6）10195129136

Befunge-93，68 71

Javascript 102 84 85

CJam，38 36 35 34 32字节

C，105

J- 36 30个字节：

Prolog-240字节

画布，5 个字节

R，99 98 93 89字节

C＃（214212）

JavaScript（ES6）- 185个 177 175 170字节

Mathematica，149个字节

Perl-90

T-SQL：180

PowerShell的118 102 97

果冻，11字节

JavaScript（Node.js），81字节

C＃208

GolfScript 46（演示）

Java- 289234字节

C＃（192/170）