ความท้าทาย

รับสายอักขระเอาท์พุทข้อความในรูปของสแควร์

คุณสามารถสันนิษฐานได้ว่าข้อความจะพอดีในรูปสี่เหลี่ยมเสมอและมันจะไม่เป็นสตริงว่างเปล่า

คุณสามารถสมมติได้ว่าจะไม่มีบรรทัดใหม่

ตัวอย่าง

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 เป็นคำตอบที่ถูกโหวตมากที่สุด
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

เป็นกลุ่ม, 59, 57 , 48 ไบต์ / การกดแป้น

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

เนื่องจาก V เข้ากันได้ย้อนหลังคุณสามารถลองออนไลน์ได้!

ฉันสุ่มได้รับ upvote จากคำตอบนี้ดังนั้นฉันจึงตรวจดูอีกครั้ง ทักษะการเล่นกอล์ฟของฉันเพิ่มขึ้นอย่างมากในช่วง 7 เดือนที่ผ่านมาดังนั้นฉันจึงเห็นว่าคำตอบนี้ไม่ดีนักกอล์ฟ อันนี้ดีกว่ามาก

Brainfuck , 116 112 bytes

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

ลองออนไลน์!

ปลอดภัยในรสชาติของ BF ที่ไม่ปิดบังเซลล์ด้วย256ไม่รองรับไบต์ว่าง

ลบลูกศรขวาเริ่มต้นหากรสชาติสนับสนุนหน่วยความจำเชิงลบสำหรับการบันทึก 4 ไบต์

คำอธิบาย

โปรแกรมแบ่งออกเป็น 3 ขั้นตอน:

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

ด่าน 1

ในขั้นตอนนี้เราใส่ตัวละครทั้งหมดลงบนเทปในขณะที่ยังคงนับจำนวนตัวละคร

นี่คือเทปสำหรับอินพุตabcdefghiหลังจากเทปนี้:

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

009คือนับ

สำหรับตัวละครแต่ละตัวเราจะย้ายศูนย์แรกทางซ้าย[<]แล้วเพิ่มอีกหนึ่งตัวเพื่อนับ<<+>>>จากนั้นย้ายไปที่ศูนย์ขวาสุด[>]เพื่อเตรียมพร้อมสำหรับตัวละครถัดไป

ด่าน 2

สเตจนี้ทำสแควร์รูทของความยาวที่เก็บไว้ในเซลล์ที่สอง

มันจะทำการลบ1, 3, 5, 7, ...ไปเรื่อย ๆ จนกว่าจำนวนจะถึงศูนย์ในขณะที่ยังคงตรวจสอบจำนวนการทำซ้ำ

1 + 3 + 5 + ...มันทำงานได้เนื่องจากหมายเลขตารางสามารถแสดงเป็น

ด่าน 3

nแสดงว่ารากที่สองของความยาวที่พบข้างต้น

สเตจนี้ส่งออกnอักขระในแต่ละครั้งจากนั้นออกบรรทัดใหม่จนกระทั่งเทปถูกเคลียร์

Python 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⁷

บันทึกขอบคุณไบต์ @ เดนนิส

ลองออนไลน์

คำอธิบาย

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 ไบต์

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

44 ไบต์ใน Firefox Nightly 43-46 เท่านั้น ( **ถูกนำมาใช้บางครั้งระหว่าง Firefox Nightly 42 และ 43 และgเป็นพารามิเตอร์ที่แยกต่างหากถูกลบบางเวลาระหว่าง Firefox Nightly 46 และ 47):

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

J, 9 ไบต์

$~,~@%:@#

นี่เป็นตะขอแบบ monadic เหนือสตริงอินพุต:

$~ ,~@%:@#

ซี่ที่ถูกต้องคือชุดขององค์ประกอบ:

,~ @ %: @ #

ด้านซ้ายเป็นคำกริยาที่สร้างขึ้นสลับไปมาในรูปแบบตะขอ

