Le défi

Étant donné une chaîne, affichez le texte sous la forme d'un carré.

Vous pouvez supposer que le texte tiendra toujours dans un carré et qu'il ne s'agira jamais d'une chaîne vide.

Vous pouvez également supposer qu'il n'aura jamais de nouvelles lignes.

Exemple

Input:
Hi, world

Output:
Hi,
 wo
rld

Cas de 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

Règles

• C'est le golf de code , donc la réponse la plus courte en octets gagne! Tiebreaker est la réponse la plus votée.
• Les failles standard sont interdites.

Vim, 59, 57 , 48 octets / touches

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

Étant donné que V est rétrocompatible, vous pouvez l' essayer en ligne!

J'ai reçu au hasard un vote positif sur cette réponse, alors j'ai relu. Mes compétences en golf sur vim ont considérablement augmenté au cours des 7 derniers mois, j'ai donc vu que cette réponse était très mal jouée. Celui-ci est bien meilleur.

Brainfuck , 116 112 bytes

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

Essayez-le en ligne!

Coffre-fort dans les saveurs de BF qui ne masque pas les cellules avec 256, ne prend pas en charge les octets nuls.

Supprimez les flèches de droite initiales si l'arôme prend en charge la mémoire négative pour 4 octets enregistrés.

Explication

Le programme est divisé en 3 étapes:

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

Étape 1

Dans cette étape, nous mettons tous les personnages sur la bande, tout en comptant le nombre de caractères.

Ceci est la bande pour l'entrée abcdefghiaprès cette bande:

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

C'est 009le comte.

Pour chaque caractère, nous déplaçons le premier zéro à gauche [<], puis nous ajoutons un au nombre <<+>>>, puis nous nous déplaçons vers le zéro le plus [>]à droite pour nous préparer pour le caractère suivant.

Étape 2

Cette étape fait la racine carrée de la longueur stockée dans la deuxième cellule.

Il continue de soustraire 1, 3, 5, 7, ...jusqu'à ce que le nombre atteigne zéro, tout en vérifiant le nombre d'itérations.

Cela fonctionne parce que les nombres carrés peuvent être exprimés comme 1 + 3 + 5 + ....

Étape 3

Désigner la racine carrée de la longueur trouvée ci-dessus comme n.

Cette étape produit des ncaractères à la fois, puis génère une nouvelle ligne, jusqu'à ce que la bande soit effacée.

Python 2, 55 octets

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

05AB1E , 5 octets

Dgtô«

Essayez-le en ligne!

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 octets

tnX^e!

Essayez-le en ligne!

Explication

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ée, 8 7 octets

sLƽ$j⁷

Enregistré un octet grâce à @ Dennis .

Essayez-le en ligne.

Explication

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 octets

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

44 octets dans Firefox Nightly 43-46 uniquement (a **été introduit quelque temps entre Firefox Nightly 42 et 43 et gun paramètre distinct a été supprimé quelque temps entre Firefox Nightly 46 et 47):

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

J, 9 octets

$~,~@%:@#

Il s'agit d'un crochet monadique sur la chaîne d'entrée:

$~ ,~@%:@#

La bonne dent est une série de compositions:

,~ @ %: @ #

La gauche est un verbe de mise en forme, commuté de telle sorte qu'il fonctionne au format crochet.

Voici quelques résultats intermédiaires:

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

Dans les mots:

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

C, 64 octets

Appelez f()avec la chaîne au carré.

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

Essayez-le sur ideone .

Perl, 23 + 4 ( -pFdrapeaux) = 27 octets

-2 octets grâce à @DomHastings
-1 octets grâce à @DomHastings

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

Essayez-le en ligne!

