Ihr Programm erhält einen Text als Eingabe, der mindestens 8 Zeichen lang ist und immer aus einer geraden Anzahl von Zeichen besteht. (keine Notwendigkeit, die Richtigkeit der Eingabe zu bewerten).

Ihr Ziel ist es, diesen Text als Rechteck anzuzeigen. Wird beispielsweise HelloWorldals Eingabe angegeben, wird angezeigt

Hell
d  o
lroW

Regeln:

• Text dreht sich im Uhrzeigersinn (Startposition nach Belieben)
• Es wird ein geschlossenes Rechteck mit einer Seitenbreite von 1 Zeichen gebildet.
• Das Rechteck muss den größten Bereich innerhalb des Rechtecks ​​umfassen. (nur um die triviale Antwort auszuschließen, dass der Text in zwei Zeilen angezeigt wird)
• Außer dem Text selbst und den erforderlichen Leerzeichen und Zeilenumbrüchen werden keine weiteren Zeichen gedruckt.

Als Code-Golf gewinnt der kürzeste Code.

_{Der Gewinner wird frühestens 10 Tage nach der ersten gültigen Antwort ausgewählt.}

GolfScript, 56 53 40 38 Zeichen

1/..,4/):l<n@l>{)" "l*2>@(n@.,l-}do-1%

Sie können das Skript online testen .

PostScript 50 binär, 113 ASCII

Dies verwendet eine grafische Ausgabe. Hexdump des Programms mit Binärtoken:

$ hexdump -C textRect_binary.ps 
00000000  74 5b 30 20 39 5b 74 92  62 34 92 36 92 38 92 10  |t[0 9[t.b4.6.8..|
00000010  32 92 19 5d 7b 92 2c 7b  32 92 19 7d 92 83 92 3e  |2..]{.,{2..}...>|
00000020  92 6e 7d 92 49 5d 39 20  39 92 6b 91 c7 39 92 8e  |.n}.I]9 9.k..9..|
00000030  92 c3                                             |..|
00000032

Laden Sie es herunter, um es zu testen . Mit Ghostscript kann der zu rendernde Text wie folgt an das Programm übergeben werden:

gs -st=helloworld textRect_binary.ps 

Die grafische Ausgabe sieht folgendermaßen aus:

Derselbe Code, der ASCII-Token verwendet, sieht folgendermaßen aus:

t[0 9[t length
4 div dup
ceiling
2 copy]{cvi{2 copy}repeat
exch neg}forall]9 9 moveto/Courier 9 selectfont
xyshow

Die Strategie besteht darin, xyshowzu definieren, wohin wir uns bewegen, nachdem wir jedes Zeichen gezeigt haben, bevor wir das nächste Zeichen zeigen. Wir beginnen in der unteren linken Ecke und bewegen uns im Uhrzeigersinn, dh zuerst nach oben, dann nach rechts, dann nach unten und dann nach links. Wir bewegen uns immer 9 Einheiten, so erste haben wir eine Relativbewegung 0 9, dann 9 0, dann 0 -9, dann -9 0. Mit der Sequenz können wir von einem Paar dieser Zahlen zum nächsten gelangen exch neg.

Wir müssen ein Array erstellen xyshow, das diese Zahlenpaare enthält, ein Paar für jedes Zeichen. Das heißt, wenn wir helloworldals Beispiel einen String haben, der 10 Zeichen hat, wollen wir zweimal nach oben, dann dreimal nach rechts, dann zweimal nach unten und dreimal nach links. Wir erhalten diese Werte (zwei und drei), indem wir die Stringlänge durch 8 dividieren, einmal auf den Boden gerundet, einmal an die Decke.

Also kopieren wir 0 9zweimal und wechseln dann mit zu den relativen x / y-Koordinaten exch neg, kopieren diese dreimal und so weiter.

Dieser kommentierte Code zeigt, was auf dem Stapel passiert:

