पाठ का एक घन ݀

Question

पिछली बार आपने पाठ का एक वर्ग बनाया था , लेकिन अब, क्या आप पाठ का घन बना सकते हैं ?

चुनौती

एक स्ट्रिंग को देखते हुए, क्यूब के रूप में स्ट्रिंग को आउटपुट करता है।

आप मान सकते हैं कि स्ट्रिंग में हमेशा 2 वर्ण या अधिक होंगे, और केवल मुद्रण योग्य एससीआई अक्षर होंगे।

कैसे एक पाठ घन बनाने के लिए

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

Input:
Test

Output:
   Test
  e  ss
 s  e e
tseT  T
s  e e
e  ss
Test

Input:
Hello, world!

Output:
            Hello, world!
           e           dd
          l           l l
         l           r  r
        o           o   o
       ,           w    w

     w           ,      ,
    o           o       o
   r           l        l
  l           l         l
 d           e          e
!dlrow ,olleH           H
d           e          e
l           l         l
r           l        l
o           o       o
w           ,      ,

,           w    w
o           o   o
l           r  r
l           l l
e           dd
Hello, world!

Input:
Hi

Output:
 Hi
iHH
Hi

पायथन में संदर्भ कार्यान्वयन

text = raw_input("Enter a string: ")

print " " * (len(text) - 1) + text

spaces = len(text) - 2
_spaces = spaces

for i in range(1, len(text) - 2 + 1):
    print " " * spaces + text[i] + " " * _spaces + text[(i + 1) * -1] + " " * (_spaces - spaces) + text[(i + 1) * -1]
    spaces -= 1

print text[::-1] + " " * _spaces + text[0]

spaces = _spaces - 1

for i in range(1, len(text) - 2 + 1):
    print text[(i + 1) * -1] + " " * _spaces + text[i] + " " * spaces + text[i]
    spaces -= 1

print text

नियम

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

Comments

अनुगामी रिक्त स्थान की अनुमति है?

— नील

@ नील हां। (15 वर्ण)

— एक्रोलिथ

बस उत्सुक, चुनौती शीर्षक में अतिरिक्त पात्रों के साथ क्या है?

— AdmBorkBork

@TimmyD "पाठ का घन" 14 वर्ण लंबा है, शीर्षक को कम से कम 15 वर्ण लंबा होना चाहिए, इसलिए मैंने एक छोटा बिंदु जोड़ा। मुझे लगता है कि यह एक है।

— एक्रोलिथ 18

आह अच्छा। यह मेरे कंप्यूटर पर IE में एक बहुत बड़े सर्कल के रूप में दिखाई देता है, इसलिए मेरा सवाल है।

— AdmBorkBork

Answer 1

पायथ, 78 बाइट्स

