La sfida

Data una stringa, genera il testo a forma di quadrato.

Puoi presumere che il testo si adatterà sempre in un quadrato e che non sarà mai una stringa vuota.

Puoi anche presumere che non avrà mai nuove righe.

Esempio

Input:
Hi, world

Output:
Hi,
 wo
rld

Casi test

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

Regole

• Questo è code-golf , quindi vince la risposta più breve in byte! Tiebreaker è la risposta più votata.
• Sono vietate le scappatoie standard.

Vim, 59, 57 , 48 byte / sequenze di tasti

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

Poiché V è retrocompatibile, puoi provarlo online!

Ho ricevuto casualmente un voto su questa risposta, quindi l'ho esaminata di nuovo. Le mie capacità di golf vim sono notevolmente aumentate negli ultimi 7 mesi, quindi ho visto che questa risposta era molto scarsamente giocata. Questo è molto meglio.

Brainfuck , 116 112 byte

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

Provalo online!

Sicuro nei sapori di BF che non maschera le celle con 256, non supporta byte null.

Rimuovere le frecce iniziali a destra se il sapore supporta la memoria negativa per 4 byte salvati.

Spiegazione

Il programma è diviso in 3 fasi:

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

Fase 1

In questa fase, mettiamo tutti i personaggi sul nastro, tenendo conto del numero di personaggi.

Questo è il nastro per l'input abcdefghidopo questo nastro:

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

Il 009è il conteggio.

Per ogni personaggio, spostiamo il primo zero a sinistra, [<]quindi ne aggiungiamo uno al conteggio <<+>>>, quindi ci spostiamo sullo zero più [>]a destra per prepararci al personaggio successivo.

Fase 2

Questa fase esegue la radice quadrata della lunghezza memorizzata nella seconda cella.

Continua a sottrarre 1, 3, 5, 7, ...fino a quando il numero raggiunge lo zero, mantenendo il controllo del numero di iterazioni.

Funziona perché i numeri quadrati possono essere espressi come 1 + 3 + 5 + ....

Fase 3

Indica la radice quadrata della lunghezza trovata sopra come n.

Questo stage genera i ncaratteri alla volta, quindi emette una nuova riga, fino a quando il nastro non viene cancellato.

Python 2, 55 byte

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

05AB1E , 5 byte

Dgtô«

Provalo 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 byte

tnX^e!

Provalo online!

Spiegazione

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

Gelatina, 8 7 byte

sLƽ$j⁷

Salvato un byte grazie a @ Dennis .

Provalo online.

Spiegazione

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 byte

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

44 byte solo in Firefox Nightly 43-46 (è **stato introdotto da tempo tra Firefox Nightly 42 e 43 e gcome parametro separato è stato rimosso da tempo tra Firefox Nightly 46 e 47):

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

J, 9 byte

$~,~@%:@#

Questo è un hook monadico sulla stringa di input:

$~ ,~@%:@#

Il dente giusto è una serie di composizioni:

,~ @ %: @ #

La sinistra è un verbo modellante, commutato in modo tale che funzioni nel formato hook.

Ecco alcuni risultati intermedi:

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

In parole:

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

C, 64 byte

Chiama f()con la stringa da quadrare.

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

Provalo su ideone .

Perl, 23 + 4 ( -pFflag) = 27 byte

-2 byte grazie a @DomHastings
-1 byte grazie a @DomHastings

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

Provalo online!

Espansioni : calcola la radice quadrata (chiamiamola Sper la spiegazione) della dimensione dell'input (sarà sempre un numero intero) ( @Fviene usata nel contesto scalare, restituendone così la dimensione), quindi aggiungi una nuova riga dopo ogni blocco di Spersonaggi.

zsh, 36 byte

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

Prende l'input come argomento della riga di comando, l'output su 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 byte

Grazie a @quartata per avermi fatto conoscere la funzione di radice quadrata

Dgtô¶ý

Provalo online!

Spiegazione

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 byte

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

Vecchia versione:

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

CJam , 8 byte

l_,mQ/N*

Provalo online!

Spiegazione

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 byte

jcs@lQ2Q

Provalo online

Come funziona

    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 byte

⊢⍴⍨2⍴.5*⍨≢

Spiegazione:

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

