El reto

Dada una cadena, genera el texto en forma de cuadrado.

Puede suponer que el texto siempre encajará en un cuadrado y que nunca será una cadena vacía.

También puede suponer que nunca tendrá nuevas líneas.

Ejemplo

Input:
Hi, world

Output:
Hi,
 wo
rld

Casos de prueba

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

Reglas

• Este es el código de golf , ¡así que la respuesta más corta en bytes gana! Tiebreaker es la respuesta más votada.
• Las lagunas estándar están prohibidas.

Vim, 59, 57 , 48 bytes / pulsaciones de teclas

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

Como V es compatible con versiones anteriores, ¡puede probarlo en línea!

Recibí un voto al azar sobre esta respuesta, así que volví a revisarla. Mis habilidades de vim-golf han aumentado mucho en los últimos 7 meses, por lo que vi que esta respuesta fue muy pobre. Éste es mucho mejor.

Brainfuck , 116 112 bytes

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

Pruébalo en línea!

Seguro en sabores de BF que no enmascara las celdas 256, no admite bytes nulos.

Elimine las flechas iniciales hacia la derecha si el sabor admite memoria negativa para 4 bytes guardados.

Explicación

El programa se divide en 3 etapas:

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

Nivel 1

En esta etapa, colocamos todos los caracteres en la cinta, mientras contamos la cantidad de caracteres.

Esta es la cinta para la entrada abcdefghidespués de esta cinta:

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

El 009es el conde.

Para cada personaje, movemos el primer cero a la izquierda [<]y luego agregamos uno al conteo <<+>>>, y luego nos movemos al cero más a la derecha [>]para prepararnos para el siguiente personaje.

Etapa 2

Esta etapa hace la raíz cuadrada de la longitud almacenada en la segunda celda.

Sigue restando 1, 3, 5, 7, ...hasta que el número llega a cero, mientras se mantiene el control del número de iteraciones.

Funciona porque los números cuadrados se pueden expresar como 1 + 3 + 5 + ....

Etapa 3

Denote la raíz cuadrada de la longitud que se encuentra arriba como n.

Esta etapa genera ncaracteres a la vez y luego genera una nueva línea, hasta que se borra la cinta.

Python 2, 55 bytes

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

05AB1E , 5 bytes

Dgtô«

Pruébalo en línea!

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!

Pruébalo en línea!

Explicación

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

Jalea, 8 7 bytes

sLƽ$j⁷

Salvó un byte gracias a @ Dennis .

Pruébalo en línea.

Explicación

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 solo en Firefox Nightly 43-46 ( **se introdujo en algún momento entre Firefox Nightly 42 y 43 y gcomo un parámetro separado se eliminó en algún momento entre Firefox Nightly 46 y 47):

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

J, 9 bytes

$~,~@%:@#

Este es un enlace monádico sobre la cadena de entrada:

$~ ,~@%:@#

El diente correcto es una serie de composiciones:

,~ @ %: @ #

El izquierdo es un verbo de configuración, cambiado de manera que funcione en el formato de gancho.

Aquí hay algunos resultados intermedios:

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

En palabras:

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

C, 64 bytes

Llama f()con la cuerda al cuadrado.

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

Pruébalo con ideone .

Perl, 23 + 4 ( -pFbanderas) = ​​27 bytes

-2 bytes gracias a @DomHastings
-1 bytes gracias a @DomHastings

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

Pruébalo en línea!

Expansiones : calcula la raíz cuadrada (llamemos Spara la explicación) del tamaño de la entrada (siempre será un número entero) ( @Fse usa en contexto escalar, devolviendo así su tamaño), luego agrega una nueva línea después de cada bloque de Scaracteres.

zsh, 36 bytes

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

Toma la entrada como un argumento de línea de comando, sale a 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

Gracias a @quartata por informarme sobre la función de raíz cuadrada

Dgtô¶ý

Pruébalo en línea!

Explicación

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

Versión antigua:

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

CJam , 8 bytes

l_,mQ/N*

Pruébalo en línea!