Expansions : calcule la racine carrée (appelons-la Spour l'explication) de la taille de l'entrée (ce sera toujours un entier) ( @Fest utilisée dans un contexte scalaire, retournant ainsi sa taille), puis ajoutez une nouvelle ligne après chaque bloc de Spersonnages.

zsh, 36 octets

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

Prend l'entrée comme argument de ligne de commande, renvoie à 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 octets

Merci à @quartata de m'avoir informé de la fonction racine carrée

Dgtô¶ý

Essayez-le en ligne!

Explication

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 octets

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

Ancienne version:

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

CJam , 8 octets

l_,mQ/N*

Essayez-le en ligne!

Explication

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 octets

jcs@lQ2Q

Essayez-le en ligne

Comment ça marche

    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 octets

⊢⍴⍨2⍴.5*⍨≢

Explication:

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

Tests:

      (⊢⍴⍨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 octets (non concurrent)

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

J'ai ajouté la .chunkfonction il y a quelque temps mais je l'ai supprimée lors de la transition vers le nouveau format stdlib et j'ai oublié de la rajouter. Cheddar a un sqrtopérateur dédié mais **.5est plus court

Essayez-le en ligne!

Explication

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

Utilitaires Bash + GNU, 25

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

Pas si différent de la réponse de @ Doorknob , mais dcc'est un moyen plus court pour obtenir la racine carrée.

𝔼𝕊𝕄𝕚𝕟, 11 caractères / 14 octets

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Généré à l'aide de ce code (exécuté dans la console du navigateur de l'interpréteur):

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

Brainfuck, 83 octets

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

Essayez-le en ligne!

Cela utilise la même idée que la réponse de Leaky Nun . Il a demandé de l'aide pour jouer au golf dans le chat, puis m'a suggéré d'ajouter ceci comme nouvelle réponse. (En fait, ce que j'ai écrit dans le chat était une solution de 84 octets très similaire à cela.)

Par souci de comparaison, un supplément >est nécessaire au début pour les implémentations brainfuck qui n'autorisent pas les adresses mémoire négatives.

Comme prévu, cela trouve la longueur de l'entrée, puis prend la racine carrée, puis imprime les lignes en conséquence. Il profite de carrés parfaits étant des sommes partielles de 1 + 3 + 5 ....

Brain-Flak , 110 96 octets

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

Essayez-le en ligne!

Deuxième solution, 96 octets

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

Essayez-le en ligne!

Explication

Ici, j'explique la première solution, les deux sont de la même longueur mais j'aime la première car elle est plus fraîche et utilise de belles astuces.

La partie la plus importante du code est une fonction de racine carrée modifiée que j'ai écrite il y a quelque temps. La version originale était

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

Et cela fonctionne, mais nous voulons en fait deux copies de la racine carrée négative. Pourquoi? Nous avons besoin de deux copies car nous parcourons la chaîne à deux niveaux, un pour créer les lignes et un pour compter le nombre de lignes. Nous voulons qu'il soit négatif parce que boucler avec des négatifs est moins cher.

Pour rendre ce négatif, nous nous déplaçons de [...]sorte qu'il ressemble à ceci

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

Pour faire deux copies, nous changeons lorsque des pops se produisent

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

Maintenant que nous avons ce bit, nous pouvons l'associer à une hauteur de pile pour obtenir le premier morceau de code dont nous avons besoin.

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

Nous passons au offstack parce que notre fonction racine carrée a besoin de deux zéros gratuits pour le calcul, et parce que cela rend les choses un peu moins chères dans le futur en termes de changement de pile.

Maintenant, nous construisons la boucle principale

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

C'est assez simple, nous bouclons n fois à chaque fois en déplaçant n éléments et en les coiffant d'une nouvelle ligne (ASCII 10).

Une fois la boucle terminée, nous devons inverser l'ordre de notre sortie, nous plaçons donc simplement une construction inverse standard.

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

PHP, 51 octets

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

Perl 6 , 38 octets

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

Explication:

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

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

Puisque les variables sont cassées, je devrais passer des variables via l'application lambda.

En outre, il s'avère que même si les variables fonctionnaient, il serait encore plus court d'utiliser l'application lambda.

Usage

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

Pyke, 5 octets

l,fnJ

Essayez-le ici!

Java 1.7, 110 octets

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

Essayez!(Ideone)

J'ai essayé une autre approche avec une fonction renvoyant le résultat sous forme de chaîne, mais le simple fait de déclarer la chaîne et l'instruction de retour est déjà plus cher (en nombre d'octets) que l'instruction print.

Je dois aimer la verbosité de Java ... :)

R , 59 54 octets

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

Essayez-le en ligne!

Imprime avec une nouvelle ligne de fin. Étonnamment court, compte tenu de la mauvaise gestion des chaînes par R.

PowerShell, 56 58 61 octets

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

Rubis -p , 40 33 30 octets

-7 octets de @Jordan.

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

Essayez-le en ligne!

Convexe , 7 octets

_,mQ/N*

Essayez-le en ligne!

Fait amusant:

_,mQ/\* fonctionne également sur TIO en raison de son fonctionnement.

Comment ai-je oublié de créer une racine carrée de 1 caractère?