38

चुनौती

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

उदाहरण

इनपुट दिया:

golf

आपका कार्यक्रम आउटपुट होना चाहिए:

golf
o  l
l  o
flog

इनपुट:

आउटपुट:

123
2 2
321

इनपुट:

आउटपुट:

इनपुट:

Hello, world!

आउटपुट (नोटिस, और w के बीच की जगह - अंतर केवल एक नई रेखा नहीं है):

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

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

स्कोरिंग

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम उत्तर जीतता है।

code-golf string code-golf number sequence combinatorics code-golf tips javascript code-golf kolmogorov-complexity fibonacci restricted-time code-golf ascii-art code-golf string text-processing code-golf sequence set-partitions code-golf kolmogorov-complexity natural-language code-golf string code-golf math code-challenge restricted-source code-golf code-golf number base-conversion cops-and-robbers encryption code-challenge quine optimized-output king-of-the-hill python

— SpookyGengar
स्रोत

@DJMcMayhem हाँ, मेरी क्षमा याचना मैं वह जोड़ना भूल गया था।

— SpookyGengar

2

कोई चिंता नहीं, बस दोहरी जाँच। अच्छा पहली चुनौती BTW! साइट के लिए :) आपका स्वागत है

— DJMcMayhem

@SpookyGengar क्या आप एक-लेटर इनपुट के लिए एक टेस्ट केस जोड़ेंगे?

— संगीतज्ञ ५२३

@ musicman523 क्या मेरे पास पहले से एक नहीं है? तीसरा उदाहरण जिसमें सिर्फ 'a' अक्षर शामिल है।

— स्पूकीगेंगर

1

मेरा बुरा @SpookyGengar, मैं अंधा जाहिरा तौर पर कर रहा हूँ

— musicman523

17

चारकोल , 7 5 बाइट्स

θ‖Ｏ↙↘

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

θ       Print the input string, making the top row
 ‖Ｏ     Reflect with overlap...
   ↙    ... down and left, to create the left side
    ↘   ... down and right, to create the bottom and right sides

(रिफ्लेक्ट कमांड के कई निर्देश एक साथ चलने के बजाय लगातार चलते हैं।)

— नील
स्रोत

वाह, जीसस, मुझे अभी भी लगता है कि चारकोल सबसे अच्छा एसोलैंग विचार था।

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

1

आप दो बाइट्स बचा सकता है अगर आप सिर्फ इनपुट स्ट्रिंग प्रिंट और यह downleftwards और downrightwards प्रतिबिंबित: θ‖Ｂ↙↘। इसे ऑनलाइन आज़माएं!

— चार्ली

अब जब मैं इसके बारे में सोचता हूं, तो शायद मुझे फ्लिपिंग पात्रों से बचने के ReflectOverlapबजाय इसका इस्तेमाल करना चाहिए ReflectButterfly। :-)

— चार्ली

1

यह उन दुर्लभ मामलों में से एक है, जहां गूढ़ भाषा में एक गूढ़ उत्तर लोकप्रिय सामान्य प्रयोजन भाषाओं के पूर्ण असंयमित संस्करणों की तुलना में पढ़ना और समझना आसान है।

— कालेब

यहां आपका जवाब 4 बाइट्स के लिए भी काम करता है।

— ओलिवर

10

MATL , 20 16 11 बाइट्स

