पाठ का एक वर्ग

Question

चुनौती

एक स्ट्रिंग को देखते हुए, एक वर्ग के आकार में पाठ को आउटपुट करें।

आप मान सकते हैं कि पाठ हमेशा एक वर्ग में फिट होगा , और यह कभी भी एक खाली स्ट्रिंग नहीं होगा।

आप यह भी मान सकते हैं कि इसमें कभी भी नयापन नहीं होगा।

उदाहरण

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

नियम

• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है! टाईब्रेकर सबसे उत्कट उत्तर है।
• मानक खामियों को मना किया जाता है।

Comments

क्या हम मान सकते हैं कि इनपुट में कभी नई लाइनें नहीं होंगी?

— मेयरमोनी

@ मेयोरमोन्टी हाँ।

— acrolith

क्या हम बदले में तार की सरणी का उत्पादन कर सकते हैं?

— लीक नून

@ लीकेन नं 15

— चरस

क्या हम एक नई रूपरेखा के साथ प्रिंट कर सकते हैं?

— Giuseppe

Answer 1

विम, 59, 57 , 48 बाइट्स / कीस्ट्रोक्स

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

चूंकि V पीछे की ओर संगत है, आप इसे ऑनलाइन आज़मा सकते हैं !

मुझे इस उत्तर पर बेतरतीब ढंग से उत्थान हुआ, इसलिए मैंने इसे फिर से देखा। मेरे विम-गोल्फ कौशल में पिछले 7 महीनों में बहुत वृद्धि हुई है, इसलिए मैंने देखा कि यह उत्तर बहुत खराब रूप से गोल्फ था। यह एक बहुत बेहतर है।

Answer 2

ब्रेनफक , 116 112 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बीएफ के स्वादों में सुरक्षित है जो कोशिकाओं के साथ मुखौटा 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एक समय में वर्णों को आउटपुट करता है, और तब तक एक नई पंक्ति का उत्पादन करता है, जब तक टेप साफ नहीं हो जाता।

Comments

+1 नहीं पढ़ा, हालांकि अद्भुत लगता है

— रोहन झुनझुनवाला

Answer 3

पायथन 2, 55 बाइट्स

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

Answer 4

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)

Comments

बहुत बढ़िया जवाब। लेकिन ये कैसे काम करता है? क्या आप कृपया स्पष्टीकरण जोड़ने के लिए संपादित कर सकते हैं ?

— grooveplex

@grooveplex किया।

— 15

बहुत प्रभावशाली!

— ग्रीफॉन -

पुराने 05AB1E उत्तरों को देखना अजीब है, जहां »अब नया अंक है ।

— मैजिक ऑक्टोपस Urn

Answer 5

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

Comments

वर्ग "टॉर"? : पी

— एक्रोलिथ

@ ईदहुगलनी: -डॉ। ठीक किया

— लुइस मेंडू

@daHugLenny यह वर्गमूल का विलोम है। ;-)

— WBT

Answer 6

जेली, 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

Comments

œsऔर sयहाँ भी वही करो।

— डेनिस

के ½बजाय काम क्यों नहीं करता है ƽ?

— लुइस मेंडो

@LuisMendo क्योंकि यह एक फ्लोट देता है। मैं पैच कर दूंगा sऔर œsइसलिए उन्होंने इंट को कास्ट किया।

— डेनिस

@ डेनिस लंबे समय से प्रतीक्षित पैच अभी भी इंतजार कर रहा है ...

— एरिक द आउटग्राफर

Answer 7

जावास्क्रिप्ट (ईएस 7), 49 बाइट्स

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

फ़ायरफ़ॉक्स नाइटली ४३-४६ में केवल ४४ बाइट्स ( **फ़ायरफ़ॉक्स नाइटली ४२ और ४३ के बीच कुछ समय पेश किया गया था और gफ़ायरफ़ॉक्स नाइटली ४६ और ४ 47 के बीच कुछ समय के लिए एक अलग पैरामीटर को हटा दिया गया था):

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

Comments

पहले संस्करण में तुम क्यों की क्या ज़रूरत है +मेंs.length*+.5

