Các thách thức

Cho một chuỗi, xuất văn bản theo hình vuông.

Bạn có thể giả định rằng văn bản sẽ luôn nằm gọn trong một hình vuông và nó sẽ không bao giờ là một chuỗi trống.

Bạn cũng có thể cho rằng nó sẽ không bao giờ có dòng mới.

Thí dụ

Input:
Hi, world

Output:
Hi,
 wo
rld

Các trường hợp thử nghiệm

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

Quy tắc

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng! Tiebreaker là câu trả lời nâng cao nhất.
• Sơ hở tiêu chuẩn bị cấm.

Vim, 59, 57 , 48 byte / tổ hợp phím

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

Vì V tương thích ngược, bạn có thể dùng thử trực tuyến!

Tôi ngẫu nhiên nhận được một upvote về câu trả lời này, vì vậy tôi nhìn qua nó một lần nữa. Kỹ năng chơi golf vim của tôi đã tăng lên rất nhiều trong 7 tháng qua, vì vậy tôi thấy rằng câu trả lời này rất kém khi chơi golf. Điều này là tốt hơn nhiều.

Brainfuck , 116 112 byte

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

Hãy thử trực tuyến!

An toàn trong các hương vị của BF không che dấu các ô 256, không hỗ trợ byte rỗng.

Xóa các mũi tên phải ban đầu nếu hương vị hỗ trợ bộ nhớ âm cho 4 byte được lưu.

Giải trình

Chương trình được chia thành 3 giai đoạn:

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

Giai đoạn 1

Trong giai đoạn này, chúng tôi đặt tất cả các ký tự lên băng, trong khi vẫn đếm số lượng ký tự.

Đây là băng cho đầu vào abcdefghisau băng này:

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

Là 009số đếm.

Đối với mỗi ký tự, chúng ta di chuyển số 0 đầu tiên bên trái [<]và sau đó thêm một số vào số đếm <<+>>>, sau đó di chuyển sang số 0 ngoài cùng bên phải [>]để sẵn sàng cho ký tự tiếp theo.

Giai đoạn 2

Giai đoạn này thực hiện căn bậc hai của chiều dài được lưu trữ trong ô thứ hai.

Nó tiếp tục trừ đi 1, 3, 5, 7, ...cho đến khi số đạt đến 0, trong khi vẫn kiểm tra số lần lặp.

Nó hoạt động vì số vuông có thể được thể hiện là 1 + 3 + 5 + ....

Giai đoạn 3

Suy ra căn bậc hai của độ dài tìm thấy ở trên như n.

Giai đoạn này xuất các nký tự tại một thời điểm, và sau đó xuất một dòng mới, cho đến khi băng được xóa.

Python 2, 55 byte

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

05AB1E , 5 byte

Dgtô«

Hãy thử trực tuyến!

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!

Hãy thử trực tuyến!

Giải trình

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

Thạch, 8 7 byte

sLƽ$j⁷

Đã lưu một byte nhờ @ Dennis .

Hãy thử trực tuyến.

Giải trình

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 chỉ trong Firefox Nightly 43-46 ( **được giới thiệu một thời gian giữa Firefox Nightly 42 và 43 và gvì một tham số riêng biệt đã bị xóa một thời gian giữa Firefox Nightly 46 và 47):

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

J, 9 byte

$~,~@%:@#

Đây là một hook đơn điệu trên chuỗi đầu vào:

$~ ,~@%:@#

Tine phải là một loạt các tác phẩm:

,~ @ %: @ #

Bên trái là một động từ định hình, được chuyển đổi sao cho nó hoạt động ở định dạng hook.

Dưới đây là một số kết quả trung gian:

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

Trong các từ:

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

C, 64 byte

Gọi f()với chuỗi để vuông.

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

Hãy thử nó trên ideone .

Perl, 23 + 4 ( -pFcờ) = 27 byte

-2 byte nhờ @DomHastings
-1 byte nhờ @DomHastings

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

Hãy thử trực tuyến!

Mở rộng : tính căn bậc hai (hãy gọi nó Sđể giải thích) về kích thước của đầu vào (nó sẽ luôn là một số nguyên) ( @Fđược sử dụng trong ngữ cảnh vô hướng, do đó trả về kích thước của nó), sau đó thêm một dòng mới sau mỗi khối Snhân vật.

zsh, 36 byte

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

Lấy đầu vào làm đối số dòng lệnh, xuất ra 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

Cảm ơn @quartata đã cho tôi biết về hàm căn bậc hai

Dgtô¶ý

Hãy thử trực tuyến!

Giải trình

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

Phiên bản cũ:

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

CJam , 8 byte

l_,mQ/N*

Hãy thử trực tuyến!

Giải trình

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

Bình thường, 8 byte

jcs@lQ2Q

Dùng thử trực tuyến

Làm thế nào nó hoạt động

    lQ     length of input
   @  2    square root
  s        floor
 c     Q   chop input into that many equal pieces
j          join on newline

APL Dyalog, 10 byte

⊢⍴⍨2⍴.5*⍨≢

Giải trình:

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