otYTO6Lt&(c

MATL ऑनलाइन पर यह कोशिश करो !

EDIT: कोड 20.2.1 रिलीज में काम करता है, जो चुनौती से पहले होता है। लिंक उस रिलीज़ का उपयोग करता है। (20.2.2 में कोड कम होगा, लेकिन यह चुनौती को स्थगित कर देता है)।

व्याख्या

o     % Implicitly input a string. Convert chars to ASCII codes
t     % Duplicate
YT    % 2-input Toeplitz matrix
O     % Push 0
6L    % Push predefined literal [2, -1+1j]. When used as an index, this is
      % interpreted as 2:end-1 (indexing is 1-based)
t     % Duplicate
&(    % 4-input assignment indexing. This writes 0 at the square formed by
      % rows 2:end-1 and columns 2:end-1 
c     % Convert to char. Char 0 is shown as space. Implicitly display

— लुइस मेंडो
स्रोत

बहुत प्रभावशाली! :) क्या हर आउटपुट के नीचे खाली लाइन को हटाना संभव है, या क्या कार्यक्षमता के लिए इसकी आवश्यकता है?

— SpookyGengar

2

@SpookyGengar एक एकल अनुगामी न्यूलाइन की अनुमति देना एक बहुत ही सामान्य अनुरोध है।

— जोनाथन एलन

@SpookyGengar धन्यवाद! MATL हमेशा एक अनुगामी न्यूलाइन प्रदर्शित करता है। जैसा कि जोनाथन कहते हैं, कि आम तौर पर अनुमति दी जाती है

— लुइस मेंडो

1

@LuisMendo आप हर रोज़ कुछ नया सीखते हैं। :) प्रस्तुत करने के लिए धन्यवाद - निश्चित रूप से अब तक का सबसे अच्छा!

— स्पूकीगेंगर

6

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

चारकोल इस स्कोर को + उछाल ~~देगा~~ ...

J⁶ẋa0,1¦"ṚṚ;$ṖŒḌY

वर्णों की सूची लेने और वापस करने वाला एक विचित्र लिंक; या परिणाम को पूरा करने वाला एक पूरा कार्यक्रम।

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

कैसे?

J⁶ẋa0,1¦"ṚṚ;$ṖŒḌY - Link: list of characters, w     e.g. "whole"
 ⁶                - literal space character              ' '
J                 - range(length(w))                     [1,2,3,4,5]
  ẋ               - repeat                               [" ","  ","   ","    ","     "]
         Ṛ        - reverse w                            "elohw"
        "         - zip with:
       ¦          -   sparse application of:
   a              -     and (vectorises)
    0,1           -     to indexes: [0,1] (last and 1st) ["e","ll","o o","h  h","w   w"]
            $     - last two links as a monad:
          Ṛ       -   reverse                            ["w   w","h  h","o o","ll","e"]
           ;      -   concatenate                        ["w   w","h  h","o o","ll","e","e","ll","o o","h  h","w   w"]
             Ṗ    - pop (remove last entry)              ["w   w","h  h","o o","ll","e","e","ll","o o","h  h"]
              ŒḌ  - reconstruct matrix from diagonals    ["whole","h   l","o   o","l   h","elohw"]
                Y - join with newlines                   "whole\nh   l\no   o\nl   h\nelohw"
                  - if running as a full program implicit print

— जोनाथन एलन
स्रोत

बहुत ही शांत! अब तक का सबसे छोटा समाधान, लेकिन एकल-वर्ण इनपुट के साथ काम नहीं करता है, और संख्याओं से मिलकर तार यानी '123'।

— SpookyGengar

आह मुझे सिंगल कैरेक्टर एज केस संभालना होगा, हां। यह डिजिट-कैरेक्टर स्ट्रिंग्स के साथ काम करता है, प्रोग्राम इनपुट को वास्तव में उद्धृत किया जाना चाहिए, जैसे 'Hello', "स्पूकी" "123", आदि। (इनपुट की व्याख्या करने के लिए पायथन का उपयोग किया जाता है)।

— जोनाथन एलन

@SpookyGengar - ने इसे 1-वर्ण मामले के लिए निर्धारित किया है।

— जोनाथन एलन

अच्छी लंबाई में कमी!

— लुइस मेंडो

2

आप चारकोल के बारे में सही हैं।

— नील

3

सी, 109 बाइट्स

i,j;f(char*s){for(i=j=printf("%s\n",s)-2;1[++s];)printf("%c%*c\n",*s,i,s[j-=2]);for(;*s*~i--;)putchar(*s--);}

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

उल्लेखनीय चाल:

