कालीन बिछाओ

Question

इस SO प्रश्न से प्रेरित ।

चुनौती:

इनपुट:

• एक स्ट्रिंग$s$
• एक चरित्र$c$

आउटपुट:

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

इनपुट: = , = आउटपुट:$s$string$c$.

..........g..........
........g.n.g........
......g.n.i.n.g......
....g.n.i.r.i.n.g....
..g.n.i.r.t.r.i.n.g..
g.n.i.r.t.s.t.r.i.n.g
..g.n.i.r.t.r.i.n.g..
....g.n.i.r.i.n.g....
......g.n.i.n.g......
........g.n.g........
..........g..........

चुनौती नियम:

• इनपुट-स्ट्रिंग भी वर्णों की एक सूची हो सकती है
• आउटपुट स्ट्रिंग-लाइन या वर्णों की मैट्रिक्स की एक सूची भी हो सकती है
• इनपुट-स्ट्रिंग और चरित्र गैर-रिक्त होने की गारंटी है
• स्ट्रिंग में चरित्र को शामिल नहीं करने की गारंटी है
• स्ट्रिंग और चरित्र दोनों ही मुद्रण योग्य ASCII (यूनिकोड रेंज [32,126], स्पेस '' टू और सहित टिल्ड '~') होंगे

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
• डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

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

इनपुट: = , = आउटपुट:$s$c =11111$c=$0

00000000100000000
00000010101000000
00001010101010000
00101010101010100
10101010101010101
00101010101010100
00001010101010000
00000010101000000
00000000100000000

इनपुट: = , = आउटपुट:$s$सी12345ABCDEF$c$#

####################F####################
##################F#E#F##################
################F#E#D#E#F################
##############F#E#D#C#D#E#F##############
############F#E#D#C#B#C#D#E#F############
##########F#E#D#C#B#A#B#C#D#E#F##########
########F#E#D#C#B#A#5#A#B#C#D#E#F########
######F#E#D#C#B#A#5#4#5#A#B#C#D#E#F######
####F#E#D#C#B#A#5#4#3#4#5#A#B#C#D#E#F####
##F#E#D#C#B#A#5#4#3#2#3#4#5#A#B#C#D#E#F##
F#E#D#C#B#A#5#4#3#2#1#2#3#4#5#A#B#C#D#E#F
##F#E#D#C#B#A#5#4#3#2#3#4#5#A#B#C#D#E#F##
####F#E#D#C#B#A#5#4#3#4#5#A#B#C#D#E#F####
######F#E#D#C#B#A#5#4#5#A#B#C#D#E#F######
########F#E#D#C#B#A#5#A#B#C#D#E#F########
##########F#E#D#C#B#A#B#C#D#E#F##########
############F#E#D#C#B#C#D#E#F############
##############F#E#D#C#D#E#F##############
################F#E#D#E#F################
##################F#E#F##################
####################F####################

इनपुट: = , = आउटपुट:$s$सी@+-|-o-|-O$c$:

::::::::::::::::::O::::::::::::::::::
::::::::::::::::O:-:O::::::::::::::::
::::::::::::::O:-:|:-:O::::::::::::::
::::::::::::O:-:|:-:|:-:O::::::::::::
::::::::::O:-:|:-:o:-:|:-:O::::::::::
::::::::O:-:|:-:o:-:o:-:|:-:O::::::::
::::::O:-:|:-:o:-:|:-:o:-:|:-:O::::::
::::O:-:|:-:o:-:|:-:|:-:o:-:|:-:O::::
::O:-:|:-:o:-:|:-:+:-:|:-:o:-:|:-:O::
O:-:|:-:o:-:|:-:+:@:+:-:|:-:o:-:|:-:O
::O:-:|:-:o:-:|:-:+:-:|:-:o:-:|:-:O::
::::O:-:|:-:o:-:|:-:|:-:o:-:|:-:O::::
::::::O:-:|:-:o:-:|:-:o:-:|:-:O::::::
::::::::O:-:|:-:o:-:o:-:|:-:O::::::::
::::::::::O:-:|:-:o:-:|:-:O::::::::::
::::::::::::O:-:|:-:|:-:O::::::::::::
::::::::::::::O:-:|:-:O::::::::::::::
::::::::::::::::O:-:O::::::::::::::::
::::::::::::::::::O::::::::::::::::::

