Соревнование

Учитывая строку, выведите текст в форме квадрата.

Вы можете предположить, что текст всегда будет помещаться в квадрат и что он никогда не будет пустой строкой.

Вы также можете предположить, что никогда не будет новых строк.

пример

Input:
Hi, world

Output:
Hi,
 wo
rld

Тестовые случаи

Input:
Hi, world! Hello

Output:
Hi, 
worl
d! H
ello

Input:
Lorem ipsum dolor sit amt

Output:
Lorem
 ipsu
m dol
or si
t amt

Input:
H

Output:
H

правила

• Это код-гольф , поэтому выигрывает самый короткий ответ в байтах! Ответ Tiebreaker является наиболее одобренным.
• Стандартные лазейки запрещены.

Vim, 59, 57 , 48 байт / нажатий клавиш

$:let @q=float2nr(sqrt(col('.')))."|li<C-v><cr><C-v><esc>@q"<cr>@q

Поскольку V имеет обратную совместимость, вы можете попробовать это онлайн!

Я случайно получил ответ на этот ответ, поэтому я снова просмотрел его. Мои навыки игры в vim-гольф значительно выросли за последние 7 месяцев, поэтому я увидел, что этот ответ был очень неудачным. Этот намного лучше.

Brainfuck , 116 112 байтов

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

Попробуйте онлайн!

Безопасный в ароматах BF, который не маскирует клетки 256, не поддерживает нулевые байты.

Удалите начальные стрелки вправо, если аромат поддерживает отрицательную память на 4 байта сохранено.

объяснение

Программа делится на 3 этапа:

Stage 1: >>>>,[[<]<<+>>>[>],]<[<]
Stage 2: <+<[>>+<[-<-<+>>]<<++[->>+<<]>]>[-]>>
Stage 3: [<[->.[-]<[->+<]<+[->+<]>>]++++++++++.[-]<[->+<]>>]

Этап 1

На этом этапе мы помещаем все символы на ленту, сохраняя при этом количество символов.

Это лента для ввода abcdefghiпосле этой ленты:

000 009 000 000 095 096 097 098 099 100 101 102 103
             ^

009 граф.

Для каждого символа мы перемещаем первый ноль слева [<]и затем добавляем один к счетчику <<+>>>, а затем перемещаемся к крайнему правому нулю[>] правому чтобы подготовиться к следующему символу.

Этап 2

Этот этап делает квадратный корень из длины, хранящейся во второй ячейке.

Это продолжает вычитать 1, 3, 5, 7, ... до тех пор, пока число не достигнет нуля, сохраняя при этом количество итераций.

Это работает, потому что квадратные числа могут быть выражены как 1 + 3 + 5 + ... .

Этап 3

Обозначим квадратный корень найденной выше длины как n .

Этот этап выводит nсимволы за раз, а затем выводит новую строку, пока лента не будет очищена.

Python 2, 55 байт

s=input()
n=int(len(s)**.5)
while s:print s[:n];s=s[n:]

05AB1E , 5 байтов

Dgtô«

Попробуйте онлайн!

D    duplicate a (implicit input)
g    length of a
t    square root of a
ô    push a split in pieces of b
«    join by newlines (implicit output)

MATL , 6 байтов

tnX^e!

Попробуйте онлайн!

объяснение

t     % Take input implicitly. Push another copy
n     % Get number of elements of the copy
X^    % Take square root
e     % Reshape the input into that number of rows, in column-major order
      % (which means: down, then across)
!     % Transpose so that text reads horizontally. Implicitly display

Желе, 8 7 байт

sLƽ$j⁷

Сохраненный байт благодаря @ Деннис .

Попробуйте онлайн.

объяснение

sLƽ$j⁷  Input: string S
    $    Monadic chain
 L         Get the length of S
  ƽ       Take the integer square root of it, call it n
s        Split S into chunks of size n
     j⁷  Join using newline

JavaScript (ES7), 49 байт

s=>s.match(eval(`/.{${s.length**.5}}/g`)).join`
`

44 байта только в Firefox Nightly 43-46 ( **был введен некоторое время между Firefox Nightly 42 и 43 и gкак отдельный параметр был удален некоторое время между Firefox Nightly 46 и 47):

s=>s.match(`.{${s.length**.5}}`,`g`).join`
`

J, 9 байт

$~,~@%:@#

Это монадический хук над строкой ввода:

$~ ,~@%:@#

Правильный зубец - это серия композиций:

,~ @ %: @ #

Слева - формирующий глагол, переключаемый таким образом, чтобы он работал в формате ловушки.

Вот некоторые промежуточные результаты:

   # 'hiya'