बाइट को बर्बाद करने के बजाय strlen, हम पहली पंक्ति को प्रिंट करते समय बस स्ट्रिंग की लंबाई को पकड़ते हैं:
```
i=j=printf("%s\n",s)-2
```
यह काम करता है क्योंकि printfलिखित बाइट्स की संख्या लौटाता है।
मध्य रेखाओं के लिए, हमें स्ट्रिंग पर लूप करने की आवश्यकता होती है, लेकिन पहले और अंतिम दोनों वर्णों को छोड़कर। यह शर्त के साथ हासिल किया जाता है
```
1[++s]
```
(जो की तुलना में कम है (++s)[1]), जो ++कि स्थिति में होने के कारण पहले चरित्र को छोड़ देता है और वर्तमान चरित्र के पिछले चरित्र को '\0'रोकने के बजाय रोककर अंतिम छोड़ देता है (बजाय रुकने के '\0' )।
पहले लूप के शरीर में,
```
printf("%c%*c\n",*s,i,s[j-=2])
```
हम वर्तमान चरित्र को प्रिंट करते हैं, फिर उपयुक्त "मिरर किए गए" चरित्र (ट्रैक को ध्यान में रखते हुए j, जो नकारात्मक में जाता है, जिसके परिणामस्वरूप स्ट्रिंग में नकारात्मक संख्या के साथ अनुक्रमण की विषम स्थिति होती है) iरिक्त स्थान की लंबाई के साथ गद्देदार (जहां iहै) सुविधा से strlen(s) - 1)।
अंतिम पंक्ति पर उलट छपाई बहुत सीधी है; एकमात्र चाल है *s*~i--, जो i+2लूप बॉडी के पुनरावृत्तियों को प्राप्त करने का सबसे छोटा तरीका है (जो निर्भर नहीं करता है i; सभी iका उपयोग गिनती के लिए किया जाता है)। फंकी वाला *s*हिस्सा सुनिश्चित करता है कि लूप नहीं चलता है अगर *sहै '\0', जो लंबाई -1 इनपुट पर होता है।

— Doorknob
स्रोत

3

ऑक्टेव, 40 बाइट्स

@(s,t=toeplitz(s),u=t(x=2:end-1,x)=32)t;

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

यह मेरा उत्तर है लेकिन @L MATL उत्तर के बाद पोस्ट किया गया है

— rahnema1
स्रोत

2

बहुत अच्छा जवाब। Btw: आपका कोड GNU ऑक्टेव डेवलपमेंट ब्रांच 4.3.1 (b481a9baeb61) से क्रैश हो गया और अब टेस्ट सूट का हिस्सा है :-) hg.savannah.gnu.org/hgweb/octave//vv/c94e9509461b

— Andy

1

@Andy धन्यवाद और codegolf में आपका स्वागत है! मुझे खुशी है कि अगर यह ऑक्टेव परियोजना को बेहतर बनाने में मदद कर सकता है!

— rahnema1

3

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

f s@(_:x)|_:y<-r x=s:[a:(y>>" ")++[b]|(a,b)<-zip x y]++[r s];f s=[s]
r=reverse

इसे ऑनलाइन आज़माएं! उपयोग: f "test"। लाइनों की एक सूची देता है।

संपादित करें: -6 बाइट्स dianne के लिए धन्यवाद!

— Laikoni
स्रोत

1

आप गार्ड के रूप में पैटर्न गार्ड का उपयोग करके और के लिए एक पर्यायवाची को परिभाषित करके कुछ बाइट्स बचा सकते हैं reverse; r=reverse;f s@(_:x)|_:y<-r x=s:[a:(y>>" ")++[b]|(a,b)<-zip x y]++[r s];f s=[s]78 बाइट्स है।

— डायने जूल

2

पायथन 2 , 89 81 88 86 बाइट्स

i=input();n=k=len(i)-2
print i
exec'print i[~k]+" "*n+i[k];k-=1;'*n
if~k:print i[::-1]

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

— कोइशोर रॉय
स्रोत

लंबाई 1 के लिए एक ही विफलता है कि मेरा था।

