एक त्रिकोणीयता कार्यक्रम को मान्य बनाएं

Question

त्रिकोणीयता श्री एक्सकोडर द्वारा विकसित एक नया एसोलैंग है जहां कोड संरचना को बहुत विशिष्ट पैटर्न का पालन करना है:

• nकोड की वें पंक्ति के लिए, उस 2n-1पर प्रोग्राम के बिल्कुल अक्षर होने चाहिए । यह एक त्रिकोणीय / पिरामिड आकार का कारण बनता है, जिसमें पहली पंक्ति में केवल एक वर्ण होता है और बाकी 2 की वृद्धि से बढ़ता है।
• प्रत्येक पंक्ति को .बाएं और दाएं पर एस के साथ गद्देदार होना चाहिए , जैसे कि वर्ण अपनी रेखाओं पर केंद्रित होते हैं और सभी रेखाएं समान लंबाई में गद्देदार होती हैं। यदि lकार्यक्रम में लाइनों की संख्या के रूप में परिभाषित किया गया है, तो कार्यक्रम में प्रत्येक पंक्ति की लंबाई होनी चाहिए2 * l - 1

उदाहरण के लिए, बाईं ओर का प्रोग्राम मान्य है, लेकिन दाईं ओर का प्रोग्राम नहीं है:

 Valid    |  Invalid  
          |
...A...   |  ABCDE
..BCD..   |  FGH
.EFGHI.   |  IJKLMN
JKLMNOP   |  OPQRS

जब वैध संरचना में रखा जाता है, तो नाम स्पष्ट हो जाता है।

कार्य

आपका कार्य इनपुट के रूप में एकल पंक्ति स्ट्रिंग लेना है, त्रिकोणीयता कोड का प्रतिनिधित्व करता है, और इसे ऊपर बताए अनुसार मान्य कोड में परिवर्तित करता है।

I / O के लिए विनिर्देशों:

• इनपुट में सीमा में केवल वर्ण होंगे 0x20 - 0x7e
• इनपुट की लंबाई हमेशा एक वर्ग संख्या होगी और इस प्रकार अच्छी तरह से पैडेबल होगी।
• आपको आउटपुट पैडिंग के लिए डॉट्स का उपयोग करना चाहिए, न कि कुछ और के लिए।

आप किसी भी स्वीकार्य विधि के माध्यम से इनपुट और आउटपुट कर सकते हैं । यह एक कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है !

परीक्षण के मामलों

input
----
output

g
----
g

PcSa
----
.P.
cSa

DfJ0vCq7G
----
..D..
.fJ0.
vCq7G

7xsB8a1Oqw5fhHX0
----
...7...
..xsB..
.8a1Oq.
w5fhHX0

QNYATbkX2sKZ6IuOmofwhgaef
----
....Q....
...NYA...
..TbkX2..
.sKZ6IuO.
mofwhgaef

ABCDEF"$%& G8"F@
----
...A...
..BCD..
.EF"$%.
& G8"F@

ab.c
----
.a.
b.c

_{जो लोग त्रिकोणीयता को जानते हैं, आप अंतिम परीक्षण के मामले से देखेंगे कि तार को संभालना नहीं है}

Comments

सैंडबॉक्स पोस्ट

— caird coinheringaahing

मुझे एहसास है कि यह शायद व्यर्थ है, लेकिन क्या नीचे वाले को अपने वोट की व्याख्या करने की परवाह होगी? मैं वैसे भी चुनौती में सुधार करना पसंद करूंगा।

— caird coinheringaahing

अग्रणी या अनुगामी newlines स्वीकार्य हैं?

— Arnauld

@ अर्नुलद हां, सफेद स्थान का नेतृत्व और अनुगामी पूरी तरह से ठीक है।

— caird coinheringaahing

क्या लाइनों की सूची ठीक है?

— श्री Xcoder

Answer 1

त्रिकोणीयता , 127 बाइट्स

.......).......
......2)1......
...../)IL^.....
....f)rMD@_....
...)2)1/)IL^...
..f+`"'.'*"+E..
.DWReD)2s^)Its.
D+@sh+s+})10cJ.

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

व्याख्या

पैडिंग के लिए बनने वाले पात्रों को हटाकर, हमें निम्नलिखित कार्यक्रम मिलते हैं:

)2)1/)IL^f)rMD@_)2)1/)IL^f+`"'.'*"+EDWReD)2s^)ItsD+@sh+s+})10cJ

