Die Herausforderung

Geben Sie bei einer gegebenen Zeichenfolge den Text in Form eines Quadrats aus.

Sie können davon ausgehen, dass der Text immer in ein Quadrat passt und niemals eine leere Zeichenfolge ist.

Sie können auch davon ausgehen, dass es niemals Zeilenumbrüche geben wird.

Beispiel

Input:
Hi, world

Output:
Hi,
 wo
rld

Testfälle

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

Regeln

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes! Tiebreaker ist die am besten bewertete Antwort.
• Standardlücken sind verboten.

Vim, 59, 57 , 48 Bytes / Tastenanschläge

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

Da V abwärtskompatibel ist, können Sie es online ausprobieren!

Ich habe zufällig eine positive Bewertung für diese Antwort erhalten, also habe ich sie noch einmal durchgesehen. Meine Vim-Golf-Fähigkeiten haben in den letzten 7 Monaten stark zugenommen, so dass ich sah, dass diese Antwort sehr schlecht golfen war. Dieser ist viel besser.

Brainfuck , 116 112 Bytes

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

Probieren Sie es online!

Sicher in Geschmacksrichtungen von BF, die die Zellen nicht maskieren 256, unterstützt keine Null-Bytes.

Entfernen Sie die anfänglichen Pfeile nach rechts, wenn die Variante einen negativen Speicher für 4 gespeicherte Bytes unterstützt.

Erläuterung

Das Programm ist in 3 Phasen unterteilt:

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

Bühne 1

In dieser Phase werden alle Zeichen auf das Band geschrieben, während die Anzahl der Zeichen gezählt wird.

Dies ist das Band für die Eingabe abcdefghinach diesem Band:

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

Das 009ist die Zählung.

Für jedes Zeichen verschieben wir die erste Null links [<]und addieren dann eine zur Zählung <<+>>>und bewegen uns dann ganz rechts zur Null, [>]um uns für das nächste Zeichen vorzubereiten .

Stufe 2

In dieser Phase wird die Quadratwurzel der in der zweiten Zelle gespeicherten Länge erstellt.

Es wird 1, 3, 5, 7, ...solange subtrahiert, bis die Zahl Null erreicht, während die Anzahl der Iterationen überprüft wird.

Es funktioniert, weil quadratische Zahlen als ausgedrückt werden können 1 + 3 + 5 + ....

Stufe 3

Bezeichnen Sie die Quadratwurzel der oben angegebenen Länge als n.

Diese Stufe gibt nZeichen auf einmal aus und gibt dann eine neue Zeile aus, bis das Band gelöscht ist.

Python 2, 55 Bytes

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

05AB1E , 5 Bytes

Dgtô«

Probieren Sie es 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!

Probieren Sie es online!

Erläuterung

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

Gelee, 8 7 Bytes

sLƽ$j⁷

Ein Byte dank @ Dennis gespeichert .

Probieren Sie es online aus.

Erläuterung

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 Bytes nur in Firefox Nightly 43-46 ( **wurde irgendwann zwischen Firefox Nightly 42 und 43 eingeführt und gals separater Parameter wurde irgendwann zwischen Firefox Nightly 46 und 47 entfernt):

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

J 9 Bytes

$~,~@%:@#

Dies ist ein monadischer Hook über der Eingabezeichenfolge:

$~ ,~@%:@#

Der richtige Ton ist eine Reihe von Kompositionen:

,~ @ %: @ #

Das linke ist ein formendes Verb, das so geschaltet ist, dass es im Hook-Format funktioniert.

Hier sind einige Zwischenergebnisse:

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

In Worten:

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

C 64 Bytes

Rufe f()mit der Schnur zum Quadrat.

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

Probiere es auf ideone aus .

Perl, 23 + 4 ( -pFFlags) = 27 Bytes

-2 Bytes dank @DomHastings
-1 Bytes dank @DomHastings

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

Probieren Sie es online!

Erweiterungen : Berechnet die Quadratwurzel (nennen wir sie Sfür die Erklärung) der Größe der Eingabe (es wird immer eine Ganzzahl sein) ( @Fwird im skalaren Kontext verwendet und gibt somit ihre Größe zurück) und fügt nach jedem Block von eine neue Zeile hinzu SZeichen.

zsh, 36 Bytes

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

Nimmt Eingaben als Befehlszeilenargument und gibt sie an STDOUT aus.

                      $#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

Vielen Dank an @quartata, dass Sie mich über die Quadratwurzelfunktion informiert haben

Dgtô¶ý

Probieren Sie es online!

Erläuterung

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

Alte Version:

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

CJam , 8 Bytes

l_,mQ/N*

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online aus

Wie es funktioniert

    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*⍨≢

Erläuterung:

         ≢   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 Bytes (nicht konkurrierend)

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