— स्टीफन

@ स्टेपहेन ने इसे ठीक किया और आगे बढ़ाया: D

— कोइशोर रॉय

2

आर , 113 बाइट्स

function(s){n=length(s<-strsplit(s,'')[[1]])
m=matrix(' ',n,n)
m[n,n:1]=m[,1]=m[1,]=m[n:1,n]=s
write(m,'',n,,'')}

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

— ग्यूसेप
स्रोत

दोतरफा चुनौती के लिए मेरा जवाब छोटा है - एक साल में क्या फर्क पड़ सकता है!

— Giuseppe

2

05AB1E , 17 16 15 19 बाइट्स

ÂDÂø¦¨Dgú€Ás)˜»Igi¨

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

व्याख्या

उदाहरण के साथ input = golf

ÂDÂ                  # bifurcate, duplicate, bifurcate
                     # STACK: 'golf', 'flog', 'flog', 'golf'
   ø                 # zip the top 2 items
                     # STACK: 'golf', 'flog', ['fg', 'lo', 'ol', 'gf']
    ¦¨               # remove the first and last element
                     # STACK: 'golf', 'flog', ['lo', 'ol']
      Dg             # get the length of the list
                     # STACK: 'golf', 'flog', ['lo', 'ol'], 2
        ú            # prepend that many spaces to each element
                     # STACK: 'golf', 'flog', ['  lo', '  ol']
         €Á          # rotate each right
                     # STACK: 'golf', 'flog', ['o  l', 'l  o']
           s         # swap the top 2 items
                     # STACK: 'golf', ['o  l', 'l  o'], 'flog'
            )˜       # wrap in a flattened list
                     # STACK: ['golf', 'o  l', 'l  o', 'flog']
              »      # join on newline
               Igi¨  # if input is length 1, remove last char

1-लेटर इनपुट के लिए फिक्स काफी महंगा था।
मुझे लगता है कि अब एक अलग दृष्टिकोण बेहतर हो सकता है।

— Emigna
स्रोत

1

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

-4 बाइट्स Musicman523 के लिए धन्यवाद।

lambda s:s[1:]and[s]+[s[i]+' '*(len(s)-2)+s[~i]for i in range(1,len(s)-1)]+[s[::-1]]or s

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

तार की सूची लौटाता है।

— totallyhuman
स्रोत

बंद करे! आउटपुट बिल्कुल वैसा नहीं है जैसा मैं पूछ रहा हूं।

— स्पूकीगेंगर

1

89 बाइट्स ले जाकर sऔर s[::-1]मेंjoin

— musicman523

यह लंबाई -1 स्ट्रिंग्स के लिए काफी काम नहीं करता है

— संगीतज्ञ 523

2

बस ध्यान देने के लिए, सभी मुद्दों को तय किया गया है।

— जुआन

1

गणितज्ञ, 128 बाइट्स