... जो काफी लंबाई-ईश है, है ना? इसे टुकड़ों में तोड़ देते हैं।

पूर्णांक बनाना [0 ... (len (इनपुट))

)2)1/)IL^f)r – Subprogram #1.
)            – Creates a new stack entry, equal to 0. This must precede any integer
               literal, because each character in '0123456789' isn't parsed on its
               own as a literal, but rather they are commands which multiply the ToS
               by 10 and add the value of their digit equivalent. 
 2           – ToS * 10 + 2 = 2.           || STACK: [2]
  )1         – The literal 1.              || STACK: [2, 1]
    /        – Division.                   || STACK: [1 / 2] = [0.5]
     )I      – Get the input at index 0.   || STACK: [0.5, input]
       L     – Length.                     || STACK: [0.5, len(input)]
        ^    – Exponentiation.             || STACK: [len(input) ** 0.5]
         f   – Trim decimals.              || STACK: [int(len(input) ** 0.5)] 
          )r – Create the list [0 .. ToS). || STACK: [[0 ... int(len(input) ** 0.5))]

डॉट्स बनाना

MD@_)2)1/)IL^f+`"'.'*"+E – Subprogram #2.
MD                       – For each integer in the range, run some code on a separate
                           stack, preinitialised to two copies of the argument.
  @_                     – Increment and negate the ToS.
    )2)1/)IL^f           – The square root of the length of the input, again.
              +          – Add the two.
               `         – And cast the integer given to a string.
                "'.'*"+  – Prepends the literal "'.'*" to the string representation.
                       E – Evaluate as a Python expression (basically string repetition).

पात्रों को सामने की ओर ट्रिम करना

DWReD)2s^)It – Subprogram #3.
D            – Duplicate the result of the expression above.
 W           – Wrap the whole intermediate stack to an array.
  Re         – Reverse the stack and dump the contents separately onto the stack.
    D        – Duplicate the result.
     )2      – Push the literal 2.
       s^    – Swap and perform exponentiation.
         )It – Push the input and trim the characters before that index.

पात्रों को अंत में ट्रिम करना

sD+@sh+s+ – Subprogram #4.
s         – Swap the top two elements on the stack.
 D+       – Double. Push twice and add.
   @      – Increment.
    sh    – Swap the top two elements and trim the characters after that index.
      +   – Append the first set of dots.
       s+ – And prepend the second set of dots.

पाश और सुंदर छपाई को समाप्त करना

})10cJ – Subprogram #5.
}      – End the loop.
 )10   – Push the literal 10.
    c  – Convert from code-point to character (yields '\n').
     J – And join the result by newlines.

Comments

क्या आपको "" के लिए बाइट्स स्कोर करने होंगे। यदि वे भाषा के अंतर्ज्ञान द्वारा अनिवार्य हैं तो वर्ण?

— JDL

@JDL हाँ, कार्यक्रम उनके बिना सही ढंग से नहीं चल सकता है, इसलिए मुझे उन्हें बाइट काउंट में शामिल करना होगा :-)

— श्री एक्सकोडर

क्या आपको "डेसीमल ट्रिम" करने की आवश्यकता है, यह देखते हुए कि इनपुट की लंबाई चौकोर होने की गारंटी है? आपको Jअंत में रॉड प्राप्त करने और लाइनों की एक सरणी आउटपुट करने में सक्षम होना चाहिए । पता नहीं है कि अगर आप कुछ भी बचाने के लिए जा रहा है, हालांकि, अगर अंतिम पंक्ति के अंत के साथ .शेष स्थान को भरने के लिए गद्देदार होना चाहिए ।

— झबरा

@ शागिगी 1) हां, fजरूरत है क्योंकि सीमा फ्लोट तर्कों (यहां तक ​​कि .02 के साथ ) को स्वीकार नहीं कर सकती है क्योंकि Jपैडिंग के कारण किसी भी बाइट को बचाने से छुटकारा नहीं मिलता है, इसलिए मैंने प्रीटीयर आउटपुट प्रारूप चुना।

