Meydan okuma

Bir dize verilen, metni bir kare şeklinde çıktılar.

Metnin her zaman bir kareye sığacağını ve asla boş bir dize olamayacağını kabul edebilirsiniz.

Ayrıca hiçbir zaman yeni satırları olmayacağını da varsayabilirsiniz.

Örnek

Input:
Hi, world

Output:
Hi,
 wo
rld

Test Kılıfları

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

kurallar

• Bu kod-golf , bayt cinsinden en kısa cevap! Tiebreaker en çok cevaplanan cevaptı.
• Standart boşluklar yasaktır.

Vim, 59, 57 , 48 bayt / tuş vuruşlarını

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

V geriye dönük olarak uyumlu olduğundan, çevrimiçi olarak deneyebilirsiniz!

Bu cevabı rastgele bir şekilde aldım, bu yüzden tekrar aradım. Vim-golf becerilerim son 7 ay boyunca oldukça arttı, bu yüzden bu cevabın çok kötü bir şekilde golf oynadığını gördüm. Bu daha iyi.

Brainfuck , 116 112 bayt

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

Çevrimiçi deneyin!

Hücreleri maskelemeyen BF tatlarında güvenlidir, 256boş baytları desteklemez.

Lezzet kaydedilen 4 byte negatif belleği destekliyorsa, ilk sağ okları çıkarın.

açıklama

Program 3 aşamaya ayrılmıştır:

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

1. Aşama

Bu aşamada, karakter sayısını sayarken tüm karakterleri kasete koyarız.

Bu, bu banttan abcdefghisonraki giriş için olan banttır:

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

009Sayısıdır.

Her karakter için, soldaki ilk sıfırı hareket ettirip [<]sayıma bir tane ekleriz ve bir sonraki karaktere hazırlanmak için <<+>>>en sağdaki sıfıra gideriz [>].

2. aşama

Bu aşama, ikinci hücrede depolanan uzunluğun karekökünü yapar.

1, 3, 5, 7, ...Yinelemelerin sayısını kontrol ederken sayı sıfıra ulaşana kadar çıkarmaya devam eder .

Çalışır, çünkü kare sayıları olarak ifade edilebilir 1 + 3 + 5 + ....

Sahne 3

Yukarıda bulunan uzunluktaki karekökü belirtin n.

Bu aşama n, bir kerede karakterleri çıkarır ve ardından bant temizlenene kadar yeni bir satır çıkarır.

Python 2,55 bayt

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

05AB1E , 5 bayt

Dgtô«

Çevrimiçi deneyin!

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 bayt

tnX^e!

Çevrimiçi deneyin!

açıklama

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

Jöle, 8 7 bayt

sLƽ$j⁷

@ Dennis sayesinde bir bayt kaydedildi .

Çevrimiçi deneyin.

açıklama

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 bayt

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

Yalnızca Firefox Nightly 43-46'daki 44 bayt ( **bir süre Firefox Nightly 42 ve 43 arasında tanıtıldı ve gayrı bir parametre olarak Firefox Nightly 46 ve 47 arasında bir süre kaldırıldı):

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

J, 9 bayt

$~,~@%:@#

Bu, giriş dizgisi üzerinde bir monadik kancadır:

$~ ,~@%:@#

Doğru diş bir dizi kompozisyondur:

,~ @ %: @ #

Sol şekillendirici bir fiil, kanca biçiminde çalışacak şekilde değiştirildi.

İşte bazı ara sonuçlar:

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

Kelimelerle:

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

C, 64 bayt

f()Kare ile dize ile arayın .

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

İdeone üzerinde deneyin .

Perl, 23 + 4 ( -pFbayraklar) = 27 bayt

-2 sayesinde bayt @DomHastings
-1 sayesinde bayt @DomHastings

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

Çevrimiçi deneyin!

Expanations : girişin boyutunun karekökünü hesaplar ( Saçıklama için çağrı yapalım ) (her zaman bir tamsayı olacaktır) ( @Fskaler bağlamda kullanılır, böylece boyutunu döndürür), sonra her satırdan sonra yeni bir satır ekleyin. Skarakter.

zsh, 36 bayt

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

Komut satırı argümanı olarak girdi alır, STDOUT'a çıkar.

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

Karekök işlevi hakkında bilgi verdiğim için @quartata'ya teşekkür ederiz

Dgtô¶ý

Çevrimiçi deneyin!

açıklama

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 bayt

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

Eski versiyon:

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

CJam , 8 bayt

l_,mQ/N*

Çevrimiçi deneyin!

açıklama

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 bayt

jcs@lQ2Q

Çevrimiçi deneyin

Nasıl çalışır

    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 bayt

⊢⍴⍨2⍴.5*⍨≢

Açıklama:

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

