O desafio

Dada uma sequência, produza o texto na forma de um quadrado.

Você pode supor que o texto sempre caiba em um quadrado e que nunca será uma string vazia.

Você também pode assumir que nunca haverá novas linhas.

Exemplo

Input:
Hi, world

Output:
Hi,
 wo
rld

Casos de teste

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

Regras

• Isso é código-golfe , então a resposta mais curta em bytes vence! O desempate é a resposta mais votada.
• As brechas padrão são proibidas.

Vim, 59, 57 , 48 bytes / pressionamentos de tecla

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

Como o V é compatível com versões anteriores, você pode experimentá-lo online!

Recebi aleatoriamente um voto positivo nesta resposta, por isso examinei-a novamente. Minhas habilidades de vim-golfe aumentaram bastante nos últimos sete meses, então vi que essa resposta era muito pouco praticada. Esse é muito melhor.

Brainfuck , 116 112 bytes

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

Experimente online!

Seguro nos tipos de BF que não mascaram as células 256, não suportam bytes nulos.

Remova as setas iniciais à direita se o sabor suportar memória negativa por 4 bytes salvos.

Explicação

O programa está dividido em 3 etapas:

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

Estágio 1

Nesta fase, colocamos todos os caracteres na fita, mantendo a contagem do número de caracteres.

Esta é a fita para a entrada abcdefghiapós esta fita:

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

O 009é a contagem.

Para cada personagem, movemos o primeiro zero à esquerda [<]e, em seguida, adicionamos um à contagem <<+>>>; depois, movemos para o zero mais à direita [>]para nos preparar para o próximo caractere.

Etapa 2

Esse estágio faz a raiz quadrada do comprimento armazenado na segunda célula.

Ele continua subtraindo 1, 3, 5, 7, ...até o número chegar a zero, enquanto verifica o número de iterações.

Funciona porque os números quadrados podem ser expressos como 1 + 3 + 5 + ....

Etapa 3

Indique a raiz quadrada do comprimento encontrado acima como n.

Esse estágio gera ncaracteres de cada vez e, em seguida, gera uma nova linha, até que a fita seja limpa.

Python 2, 55 bytes

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

05AB1E , 5 bytes

Dgtô«

Experimente online!

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 bytes

tnX^e!

Experimente online!

Explicação

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

Geléia, 8 7 bytes

sLƽ$j⁷

Guardou um byte graças a @ Dennis .

Experimente online.

Explicação

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 bytes

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

44 bytes apenas no Firefox Nightly 43-46 ( **foi introduzido algum tempo entre o Firefox Nightly 42 e 43 e gcomo um parâmetro separado foi removido algum tempo entre o Firefox Nightly 46 e 47):

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

J, 9 bytes

$~,~@%:@#

Este é um gancho monádico sobre a sequência de entrada:

$~ ,~@%:@#

O dente certo é uma série de composições:

,~ @ %: @ #

A esquerda é um verbo de modelagem, alternado para que funcione no formato de gancho.

Aqui estão alguns resultados intermediários:

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

Em palavras:

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

C, 64 bytes

Ligue f()com a corda para o quadrado.

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

Experimente em ideone .

Perl, 23 + 4 ( -pFsinalizadores) = 27 bytes

-2 bytes graças a @DomHastings
-1 bytes graças a @DomHastings

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

Experimente online!

Expanações : calcula a raiz quadrada (vamos chamá-la Sde explicação) do tamanho da entrada (sempre será um número inteiro) ( @Fé usado no contexto escalar, retornando assim seu tamanho) e, em seguida, adicione uma nova linha após cada bloco de Spersonagens.

zsh, 36 bytes

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

Recebe a entrada como argumento da linha de comando e gera para 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 bytes

Obrigado a @quartata por me informar sobre a função de raiz quadrada

Dgtô¶ý

Experimente online!

Explicação

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 bytes

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

Versão antiga:

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

CJam , 8 bytes

l_,mQ/N*

Experimente online!

Explicação

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

Pitão, 8 bytes

jcs@lQ2Q

Experimente online

Como funciona

    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 bytes

⊢⍴⍨2⍴.5*⍨≢