इनपुट: = , = आउटपुट:$s$सीAB$c$c

ccBcc
BcAcB
ccBcc

इनपुट: = , = आउटपुट:$s$सी~$c$X

~

इनपुट: = , = आउटपुट:$s$सी/\^/\$c$X

XXXXXXXX\XXXXXXXX
XXXXXX\X/X\XXXXXX
XXXX\X/X^X/X\XXXX
XX\X/X^X\X^X/X\XX
\X/X^X\X/X\X^X/X\
XX\X/X^X\X^X/X\XX
XXXX\X/X^X/X\XXXX
XXXXXX\X/X\XXXXXX
XXXXXXXX\XXXXXXXX

Comments

क्या स्ट्रिंग में स्थान हो सकते हैं?

— एमिगा

@Emigna हाँ, सभी मुद्रण योग्य ASCII (यूनिकोड रेंज [32,126]) वैध इनपुट-वर्ण हैं।

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

यह डीबग करने के लिए अद्भुत हो जाता है यदि आप ऐसे पात्रों का उपयोग करते हैं जो नेत्रहीन एक ही चरित्र की तरह दिखते हैं, जैसे ()()()।

— फिलिप हगलुंड

यदि $ s $ खाली है तो क्या होना चाहिए?

— सोलोमन उको

@SolomonUcko नियम अनुभाग से: " इनपुट-स्ट्रिंग और चरित्र गैर-रिक्त होने की गारंटी है " :)

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

Answer 1

कैनवस , 8 बाइट्स

Ｒ±［］／┼┼＊

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

7 बाइट्स लेकिन चार का एक गुच्छा दर्पण।

Answer 2

आर , 118 95 92 बाइट्स

function(a,d,n=length(a),I=c(n:1,1:n)[-n])for(i in I-1)write(c(a,d)[pmin(I+i,n+1)],1,n*2,,d)

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

करने के लिए धन्यवाद:

• एक त्रुटि और एक गोल्फ को ठीक करने के लिए Giuseppe
• 22 बाइट के लिए हारून हेमैन गोल्फ के लायक है

Comments

मुझे लगता है कि मुझे forकम से कम गोल्फ के लिए, आर में छोरों पर अपने फैलाव को छोड़ने की आवश्यकता है ।

— एरॉन हेमैन

@Giuseppe, धन्यवाद, मुझे अतिरिक्त परीक्षण मामलों को शामिल करने के बारे में इतना आलसी नहीं होना चाहिए!

— किरिल एल।

98 के लिए यह मेरा समाधान की तुलना में करीब लगता है ऑनलाइन कोशिश करो!

— एरोन हेमैन

पुन: व्यवस्थित होने के साथ एक और दो को हटा सकते हैं: इसे ऑनलाइन आज़माएं!

— आरोन हेमैन

@AaronHayman या फिर इस 92 बायटर pminको पुनर्व्यवस्था के साथ तर्क का संयोजन करना :-)

— Giuseppe

Answer 3

जे , 59 56 बाइट्स