นี่คือผลลัพธ์ระดับกลางบางส่วน:

   # '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 ไบต์

โทรf()ด้วยสายอักขระที่ตาราง

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

ลองบน ideone

Perl, 23 + 4 ( -pFธง) = 27 ไบต์

-2 ไบต์ขอบคุณ@DomHastings
-1 ไบต์ขอบคุณ@DomHastings

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

ลองออนไลน์!

Expanations : คำนวณสแควร์รูท (ให้เรียกมันSสำหรับคำอธิบาย) ของขนาดของอินพุต (มันจะเป็นจำนวนเต็มเสมอ) ( @Fใช้ในบริบทสเกลาร์, ดังนั้นจึงคืนขนาดของมัน) จากนั้นเพิ่มบรรทัดใหม่หลังจากแต่ละกลุ่มSตัวละคร

zsh, 36 ไบต์

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

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดรับคำสั่งเอาต์พุตไปยัง 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 ไบต์

ขอบคุณ @quartata ที่ให้ฉันรู้เกี่ยวกับฟังก์ชันสแควร์รูท

Dgtô¶ý

ลองออนไลน์!

คำอธิบาย

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 ไบต์

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

เวอร์ชั่นเก่า:

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

CJam , 8 ไบต์

l_,mQ/N*

ลองออนไลน์!

คำอธิบาย

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 ไบต์

jcs@lQ2Q

ลองออนไลน์

มันทำงานอย่างไร

    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 ไบต์

⊢⍴⍨2⍴.5*⍨≢

คำอธิบาย:

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