Explicação:

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

Testes:

      (⊢⍴⍨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

Cheddar, 27 bytes (não concorrente)

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

Eu adicionei a .chunkfunção há algum tempo, mas a removi na transição para o novo formato stdlib e esqueci de adicioná-la novamente. Cheddar tem um sqrtoperador dedicado , mas **.5é mais curto

Experimente online!

Explicação

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

Utilitários Bash + GNU, 25

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

Não é tão diferente da resposta de @ Doorknob , mas dcé uma maneira mais curta de obter a raiz quadrada.

11, 11 caracteres / 14 bytes

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Gerado usando este código (executado no console do navegador do intérprete):

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

Brainfuck, 83 bytes

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

Experimente online!

Isso usa a mesma idéia que a resposta de Leaky Nun . Ele pediu ajuda para jogar no chat e sugeriu que eu adicionasse isso como uma nova resposta. (Na verdade, o que escrevi no chat foi uma solução de 84 bytes muito semelhante a isso.)

Para fins de comparação, >é necessário um extra no início para implementações que não permitem endereços de memória negativos.

Como esperado, ele encontra o comprimento da entrada, pega a raiz quadrada e imprime as linhas de acordo. Aproveita os quadrados perfeitos sendo somas parciais de 1 + 3 + 5 ....

Brain-Flak , 110 96 bytes

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

Experimente online!

Segunda solução, 96 bytes

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

Experimente online!

Explicação

Aqui eu explico a primeira solução, ambas têm o mesmo comprimento, mas eu gosto da primeira porque é mais fria e emprega alguns truques legais.

A parte mais importante do código é uma função de raiz quadrada modificada que escrevi há algum tempo. A versão original era

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

E isso funciona, mas na verdade queremos duas cópias da raiz quadrada negativa. Por quê? Precisamos de duas cópias, porque estamos percorrendo a cadeia em dois níveis, um para fazer as linhas e outro para contar o número de linhas. Queremos que seja negativo, porque fazer loop com negativos é mais barato.

Para tornar isso negativo, movemos o cursor [...]para que fique assim

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

Para fazer duas cópias, mudamos quando ocorrem pops

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

Agora que temos esse pedaço, podemos montá-lo com uma altura de pilha para obter o primeiro pedaço de código necessário.

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

Passamos para o offstack porque nossa função de raiz quadrada precisa de dois zeros livres para o cálculo e porque torna as coisas um pouco mais baratas no futuro em termos de troca de pilha.

Agora construímos o loop principal

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

Isso é bastante simples: repetimos n vezes cada vez que movemos n itens e o limitamos com uma nova linha (ASCII 10).

Depois que o loop estiver concluído, precisamos reverter a ordem de nossa saída, para que apenas aderamos a uma construção reversa padrão.

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

PHP, 51 bytes

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

Perl 6 , 38 bytes

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

Explicação:

$_ = 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

Cheddar, 57 bytes

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

Como as variáveis ​​estão quebradas, eu precisaria passar as variáveis ​​pelo aplicativo lambda.

Além disso, verifica-se que, mesmo que as variáveis ​​funcionassem, ainda seria mais curto usar o aplicativo lambda.

Uso

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

Pyke, 5 bytes

l,fnJ

Experimente aqui!

Java 1.7, 110 bytes

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

Tente! (Ideona)

Tentei outra abordagem com uma função retornando o resultado como uma string, mas apenas ter que declarar a string e a declaração de retorno já é mais cara (contagem de bytes) do que a declaração de impressão.

Tenho que amar a verbosidade do Java ... :)

R , 59 54 bytes

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

Experimente online!

Imprime com uma nova linha à direita. Surpreendentemente curto, considerando o quanto R lida com seqüências de caracteres.

PowerShell, 56 58 61 bytes

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

Ruby -p , 40 33 30 bytes

-7 bytes de @Jordan.

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

Experimente online!

Convexo , 7 bytes

_,mQ/N*

Experimente online!

Fato engraçado:

_,mQ/\* também funciona no TIO devido a como ele funciona.

Como eu esqueci de fazer uma operação com raiz quadrada de 1 caractere?