Các xét nghiệm:

      (⊢⍴⍨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 (không cạnh tranh)

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

Tôi đã thêm .chunkchức năng này một thời gian trước nhưng tôi đã loại bỏ nó trong quá trình chuyển đổi sang định dạng stdlib mới và quên thêm lại nó. Cheddar có một sqrtnhà điều hành chuyên dụng nhưng **.5ngắn hơn

Hãy thử trực tuyến!

Giải trình

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

Tiện ích Bash + GNU, 25

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

Không quá khác biệt với câu trả lời của @ Doorknob , nhưng dclà một cách ngắn hơn để lấy căn bậc hai.

, 11 ký tự / 14 byte

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Được tạo bằng mã này (chạy trong bảng điều khiển trình duyệt của trình thông dịch):

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

Brainfuck, 83 byte

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

Hãy thử trực tuyến!

Điều này sử dụng ý tưởng tương tự như câu trả lời của Leaky Nun . Anh ấy đã yêu cầu giúp đỡ chơi golf trong trò chuyện, sau đó đề nghị tôi thêm điều này như một câu trả lời mới. (Trên thực tế những gì tôi đã viết trong trò chuyện là một giải pháp 84 byte rất giống với điều này.)

Để dễ so sánh, >ban đầu cần có thêm một phần bổ sung cho việc triển khai brainfuck không cho phép các địa chỉ bộ nhớ tiêu cực.

Như mong đợi, điều này tìm thấy độ dài của đầu vào, sau đó lấy căn bậc hai, sau đó in các dòng tương ứng. Nó tận dụng các hình vuông hoàn hảo là một phần của 1 + 3 + 5 ....

Brain-Flak , 110 96 byte

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

Hãy thử trực tuyến!

Giải pháp thứ hai, 96 byte

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

Hãy thử trực tuyến!

Giải trình

Ở đây tôi giải thích giải pháp đầu tiên, cả hai đều có cùng độ dài nhưng tôi thích giải pháp đầu tiên vì nó mát hơn và sử dụng một số thủ thuật hay.

Phần quan trọng nhất của mã là một hàm căn bậc hai đã sửa đổi mà tôi đã viết cách đây một thời gian. Phiên bản gốc là

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

Và điều này hoạt động, nhưng chúng tôi thực sự muốn hai bản sao của căn bậc hai âm. Tại sao? Chúng tôi cần hai bản sao vì chúng tôi đang lặp qua chuỗi ở hai cấp độ, một để tạo các dòng và một để đếm số lượng dòng. Chúng tôi muốn nó là tiêu cực bởi vì lặp với tiêu cực là rẻ hơn.

Để làm cho điều này tiêu cực, chúng tôi di chuyển xung quanh [...]để nó trông như thế này

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

Để tạo hai bản sao, chúng tôi thay đổi khi xuất hiện

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

Bây giờ chúng ta có bit đó, chúng ta có thể đặt nó cùng với chiều cao ngăn xếp để có được đoạn mã đầu tiên chúng ta cần.

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

Chúng tôi chuyển sang offstack vì hàm căn bậc hai của chúng tôi cần hai số không miễn phí để tính toán, và vì nó làm cho công cụ rẻ hơn một chút so với tương lai về mặt chuyển đổi ngăn xếp.

Bây giờ chúng ta xây dựng vòng lặp chính

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

Điều này khá dễ dàng, chúng tôi lặp lại n lần mỗi lần di chuyển n mục và giới hạn nó bằng một dòng mới (ASCII 10).

Sau khi hoàn thành vòng lặp, chúng ta cần đảo ngược thứ tự đầu ra để chúng ta giải quyết một cấu trúc đảo ngược tiêu chuẩn.

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

PHP, 51 byte

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

Perl 6 , 38 byte

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

Giải trình:

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

Vì các biến bị hỏng, tôi sẽ phải chuyển các biến qua ứng dụng lambda.

Ngoài ra, nó chỉ ra rằng ngay cả khi các biến hoạt động, nó vẫn sẽ ngắn hơn để sử dụng ứng dụng lambda.

Sử dụng

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

Hãy thử nó ở đây!

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

Thử nó! (Ý)

Tôi đã thử một cách tiếp cận khác với một hàm trả về kết quả dưới dạng một chuỗi, nhưng chỉ cần khai báo chuỗi và câu lệnh return đã đắt hơn (byte-Count-khôn ngoan) so với câu lệnh in.

Phải yêu sự dài dòng của Java ... :)

R , 59 54 byte

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

Hãy thử trực tuyến!

In với một dòng mới. Đáng ngạc nhiên là ngắn, xem xét R xử lý chuỗi tồi tệ như thế nào.

PowerShell, 56 58 61 byte

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

Ruby -p , 40 33 30 byte

-7 byte từ @Jordan.

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

Hãy thử trực tuyến!

Lồi , 7 byte

_,mQ/N*

Hãy thử trực tuyến!

Sự thật thú vị:

_,mQ/\* cũng hoạt động trên TIO do cách thức hoạt động của nó.

Làm thế nào tôi đã quên để thực hiện một op vuông 1-char?