แบบทดสอบ:

      (⊢⍴⍨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 ไบต์ (ไม่ใช่การแข่งขัน)

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

ฉันได้เพิ่ม.chunkฟังก์ชั่นเมื่อไม่นานมานี้ แต่ฉันได้ลบมันออกไปในรูปแบบ stdlib ใหม่และลืมที่จะเพิ่มใหม่อีกครั้ง Cheddar มีผู้ให้sqrtบริการเฉพาะ**.5สั้นกว่า

ลองออนไลน์!

คำอธิบาย

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

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

ไม่ต่างจากคำตอบของ @ Doorknobมากนัก แต่dcเป็นวิธีที่สั้นกว่าในการรับสแควร์รูท

𝔼𝕊𝕄𝕚𝕟, 11 ตัวอักษร / 14 ไบต์

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

สร้างโดยใช้รหัสนี้ (ทำงานในคอนโซลเบราว์เซอร์ของล่าม):

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

Brainfuck, 83 ไบต์

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

ลองออนไลน์!

นี้ใช้ความคิดเช่นเดียวกับการรั่วของแม่ชีคำตอบ เขาขอความช่วยเหลือจากการเล่นกอล์ฟในการแชทจากนั้นแนะนำว่าฉันเพิ่มสิ่งนี้เป็นคำตอบใหม่ (อันที่จริงสิ่งที่ฉันเขียนในการแชทเป็นวิธีแก้ปัญหา 84 ไบต์คล้ายกับสิ่งนี้)

เพื่อประโยชน์ในการเปรียบเทียบ>จำเป็นต้องมีสิ่งเพิ่มเติมในตอนเริ่มต้นสำหรับการใช้งาน brainfuck ที่ไม่อนุญาตที่อยู่หน่วยความจำเชิงลบ

ตามที่คาดไว้สิ่งนี้จะหาความยาวของอินพุตจากนั้นนำสแควร์รูทแล้วพิมพ์บรรทัดตามนั้น 1 + 3 + 5 ...จะใช้ประโยชน์จากที่สมบูรณ์แบบสี่เหลี่ยมเป็นผลรวมบางส่วนของ

Brain-Flak , 110 96 ไบต์

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

ลองออนไลน์!

วิธีที่สอง 96 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ที่นี่ฉันอธิบายวิธีแก้ปัญหาแรกทั้งสองมีความยาวเท่ากัน แต่ฉันชอบโซลูชันแรกเพราะเย็นกว่าและใช้กลเม็ดที่ดี

ส่วนที่สำคัญที่สุดของรหัสคือฟังก์ชั่นสแควร์รูทที่แก้ไขแล้วที่ฉันเขียนเมื่อไม่นานมานี้ รุ่นเดิมคือ

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

และมันใช้งานได้ แต่เราอยากได้สแควร์รูทลบสองตัว ทำไม? เราต้องการสำเนาสองชุดเพราะเราวนลูปผ่านสตริงในสองระดับระดับหนึ่งเพื่อสร้างบรรทัดและอีกหนึ่งรายการเพื่อนับจำนวนบรรทัด เราต้องการให้มันเป็นเชิงลบเพราะการวนซ้ำกับเชิงลบนั้นราคาถูกกว่า

ในการทำให้แง่ลบนี้เราเคลื่อนที่ไปรอบ ๆ[...]ดังนั้นมันจะเป็นแบบนี้

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

ในการทำสำเนาสองชุดเราจะเปลี่ยนเมื่อปรากฏขึ้น

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

ตอนนี้เรามีบิตนั้นเราสามารถรวมเข้ากับความสูงของสแต็กเพื่อรับรหัสก้อนแรกที่เราต้องการ

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

เราย้ายไปที่ offstack เพราะฟังก์ชันสแควร์รูทของเราต้องการศูนย์อิสระสองตัวสำหรับการคำนวณและเพราะมันทำให้สิ่งที่ถูกกว่าเขาในอนาคตในแง่ของการสลับสแต็ก

ตอนนี้เราสร้างลูปหลัก

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

นี่เป็นสิ่งที่ตรงไปตรงมาเราวนรอบ n ครั้งในแต่ละครั้งที่เคลื่อนย้ายรายการ n และกำหนดให้เป็นบรรทัดใหม่ (ASCII 10)

เมื่อวนรอบเสร็จแล้วเราจำเป็นต้องกลับคำสั่งของเอาท์พุทของเราดังนั้นเราเพียงแค่ยึดโครงสร้างย้อนกลับมาตรฐาน

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

PHP, 51 ไบต์

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

Perl 6 , 38 ไบต์

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

คำอธิบาย:

$_ = 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 ไบต์

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

เนื่องจากตัวแปรถูกทำลายฉันจะต้องส่งผ่านตัวแปรผ่านแอปพลิเคชันแลมบ์ดา

ยิ่งไปกว่านั้นมันกลับกลายเป็นว่าแม้ว่าตัวแปรทำงานได้ แต่ก็ยังสั้นกว่าที่จะใช้แอปพลิเคชันแลมบ์ดา

การใช้

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

Pyke ขนาด 5 ไบต์

l,fnJ

ลองที่นี่!

Java 1.7, 110 ไบต์

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

ลองมัน! (Ideone)

ฉันลองวิธีอื่นด้วยฟังก์ชันที่คืนค่าผลลัพธ์เป็นสตริง แต่เพิ่งประกาศสตริงและคำสั่ง return มีราคาแพงกว่า (นับไบต์ - ฉลาด - ฉลาด) กว่าคำสั่ง print

ต้องรักความฟุ้งซ่านของ Java ... :)

R , 59 54 ไบต์

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

ลองออนไลน์!

พิมพ์ด้วยบรรทัดใหม่ต่อท้าย สั้นน่าแปลกใจที่พิจารณาว่า R จัดการสตริงได้ไม่ดี

PowerShell, 56 58 61ไบต์

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

Ruby -p , 40 33 30 ไบต์

-7 ไบต์จาก @Jordan

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

ลองออนไลน์!

นูน 7 ไบต์

_,mQ/N*

ลองออนไลน์!

สนุกกับความเป็นจริง:

_,mQ/\* ยังทำงานบน TIO เนื่องจากวิธีการทำงาน

ฉันลืมที่จะสร้าง op-root แบบ 1-char ได้อย่างไร