4
   %:@# 'hiya'
2
   ,~@%:@# 'hiya'
2 2

В словах:

   size =: #
   sqrt =: %:
   dup =: ,~
   on =: @
   shape =: $~
   block =: shape dup on sqrt on size
   block 'Hello, World! :)'
Hell
o, W
orld
! :)

C, 64 байта

Позвоните f()со строкой в ​​квадрат.

m;f(char*s){for(m=sqrt(strlen(s));*s;s+=m)printf("%.*s\n",m,s);}

Попробуйте это на Ideone .

Perl, 23 + 4 ( -pFфлаги) = 27 байт

-2 байта благодаря @DomHastings
-1 байтов благодаря @DomHastings

$==sqrt@F;s/.{$=}/$&
/g

Попробуйте онлайн!

Расширения : вычисляет квадратный корень (давайте назовем его Sдля объяснения) размера входных данных (это всегда будет целое число) ( @Fиспользуется в скалярном контексте, таким образом, возвращая его размер), затем добавьте новую строку после каждого блока Sсимволы.

зш, 36 байт

fold -`sed s/.$//<<<$[$#1**.5]`<<<$1

Принимает ввод в качестве аргумента командной строки, выводит в STDOUT.

                      $#1             get the length of the input string
                    $[   **.5]        take it to the .5 power (sqrt)
                 <<<                  and pass the result to
       sed s/.$//                     sed, which removes the last character
                                      this is because sqrt(9) is 3. instead of 3
     -`                       `       give the result as a command line flag to
fold                                  the fold util, which wraps at nth column
                               <<<$1  pass the input as input to fold

05AB1E , 8 6 байт

Спасибо @quartata за сообщение о функции квадратного корня

Dgtô¶ý

Попробуйте онлайн!

объяснение

D     Implicit input. Duplicate
g     Number of elements
t     Square root
ô     Split into chunks of that length
¶     Push newline character
ý     Join list by newlines. Implicit display

Python, 94 75 71 65 63 байта

import re;lambda r:"\n".join(re.findall("."*int(len(r)**.5),r))

Старая версия:

lambda r:"\n".join(map("".join,zip(*[iter(r)]*int(len(r)**.5))))

CJam , 8 байт

l_,mQ/N*

Попробуйте онлайн!

объяснение

l     e# Read line from input
_,    e# Duplicate. Get length 
mQ    e# Integer square root
/     e# Split into pieces of that size
N*    e# Join by newline. Implicitly display

Pyth, 8 байт

jcs@lQ2Q

Попробуйте онлайн

Как это работает

    lQ     length of input
   @  2    square root
  s        floor
 c     Q   chop input into that many equal pieces
j          join on newline

Dyalog APL, 10 байт

⊢⍴⍨2⍴.5*⍨≢

Объяснение:

         ≢   length of the argument   
     .5*⍨    square root 
   2⍴        reshape that to a length-2 vector
⊢⍴⍨          reshape the input by that vector

тесты:

      (⊢⍴⍨2⍴.5*⍨≢)'Hi, world'
Hi,
 wo
rld
      (⊢⍴⍨2⍴.5*⍨≢)'Hi, world! Hello'
Hi, 
worl
d! H
ello
      (⊢⍴⍨2⍴.5*⍨≢)'Lorem ipsum dolor sit amt'
Lorem
 ipsu
m dol
or si
t amt
      (⊢⍴⍨2⍴.5*⍨≢) 'H'
H

Чеддер, 27 байтов (не конкурирующий)

s->s.chunk(s.len**.5).vfuse

Я добавил .chunkфункцию некоторое время назад, но удалил ее при переходе на новый формат stdlib и забыл добавить ее заново. У Чеддера есть специальный sqrtоператор, но **.5он короче

Попробуйте онлайн!

объяснение

s ->              // Function with argument s
    s.chunk(      // Chunk it into pieces of size...
      s.len ** .5 // Square root of length.
    ).vfuse       // Vertical-fuse. Join on newlines

Утилиты Bash + GNU, 25

fold -`dc -e${#1}vp`<<<$1

Не очень отличается от ответа @ Doorknob , но dcэто более короткий способ получить квадратный корень.

𝔼𝕊𝕄𝕚𝕟, 11 символов / 14 байтов

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Генерируется с помощью этого кода (запускается в консоли браузера переводчика):

c.value=`Ѩ${alias(_,'chunk')}(ï,√ ïꝈ⸩${alias(Array.prototype,'mjoin')}⬮`

Brainfuck, 83 байта

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

Попробуйте онлайн!