(c=Column;g=Length[x=Characters@#]-1;If[g==0,#,c@{#,c@Table[""<>{x[[i]],""<>Table[" ",g-1],x[[-i]]},{i,2,g}],StringReverse@#}])&

— J42161217
स्रोत

1

सी, 96 बाइट्स

i,l;f(char*s){for(i=l=puts(s)-2;--i;)printf("%c%*c\n",s[l-i],l,s[i]);for(;l+1;)putchar(s[l--]);}

बोनस संस्करण (122 बाइट्स):

x,y,i,l;f(char*s){for(i=l=puts(s)-1;++i<l*-~l;putchar(x==l?10:x%~-l*(y%~-l)?32:s[(x*y?l+l-2-x-y:x+y)%l]))x=i%-~l,y=i/-~l;}

— orlp
स्रोत

1

स्विफ्ट 3 , 215 199 बाइट्स

let s=readLine()!,c=s.characters,r:[Character]=c.reversed(),b=c.count
print(s)
if b>1{for i in 0..<b-2{print("\(r.reversed()[i+1])\(String.init(repeating:" ",count:b-2))\(r[i+1])")};print(String(r))}

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

— Mic1780
स्रोत

1

पायथन 3, 88 बाइट्स

w=input();p=print;l=len(w)-2
[p(w[n+1]+' '*l+w[l-n])for n in range(l)]
l+1and p(w[::-1])

— लेवि
स्रोत

1

PPCG में आपका स्वागत है!

— मार्टिन एंडर

साइट पर भी आपका स्वागत है! मेरा मानना है कि बाइट को बचाने के लिए l+1 andइसे फिर से लिखा जा सकता है l+1and।

— गेहूं जादूगर

@WheatWizard संपादित - धन्यवाद! मुझे आश्चर्य था कि काम किया ...

— लेवी

यह उस मामले को छोड़कर काम करेगा 0or, जहां अजगर पार्स करने में विफल रहता है क्योंकि 0oएक अष्टक उपसर्ग है।

— गेहूं जादूगर

जब मैं इसे चलाता हूं, तो यह शीर्ष पंक्ति को प्रिंट नहीं करता है ... tio.run/##FcoxCsQgEAXQPqeYLk7EwqRL8CRiEVh3Iww/

— Johnathan Saxman

1

जावास्क्रिप्ट (ईएस 8), 108 112 बाइट्स

let f = 

s=>(n=s.length)<2?s:(r=[...s].reverse()).slice(1,-1).reduce((a,v,i)=>a+`
`+s[i+1].padEnd(n-1)+v,s)+`
`+r.join``

o.innerHTML = f("hello folks!")

<pre id="o"></pre>

स्निपेट का विस्तार करें

कम गोल-मोल

s=>
   (n=s.length) < 2 ?    // record and check length
   s :                   // s has 0 or 1 char, else
   (r=[...s].reverse())  // reverse characters,
   .slice(1,-1)          // exclude 1st and last
   .reduce((a,v,i)=>     // append inner lines
      a +'\n' +s[i+1].padEnd(n-1) + v
    ,s)                  // to first line
    + '\n' +r.join("")   // append characters reversed

बहुत सारे बाइट्स बचाने के लिए जस्टिन मैरिनर का धन्यवाद, जो तब सभी को चुनौती का पालन करने के लिए आवश्यक शून्य या एकल चरित्र चेक को जोड़ने की आदत हो गई। कि आपको मिलता है :-(

— traktor53
स्रोत

दूसरी लाइन बनाकर `+s[i+1].padEnd(s.length-1)+v,s)+`और प्रयोग करके आप 7 बाइट्स बचा सकते हैं r.join``।

— जस्टिन मेरिनर

String.prototype.padStartटेम्पलेट शाब्दिकों के बारे में और टैग किए गए सुझावों के लिए @JustinMariner धन्यवाद । मुझे इसकी आवश्यकता थी कि लंबाई की जाँच को न्यूनतम रखने में मदद करने के लिए :-)

— traktor53

आपका रिक्ति अब बहुत छोटा है; आप इसे ठीक कर सकते हैं (n=s.length-1)?(r=<...>+r.join``:sऔर कुछ करके और उपयोग करके बचा सकते हैं padEnd(n)। लंबाई है 1, length-1है 0(गलत)।

— जस्टिन मेरिनर

@JustinMariner रिक्ति तय है, लेकिन मैंने लंबाई परीक्षण रखा है - जैसा कि मैं इसे समझता हूं, दोनों शून्य लंबाई के तार और एक चरित्र के तार खुद को बिना गाड़ी वापसी या स्ट्रिंग की पुनरावृत्ति के बिना वापस कर देते हैं।

— traktor53

1

padEndES2017 है।

— नील

1

PHP , 118 बाइट्स

echo $s=$argv[1];$l=strlen($r=strrev($s))-1;for($i=$l-1;$l&&$i;)echo "\n".str_pad($r[$i],$l).$s[$i].(--$i?"":"\n$r");

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

echo $s = $argv[1];
$l = strlen($r = strrev($s)) - 1;

for ($i = $l - 1; $l && $i;)
    echo "\n" . str_pad($r[$i], $l) . $s[$i] . (--$i ? "" : "\n$r");

— marcv
स्रोत

1

एपीएल , 58 बाइट्स

{(' ',⍵)[x+(x←∘.{((c-1)=⍺⌈⍵)∨0=⍺⌊⍵}⍨r)×o⌊⌽⊖o←∘.⌈⍨r←⍳c←≢⍵]}

के साथ ⎕IO←0।

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

कैसे?

c←≢⍵ - स्ट्रिंग की लंबाई

r←⍳ - सीमा

o←∘.⌈⍨ - न्यूनतम के साथ बाहरी उत्पाद

123
223
333

o⌊⌽⊖- खुद के साथ कम से कम 180 ^ओ बदल गया

123  ⌊  333  =  123
223  ⌊  322  =  222
333  ⌊  321  =  321

× - साथ गुणा करें

x←∘....⍨r - रेंज का बाहरी उत्पाद

((c-1)=⍺⌈⍵)∨0=⍺⌊⍵ - मैट्रिक्स का फ्रेम

111  ×  123  =  123
101  ×  222  =  202
111  ×  321  =  321

x+ - फ्रेम जोड़ें

111  +  123  =  234
101  +  202  =  303
111  +  321  =  432

(' ',⍵)[...] - स्ट्रिंग से इंडेक्स द्वारा अंतरिक्ष में पहुंचा

— Uriel
स्रोत

हो सकता ⍉⊖⍉⊖है ⌽⊖?

— जकार्इ

@ जाकारी धन्यवाद

— ऊरीएल

0

जावास्क्रिप्ट (ES2017), 87 बाइट्स

s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i].padEnd(l)+c:z.join``:s).join`
`

ईएस 6 संस्करण: 93 बाइट्स

s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i]+' '.repeat(l-1)+c:z.join``:s).join`
`