,{~[:((0-2*#)}.\[:,0,:"0({:>:t)*t=:]+/<:)[:(|.@}.,])#\@]

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

जम्मू के लिए बहुत लंबा समाधान ... (पूरी तरह से मेरी गलती)

Comments

यहाँ 39 है

— FrownyFrog

@FrownyFrog धन्यवाद, मुझे लगता है कि आपको इसे अपने समाधान के रूप में पोस्ट करना चाहिए

— गैलन इवानोव

Answer 4

आर , एक बदसूरत 118 बाइट्स संस्करण

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

function(s,C,l=length(s),L=4*l-3,k=2*l-1,y=abs(rep(1:k,L)-l)+abs(rep(1:L,e=k)-k)/2+1)matrix(ifelse(y%%1|y>l,C,s[y]),k)

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

आर , 161 157 बाइट्स

सशर्त रूप से संशोधित करने के बजाय ifelse का उपयोग करके 4 बाइट्स को बचाया y

function(S,C,l=nchar(S),L=4*l-3,k=2*l-1,y=abs(rep(1:L,k)-k)/2+abs(rep(1:k,e=L)-l)+1)cat(rbind(matrix(ifelse(y%%1|y>l,C,el(strsplit(S,''))[y]),L),'
'),sep='')

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

असहमति और टिप्पणी की

function(S,C){
    s=el(strsplit(S,''))
    l=nchar(S)
    L=4*l-3
    k=2*l-1
    y=abs(rep(1:L,k)-k)/2+abs(rep(1:k,e=L)-l)+1 # distance from centre
    y[!!y%%1]=l+1  # set non integers to one more than length of string
    y[y>l]=l+1     # set number beyond length of string to one more than length of string
    M = rbind(matrix(c(s,C)[y],L),'\n') # build matrix and add line returns
    cat(M,sep='') # print the matrix as a string
}

हम्म, लगता है कि अब तक का सबसे लंबा जवाब!

Comments

ओह प्रिय, इस प्रश्न को बेहतर ढंग से देखना चाहिए था

— हारून हेमैन

@ केविनक्रूजसेन मैंने इसे अभी तय किया है

— हारून हेमैन

+15 बाइट्स के लिए, आप अपने बदसूरत जवाब को आस्की-कला बना सकते हैं: इसे ऑनलाइन आज़माएं!

— ग्यूसेप

Answer 5

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

def f(s,c):r=range(len(s));return[c.join(c*i+s[:i:-1]+s[i:]+c*i)for i in r[:0:-1]+r]

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

Answer 6

05AB1E , 15 11 बाइट्स

.sûsζøsýí€û

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

.s            # push suffixes of input
  û           # palendromize this list
   sζ         # transpose using the second input as filler
     ø        # transpose back
      sý      # merge each on the second input
        í     # reverse each row
         €û   # palendromize each row

Comments

@ केविनक्रूजसेन: हाँ। सौभाग्य से इसे ठीक करने के लिए किसी बाइट का खर्च नहीं आया। मुझे अभी भी ऐसा लगता है कि ऐसा करने का एक बेहतर तरीका होना चाहिए, इसलिए मैं देखता रहूंगा।

— एमिगा

" आउटपुट स्ट्रिंग-लाइनों या वर्णों की मैट्रिक्स की एक सूची भी हो सकती है ", इसलिए आप »पाद लेख पर जा सकते हैं । :)

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

@KevinCruijssen आह ठीक है। मैंने उस हिस्से पर नज़र डाली। धन्यवाद :)

— Emigna

Answer 7

जे , 35 34 33 बाइट्स

,{~1j1(}:@#"1{:(<*-)1-|+/|)i:@-&#

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

-&#$c$$s$
i:
1-|+/|
{: (<*-)-&#

 0  0 _1  0  0
 0 _1 _2 _1  0
_1 _2 _3 _2 _1
 0 _1 _2 _1  0
 0  0 _1  0  0

नकारात्मक सूचकांकों की शुरुआत अजगर की तरह -1 से होती है। केवल एक चीज बची है, वह है शून्य के कॉलम को सम्मिलित करना।

1j1( #"1
  }:@
,{~$c$$s$

एल्गोरिथ्म के लिए गैलेन इवानोव को बहुत धन्यवाद।

Comments

क्या आप एक स्पष्टीकरण जोड़ना चाहेंगे? मैं जे के साथ परिचित नहीं हूँ

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

Answer 8

के (ngn / k) , 38 बाइट्स

{1_',/'y,''2{+x,1_|x}/(#x)'1_,/+y,'|x}

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

{ }तर्कों के साथ कार्य x(स्ट्रिंग एस ) और y(चरित्र सी )

|x उलटा x

y,'पहले जोड़ें yप्रत्येक के लिए

+ पक्षांतरित

,/ concat

1_ छोड़ पहले चार

इस बिंदु पर हमारे पास वर्णों की लंबाई ( x) के उदाहरण हैंyx

#x की लंबाई x

(#x)' लगातार कई दिनों की खिसकती खिड़की

2{ }/ दो बार करो

+x,1_|xमें शामिल होने के xउलट साथ xअपनी पहली तत्व के बिना, और पक्षांतरित

y,''आगे जोड़ते yप्रत्येक प्रत्येक के लिए

,/' प्रत्येक को सम्‍मिलित करें

1_' प्रत्येक से एक छोड़ दो

Answer 9

जाप , 15 बाइट्स

लाइनों की एक सरणी देता है

Ôå+ ®¬qV êÃûV ê

कोशिश करो

Ôå+ ®¬qV êÃûV ê     :Implicit input of strings U=s & V=c
Ô                   :Reverse U
 å+                 :Prefixes
    ®               :Map
     ¬              :  Split
      qV            :  Join with V
         ê          :  Palindromise
          Ã         :End map
           ûV       :Centre pad each string with V, to the length of the longest
              ê     :Palindromise

Answer 10

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

ＵＢηＥθ✂θκ‖Ｏ↑←ＵＥ¹

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मूल रूप से अब हटाए गए सैंडबॉक्स पोस्ट पर एक टिप्पणी के रूप में प्रस्तुत किया गया है । स्पष्टीकरण:

ＵＢη

पृष्ठभूमि को दूसरे इनपुट पर सेट करें c।

Ｅθ✂θκ

sसभी प्रत्ययों को उत्पन्न करने के लिए पहले इनपुट पर नक्शा और अलग-अलग लाइनों पर उन्हें मुद्रित करना।

‖Ｏ↑←

क्षैतिज और लंबवत प्रतिबिंबित करें।

ＵＥ¹

क्षैतिज रूप से अतिरिक्त स्थान जोड़ें।

Answer 11

रूबी , 95 84 75 बाइट्स

->a,c{(1...2*z=a.size).map{|i|s=a[j=(z-i).abs,z]*c+c*2*j;s.reverse.chop+s}}

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

इनपुट स्ट्रिंग को एक वर्ण के रूप में लेता है। स्ट्रिंग्स की एक सरणी देता है।

Answer 12

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 121 बाइट्स

Join[q=Table[(v=Table[#2,2(l-k)])<>Riffle[Join[(h=Reverse)[n=(g=Take)[#,-k]],g[n,-k+1]],#2]<>v,{k,l=Length@#}],Rest@h@q]&

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

Answer 13

जाप , 16 बाइट्स

नोट: मैं इसे गोल्फ दूँगा :)

Ôå+ ®¬qVÃùV mê ê

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

Comments

यह अन्य जाप उत्तर के समान है, लेकिन एक अलग क्रम में है, है ना? मैं जाप को नहीं जानता, लेकिन मुझे दोनों उत्तरों में समान अक्षर दिखाई देते हैं। ;)

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

@ केविनक्रूजसेन हाँ, दोनों लगभग एक ही हैं, अभी के लिए

— लुइस फेलिप डी जीसस मुनोज़

@ केविनक्रूजसेन, लुइस ने इसे स्वतंत्र रूप से मेरे समाधान से विकसित किया।

— झबरा

Answer 14

पॉवरशेल , 120 बाइट्स

param($s,$c)($s,(($l=$s.length-1)..0+1..$l|%{($x=$c*(2*$_))+($s[($_,($l..$_+($_+1)..$l))[$_-ne$l]]-join$c)+$x}))[$l-gt0]

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

कुछ दिनों में, स्लाइस के बजाय इंडेक्स रेंज होने से वास्तव में दर्द होता है। आज का दिन ही बुरा है। एकल तत्वों (जैसे 0..0 + 1..0 लौटाने) के साथ काम करते समय संयुक्त सीमाओं के कारण गड़बड़ होती है, विशेष-आवरण का उपयोग पूरी तरह से (कई बाइट्स की कीमत पर) से बचने के लिए किया जाता है।

Answer 15

जाप , 15 बाइट्स

Ôå+ ê ®ê ¬qV
ûV

कोशिश करो

Answer 16

जेली , 11 बाइट्स

jÐƤṚzṚŒḄZŒḄ

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

$s$
$c$
ŒṘY\n

Answer 17

पॉवरशेल , 82 83 बाइट्स

+2 बाइट्स धन्यवाद Veskah: सिंगल कैरेक्टर केस बग फिक्स

-1 बाइट: नियम का Input-string may also be a list of charactersइस्तेमाल किया

$c,$s=$args
($s|%{(-join$s|% s*g $i)+$c*$i++})[($r=$i..0+1..$i)]|%{"$_"[$r]-join$c}

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

कम गोल्फ वाला:

$c,$s=$args
$southEast = $s|%{
    (-join$s|% substring $i) + $c*$i++
}
$range=$i..0+1..$i
$southEast[$range]|%{
    "$_"[$range]-join$c
}

Comments

ऐसा लगता है कि एकल चरित्र मामले के लिए यह टूट जाता है। TIO लिंक में बस एक खाली लाइन है~

— Veskah

वास्तव में। धन्यवाद!

— माज़ी

Answer 18

पिप , 24 20 बाइट्स

QPRV:_JbMa@>RV,#aZDb

-lमानव-पठनीय आउटपुट प्राप्त करने के लिए ध्वज का उपयोग करें । इसे ऑनलाइन आज़माएं!

व्याख्या

QPRV:_JbMa@>RV,#aZDb
                      a,b are cmdline args (implicit)
                a     1st cmdline arg (the string)
               #      Length
              ,       Range
            RV        Reverse
         a@>          Take slices of a starting at those indices
                 ZDb  Zip the list of slices together, filling out missing values in
                      the matrix with b (the character)
        M             To each row, map this function:
     _Jb               Join on b
  RV:                 Reverse (making top row the bottom and vice versa)
QP                    Quad-palindromize: reflect downward and rightward, with overlap

उदाहरण के लिए, की जानकारी के साथ abcdऔर .:

RV,#a
 [3 2 1 0]
a@>
 ["d" "cd" "bcd" "abcd"]
ZDb
 [['d 'c 'b 'a] ['. 'd 'c 'b] ['. '. 'd 'c] ['. '. '. 'd]]
_JbM
 ["d.c.b.a" "..d.c.b" "....d.c" "......d"]
RV:
 ["......d" "....d.c" "..d.c.b" "d.c.b.a"]
QP
 ["......d......" "....d.c.d...." "..d.c.b.c.d.." "d.c.b.a.b.c.d" "..d.c.b.c.d.." "....d.c.d...." "......d......"]

Answer 19

अटैची , 57 बाइट्स

${q:=#x-1Bounce!Bounce@Join&y@PadLeft&y&#x=>x[q::(q::0)]}

इसे ऑनलाइन आज़माएं! आउटपुट लाइनों की एक सूची है।

व्याख्या

?? parameters: x, y
${
    ?? q is length of x - 1
    q:=#x-1
    ?? Reflect, collapsing middle:
    Bounce!
        ?? Function:
            ?? Reflect,
            Bounce@
            ?? Joined by y,
            Join&y@
            ?? padded to the length of x with y
            PadLeft&y&#x
        ?? Mapped over
        =>
            ?? The elements of x at
            x[
                ?? decreasing range from q to
                q::(
                    ?? each element in the range from q to 0
                    q::0
                )
            ]
}

Answer 20

पर्ल 6 , 79 बाइट्स

->\c{{map {join c,g $_ X||c},g .[^*X+(^$_,)]}o*.comb}
my&g={.[$_-1...0...$_-1]}

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

बेनामी कोडब्लॉक जो इनपुट क्यूरेड (जैसे f(char)(string)) लेता है और लाइनों की एक सूची देता है। मुझे लगता है कि एक अलग दृष्टिकोण छोटा होगा।

स्पष्टीकरण:

my&g={.[$_-1...0...$_-1]}  # Helper function to palindromise a list
->\c{                                                }  # Code block that takes a char
     {                                       }o*.comb   # And returns a function
                                .[^*X+(^$_,)]  # Get all prefixes with end padding
                                               # e.g. "str" => [["r",Nil,Nil]
                                                                ["t","r",Nil]
                                                                ["s","t","r"]]
                              g   # Palindromise the lsit
       map {                },    # Map each element to
                     $_ X||c      # Replace all Nils with the character
                   g              # Palindromise it
            join c,               # And join by the character

Answer 21

APL (Dyalog Classic) , 32 31 बाइट्स

(⍉1↓¯1↓⊖⍪1↓⊢)⍣2∘↑(≢⊣),/,¨,2⍴¨⊢¨

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

Answer 22

पर्ल 5-lF , के साथ -M5.010, 71 बाइट्स

$"=<>;$A=abs,$_="@F[$A..$#F]".$"x($A*2),/./,say reverse.$' for-$#F..$#F

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

Answer 23

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 249 बाइट्स

s=>c=>{var r=s.Select((x,_)=>{int k=s.Length;var m=s.Substring(_,k-_).Aggregate("",(a,b)=>a+c+b);return new string(m.Skip(2).Reverse().Concat(m.Skip(1)).ToArray()).PadLeft(2*k-3+m.Length,c).PadRight(4*k-3,c);});return r.Skip(1).Reverse().Concat(r);}

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

यह कामचलाऊ होना चाहिए ...

Comments

213

— दाना

Answer 24

जावास्क्रिप्ट (Node.js) , 143 बाइट्स

(s,c)=>{q=Math.abs;m=(l=s.length*4-3)-1;for(i=j=0;j<l/2;(i=(++i)%l)?0:++j){p=s[q(i-m/2)/2+q(j-m/4)];process.stdout.write((i?"":"\n")+(p?
p:c))}}

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

थोड़ा और सोच एक आयामी सरणी के संदर्भ में गणना करने के लिए नेतृत्व करेंगे, और कम बाइट्स।

Answer 25

कोटलिन , 250 बाइट्स

नोट: कोटलिन टियो वर्तमान में एक नया वर्ग वापस करने में विफल रहता है इसलिए इस कोड को एक शून्य सूचक अपवाद मिलता है। यह उन कोडों के लिए भी होता है जिन्हें मैंने पहले पोस्ट किया था जो उस समय काम करते थे। मुझे लगता है कि यह अंततः ठीक हो जाएगा, लेकिन इस मुद्दे को रिपोर्ट करने के लिए एक समर्थन संपर्क नहीं मिल सका। इसे यहां भी चलाया जा सकता है ।

{s:String,c:Char->val h=s.length*2-1
val w=h*2-1
val m=Array(h){Array(w){c}}
for(i in s.indices)for(r in 0..h-1){val o=(i-Math.abs(h/2-r))*2
if(o>=0){m[r][w/2+o]=s[i].toChar()
m[r][w/2-o]=s[i].toChar()}}
m.map{it.joinToString("")}.joinToString("\n")}

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

Comments

आप उन्नीसवीं बाइट चैट में @ डेनिस से संपर्क कर सकते हैं । वह TIO के लिए मॉडरेटर है। इसके अलावा, मैं वास्तव में छपाई के बजाय तार की एक सूची को वापस करने की अनुमति देता हूं, इसलिए मुझे लगता है कि (यकीन नहीं) आप .joinToString("\n")बाइट-काउंट से हटा सकते हैं (और फ़ंक्शन के बाहर पाद लेख में ऐसा कर सकते हैं)।

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

Answer 26

गैया , 19 बाइट्स

:ṫl¤┅v;@&Z¦<¦v¦ṫ¦ṫṣ

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

अनुसरण करने की व्याख्या।

Answer 27

जावास्क्रिप्ट (Node.js) , 101 बाइट्स

s=>c=>[l=s.length-1,...Array(l*2)].map((x,i,a,m=Math.abs)=>a.map((y,j)=>s[m(l-i)+m(l-j)]||c).join(c))

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

Comments

करीब :(

— ASCII- केवल

Answer 28

TSQL क्वेरी, 191 बाइट्स

MS-SQL सर्वर मैनेजमेंट स्टूडियो में इस क्वेरी को चलाने से पहले Ctrl-T दबाएं, इससे आउटपुट टेक्स्ट में बदल जाएगा।

यह स्क्रिप्ट एक लंबे "स्ट्रिंग" में बाएं से दाएं आउटपुट का निर्माण कर रही है, प्रत्येक स्थिति में डालने के लिए मूल्य की गणना करती है। आउटपुट 4096 वर्णों तक सीमित है।

golfed:

SELECT
string_agg(iif(h>k/2,@y,substring(@,h+1,1))+iif(-~n%k=0,'
',@y),'')FROM(SELECT
abs(k/2-n%k)+abs(k/2-n/k)h,*FROM(SELECT
number n,len(@)*2-1k,*FROM spt_values)c)d
WHERE n<k*k and'P'=type

Ungolfed:

USE master
DECLARE 
@y char='.',
@ varchar(20) = 'abcd'

SELECT
  string_agg(iif(h>k/2,@y,substring(@,h+1,1))+iif(-~n%k=0,'
',@y),'')
FROM
(
  SELECT
    abs(k/2-n%k)+abs(k/2-n/k)h,*
  FROM
  (
    SELECT
      number n,
      len(@)*2-1k,*
    FROM spt_values
  )c
)d
WHERE n<k*k and'P'=type

मुझे ऑनलाइन संस्करण में आउटपुट को प्रारूपित करने के लिए कुछ बदलाव करने थे।

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

Answer 29

जावा (JDK) , 213 199 198 बाइट्स

a->b->{int i=0,l=a.length()-1;String s=a,r[]=new String[l-~l],p;for(;i<=l;s=s.substring(1))r[l+i]=r[l-i]=new StringBuffer(p=b.join(b,s.split(""))+b.repeat(2*i++)).reverse()+p.substring(1);return r;}

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

-14 bytes@KevinCruijssen को
-1 byteधन्यवाद @ceilingcat को धन्यवाद

Ungolfed

a->
    b-> {
        int i = 0, l = a.length() - 1;
        String s = a, r[]=new String[a.length()*2-1],p;
        for (; i<=l; s=s.substring(1))
            r[l+i]
              = r[l-i++]
              =   new StringBuffer(
                                   p =   String.join(b,s.split(""))
                                       + b.repeat(2*i)
                                  ).reverse()
                + p.substring(1);
        return r;
    }

Comments

अच्छा जवाब, आप इसे 200 से नीचे 14 बाइट्स में गोल्फ कर सकते हैं । :)

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

@ केविनक्रूजसेन अच्छी तरह से देखा, धन्यवाद!

— सारा जे

@ceilingcat अच्छी सोच, धन्यवाद!

— सारा जे

Answer 30

वोल्फ्राम भाषा (गणितज्ञ) , 68 बाइट्स

Table[#[[1+Abs@y+Abs@x/2]]/._@__:>#2,{y,l=1-Tr[1^#],-l},{x,2l,-2l}]&

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

इनपुट के रूप में पात्रों की सूची (भराव चरित्र के साथ) लेता है, और वर्णों का एक मैट्रिक्स आउटपुट करता है।

Table[                              ,{y,l=1-Tr[1^#],-l},{x,2l,-2l}]&    (* make a (2*len-1 x 4*len-3) table centered at (0,0) *)
      #[[               ]]                                              (*  where the value at each point is the string indexed at *)
         1+Abs@y+Abs@x/2                                                (*   (1 + |y-coordinate| + |x-coordinate|/2) *)
                          /._@__:>#2                                    (*  if that indexing fails, use the filler character instead *)

पात्रों की सूची का सूचकांक लेने के लिए, हम उपयोग करते हैं list[[index]], जिसे आंतरिक रूप से विस्तारित किया जाता है Part[list, index]। यदि सूचकांक वैध है, तो यह अभिव्यक्ति उस सूचकांक के मूल्य का मूल्यांकन करती है। यदि नहीं - यदि सूचकांक एक पूर्णांक नहीं है या सीमा से बाहर है - तो अभिव्यक्ति का मूल्यांकन नहीं हुआ है।
सबसे सरल (सबसे छोटा) पैटर्न जो मेल खाता है Part[...]लेकिन एक एकल चरित्र नहीं है _@__, जो किसी भी अभिव्यक्ति को एक या अधिक तर्कों के साथ मेल खाता है।