— Downgoat

मैंने पहले *+सिंटैक्स नहीं देखा है । क्या कोई इसे समझा सकता है?

— मेयरमोनी

उसका शायद मतलब है **।

— कॉनर ओ'ब्रायन

@MayorMonty हाँ यह एक टाइपो खेद था।

— नील

@Downgoat यह एक टाइपो खेद था।

— नील

Answer 8

जे, 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
! :)

Comments

मुझे यह तथ्य पसंद है $~,~@ किसी प्रकार के इमोटिकॉन जैसा दिखता है लेकिन @एक कान के लिए अजीब लगता है लेकिन &बेहतर फिट बैठता है, या$~,~&

— मील

और मुझे लगता है कि वे कार्यात्मक रूप से समकक्ष हैं। खैर, ज्यादातर। एक आपको दूसरे से बेहतर सुनने देता है;)

— कॉनर ओ'ब्रायन

आपके स्कोर के लिए +1 n² होना चाहिए। मेरा भी है :)

— डिजिटल आघात

@DigitalTrauma मज़ा! इसी तरह +1!

— कॉनर ओ'ब्रायन

$~2#%:@#is 8. एक कांटा का बायां हिस्सा एक स्थिर हो सकता है।

— फ्रॉन्फ्रॉग

Answer 9

सी, 64 बाइट्स

f()स्ट्रिंग टू स्क्वायर के साथ कॉल करें ।

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

इसे आइडोन पर आज़माएं ।

Comments

क्या आप intइसके बजाय निहित तर्क के साथ काम कर सकते हैं char*?

— अनातोलीग

मुझे ऐसा नहीं लगता। इसे निष्क्रिय करने की आवश्यकता है, इसलिए एक संख्यात्मक प्रकार काम नहीं करेगा, और यह तब से नहीं हो सकता int*है जब जोड़ते समय यह गलत होगा।

— ओवैकोडर

s+=write(puts(""),s,m));इसके बजाय सुझाव देंs+=m)printf("%.*s\n",m,s);

— सीलिंग

Answer 10

पर्ल, 23 ​​+ 4 ( -pFझंडे) = 27 बाइट्स

-2 बाइट्स @DomHastings
के लिए धन्यवाद -1 बाइट्स @DomHastings के लिए धन्यवाद

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

इसे ऑनलाइन आज़माएं!

विस्तार : Sइनपुट के आकार के वर्गमूल (इसे स्पष्टीकरण के लिए कॉल करने देता है) की गणना करता है (यह हमेशा पूर्णांक होगा) ( @Fस्केलर संदर्भ में उपयोग किया जाता है, इस प्रकार इसका आकार वापस लौटता है), फिर प्रत्येक ब्लाक के बाद एक नई पंक्ति जोड़ें Sवर्ण।

Comments

का अच्छा उपयोग $@;) आप y///cलंबाई के बजाय बाइट का उपयोग करके बचा सकते हैं और मुझे लगता है कि आप एक शाब्दिक नई लाइन का भी उपयोग कर सकते हैं। मैं सेटिंग $,और मिलान के साथ कुछ करने की कोशिश कर रहा था , लेकिन मुझे लगता है कि यह बहुत छोटा है!

— डोम हेस्टिंग्स

@DomHastings हाँ, मुझे लगा कि आप चाहेंगे $@! इसके लिए धन्यवाद y///c, मैं भूल जाता हूं कि यह मौजूद है।

— दादा

@DomHastings ने $=इसके बजाय 1 बाइट बचाने में कामयाबी हासिल की $@, जो -lझंडे का उपयोग नहीं करने की अनुमति देता है ।

— दादा

अच्छे जा रहे हो! वास्तविक कारणों के लिए जादू चर का उपयोग करने के लिए भी अच्छा है!

— डोम हेस्टिंग्स 14

अरे, आशा है कि आप ठीक कर रहे हैं! यह मुखपृष्ठ पर टकरा गया और मैंने -1: 23 बाइट्स कोड + 4 के लिए-pF