AtBtlQJ_SH
+*dGQVJs[*Nd@Q-GN*dHK@QN*d-HNK;
++_Q*dHhQVJs[@QN*dH@Q-GN*dtN@Q-GN;

अनुगामी न्यूलाइन के साथ। जोशुआ डी हैन के पायथन 3 उत्तर से प्रेरित।

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

Answer 2

अजगर 2, 228 223 221 203 199 195 189

t=input()
x=" "
l=len(t)-1
q=l-1
f=range(q,0,-1)
print x*l+t
for i in f:print x*i+t[l-i]+x*q+t[i]+x*(q-i)+t[i]
print t[::-1]+x*q+t[0]
for i in f:print t[i]+x*q+t[l-i]+x*(i-1)+t[l-i]
print t

पायथन 3, 192 188 182

t=input()
x=" "
l=len(t)-1
q=l-1
p=print
f=range(q,0,-1)
p(x*l+t)
for i in f:p(x*i+t[l-i]+x*q+t[i]+x*(q-i)+t[i])
p(t[::-1]+x*q+t[0])
for i in f:p(t[i]+x*q+t[l-i]+x*(i-1)+t[l-i])
p(t)

Comments

वह 203 बाइट्स है। इसके अलावा, आप की जगह 4 बाइट बचा सकता है raw_input()के साथ input()।

— एक्रोलिथ

सही है, धन्यवाद!

— जोशुआ डी हैन

x*(q)? आपको पैरेंस को हटाने में सक्षम होना चाहिए, हां?

— मूल्य इंक

तुम सही हो, मुझे मूर्ख;) यह अब ठीक कर रहा है

— यहोशू डे हॉन

x*(i-1)->x*~-i

— mbomb007

Answer 3

x86 (IA-32) मशीन कोड, 126 बाइट्स

Hexdump:

60 8b f9 57 33 c0 f2 ae 5e 2b fe 4f 87 fa 8d 1c
12 8b c3 48 f6 e3 c6 04 07 00 48 c6 04 07 20 75
f9 8b ea 4d 53 8d 04 2a 50 53 8b c5 f6 e3 8d 44
68 01 50 53 2b c2 8b c8 50 4b 53 55 53 03 c5 50
f7 d3 53 50 53 95 f6 e2 6b c0 04 50 43 53 51 6a
01 4a 52 6a 01 50 6a ff 51 b0 0a 6a 0b 8b dc 59
8b 6c cb fc 88 04 2f 03 2c cb 89 6c cb fc 83 f9
0a 75 01 ac e2 ea 4a 79 e0 83 c4 58 61 c3

यह थोड़ा लंबा है, इसलिए इसे समझाने के लिए मैं पहले C कोड दूंगा:

void doit(const char* s, char out[])
{
    int n = strlen(s);
    int w = 2 * n;
    int h = w - 1;
    int m = n - 1;

    memset(out, ' ', h * w);
    out[h * w] = 0;

    int offset1 = n + m;
    int offset2 = w * m + 2 * m + 1; // 2 * n * n - 1
    int offset3 = offset2 - n; // 2 * n * n - n - 1
    int offset4 = 4 * n * m; // 4 * n * n - 4 * n

    int offsets[] = {
        offset3, -1,
        offset4, 1,
        m, 1,
        offset3, 1 - w,
        offset4, -w,
        offset2 - 1, -w,
        offset2 - 1, w - 1,
        m, w - 1,
        offset3, w,
        offset2, w,
        offset1, w,
    };

    do
    {
        char c = *s++;
        for (int i = 0; i < 11; ++i)
        {
            if (i == 9)
                c = '\n';
            int offset = offsets[i * 2];
            assert(offset > 0 && offset < w * h);
            out[offset] = c;
            offsets[i * 2] += offsets[i * 2 + 1];
        }
    } while (--n);
}

यहां nइनपुट स्ट्रिंग की लंबाई है।

उत्पादन क्षेत्र के आयाम 2n(चौड़ाई) द्वारा 2n-1(ऊंचाई) हैं। सबसे पहले, यह रिक्त स्थान के साथ सब कुछ भरता है (और एक समाप्ति नल बाइट जोड़ता है)। फिर, यह आउटपुट क्षेत्र में 11 सीधी रेखाओं के साथ यात्रा करता है, और उन्हें पाठ से भरता है:

• 2 लाइनें अंतिम पंक्ति के बाइट्स से भरी हुई हैं (= 10)
• इनपुट स्ट्रिंग के लगातार बाइट्स के साथ 9 लाइनें भरी हुई हैं

प्रत्येक पंक्ति को दो संख्याओं द्वारा दर्शाया जाता है, एक स्टार्ट ऑफ़ और एक स्ट्राइड। मैंने उन दोनों को सरणी में भर दिया offsets, ताकि पहुंच को "आसान" बनाया जा सके।

दिलचस्प हिस्सा सरणी भर रहा है। सरणी में प्रविष्टियों के क्रम के लिए बहुत कम महत्व है; मैंने उन्हें रजिस्टर संघर्षों की संख्या को कम करने के लिए पुनर्व्यवस्थित करने की कोशिश की। इसके अलावा, गणना के तरीके को चुनने में द्विघात सूत्रों को कुछ स्वतंत्रता है; मैंने घटाव की संख्या को कम करने की कोशिश की (क्योंकि जोड़ लचीले द्वारा लागू किए जा सकते हैंLEA निर्देशों निर्देश )।

विधानसभा स्रोत:

    pushad;

    ; // Calculate the length of the input string
    mov edi, ecx;
    push edi;
    xor eax, eax;
    repne scasb;
    pop esi; // esi = input string
    sub edi, esi;
    dec edi;

    ; // Calculate the size of the output area
    xchg edi, edx;  // edx = n
                    // edi = output string
    lea ebx, [edx + edx]; // ebx = w
    mov eax, ebx;
    dec eax; // eax = h
    mul bl; // eax = w * h

    ; // Fill the output string with spaces and zero terminate it
    mov byte ptr [edi + eax], 0;
myfill:
    dec eax;
    mov byte ptr [edi + eax], ' ';
    jnz myfill;

    mov ebp, edx;
    dec ebp; // ebp = m

    ; // Fill the array of offsets
    push ebx; // w
    lea eax, [edx + ebp];
    push eax; // offset1
    push ebx; // w
    mov eax, ebp;
    mul bl;
    lea eax, [eax + 2 * ebp + 1];
    push eax; // offset2
    push ebx; // w
    sub eax, edx;
    mov ecx, eax; // ecx = offset3
    push eax; // offset3
    dec ebx;
    push ebx; // w - 1
    push ebp; // m
    push ebx; // w - 1
    add eax, ebp;
    push eax; // offset2 - 1
    not ebx;
    push ebx; // -w
    push eax; // offset2 - 1
    push ebx; // -w
    xchg eax, ebp; // eax = m
    mul dl;
    imul eax, eax, 4;
    push eax; // offset4
    inc ebx;
    push ebx; // 1 - w
    push ecx; // offset3
    push 1;
    dec edx; // edx = n - 1
    push edx;
    push 1;
    push eax;
    push -1;
    push ecx;

    ; // Use the array of offsets to write stuff to output
myout:
    mov al, '\n';
    push 11;
    mov ebx, esp;
    pop ecx;
myloop:
    mov ebp, [ebx + ecx * 8 - 4];
    mov [edi + ebp], al;
    add ebp, [ebx + ecx * 8];
    mov [ebx + ecx * 8 - 4], ebp;
    cmp ecx, 10;
    jne skip_read;
    lodsb;
skip_read:
    loop myloop;
    dec edx;
    jns myout;

    add esp, 11 * 8;

    popad;
    ret;

मैंने यहां बाइट गुणा का उपयोग किया है, इनपुट स्ट्रिंग की लंबाई 127 तक सीमित कर दी है। यह रजिस्टर को क्लॉबरिंग करने से बचता है edx- उत्पाद की गणनाax इसके बजाय ।

एक छोटी सी गड़बड़: सरणी भरते समय, स्ट्रिंग की लंबाई 1 से कम हो जाती है। इसलिए मैंने लूप बाहर निकलने की स्थिति को समायोजित किया:

    jns myout

यह -1 तक गिना जाता है।

Answer 4

रूबी, १४ Rub 144 बाइट्स

nझंडे से +1 बाइट । पठनीयता (समान कार्यक्षमता) के लिए अर्धविरामों के बजाय नई सूचियाँ दिखाता है।

S=" "
X=S*s=$_.size-2
puts X+S+I=$_,(r=1..s).map{|i|c=I[~i];S*(s-i+1)+I[i]+X+c+S*~-i+c},I.reverse+X+I[0],r.map{|i|c=I[i];I[~i]+X+c+S*(s-i)+c},I

ऐसे ही दौड़ो। इनपुट STDIN की एक पंक्ति है, जिसमें कोई अनुगामी न्यूलाइन नहीं है, इसलिए इसे फ़ाइल से पाइप करने की आवश्यकता है।

ruby -ne 'S=" ";X=S*s=$_.size-2;puts X+S+I=$_,(r=1..s).map{|i|c=I[~i];S*(s-i+1)+I[i]+X+c+S*~-i+c},I.reverse+X+I[0],r.map{|i|c=I[i];I[~i]+X+c+S*(s-i)+c},I'

Answer 5

जावास्क्रिप्ट, 225 198 बाइट्स

@Neil की बदौलत 27 बाइट्स बचाए

f=(s,l=s.length-2,d=' ',r='repeat',t=d[r](l))=>[d+t+s,...a=[...Array(l)].map((_,i)=>d[r](l-i)+s[i+1]+t+(p=s[l-i])+d[r](i)+p),[...s].reverse().join``+t+s[0],...a.map(v=>v.trim()).reverse(),s].join`
`

• [...] इसके बजाय .concat
• [...] + के बजाय नक्शा के लिए पाश
• फ़ंक्शन मापदंडों के रूप में चर को स्थानांतरित करके केवल एक बयान
• एल और टी के लिए बेहतर आरंभीकरण

मूल उत्तर:

f=s=>{l=s.length,d=' ',r='repeat',a=[],t=d[r](l-2)+s;for(i=1;i++<l-1;)a.push(d[r](l-i)+s[i-1]+d[r](l-2)+(p=s[l-i])+d[r](i-2)+p);console.log(d+[t].concat(a,[...t].reverse().join``+s[0],a.map(v=>v.trim()).reverse(),s).join`
`)}

Comments

अच्छा है, हालांकि गोल्फ: (s,l=s.length-2,d=' ',r='repeat',t=d[r](l))=>[d+t+s,...a=[...Array(l)].map((_,i)=>d[r](l-i)+s[i+1]+t+(p=s[l-i])+d[r](i)+p),[...s].reverse().join``+t+s[0],...a.map(v=>v.trim()).reverse(),s].join`\n`( \nक्योंकि आप टिप्पणियों में newlines नहीं डाल सकते हैं)।

— नील

Answer 6

जावा 7, 283 बाइट्स

void a(String s){int h=s.length(),n=h*2-1,t=n-h,u=n-1;char[][]c=new char[n][n];for(int i=0;i<h;i++){c[0][t+i]=c[i][t-i]=c[t][t-i]=c[t+i][t]=c[t+i][u-i]=c[t-i][t+i]=c[t-i][u]=c[u][i]=c[u-i][0]=s.charAt(i);}for(int y=0;y<n;y++){System.out.println(new String(c[y]).replace('\0',' '));}}

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

Ungolfed:

void a(String s) {
    int length=s.length(),
        n=length*2-1,
        mid=n-length,
        doubleMid=n-1;
    char[][]c=new char[n][n];
    for(int i=0;i<length;i++) {
        c[0][mid+i]= 
        c[i][mid-i]=
        c[mid][mid-i]=
        c[mid+i][mid]=
        c[mid+i][doubleMid-i]=
        c[mid-i][mid+i]=
        c[mid-i][doubleMid]=
        c[doubleMid][i]=
        c[doubleMid-i][0]=s.charAt(i);
    }
    for(int y=0;y<n;y++){
        System.out.println(new String(c[y]).replace('\0',' '));
    }
}