도전

문자열이 주어지면 사각형 모양으로 텍스트를 출력하십시오.

텍스트가 항상 square에 맞고 빈 문자열이 아니라고 가정 할 수 있습니다 .

또한 줄 바꿈이 없을 것이라고 가정 할 수도 있습니다.

예

Input:
Hi, world

Output:
Hi,
 wo
rld

테스트 사례

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

규칙

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 승리합니다! Tiebreaker가 가장 큰 답입니다.
• 표준 허점은 금지되어 있습니다.

Vim, 59, 57 , 48 바이트 / 키 스트로크

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

V는 이전 버전과 호환 되므로 온라인으로 사용해 볼 수 있습니다!

나는이 답변에 대한 찬성 투표를 무작위로 받았으므로 다시 살펴 보았습니다. 지난 7 개월 동안 저의 vim-golfing 기술이 크게 향상 되었기 때문에이 답변의 골프 수준이 매우 낮았습니다. 이것은 훨씬 낫습니다.

브레인 퍽 , 116 112 바이트

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

온라인으로 사용해보십시오!

로 셀을 마스킹하지 않는 BF의 풍미에서 안전하며 256null 바이트를 지원하지 않습니다.

플레이버가 4 바이트 동안 네거티브 메모리를 지원하는 경우 초기 오른쪽 화살표를 제거하십시오.

설명

이 프로그램은 3 단계로 나뉩니다.

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

스테이지 1

이 단계에서는 모든 문자를 테이프에 넣고 문자 수를 계산합니다.

이 테이프 다음에 입력 abcdefghi할 테이프입니다.

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

는 009계수이다.

각 문자에 대해 왼쪽의 첫 번째 0 을 이동 한 다음 [<]count에 1을 더한 <<+>>>다음 가장 오른쪽의 0 [>]으로 이동 하여 다음 문자를 준비합니다.

2 단계

이 단계는 두 번째 셀에 저장된 길이의 제곱근을 수행합니다.

1, 3, 5, 7, ...반복 횟수를 확인하면서 숫자가 0에 도달 할 때까지 빼기를 계속합니다.

사각형 숫자는로 표현 될 수 있기 때문에 작동합니다 1 + 3 + 5 + ....

3 단계

위에서 찾은 길이의 제곱근을 나타냅니다 n.

이 단계 n에서는 한 번에 문자를 출력 한 다음 테이프가 지워질 때까지 줄 바꿈을 출력합니다.

파이썬 2, 55 바이트

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

05AB1E , 5 바이트

Dgtô«

온라인으로 사용해보십시오!

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 바이트

tnX^e!

온라인으로 사용해보십시오!

설명

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

젤리, 8 7 바이트

sLƽ$j⁷

@ Dennis 덕분에 바이트를 절약했습니다 .

온라인으로 사용해보십시오.

설명

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

자바 스크립트 (ES7), 49 바이트

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

Firefox Nightly 43-46에서만 44 바이트 ( **Firefox Nightly 42와 43 사이에 일정 시간 도입 g되었으며 Firefox Nightly 46과 47 사이에 별도의 매개 변수가 제거됨) :

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

J, 9 바이트

$~,~@%:@#

이것은 입력 문자열에 대한 모나 딕 후크입니다.

$~ ,~@%:@#

올바른 타인은 일련의 구성입니다.

,~ @ %: @ #

왼쪽은 성형 동사이며 후크 형식으로 작동하도록 전환되었습니다.

중간 결과는 다음과 같습니다.

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

한마디로 :

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

C, 64 bytes

Call f() with the string to square.

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

Try it on ideone.

Perl, 23 + 4 (-pF flags) = 27 bytes

-2 bytes thanks to @DomHastings
-1 bytes thanks to @DomHastings

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

Try it online!

Expanations : computes the square root (lets call it S for the explanation) of the size of the input (it will be always be an integer) (@F is used in scalar context, thus returning its size), then add a newline after each bloc of S characters.

zsh, 36 bytes

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

Takes input as a command line argument, outputs to 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

Thanks to @quartata for letting me know about the square-root function

Dgtô¶ý

Try it online!

Explanation

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

Old version:

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

CJam, 8 bytes

l_,mQ/N*

Try it online!

Explanation

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

Try it online

How it works

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

Explanation:

         ≢   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 (non-competing)

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

I added the .chunk function a while ago but I removed it in the transition to the new stdlib format and forgot to re-add it. Cheddar has a dedicated sqrt operator but **.5 is shorter

Try it online!

Explanation

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

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

Not so different to @Doorknob's answer, but dc is a shorter way to get the square root.

𝔼𝕊𝕄𝕚𝕟, 11 chars / 14 bytes

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Generated using this code (run in the interpreter's browser console):

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

Brainfuck, 83 bytes

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

Try it online!

This uses the same idea as Leaky Nun's answer. He asked for help golfing it in chat, then suggested that I add this as a new answer. (Actually what I wrote in chat was an 84-byte solution very similar to this.)

For the sake of comparison, an extra > is needed at the beginning for brainfuck implementations that don't allow negative memory addresses.

As expected, this finds the length of the input, then takes the square root, then prints the lines accordingly. It takes advantage of perfect squares being partial sums of 1 + 3 + 5 ....

Brain-Flak, 110 96 bytes

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

Try it online!

Second solution, 96 bytes

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

Try it online!

Explanation

Here I explain the first solution, both are the same length but I like the first one because it is cooler and employs some nice tricks.

The most important part of the code is a modified square root function I wrote some time ago. The original version was

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

And this works, but we actually want two copies of the negative square root. Why? We need two copies because we are looping through the string at two levels, one to make the lines and one to count the number of lines. We want it to be negative because looping with negatives is cheaper.

To make this negative we move around the [...] so it looks like this

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

To make two copies we change when pops occur

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

Now that we have that bit we can put it together with a stack height to get the first chunk of code we need.

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

We move to the offstack because our square root function needs two free zeros for computation, and because it makes stuff a little bit cheaper int he future in terms of stack switching.

Now we construct the main loop

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

This is pretty straight forward, we loop n times each time moving n items and capping it with a new line (ASCII 10).

Once the loop is done we need to reverse the order of our output so we just tack on a standard reverse construct.

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

PHP, 51 bytes

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

Perl 6, 38 bytes

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

Explanation:

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

Since variables are broken, I would have to pass in variables through lambda application.

Also, it turns out that even if variables worked, it would still be shorter to use lambda application.

Usage

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

Try it here!

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

Try it! (Ideone)

I tried another approach with a function returning the result as a string, but just having to declare the string and the return statement is already more expensive (byte-count-wise) than the print statement.

Gotta love Java's verbosity... :)

R, 59 54 bytes

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

Try it online!

Prints with a trailing newline. Surprisingly short, considering how badly R handles strings.

PowerShell, 56 58 61 bytes

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

Ruby -p, 40 33 30 bytes

-7 bytes from @Jordan.

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

Try it online!

Convex, 7 bytes

_,mQ/N*

Try it online!

Fun fact:

_,mQ/\* also works on TIO due to how it works.

How have I forgotten to make a 1-char square root op?