— श्री एक्सकोडर

Answer 2

जाप , 15 14 10 बाइट्स

लाइनों की एक सरणी आउटपुट।

ò@°T¬v1Ãû.

कोशिश करो | सभी परीक्षण मामलों की जाँच करें

---

Explantion

ò@     Ã       :Partition at characters where the following function returns true
  °T           :  Increment T (initially 0)
    ¬          :  Square root
     v1        :  Divisible by 1?
               :(Or, in other words, split after every character with a 1-based index that's a perfect square)
        û.     :Centre pad each element with .s to the length of the longest element

---

मूल समाधान

ʬÆsTT±X+°XÃû.

कोशिश करो

Ê                  :Length of input
 ¬                 :Square root
  Æ        à       :Range [0,ʬ) and pass each X through a function
   s               :  Slice input
    T              :    from index T, initially 0
     T±X+°X        :    to index T incremented by X plus X incremented
            û.     :Centre pad each element with .s to the length of the longest element

Answer 3

भूसी , 15 बाइट्स

Ṡzö`JR2tR'.ṡCİ1

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

व्याख्या

Ṡzö`JR2tR'.ṡCİ1  Implicit input, say s = "DfJ0vCq7G".
             İ1  List of odd positive integers: [1,3,5,7,..
            C    Cut s to those lengths: x = ["D","fJ0","vCq7G"]
           ṡ     Reversed indices of x: y = [3,2,1]
Ṡz               Zip x and y using this function:
                  Arguments are a string and a number, e.g. r = "fJ0" and n = 2.
        R'.       n copies of '.': ".."
       t          Drop first element: "."
     R2           Two copies of this: [".","."]
  ö`J             Join by r: ".fJ0."
                 Result is ["..D..",".fJ0.","vCq7G"]; implicitly print on separate lines.

Answer 4

05AB1E , 20 19 18 बाइट्स

मैजिक ऑक्टोपस Urn को बाइट धन्यवाद दिया

ā·<£õKRvy'.N×.ø}r»

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

व्याख्या

ā                    # push the list [1 ... len(input)]
 ·<                  # multiply each by 2 and decrement each, making a list of odd numbers
   £                 # split the input into chunks of these sizes
    õK               # remove empty strings
      R              # reverse list
       vy      }     # for each y in the list
             .ø      # surround it with
         '.N×        # "." (dot) repeated N times, where N is the current iteration index
                r    # reverse the stack
                 »   # join stack by newlines

Comments

ÅÉबाधाओं में मदद मिल सकती है?

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

कुछ पसंद है g;ÅÉ£Rvy'.N×.ø}r»? लेकिन ऐसा नहीं है क्योंकि यह सही नहीं है।

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

@MagicOctopusUrn: ÅÉयदि हम 2 बाइट्स में नीचे की पंक्ति की लंबाई का पता लगा सकते हैं तो निश्चित रूप से मदद मिलेगी। मुझे नहीं पता कि क्या हम कर सकते हैं। इसे शामिल करने का एक और तरीका हो सकता है।

— Emigna

@MagicOctopusUrn: मेरे पास यह एक ही समाधान पहले था सिवाय इसके कि मैं इस्तेमाल करता था जिसके )Rबजाय rकिसी भी बाइट को बचाया नहीं गया: /

— Emigna

मैं "लूप को रिवर्स" करने का एक तरीका खोजने की कोशिश कर रहा था, क्योंकि यह होता है, हालांकि उस पर कोई विचार नहीं है।

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

Answer 5

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

i=input();u=int(len(i)**.5)
for t in range(u):g="."*(u+~t);print g+i[t*t:][:t-~t]+g

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

Answer 6

जेली ,  22  19 बाइट्स

J²‘Ṭœṗ⁸Ṛz”.Zµṙ"JC$Ṛ

पात्रों की सूचियों की एक सूची लौटाने वाला एक विचित्र लिंक (लाइनें)

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

कैसे?

J²‘Ṭœṗ⁸Ṛz”.Zµṙ"JC$Ṛ - Link: list of characters e.g. "DfJ0vCq7G"
J                   - range of length               [1,2,3,4,5,6,7,8,9]
 ²                  - square (vectorises)           [1,4,9,16,25,36,49,64,81]
  ‘                 - increment                     [2,5,10,17,26,37,50,65,82]
   Ṭ                - untruth (1s at those indices) [0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,...]
      ⁸             - chain's left argument         "DfJ0vCq7G"
    œṗ              - partition at indexes          ["D","fJ0","vCq7G"]
       Ṛ            - reverse                       ["vCq7G","fJ0","D"]
         ”.         - literal '.'                   '.'
        z           - transpose with filler         ["vfD","CJ.","q0.","7..","G.."]
           Z        - transpose                     ["vCq7G","fJ0..","D...."]
            µ       - start a new monadic chain
                 $  - last two links as a monad:
               J    -   range of length             [1,2,3]
                C   -   complement (vectorises)     [0,-1,-2]
              "     - zip with:
             ṙ      -   rotate left by              ["vCq7G",".fJ0.","..D.."]
                  Ṛ - reverse                       ["..D..",".fJ0.","vCq7G"]

Answer 7

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

f=(s,k=1-s.length**.5*2,p='')=>s&&f(s.slice(0,k),k+2,p+'.')+`
`+p+s.slice(k)+p

परीक्षण के मामलों

f=(s,k=1-s.length**.5*2,p='')=>s&&f(s.slice(0,k),k+2,p+'.')+`
`+p+s.slice(k)+p

console.log(f('g'))
console.log(f('PcSa'))
console.log(f('DfJ0vCq7G'))
console.log(f('7xsB8a1Oqw5fhHX0'))
console.log(f('QNYATbkX2sKZ6IuOmofwhgaef'))
console.log(f('ABCDEF"$%& G8"F@'))

टिप्पणी की गई

f = (                       // f = recursive function taking:
  s,                        //   s = input string
  k = 1 - s.length**.5 * 2, //   k = additive inverse of the length of the base
  p = ''                    //   p = padding string
) =>                        //
  s &&                      // if s is not empty:
    f(                      //   do a recursive call with:
      s.slice(0, k),        //     s without the last -k characters
      k + 2,                //     the updated base length (2 less characters)
      p + '.'               //     the updated padding string
    ) +                     //   end of recursive call()
    `\n` +                  //   append a line feed
    p +                     //   append the left padding string
    s.slice(k) +            //   append the last -k characters of s
    p                       //   append the right padding string

Comments

[मामूली] '/ n' प्रतीक शीर्ष पर कोड ब्लॉक में एक वास्तविक रेखा विराम बन गया - इसे स्पष्टता के लिए बचने पर विचार करें :)

— G0BLiN

@ G0BLiN यह दूसरी तरह के आसपास है: यह है वास्तव में golfed कोड है, जो स्पष्टता के लिए ungolfed संस्करण में एक भाग निकले लाइन ब्रेक के साथ बदल दिया गया था में एक शाब्दिक लाइन ब्रेक। :)

— अरनौल

हा, मुझ पर चुटकुला, फिर ... :-)

— G0BLiN

Answer 8

05AB1E , 25 बाइट्स

gÅÉ£õKð'ø‡.c¶¡ζøð'.‡'øð‡»

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

Answer 9

MATL , 21 बाइट्स

tnX^eRP&1ZvGyg(46y~(!

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

व्याख्या

'DfJ0vCq7G'उदाहरण के रूप में इनपुट पर विचार करें । स्टैक सामग्री को अल्पविराम द्वारा अलग दिखाया गया है, शीर्ष तत्व अंतिम के साथ। 2 डी सरणी में पंक्तियाँ अर्धविराम को विभाजक के रूप में उपयोग करती हैं।

t      % Implicit input: string. Duplicate
       % STACK: 'DfJ0vCq7G',
                'DfJ0vCq7G'
nX^    % Number of elements. Square root
       % STACK: 'DfJ0vCq7G',
                3
e      % Reshape with that many rows (in column major order)
       % STACK: ['D0q';
                 'fv7';
                 'JCG']
R      % Upper triangular part: set elements below diagonal to char(0)
       % (displayed as space)
       % STACK: ['D0q';
                 ' v7';
                 '  G']
P      % Flip vertically
       % STACK: ['  G';
                 ' v7';
                 'D0q']
&1Zv   % Reflect vertically
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G']
G      % Push input again
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G'],
                'DfJ0vCq7G'
yg     % Duplicate from below and convert to logical. This gives true for
       % for nonzero chars (the entries where input chars will be written)
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G'],
                'DfJ0vCq7G',
                [0 0 1;
                 0 1 1;
                 1 1 1;
                 0 1 1;
                 0 0 1]
(      % Assignment indexing: write values at those positions
       % STACK: ['  v';
                 ' fC';
                 'DJq';
                 ' 07';
                 '  G']
46     % Push 46, which is ASCII for '.'
       % STACK: ['  v';
                 ' fC';
                 'DJq';
                 ' 07';
                 '  G'],
                 46
y~     % Duplicate from below and apply logical negate. This gives true
       % for char(0) (the entries where '.' will be written)
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G'],
                46
                [1 1 0;
                 1 0 0;
                 0 0 0;
                 1 0 0;
                 1 1 0]
(      % Assignment indexing: write value at those positions
       % STACK: ['..G';
                 '.v7';
                 'D0q';
                 '.v7';
                 '..G'],
!      % Transpose. Implicit display
       % STACK: ['..D..';
                 '.fJ0.';
                 'vCq7G']

Answer 10

क्लीन , 107 94 89 88 बाइट्स

import StdEnv
@s _[]=s
@s n r= @([['.':l]++['.']\\l<-s]++[take n r])(n+2)(drop n r)

@[]1

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: @[]1 ['ABCDEF"$%& G8"F@']।

Answer 11

हास्केल , 84 68 बाइट्स

[]%1
(s%n)[]=s
(s%n)r=(['.':l++"."|l<-s]++[take n r])%(n+2)$drop n r

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

उदाहरण का उपयोग: []%1 $ "abcd"लाइनों की सूची की पैदावार [".a.","bcd"]।

Answer 12

पर्ल, 56 52 बाइट्स

के लिए शामिल +3है-p

#!/usr/bin/perl -p
$_=("."x y///c**.5)=~s%.%$'@{[$&x/$`$`./g]}$'
%rg

STDIN पर इनपुट दें (सिद्धांत में अंतिम नई लाइन के बिना, लेकिन यह केवल खाली इनपुट के लिए मायने रखता है)

Comments

पीसीजी के नियमों के अनुसार -p

— मिक्स

@ केवल अगर कोड शामिल नहीं है '। लेकिन यह कोड करता है, इसलिए इसे एक फाइल (या कमांडलाइन पर भागने) में डालने की आवश्यकता होती है जिसे सामान्य #!लाइन की तुलना में 3 अतिरिक्त वर्णों की आवश्यकता होती है । तो इस मामले में यह है +3(सामान्य कोड के लिए आप देखेंगे कि मैं वास्तव में केवल गिनती के +लिए p)

— टन हास्पेल

Answer 13

लाल , 227 203 बाइट्स

f: func[s][l: to-integer(length? s)** 0.5
n: 0 foreach m parse s[collect[(r: []repeat i l[append r reduce['keep i * 2 - 1
charset[not{Я}]]])r]][v: copy""insert/dup v"."l - n: n + 1 print rejoin[v m v]]]

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

Ungolfed:

f: func[s][
l: to-integer (length? s) ** 0.5
n: 0
foreach m parse s [ 
    collect [
        (r: []
        repeat i l [ append r reduce [
            'keep i * 2 - 1 charset [ not{Я} ]]])
    r ]] 
    [v: copy ""
    insert/dup v "." l - n: n + 1
    print rejoin [v m v]]
]

Answer 14

रेटिना , 88 72 71 बाइट्स

S1`
+m`^(.)+¶(?>(?<-1>.)+)..(?!¶)
$&¶
P^'.m`^.(?=(..)*)(?<-1>.)*
P'.`.+

इसे ऑनलाइन आज़माएं! संपादित करें: @MartinEnder के लिए 12 13 बाइट्स सहेजे गए। स्पष्टीकरण:

S1`

गेंद को लुढ़काने के लिए पहले पात्र को अपनी रेखा में विभाजित करें।

+m`^(.)+¶(?>(?<-1>.)+)..(?!¶)
$&¶

पिछले एक की तुलना में प्रत्येक पंक्ति दो वर्णों को काटें।

P^'.m`^.(?=(..)*)(?<-1>.)*

प्रत्येक पंक्ति के पहले भाग को बाएं-पैड पर प्रभावी ढंग से केंद्रित करते हुए।

P'.`.+

सभी लाइनों का राइट-पैड।

Answer 15

चारकोल , 21 19 बाइट्स

ＵＢ.Ｆ₂Ｌθ«Ｐ✂θＸι²Ｘ⊕ι²↙

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: खोज कर 2 बाइट्स सहेजे गए SquareRoot। स्पष्टीकरण:

ＵＢ.                 Set the background fill to `.`
      θ             (First) input
     Ｌ              Length
    ₂               Square root
   Ｆ   «            Loop over implicit range
            ι   ι   Current value
               ⊕    Incremented
             ²   ²  Literal 2
           Ｘ  Ｘ     Power
         ✂θ         Slice the (first) input string
        Ｐ           Print without moving the cursor
                  ↙ Move down left

Comments

: / यह लगभग काम करता है लेकिन ऐसा प्रतीत होता है कि चारकोल थोड़ा छोटा है। हालांकि यह काम करता है, मुझे लगता है?

— केवल

@ ASCII- ही ... यह कौन सा काला जादू है?

— नील

नल बाइट्स के लिए मूल रूप से चेक भरें (यानी अंतरिक्ष के लिए उपयोग किया जाने वाला चरित्र जहां कुछ भी नहीं खींचा जाता है), इसलिए आप बस नल बाइट्स के साथ एक बहुभुज आकर्षित कर सकते हैं (ठीक है, अगर यह सही ढंग से काम करता है> _>) और इसे भरें। जाहिर है कि यह वास्तव में इरादा नहीं है क्योंकि आप वास्तव में नल बाइट्स को किसी कारण से भरने से पहले भी देख सकते हैं> _>

— केवल

यह ठीक से अगले पुल पर काम करना चाहिए

— केवल

Answer 16

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

s=input()
l=int(len(s)**.5)
for i in range(l):print s[i*i:][:i-~i].center(l*2-1,'.')

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

Answer 17

क्लीन , 123 बाइट्स

import StdEnv
?n l#(a,b)=splitAt n l
|b>[]=[a: ?(n+2)b]=[a]
$s#s= ?1s
=[c++l++c\\l<-s&i<-[1..],c<-[repeatn(length s-i)'.']]

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

Comments

कुछ दोस्ताना प्रतियोगिता ।

— लाकोनी

@ लिकोनी ऊह, यह मेरी पसंदीदा किस्म की प्रतियोगिता है!

— Οurous

Answer 18

रूबी , 73 66 बाइट्स

->s{(1..z=s.size**0.5).map{|q|s[q*q-2*q+1...q*q].center 2*z-1,?.}}

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

-5 बाइट्स: उन्हें प्रिंट करने के बजाय स्ट्रिंग्स की एक सरणी लौटें

-2 बाइट्स: zसमय से पहले की जगह डिक्लेयर करें

Ungolfed:

->s{
  (1..z=s.size**0.5).map{|q|   # Map the range [1,sqrt(s.size)]
    s[q*q-2*q+1...q*q]         # To the relevant portion of s,
      .center 2*z-1, ?.        #   padded left and right with . characters
  }
}

एक चर की घोषणा करना r=q-1ताकि मैं ले सकता हूँ s[r*r...q*q]बिल्कुल शून्य बाइट्स बचाता है।

.centerमैन्युअल रूप से पैडिंग करने के बजाय शून्य बाइट्स का उपयोग करने से भी बचत होती है, लेकिन मुझे यह बेहतर लगता है।

Answer 19

स्टैक्स , 19 बाइट्स

╚└÷2╬#►o┴X≡¥ΩåV∙¬?♥

इसे चलाएं और डीबग करें

ASCII समकक्ष:

z;%|q{Hv,:/~]+F|Cm0]'.R