— डोम हेस्टिंग्स

Answer 11

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

Comments

आपके स्कोर के लिए +1 n² होना चाहिए। मेरा भी है :)

— डिजिटल आघात

Answer 12

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

Comments

बहुत अच्छा! इसके अलावा, «newlines पर शामिल होने के लिए कम है :)।

— अदनान

@ अदनान धन्यवाद! अब मैंने खुद को बाहर कर लिया है :-D

— लुइस

क्योंकि वहाँ के साथ पिछले एक जवाब था मैं अपने 6-बाइट संस्करण के लिए वापस लुढ़का है«

— लुइस Mendo

ओह, यह बहुत बुरा है :(

— अदनान

क्या किसी और को उन भाषाओं की तरह महसूस होता है जो विशेष रूप से कोड गोल्फ के लिए बनाई गई हैं, इस पूरी चीज़ की अपील को नष्ट कर रही हैं?

— रेने रोथ

Answer 13

पायथन, 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))))

Comments

ध्यान दें कि आप input() डिफ़ॉल्ट रूप से उद्धरणों में इनपुट प्राप्त करने के लिए उपयोग कर सकते हैं , जब तक कि आप विशेष रूप से उस विकल्प को हटाना नहीं चाहते हैं।

— xnor

@xnor ओह वाह, कुछ दिन पहले मैं सोच रहा था कि क्या मैं इनपुट पर उद्धरण का उपयोग कर सकता हूं ...

— acrolith

यह एक मेमने का उपयोग करने के लिए छोटा नहीं होगा?

— लीकी नून

@LeakyNun सच ...

— acrolith 15

Answer 14

सीजेएम , 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

Answer 15

पायथ, 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

Answer 16

Dyalog एपीएल, 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

Answer 17

चेडर, 27 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

मैंने .chunkकुछ समय पहले फ़ंक्शन को जोड़ा था लेकिन मैंने इसे नए stdlib प्रारूप में बदल दिया और इसे फिर से जोड़ना भूल गया। चेडर के पास एक समर्पित 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

Answer 18

बैश + जीएनयू उपयोगिताओं, 25

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

@ Doorknob के उत्तर के लिए इतना अलग नहीं है , लेकिन dcवर्गमूल प्राप्त करने का एक छोटा तरीका है।

Answer 19

S, 11 चार्ट / 14 बाइट्स

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

इस कोड का उपयोग करके उत्पन्न (दुभाषिया के ब्राउज़र कंसोल में चलाएं):

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

Answer 20

ब्रेनफक, 83 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह उसी विचार का उपयोग करता है जैसे लीक नन का उत्तर । उसने चैट में इसे मदद करने के लिए कहा, फिर सुझाव दिया कि मैं इसे एक नए उत्तर के रूप में जोड़ता हूं। (वास्तव में मैंने चैट में जो लिखा था, वह 84-बाइट समाधान के समान था।)

तुलना के लिए, >ब्रेनफुक कार्यान्वयन के लिए शुरुआत में एक अतिरिक्त की आवश्यकता होती है जो नकारात्मक स्मृति पते की अनुमति नहीं देता है।

जैसा कि अपेक्षित था, यह इनपुट की लंबाई पाता है, फिर वर्गमूल लेता है, फिर तदनुसार लाइनों को प्रिंट करता है। यह आंशिक रूप से पूर्ण राशि होने का लाभ उठाता है 1 + 3 + 5 ...।

Answer 21

ब्रेन-फ्लैक , 110 96 बाइट्स

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

इसे ऑनलाइन आज़माएं!

दूसरा समाधान, 96 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

यहां मैं पहला समाधान बताता हूं, दोनों एक ही लंबाई के हैं, लेकिन मैं पहले वाले को पसंद करता हूं क्योंकि यह कूलर है और कुछ अच्छी चालें नियुक्त करता है।

कोड का सबसे महत्वपूर्ण हिस्सा एक संशोधित स्क्वायर रूट फ़ंक्शन है जो मैंने कुछ समय पहले लिखा था। मूल संस्करण था

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