Это использует ту же идею, что и Leaky Nun's ответ . Он попросил помочь в игре в гольф в чате, а затем предложил добавить это в качестве нового ответа. (На самом деле то, что я написал в чате, было 84-байтовым решением, очень похожим на это.)

Для сравнения, дополнительный > вначале требуется для реализаций мозгового бездействия, которые не допускают отрицательных адресов памяти.

Как и ожидалось, он находит длину ввода, затем принимает квадратный корень, а затем печатает строки соответственно. Он использует в качестве идеальных квадратов частичные суммы 1 + 3 + 5 ....

Brain-Flak , 110 96 байт

([]<>){({}{}(({}[()])))}{}{({}()<(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>)>)}{}{}{({}<>)<>}<>

Попробуйте онлайн!

Второй раствор, 96 байт

(([]<>)<{({}({})({}[()]))}{}>){({}(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>))}{}{}{({}<>)<>}<>

Попробуйте онлайн!

объяснение

Здесь я объясняю первое решение, оба имеют одинаковую длину, но мне нравится первое, потому что оно круче и использует несколько приятных трюков.

Самая важная часть кода - это модифицированная функция квадратного корня, которую я написал некоторое время назад. Оригинальная версия была

{({}[({})({}())])}{}

И это работает, но мы на самом деле хотим две копии отрицательного квадратного корня. Зачем? Нам нужны две копии, потому что мы перебираем строку на двух уровнях: один для создания строк и один для подсчета количества строк. Мы хотим, чтобы оно было отрицательным, поскольку циклы с отрицательными значениями дешевле.

Чтобы сделать это негативным, мы перемещаемся [...]так, чтобы это выглядело так

{({}({})({}[()]))}{}

Чтобы сделать две копии, мы меняемся при появлении попсов

{({}{}(({}[()])))}{}

Теперь, когда у нас есть этот бит, мы можем собрать его вместе с высотой стека, чтобы получить первый кусок кода, который нам нужен.

([]<>){({}{}(({}[()])))}{}

Мы переходим в стэк, потому что нашей функции квадратного корня требуются два свободных нуля для вычислений, и потому что она делает вещи немного дешевле в будущем с точки зрения переключения стеков.

Теперь мы строим основной цикл

{({}()<(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>)>)}{}{}

Это довольно просто, мы зацикливаемся n раз каждый раз, перемещая n элементов и закрывая их новой строкой (ASCII 10).

Как только цикл завершен, нам нужно изменить порядок вывода, поэтому мы просто добавим стандартную обратную конструкцию.

{({}<>)<>}<>

PHP, 51 байт

<?=join("
",str_split($x=$argv[1],strlen($x)**.5));

Perl 6 , 38 байт

$_=get;.put for .comb: .chars.sqrt.Int

Объяснение:

$_ = get;          # get a single line of input


$_.put             # print with trailing newline

for                # every one of the following:

$_.comb:           # the input split into

$_.chars.sqrt.Int  # chunks of the appropriate size

Чеддер, 57 байт

n->(m->(|>m).map(i->n.slice(i*m,i*m+m)).vfuse)(n.len**.5)

Поскольку переменные не работают, мне придется передавать переменные через лямбда-приложение.

Кроме того, оказывается, что даже если бы переменные работали, все равно было бы короче использовать лямбда-приложение.

использование

cheddar> (n->(m->(|>m).map(i->n.slice(i*m,i*m+m)).vfuse)(n.len**.5))("abcd")
"ab
cd"

Пайк, 5 байт

l,fnJ

Попробуй это здесь!

Java 1.7, 110 байт

void f(String s){for(int i=-1,k=(int)Math.sqrt(s.length());++i<k;)System.out.println(s.substring(i*k,i*k+k));}

Попытайся! (Ideone)

Я попробовал другой подход с функцией, возвращающей результат в виде строки, но просто нужно объявить строку и оператор return уже дороже (в байтовом выражении), чем оператор print.

Должен любить многословие Java ... :)

R , 59 54 байта

function(s)write(el(strsplit(s,'')),1,nchar(s)^.5,,'')

Попробуйте онлайн!

Печать с завершающим переводом строки. Удивительно коротко, учитывая, как плохо R обрабатывает струны.

PowerShell, 56 58 61 байт

param($i)$i-replace".{$([Math]::Sqrt($i.Length))}",'$&
'

Руби -p , 40 33 30 байт

-7 байт от @Jordan.

gsub(/#{?.*~/$/**0.5}/){$&+$/}

Попробуйте онлайн!

Выпуклый , 7 байт

_,mQ/N*

Попробуйте онлайн!

Интересный факт:

_,mQ/\* также работает на TIO из-за того, как он работает.

Как я забыл сделать операцию с квадратным корнем из 1 символа?