Explicació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 bytes

jcs@lQ2Q

Pruébalo en línea

Cómo 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*⍨≢

Explicación:

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

Pruebas:

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

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

.chunkAgregué la función hace un tiempo, pero la eliminé en la transición al nuevo formato stdlib y olvidé volver a agregarla. Cheddar tiene un sqrtoperador dedicado pero **.5es más corto

Pruébalo en línea!

Explicación

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 utilidades, 25

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

No es tan diferente a la respuesta de @ Doorknob , pero dces una forma más corta de obtener la raíz cuadrada.

𝔼𝕊𝕄𝕚𝕟, 11 caracteres / 14 bytes

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Generado usando este código (ejecutado en la consola del navegador del intérprete):

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

Brainfuck, 83 bytes

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

Pruébalo en línea!

Utiliza la misma idea que la respuesta de Leaky Nun . Pidió ayuda para jugar golf en el chat, luego sugirió que agregue esto como una nueva respuesta. (En realidad, lo que escribí en el chat fue una solución de 84 bytes muy similar a esta).

En aras de la comparación, un extra > se necesita al principio para las implementaciones de brainfuck que no permiten direcciones de memoria negativas.

Como se esperaba, esto encuentra la longitud de la entrada, luego toma la raíz cuadrada, luego imprime las líneas en consecuencia. Aprovecha que los cuadrados perfectos son sumas parciales de 1 + 3 + 5 ....

Brain-Flak , 110 96 bytes

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

Pruébalo en línea!

Segunda solución, 96 bytes

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

Pruébalo en línea!

Explicación

Aquí explico la primera solución, ambas tienen la misma longitud, pero me gusta la primera porque es más fresca y emplea algunos buenos trucos.

La parte más importante del código es una función de raíz cuadrada modificada que escribí hace algún tiempo. La versión original era

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

Y esto funciona, pero en realidad queremos dos copias de la raíz cuadrada negativa. ¿Por qué? Necesitamos dos copias porque estamos recorriendo la cadena en dos niveles, uno para hacer las líneas y otro para contar el número de líneas. Queremos que sea negativo porque el bucle con negativos es más barato.

Para hacer esto negativo, nos movemos [...]para que se vea así

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

Para hacer dos copias, cambiamos cuando aparecen pops

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

Ahora que tenemos ese bit podemos juntarlo con una altura de pila para obtener el primer fragmento de código que necesitamos.

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

Nos movemos a la pila porque nuestra función de raíz cuadrada necesita dos ceros libres para el cálculo, y porque hace que las cosas sean un poco más baratas en el futuro en términos de cambio de pila.

Ahora construimos el bucle principal

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

Esto es bastante sencillo, hacemos un bucle n veces cada vez que movemos n elementos y lo limitamos con una nueva línea (ASCII 10).

Una vez que se realiza el bucle, necesitamos invertir el orden de nuestra salida, por lo que simplemente añadimos una construcción inversa estándar.

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

PHP, 51 bytes

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

Perl 6 , 38 bytes

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

Explicación:

$_ = 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 las variables están rotas, tendría que pasar variables a través de la aplicación lambda.

Además, resulta que incluso si las variables funcionaran, aún sería más corto usar la aplicación 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

Pruébalo aquí!

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

¡Intentalo! (Ideona)

Intenté otro enfoque con una función que devuelve el resultado como una cadena, pero solo tener que declarar la cadena y la declaración de devolución ya es más costosa (byte-count-wise) que la declaración de impresión.

Tengo que amar la verbosidad de Java ... :)

R , 59 54 bytes

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

Pruébalo en línea!

Imprime con una nueva línea final. Sorprendentemente corto, considerando lo mal que R maneja las cuerdas.

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}/){$&+$/}

Pruébalo en línea!

Convexo , 7 bytes

_,mQ/N*

Pruébalo en línea!

Hecho de la diversión:

_,mQ/\* También funciona en TIO debido a cómo funciona.

¿Cómo he olvidado hacer una operación de raíz cuadrada de 1 carácter?