Testler:

      (⊢⍴⍨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

Çedar, 27 bayt (yarışmaz)

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

.chunkFonksiyonu bir süre önce ekledim ama yeni stdlib formatına geçişte kaldırdım ve tekrar eklemeyi unuttum. Çedar özel bir sqrtoperatöre sahip ancak **.5daha kısa

Çevrimiçi deneyin!

açıklama

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 yardımcı programları, 25

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

@ Doorknob'un cevabından çok farklı değil , fakat dckarekökü almak için daha kısa bir yol var.

11, 11 karakter / 14 bayt

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Bu kodu kullanarak üretilir (tercümanın tarayıcı konsolunda çalışır):

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

Brainfuck, 83 bayt

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

Çevrimiçi deneyin!

Bu, Leaky Nun'un cevabı ile aynı fikri kullanır . Sohbette golf oynamak için yardım istedi, sonra bunu yeni bir cevap olarak eklememi önerdi. (Aslında sohbete yazdıklarım buna çok benzeyen 84 baytlık bir çözümdü.)

Karşılaştırma uğruna, >negatif hafıza adreslerine izin vermeyen beyin fırtınası uygulamaları için başlangıçta bir ekstraya ihtiyaç vardır.

Beklendiği gibi, bu girdi uzunluğunu bulur, sonra karekökü alır, sonra çizgileri buna göre basar. Kısmi toplamlar olan mükemmel karelerden yararlanır 1 + 3 + 5 ....

Brain-Flak , 110 96 bayt

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

Çevrimiçi deneyin!

İkinci çözüm, 96 bayt

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

Çevrimiçi deneyin!

açıklama

Burada ilk çözümü açıklıyorum, ikisi de aynı uzunluktadır ancak ilkini seviyorum çünkü daha serin ve bazı güzel numaralar kullanıyor.

Kodun en önemli kısmı, bir süre önce yazdığım, değiştirilmiş bir karekök işlevidir. Orijinal versiyon

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

Ve bu işe yarıyor, ama aslında negatif karekökün iki kopyasını istiyoruz. Niye ya? İki kopyaya ihtiyacımız var çünkü dize boyunca iki düzeyde döngü yapıyoruz, biri satır yapmak, diğeri satır sayısını saymak. Negatif olmasını istiyoruz çünkü negatiflerle döngü daha ucuzdur.

Bunu olumsuz yapmak için etrafta hareket ediyoruz, [...]öyle gözüküyor

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

İki kopya çıkarmak için pop'lar oluştuğunda değişiyoruz

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

Şimdi, bu parçaya sahip olduğumuz için, ihtiyacımız olan ilk kod parçasını elde etmek için yığın yüksekliğiyle bir araya getirebiliriz.

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

Kök kökü fonksiyonumuzun hesaplama için iki serbest sıfır gerektirdiğinden ve yığın değiştirme konusunda geleceği biraz daha ucuz hale getirdiğinden dolayı, offstack'a geçiyoruz.

Şimdi ana döngüyü inşa ediyoruz

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

Bu oldukça açıktır, n öğelerini her hareket ettirdiğinizde ve onu yeni bir satırla kapattığımızda n kez döngü yaparız (ASCII 10).

Döngü tamamlandıktan sonra, çıktımızın sırasını tersine çevirmeliyiz, bu yüzden sadece standart bir ters yapı üzerine yapmalıyız.

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

PHP, 51 bayt

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

Perl 6 , 38 bayt

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

Açıklama:

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

Çedar, 57 bayt

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

Değişkenler kırıldığından lambda uygulamasıyla değişkenlerden geçmek zorunda kalacağım.

Ayrıca, değişkenler çalışsa bile lambda uygulamasının kullanılmasının daha kısa olacağı ortaya çıktı.

kullanım

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

Pyke, 5 bayt

l,fnJ

Burada dene!

Java 1.7, 110 bayt

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

Dene!(Ideone)

Sonucu bir dize olarak döndüren bir işlevle başka bir yaklaşım denedim, ancak sadece dize bildirmek zorundayım ve return ifadesi zaten print deyiminden daha pahalı (byte-count-wise).

Java'nın ayrıntılarını sevmeliyim ... :)

R , 59 54 bayt

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

Çevrimiçi deneyin!

Sondaki yeni satır ile yazdırır. Şaşırtıcı derecede kısa, R'nin dizeleri ne kadar kötü ele aldığını düşünürsek.

PowerShell, 56 58 61 bayt

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

Ruby -p , 40 33 30 bayt

-Jordan'dan -7 bayt.

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

Çevrimiçi deneyin!

Dışbükey , 7 bayt

_,mQ/N*

Çevrimiçi deneyin!

Eğlenceli gerçek:

_,mQ/\* ayrıca TIO'da nasıl çalıştığından dolayı da çalışır.

1-char karekök op yapmak için nasıl unuttum?