और यह काम करता है, लेकिन हम वास्तव में नकारात्मक वर्गमूल की दो प्रतियां चाहते हैं। क्यूं कर? हमें दो प्रतियों की आवश्यकता है क्योंकि हम दो स्तरों पर स्ट्रिंग के माध्यम से लूप कर रहे हैं, एक लाइनों को बनाने के लिए और एक लाइनों की संख्या को गिनने के लिए। हम चाहते हैं कि यह नकारात्मक हो क्योंकि नकारात्मक के साथ लूपिंग सस्ता है।

इसे नकारात्मक बनाने के लिए हम चारों ओर घूमते हैं [...]ताकि यह इस तरह दिखे

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

दो प्रतियाँ बनाने के लिए हम बदलते हैं जब चबूतरे होते हैं

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

अब जब हमारे पास वह बिट है, तो हमें कोड की पहली चंक को प्राप्त करने के लिए इसे एक ऊंचाई के साथ एक साथ रख सकते हैं।

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

हम इस कदम से आगे बढ़ते हैं क्योंकि हमारे वर्गाकार रूट फ़ंक्शन को संगणना के लिए दो मुक्त शून्य की आवश्यकता होती है, और क्योंकि यह स्टैक स्विचिंग के संदर्भ में भविष्य में थोड़ा सा सस्ता int बनाता है।

अब हम मुख्य लूप का निर्माण करते हैं

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

यह बहुत सीधे आगे है, हम हर बार एन आइटम को घुमाते हैं और एक नई लाइन (एएससीआईआई 10) के साथ कैपिंग करते हैं।

एक बार लूप पूरा हो जाने के बाद हमें अपने आउटपुट के क्रम को उलटने की जरूरत होती है ताकि हम सिर्फ एक मानक रिवर्स निर्माण पर काम करें।

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

Comments

इसके अलावा 96

— H.PWiz

Answer 22

PHP, 51 बाइट्स

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

Answer 23

पर्ल 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

Answer 24

चेडर, 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"

Answer 25

पाइके, 5 बाइट्स

l,fnJ

यहाँ यह कोशिश करो!

Answer 26

जावा 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)

मैंने फ़ंक्शन को स्ट्रिंग के रूप में वापस करने के साथ एक और दृष्टिकोण की कोशिश की, लेकिन सिर्फ स्ट्रिंग की घोषणा करने और रिटर्न स्टेटमेंट पहले से ही प्रिंट स्टेटमेंट की तुलना में अधिक महंगा (बाइट-काउंट-वार) है।

होगा जावा की वाचालता प्यार ... :)

Comments

अच्छा जवाब +1। आप का उपयोग करके गोल्फ यह 1 बाइट से कर सकते हैं i=0, i<kऔर s.substring(i*k,i++*k+k)के बजाय i=-1, ++i<k, s.substring(i*k,i*k+k)। इसके अलावा, आमतौर पर हम इसके Java 7बजाय का उपयोग करते हैं Java 1.7, लेकिन यह अच्छा है कि आपने इसे जोड़ा है, बहुत सारे लोग ऐसा करना भूल जाते हैं।

— केविन क्रूज़सेन

Answer 27

आर , 59 54 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक अनुगामी न्यूलाइन के साथ प्रिंट। आश्चर्यजनक रूप से संक्षेप में, यह देखते हुए कि आर कितनी बुरी तरह से तारों को संभालता है।

Answer 28

पॉवरशेल, 56 58 61 बाइट्स

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

Comments

इसे परम के रूप में लेने से दो बाइट्स

— बचते हैं

Answer 29

रूबी -p , ४० ३३ 30 बाइट्स

-7 बाइट @ जोर्डन से।

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

इसे ऑनलाइन आज़माएं!

Answer 30

उत्तल , 7 बाइट्स

_,mQ/N*

इसे ऑनलाइन आज़माएं!

मजेदार तथ्य:

_,mQ/\* TIO पर भी काम करता है कि यह कैसे काम करता है।

मैं 1-चार वर्गमूल ऑप बनाने के लिए कैसे भूल गया हूं?