t[0 9                % t [ 0 9
[t length            % t [ 0 9 [ length
4 div dup            % t [ 0 9 [ length/4 length/4
ceiling              % t [ 0 9 [ length/4=height width
2 copy]              % t [ 0 9 [height width height width]
{%forall             % t [ 0 9 ... x y height_or_width
  cvi                % t [ 0 9 ... x y height_or_width_integer
  {2 copy}           % t [ 0 9 ... x y height_or_width_integer {2 copy}
  repeat             % t [ 0 9 ... x y .. x y
  exch neg           % t [ 0 9 ... x y .. y -x
}forall]             % t [0 9 ... -9 0]
9 9 moveto/Courier 9 selectfont
xyshow

Ruby 112 100

Ich bin neu in Ruby und dies ist mein erster Code Golf. Ich habe mich an Memowes Perl-Implementierung orientiert und versucht, eine Ruby-Version davon zu erstellen. Dies ist 112 100 Zeichen und setzt voraus, dass Sie x eine Zeichenfolge zuweisen. Ich freue mich darauf, andere zu sehen.

l=x.size
puts x[0..w=l/2-h=l/4]
1.upto(h-1){|i|puts x[-i]+' '*(w-1)+x[w+i]}
puts x[w+h..l-h].reverse

Bearbeitet, um Vorschläge umzusetzen. Ich denke, es sind jetzt 100 Zeichen. Danke Leute!

Perl (124 118 109 + 3 = 112)

Das war früher ziemlich einfach. Zählte alle Befehlszeilenoptionen als jeweils 1 Zeichen.

-nlE
$w=(@s=split//)/2-($h=int@s/4);say@s[0..$w--];say$s[1-$_].$"x$w.$s[$w+$_]for+2..$h;say+reverse@s[@s/2..@s-$h]

Beispiel:

$ perl -nlE '$w=(@s=split//)/2-($h=int@s/4);say@s[0..$w--];say$s[1-$_].$"x$w.$s[$w+$_]for+2..$h;say+reverse@s[@s/2..@s-$h]'
abcdefghijklmnopqrstuvwxyz
abcdefgh
z      i
y      j
x      k
w      l
v      m
utsrqpon

Brainfuck - 194 187

+>,[>+[>+<-],]
>-->++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>[-]>[<<+<<+>>>>-]<<<<
[[<]>+[>]<-]<[<]>-
[>.[-]<[>+<-]>-]>[>]
++++++++++.<.[-]
>[>+++>>+<<<-]>++>--[<.>-]<<<<[<]>.[-]>[>]>>>>.
<<<<<[.<]

Mathematica 156 199 344

Bearbeiten : Dies ist eine umfangreiche Neufassung des früheren Codes. Es funktioniert im Wesentlichen genauso, nimmt jedoch als Eingabe eine Zeichenfolge mit einer Länge von <120 Zeichen und passt die Größe des Quadrats automatisch an.

Es könnte noch ein bisschen Golf gespielt werden, wird aber nicht die Größe der früheren und fehlerhafteren Versionen erreichen.

f@s_ := ({a, t, w, q} = {Automatic, Text, Quotient[StringLength@s, 2],
 Quotient[StringLength[s], 4] + 1};z = StringSplit[StringInsert[s <> ConstantArray[" ", 0],
 "*", {q, 2 q, 3 q}], "*"];
Graphics[{t[z[[1]], {0, q}],t[z[[2]], {q, 0}, a, {0, -1}],t[z[[3]], {0, -q}, a, {-1, 0}],
t[z[[4]], {-q, 0}, a, {0, 1}]},ImageSize -> 500,BaseStyle -> {FontFamily -> "Courier", 21},
PlotRange -> 34,ImagePadding -> 22])

Beispiele

f["Hello Code Golf World!"]
f["January, February, March,April, May, June, July"]
f["This text is normal, this goes downwards,this is upside-down, and this is upwards"]

Perl + Regexes: 104 (101 + 3)

(Zählcode + Schalter)

Hier ist eine Lösung mit netten Regexes und ein bisschen Perl:

perl -plE'$w=($l=length)/2-($h=int$l/4);s/..{$w}\K.*/"\n".reverse$&/e;$"x=--$w;s/.\K(.*)(.)$/$"$2\n$1/while--$h'

Dies funktioniert nur auf einer Eingangsleitung korrekt .

Inspiriert von memowe, aber im Wesentlichen ohne Arrays.

PostScript (106)

Dies ist inspiriert von der Mathematica-Lösung von Dude .

0{= =
4 add dup
t length mod 4
lt{-90 rotate}if}0[0 3 -3 0 9 9]concat
0 moveto/Courier 5 selectfont
t kshow

Bei Ghostscript nennt man das so

gs -st=hello! boxtext.ps

Es erzeugt eine Ausgabe wie.

Hiermit kshowwerden die Glyphen einzeln angezeigt. Nachdem genügend Glyphen für eine Seite angezeigt wurden, wird alles um -90 Grad gedreht, bevor mit den verbleibenden Glyphen fortgefahren wird.

Um zu wissen, wann genügend Glyphen auf der Seite angezeigt wurden, erhöhen wir jedes Mal, wenn eine Glyphe angezeigt wird, einen Zähler um 4. Wenn der Zählerwert modulo the string length kleiner als 4 ist, dann wissen wir, dass wir drehen müssen:

char  counter  mod 6  compared to 4
 h       4       4          =
 e       8       2          <   => rotate
 l      12       0          <   => rotate
 l      16       4          =
 o      20       2          <   => rotate
 !      24       0          <   => rotate

Kommentierter und nicht Golf spielender Quellcode:

0                      % n
{%kshow                % n char1 char2
  = =                  % n
  4 add dup            % n' n'
  t length mod         % n' (n' mod t_length)
  4 lt                 % n' bool
  {-90 rotate}if       % n'
}                      % n kshowProc
% First 0 for moveto. We add it here to take 
% advantage of the surrounding self delimiting tokens.
0                      % n kshowProc 0
% We change the graphics state so that the drawn
% text is at a nice size and not off screen.
[0 3 -3 0 9 9]concat   % n kshowProc 0
0                      % n kshowProc 0 0
moveto                 % n kshowProc
/Courier 5 selectfont  % n kshowProc
t                      % n kshowProc text
kshow                  % n

Python 2.x: 137

Ich bin neu im Code-Golfen und bin mir ziemlich sicher, dass dies verbessert werden kann ...

def s(t):c=len(t);w=1+c/4;h=(c-w-w)/2;u=w+h;n='\n';print t[:w]+n+n.join(map(((w-2)*' ').join,zip(t[:w+u-1:-1],t[w:u])))+n+t[w+u-1:u-1:-1]

Visueller Testcode:

from itertools import chain
from string import letters
for i in range(8,101,2):
    t = ''.join(chain(letters))[:i]
    print '%d: %s' % (i, t)
    s(t)
    print '-----'

Etwas von Interesse: Diese Lösung hängt von der ganzzahligen Mathematik ab. Wenn Sie nur symbolisch rechnen, werden Sie feststellen, h=(c-w-w)/2 => h=w-2dass bei jedem anderen Ergebnis zwei Zeichen links unten fehlen, wenn Sie dieses Ergebnis ersetzen.

K 84

{-1'(*r;((|r 3),\:(w-2)#" "),'r 1;|(r:(0,+\(w;h;w;h:_(l-2*w:-_-(1+(l:#x)%4))%2))_x)2);}

.

k){-1'(*r;((|r 3),\:(w-2)#" "),'r 1;|(r:(0,+\(w;h;w;h:_(l-2*w:-_-(1+(l:#x)%4))%2))_x)2);}"HelloWorld"
Hell
d  o
lroW

k){-1'(*r;((|r 3),\:(w-2)#" "),'r 1;|(r:(0,+\(w;h;w;h:_(l-2*w:-_-(1+(l:#x)%4))%2))_x)2);}"Hellooooooooooooooo Worlddddd!"
Hellooooo
!       o
d       o
d       o
d       o
d       o
d       o
lroW oooo

Scala (135)

Das folgende Snippet setzt voraus, dass es xdie zu formatierende Zeichenfolge enthält und in die Scala REPL eingefügt werden soll:

val (h,w)=((x.size+3)/4,println(_:Any));val s=x.grouped(h)toSeq;w(s(0));for((l,r)<-s(1)zip(s(3)reverse))w(r+" "*(h-2)+l);w(s(2)reverse)

Wenn Sie Scala nicht installiert haben, können Sie es mit diesem Online-Scala-Interpreter schnell überprüfen: http://www.simplyscala.com/ . Fügen Sie einfach den folgenden Text ein und drücken Sie auswerten:

val x="HelloWorld"
val (h,w)=((x.size+3)/4,println(_:Any));val s=x.grouped(h)toSeq;w(s(0));for((l,r)<-s(1)zip(s(3)reverse))w(r+" "*(h-2)+l);w(s(2)reverse)

Python 3 (120)

s=input()
n=len(s)
h=n//4
q=(n+2)//4-1
p=print
p(s[:q+2])
for i in range(1,h):p(s[n-i]+' '*q+s[q+1+i])
p(s[n-h:q+h:-1])

Prüfung

Eingang:

abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz

Ausgabe:

abcdefghijklmn
z            o
y            p
x            q
w            r
v            s
u            t
t            u
s            v
r            w
q            x
p            y
o            z
nmlkjihgfedcba

PHP (149)

Der zu druckende Text sollte sich in einer Variablen mit dem Namen befinden $x.

@$s=substr;echo$s($x,-$w=($l=strlen($x)/2)-$h=$i=$l-2>>1).'
';while($i--)echo$x[$l+$i].str_repeat(' ',$w-2).$x[$h-$i-1].'
';echo$s(strrev($x),$l,$w);

Python2.7 (99)

t=''.join(raw_input().split())
u=len(t)/2-1
print t[:u]+"\n"+t[-1]+" "*(u-2)+t[u]+"\n"+t[-2:u:-1]

Bearbeiten: Es verstößt anscheinend gegen die Regel, die maximale Fläche im Inneren einzuschließen.

JAVA - 320

public class A{
public static void main(String[] a){
String s=a[0];
int l=s.length(),h=l/2,f=h-1,i=0;       
for(i=0;i<f;i++)
System.out.print(s.charAt(i));
System.out.print("\n"+s.charAt(l-1));
for(i=0;i<f-2;i++)
System.out.print(" ");
System.out.println(s.charAt(h-1));
for(i=l-2;i>h-1;i--)
System.out.print(s.charAt(i));}}

Hinweis: - Die Eingabe erfolgt über die Befehlszeile

Eingabe: - HelloWorld

Ausgabe : -

Hell
d  o
lroW

Eingabe: - abcdefghijklmnopqrstuvwxyz

Ausgabe : -

abcdefghijkl
z          m
yxwvutsrqpon