कम गोल्फ वाला

s => (
  l = s.length-1,
  [...s].reverse().map( // scan string backwards
     (c, i, z) => 
     i != 0 // check if top row
     ? l-i != 0 // check if bottom row
       ? s[i].padEnd(l) + c // any middle row
       : z.join`` // bottom row: string reversed
     :s // top row: original string
  ).join`\n`
)

F=
s=>[...s].reverse(l=s.length-1).map((c,i,z)=>i?l-i?s[i].padEnd(l)+c:z.join``:s).join`
`

function update() {
  O.textContent = F(I.value)
}

update()

<input id=I value='Hello, world!' oninput='update()'>
<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

padEndES2017 है।

— नील

@ धन्यवाद मैं अपनी हेडिंग

— बदलूंगा

आप अपने ईएस 6 संस्करण पर एक बाइट का उपयोग करके l+~iबचा सकते हैं, यह 1 बार घटाव करने से बचता है बजाय इसके कि आप 2 बार घटा सकते हैं।

— नील

@ यह होना चाहिएl-~-i

— edc65

मैं सोच रहा था, s=>[...s].reverse(l=s.length).map((c,i,z)=>i?l+~i?s[i]+' '.repeat(l-2)+c:z.join``:s).join`\n` लेकिन s=>[...s].reverse(l=s.length-2).map((c,i,z)=>i?i+~l?s[i]+' '.repeat(l)+c:z.join``:s).join`\n` यह भी काम करता है।

— नील

0

जावा, 191 बाइट्स

(s)->{PrintStream o=System.out;int l=s.lenght();o.println(s);for(int i=0;i<l;i++){o.printf("%"+"s%"+(l-1)+"s%n",s.charAt(i),s.charAt(l-1-i));for(int i=0;i<l;i++){o.print(s.charAt(l-1-i));}}};

— Serverfrog
स्रोत

