Ваша программа получает в качестве ввода текст длиной не менее 8 символов и всегда состоящий из четного числа символов. (нет необходимости оценивать правильность ввода).

Ваша цель - отобразить этот текст в виде прямоугольника. Например, HelloWorldв качестве входных данных отобразить

Hell
d  o
lroW

Правила:

• Текст вращается по часовой стрелке (начальная позиция, как вам нравится)
• Он сформирует закрытый прямоугольник, стороны 1 символ шириной.
• Прямоугольник должен охватывать наибольшую площадь внутри. (просто чтобы исключить тривиальный ответ отображения текста в две строки)
• Никакие другие символы не печатаются, кроме самого текста и необходимых пробелов и перевода строки.

Как код-гольф, выигрывает самый короткий код.

_{Победитель выбирается не ранее, чем через 10 дней после первого правильного ответа.}

GolfScript, 56 53 40 38 символов

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

Вы можете проверить скрипт онлайн .

PostScript 50 двоичный, 113 ASCII

Это использует графический вывод. Hexdump программы с использованием двоичных токенов:

$ 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

Загрузите, чтобы попробовать . Используя Ghostscript, передаваемый текст может быть передан в программу следующим образом:

gs -st=helloworld textRect_binary.ps 

Графический вывод выглядит так:

Тот же код с использованием токенов ASCII выглядит следующим образом:

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

Стратегия заключается в том, xyshowчтобы определить, куда мы движемся после показа каждого персонажа, прежде чем показывать следующий. Мы начинаем в левом нижнем углу, двигаясь по часовой стрелке, то есть сначала вверх, затем вправо, затем вниз, затем влево. Мы всегда перемещаемся на 9 единиц, поэтому сначала у нас есть относительное движение 0 9, потом 9 0, потом 0 -9, потом -9 0. Мы можем перейти от одной пары этих чисел к следующей с помощью последовательности exch neg.

Нам нужно построить массив, xyshowкоторый будет содержать эти пары чисел, по одной паре для каждого символа. Это означает, что если у нас в helloworldкачестве примера строка, которая имеет 10 символов, мы хотим подняться дважды, затем вправо трижды, затем вниз дважды и влево трижды. Мы получим эти значения (два и три), разделив длину строки на 8, один раз округлив до пола, один раз до потолка.

Итак, мы копируем 0 9дважды, затем переключаемся на относительные координаты x / y exch neg, копируем их трижды и так далее.

Этот закомментированный код показывает, что происходит в стеке:

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

Я новичок в Ruby, и это мой первый гольф-код. Я обратил внимание на реализацию memlow в Perl и попытался сделать ее версию на Ruby. Это 112 100 символов и предполагает, что вы присваиваете строку x. Ждем встречи с другими.

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

Отредактировано для реализации предложений. Я думаю, что сейчас 100 символов. Спасибо ребята!

Perl (124 118 109 + 3 = 112)

Раньше это было довольно просто. Все параметры командной строки учитываются как 1 символ каждый.

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

Пример:

$ 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

Редактировать : это основной переписать предыдущий код. Он работает практически так же, но теперь принимает в качестве входных данных строку длиной <120 символов и автоматически измеряет квадрат.

Это может все еще быть немного игрой в гольф, но не уменьшится до размера более ранних, и изнурительных версий.

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

Примеры

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)

(считая код + переключатели)

Вот решение с использованием хороших регулярных выражений и небольшого количества 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'

Это будет правильно работать только на одной входной линии.

Вдохновленный memowe, но по существу без каких-либо массивов.

PostScript (106)

Это вдохновлено решением Mathematica чувак .

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

С Ghostscript это называется

gs -st=hello! boxtext.ps

Это производит вывод как.

Он использует, kshowчтобы показать глифы один за другим. После того, как будет показано достаточное количество глифов для одной стороны, все поворачивается на -90 градусов, прежде чем продолжить работу с оставшимися глифами.

Чтобы знать, когда на стороне было показано достаточное количество глифов, мы увеличиваем счетчик на 4 каждый раз, когда отображается глиф. Если значение счетчика по модулю длины строки меньше 4, то мы знаем, что нужно повернуть:

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

Прокомментированный исходный код без гольфа:

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

Я новичок в коде игры в гольф и уверен, что это можно улучшить ...

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]

Код визуального тестирования:

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

Что-то интересное: это решение зависит от целочисленной математики. Если вы просто выполните математику символически, вы найдете это h=(c-w-w)/2 => h=w-2, но если вы замените этот результат, в каждом другом результате будут пропущены два нижних левых символа.

К, 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

Скала (135)

Следующий фрагмент предполагает, что xсодержит строку для форматирования и должен быть вставлен в scala REPL:

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)

Если у вас не установлена ​​программа Scala, вы можете быстро проверить ее с помощью онлайн-переводчика Scala: http://www.simplyscala.com/ . Просто вставьте следующий текст и нажмите «оценить»:

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)

Питон 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])

Тестовое задание

вход:

abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz

выход:

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)

Текст для печати должен быть в переменной с именем $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]

Редактировать: Это очевидно нарушает правило охвата максимальной площади внутри.

ЯВА - 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));}}

Примечание: - Ввод взят из командной строки

Вход: - HelloWorld

Выход : -

Hell
d  o
lroW

Входные данные: - abcdefghijklmnopqrstuvwxyz

Выход : -

abcdefghijkl
z          m
yxwvutsrqpon