test:

      (⊢⍴⍨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 byte (non concorrenti)

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

Ho aggiunto la .chunkfunzione qualche tempo fa ma l'ho rimossa nel passaggio al nuovo formato stdlib e ho dimenticato di aggiungerla di nuovo. Cheddar ha un sqrtoperatore dedicato ma **.5è più corto

Provalo online!

Spiegazione

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à Bash + GNU, 25

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

Non così diverso dalla risposta di @ Doorknob , ma dcè un modo più breve per ottenere la radice quadrata.

𝔼𝕊𝕄𝕚𝕟, 11 caratteri / 14 byte

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Generato utilizzando questo codice (eseguito nella console del browser dell'interprete):

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

Brainfuck, 83 byte

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

Provalo online!

Questo usa la stessa idea della risposta di Leaky Nun . Mi ha chiesto aiuto per giocare a golf in chat, poi mi ha suggerito di aggiungere questo come nuova risposta. (In realtà quello che ho scritto in chat era una soluzione a 84 byte molto simile a questa.)

Per motivi di confronto, all'inizio >è necessario un extra per le implementazioni di Brainfuck che non consentono indirizzi di memoria negativi.

Come previsto, trova la lunghezza dell'input, quindi prende la radice quadrata, quindi stampa le linee di conseguenza. Sfrutta i quadrati perfetti essendo somme parziali di 1 + 3 + 5 ....

Brain-Flak , 110 96 byte

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

Provalo online!

Seconda soluzione, 96 byte

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

Provalo online!

Spiegazione

Qui spiego la prima soluzione, entrambe hanno la stessa lunghezza ma mi piace la prima perché è più fresca e impiega alcuni trucchi.

La parte più importante del codice è una funzione di radice quadrata modificata che ho scritto qualche tempo fa. La versione originale era

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

E questo funziona, ma in realtà vogliamo due copie della radice quadrata negativa. Perché? Abbiamo bisogno di due copie perché stiamo eseguendo il looping della stringa a due livelli, uno per creare le righe e uno per contare il numero di righe. Vogliamo che sia negativo perché il ciclo con i negativi è più economico.

Per rendere questo negativo ci muoviamo in [...]modo che assomigli a questo

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

Per fare due copie cambiamo quando si verificano pop

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

Ora che abbiamo quel bit possiamo metterlo insieme con un'altezza dello stack per ottenere il primo pezzo di codice di cui abbiamo bisogno.

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

Ci spostiamo nello stack perché la nostra funzione di radice quadrata ha bisogno di due zeri liberi per il calcolo e perché rende le cose un po 'più economiche in futuro in termini di cambio di stack.

Ora costruiamo il ciclo principale

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

Questo è piuttosto semplice, ci muoviamo n volte ogni volta spostando n elementi e tappandolo con una nuova linea (ASCII 10).

Una volta terminato il loop, abbiamo bisogno di invertire l'ordine del nostro output, quindi puntiamo su un costrutto inverso standard.

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

PHP, 51 byte

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

Perl 6 , 38 byte

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

Spiegazione:

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

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

Poiché le variabili sono rotte, dovrei passare le variabili tramite l'applicazione lambda.

Inoltre, risulta che anche se le variabili funzionassero, sarebbe comunque più breve utilizzare l'applicazione lambda.

uso

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

Pyke, 5 byte

l,fnJ

Provalo qui!

Java 1.7, 110 byte

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

Provalo! (Ideone)

Ho provato un altro approccio con una funzione che restituisce il risultato come stringa, ma devo semplicemente dichiarare la stringa e l'istruzione return è già più costosa (in termini di byte) rispetto all'istruzione print.

Devo amare la verbosità di Java ... :)

R , 59 54 byte

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

Provalo online!

Stampa con una nuova riga finale. Sorprendentemente breve, considerando quanto R gestisce le stringhe.

PowerShell, 56 58 61 byte

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

Rubino -p , 40 33 30 byte

-7 byte da @Jordan.

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

Provalo online!

Convesso , 7 byte

_,mQ/N*

Provalo online!

Fatto divertente:

_,mQ/\* funziona anche su TIO a causa di come funziona.

Come ho dimenticato di fare un'operazione di radice quadrata da 1 carattere?