Ich habe die .chunkFunktion vor einiger Zeit hinzugefügt , sie aber beim Übergang zum neuen stdlib-Format entfernt und vergessen, sie erneut hinzuzufügen. Cheddar hat einen engagierten sqrtOperator, **.5ist aber kürzer

Probieren Sie es online!

Erläuterung

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

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

Nicht so unterschiedlich zu @ Doorknobs Antwort , aber es dcist ein kürzerer Weg, um die Quadratwurzel zu erhalten.

𝔼𝕊𝕄𝕚𝕟 11 Zeichen / 14 Bytes

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Mit diesem Code generiert (in der Browserkonsole des Interpreters ausführen):

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

Brainfuck, 83 Bytes

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

Probieren Sie es online!

Dies verwendet die gleiche Idee wie die Antwort von Leaky Nun . Er bat um Hilfe beim Golfspielen im Chat und schlug mir vor, dies als neue Antwort hinzuzufügen. (Eigentlich war das, was ich im Chat geschrieben habe, eine 84-Byte-Lösung, die dieser sehr ähnlich ist.)

Zum Vergleich >wird zu Beginn ein zusätzliches Element für Brainfuck-Implementierungen benötigt, die keine negativen Speicheradressen zulassen.

Wie erwartet wird die Länge der Eingabe ermittelt, die Quadratwurzel verwendet und die Zeilen entsprechend gedruckt. Es nutzt perfekte Quadrate als Teilsummen von 1 + 3 + 5 ....

Brain-Flak , 110 96 Bytes

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

Probieren Sie es online!

Zweite Lösung, 96 Bytes

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

Probieren Sie es online!

Erläuterung

Hier erkläre ich die erste Lösung, beide sind gleich lang, aber ich mag die erste, weil sie kühler ist und einige nette Tricks anwendet.

Der wichtigste Teil des Codes ist eine modifizierte Quadratwurzelfunktion, die ich vor einiger Zeit geschrieben habe. Die ursprüngliche Version war

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

Und das funktioniert, aber wir wollen eigentlich zwei Kopien der negativen Quadratwurzel. Warum? Wir benötigen zwei Kopien, da wir die Zeichenfolge auf zwei Ebenen durchlaufen, eine, um die Zeilen zu erstellen, und eine, um die Anzahl der Zeilen zu zählen. Wir wollen, dass es negativ ist, weil das Schleifen mit Negativen billiger ist.

Um dieses Negativ zu machen, bewegen wir uns [...]so, dass es so aussieht

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

Um zwei Kopien zu erstellen, ändern wir, wenn Pops auftreten

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

Jetzt, da wir das Bit haben, können wir es mit einer Stapelhöhe zusammenfügen, um den ersten Code zu erhalten, den wir brauchen.

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

Wir begeben uns in den Offstack, weil unsere Quadratwurzelfunktion zwei freie Nullen für die Berechnung benötigt und weil dies die Dinge in der Zukunft im Hinblick auf die Stapelumschaltung ein wenig billiger macht.

Nun konstruieren wir die Hauptschleife

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

Dies ist ziemlich einfach, wir wiederholen n-mal jedes Mal, wenn wir n Elemente verschieben und mit einer neuen Zeile abschließen (ASCII 10).

Sobald die Schleife beendet ist, müssen wir die Reihenfolge unserer Ausgabe umkehren, damit wir nur ein Standard-Umkehrkonstrukt verwenden.

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

PHP, 51 Bytes

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

Perl 6 , 38 Bytes

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

Erläuterung:

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

Da Variablen defekt sind, müsste ich Variablen durch Lambda-Anwendung übergeben.

Es stellt sich auch heraus, dass die Verwendung der Lambda-Anwendung kürzer wäre, selbst wenn die Variablen funktionieren würden.

Verwendung

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

Probieren Sie es hier aus!

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

Versuch es! (Ideone)

Ich habe einen anderen Ansatz mit einer Funktion versucht, die das Ergebnis als String zurückgibt, aber nur den String deklarieren zu müssen und die return-Anweisung ist bereits teurer (byte-count-weise) als die print-Anweisung.

Muss Javas Ausführlichkeit lieben ... :)

R , 59 54 Bytes

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

Probieren Sie es online!

Druckt mit einem nachgestellten Zeilenumbruch. Überraschend kurz, wenn man bedenkt, wie schlecht R mit Saiten umgeht.

PowerShell, 56 58 61 Bytes

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

Ruby -p , 40 33 30 Bytes

-7 Bytes von @Jordan.

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

Probieren Sie es online!

Konvex , 7 Bytes

_,mQ/N*

Probieren Sie es online!

Lustige Tatsache:

_,mQ/\* funktioniert auch mit TIO, weil es so funktioniert.

Wie habe ich vergessen, eine 1-Zeichen-Quadratwurzel-Operation durchzuführen?