(s)बस हो सकता है s। अंदर एकल लाइनों के साथ छोरों को उनके घुंघराले ब्रेसिज़ को हटाया जा सकता है। यदि आप किसी भी बाइट को बचाएंगे तो आप मुद्रण के बजाय वापस आ सकते हैं। आप int iदोनों छोरों में उपयोग करते हैं , मैं नहीं बता सकता कि वे अलग-अलग स्कोप में हैं लेकिन इंगित करने के लायक हैं। एक साथ चर की तरह शुरू करना आमतौर पर बाइट्स को बचाता है। for(int i=0;i<l;i++){o.print(s.charAt(l-1-i));}-> for(int i=0;i<l;){o.print(s.charAt(l-1-i++));}। आपको अनुगामी अर्ध उपनिवेश की आवश्यकता नहीं है।

— द लीथलकोडर

इशारा करने के लिए धन्यवाद;) (गोल्फिंग से बहुत परिचित नहीं)। बाद में इसका अनुकूलन करेंगे!

— Serverfrog

0

सी # (.NET कोर) , 179 161 बाइट्स

-18 बाइट्स TheLethalCoder का धन्यवाद

using System.Linq;
s=>{int l=s.Length-1,i=1;var d=s.Reverse().ToArray();while(i<l)s+="\n"+s[i]+new string(' ',l-1)+d[i++];if(l>1)s+="\n"+new string(d);return s;};

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

मुझे नियमों के बारे में निश्चित नहीं है, अगर इसकी गिनती बाइट की जरूरत है या नहीं:

~~using System.Linq;~~

~~कृपया कोई मुझे इस बारे में सही करे।~~

Ungolfed:

s =>
{
    int l = s.Length - 1, i = 1;
    var d = s.Reverse().ToArray();
    while (i < l)
        s += "\n" + s[i] + new string(' ', l - 1) + d[i++];
    if (l > 1)
        s += "\n" + new string(d);
    return s;
};

— ग्रेज़गोरज़ पुलावस्की
स्रोत

नमस्कार और PPCG में आपका स्वागत है! आप Linq का उपयोग कर रहे हैं इसलिए आपको usingअपनी बाइट गिनती में शामिल करना चाहिए । जैसा कि आप उपयोग कर रहे हैं Linq ToCharArray()बस हो सकता है ToArray(), क्या आपको वास्तव में Reverse()हालांकि इससे पहले इसकी आवश्यकता है ? जैसा कि आप उपयोग कर रहे Stringहैं या तो इसे पूरी तरह से अर्हता प्राप्त करने या उपयोग को शामिल करने की आवश्यकता है, हालांकि, इसे आसानी से बदलकर भी तय किया जा सकता है string। ifकी तरह एक त्रिगुट के रूप में कम हो सकता है s+=l>1?if code:"";। आप i++लूप से निकाल सकते हैं और इसे बढ़ा सकते हैं d[i++]।

— TheLethalCoder

जैसे के iसाथ प्रारंभिक । और मुझे लगता है कि यह हो सकता है! lint l=s.Length-1,i=1;

— TheLethalCoder

@LethalCoder धन्यवाद! मैंने आपके सुझाव कोड में जोड़ दिए। कुछ नोट्स: मैं पूरी तरह से भूल गया कि स्ट्रिंग वास्तव में IEnumerable है; स्ट्रिंग के बजाय स्ट्रिंग एक जावा अवशेष था जिसे मैं अभी भी लड़ता हूं, टर्नरी वास्तव में लंबे सुपरराइजिंग के रूप में था; और आपके परिवर्तन के बाद मैं (के लिए; expr) बदल गया, जबकि (expr) के बाद से यह अच्छा लग रहा है और एक ही बाइट गिनती है। फिर से धन्यवाद।

— ग्रेजगोरज पुलावस्की

कोई चिंता नहीं! टेरानरी कभी-कभी होती है, लेकिन आमतौर पर कम निकलती है इसलिए हमेशा उन्हें आज़माने लायक होता है।

— द लीथेलकोडर

0

रेटिना , 106 बाइट्स

..+
$&¶$&
O$^`.(?=.*$)

\G.
$&$%'¶
r`.\G
¶$%`$&
+`(.+)¶¶((.*¶)*).(.*)
¶¶$1$4$2
T`p` `(?<=.¶.).*(?=.¶.)
G`.

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

..+
$&¶$&

यदि कम से कम दो अक्षर हैं, तो इनपुट को डुप्लिकेट करें।

O$^`.(?=.*$)

डुप्लिकेट उल्टा।

\G.
$&$%'¶
r`.\G
¶$%`$&

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

+`(.+)¶¶((.*¶)*).(.*)
¶¶$1$4$2

त्रिभुजों को एक साथ मिलाएं, अतिव्यापी जिससे कि अंतिम वर्ण /विकर्ण बनाता है ।

T`p` `(?<=.¶.).*(?=.¶.)

सभी वर्णों को रिक्त स्थान में बदलें, अगर वे हर तरफ से कम से कम एक वर्ण दूर हों।

G`.

किसी भी बचे हुए खाली लाइनों को हटा दें।

— नील
स्रोत

0

पायथन 3, 85 बाइट्स

शीर्ष पंक्ति के लिए इनपुट का उपयोग करना :)

a=input()
b=len(a)
for i in range(b-2):print(a[1+i]+" "*(b-2)+a[-2-i])
print(a[::-1])

— abc123
स्रोत

क्या आपको यकीन है कि यह सही उत्तर देता है?

— कोइशोर रॉय

0

लुआ , 104 बाइट्स

print(s);for a=2,#s-1 do print(s:sub(a,a)..(" "):rep(#s-2)..s:sub(#s-a+1,#s-a+1)) end;print(s:reverse())

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

लेकिन आप केवल pएक बार इस्तेमाल किया ...

— लीक नून

सच ... बदलने वाला है।

0

पायथन 3, 106 बाइट्स

एक कार्यात्मक संस्करण ...

w=input();p=print;l=len(w)-2
def f(k):p(w[k]+' '*l+w[-k-1]);l-k>0and f(k+1)
l<0 or f(1)or l<1or p(w[::-1])

— लेवि
स्रोत

0

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

lambda a:'\n'.join([a]+(len(a)>1)*([a[i]+(len(a)-2)*' '+a[~i]for i in range(1,len(a)-1)]+[a[::-1]]))

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

— officialaimm
स्रोत

0

गणितज्ञ, 138 91 बाइट्स

(b=Outer[" "&,#,#];Do[l={{1,k},{k,1}};b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,Length@#}];b)&

आप इसे वुल्फराम क्लाउड सैंडबॉक्स में निम्नलिखित पेस्ट करके और "सेल का मूल्यांकन करें" पर क्लिक करके या Shift + Enter या Numpad Enter क्लिक करके ऑनलाइन कोशिश कर सकते हैं :

(b=Outer[" "&,#,#];Do[l={{1,k},{k,1}};b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,Length@#}];b)&@{"g","o","l","f","y"}//MatrixForm

— निशान।
स्रोत

चुकता शब्द बनाना

चारकोल , 7 5 बाइट्स

MATL , 20 16 11 बाइट्स

व्याख्या

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

कैसे?

सी, 109 बाइट्स

ऑक्टेव, 40 बाइट्स

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

पायथन 2 , 89 81 88 86 बाइट्स

आर , 113 बाइट्स

05AB1E , 17 16 15 19 बाइट्स

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

गणितज्ञ, 128 बाइट्स

सी, 96 बाइट्स

स्विफ्ट 3 , 215 199 बाइट्स

पायथन 3, 88 बाइट्स

जावास्क्रिप्ट (ईएस 8), 108 112 बाइट्स

PHP , 118 बाइट्स

एपीएल , 58 बाइट्स

जावास्क्रिप्ट (ES2017), 87 बाइट्स

जावा, 191 बाइट्स

सी # (.NET कोर) , 179 161 बाइट्स

रेटिना , 106 बाइट्स

पायथन 3, 85 बाइट्स

लुआ , 104 बाइट्स

पायथन 3, 106 बाइट्स

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

गणितज्ञ, 138 91 बाइट्स