आइए एक डिजिट मोज़ेक डिज़ाइन करें

Question

चुनौती

सकारात्मक पूर्णांक को देखते हुए , इसके प्रत्येक अंक में अपनी स्थिति के अनुरूप कई बार । दूसरे शब्दों में, प्रत्येक अंक को बार दोहराया जाना चाहिए (प्रत्येक , 1-अनुक्रमित के लिए), इस प्रकार नया नंबर बनाना:$N$$d_1, d_2, d_3, \cdots, d_n$$N$$d_k$$k$$1\le k\le n$

$$\overline{d_1d_2d_2d_3d_3d_3\cdots\underbrace{d_nd_nd_n\cdots d_n}_{n\text { times}}}$$

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

$$\begin{bmatrix} \color{red}{d_1} \color{green}{d_2 d_2} \color{blue}{d_3 d_3 d_3} \cdots \\ \color{green}{d_2 d_2 d_2} \color{blue}{d_3 d_3 d_3} \cdots \\ \color{green}{d_2 d_2 d_2} \color{blue}{d_3 d_3 d_3} \cdots \\ \color{blue}{d_3 d_3 d_3 d_3 d_3 d_3} \cdots \\ \color{blue}{d_3 d_3 d_3 d_3 d_3 d_3} \cdots \\ \color{blue}{d_3 d_3 d_3 d_3 d_3 d_3} \cdots \\ \vdots \end{bmatrix}$$

---

चश्मा

आप को पूर्णांक, एक स्ट्रिंग, अंकों की सूची या अंकों का प्रतिनिधित्व करने वाले पात्रों की सूची के रूप में ले सकते हैं । आउटपुट न्यूलाइन-सेपरेटेड स्ट्रिंग, स्ट्रिंग्स / पूर्णांकों की सूची या वर्ण / अंकों की सूची की सूची हो सकती है, लेकिन यदि संभव हो तो एक सुंदर-प्रिंट संस्करण भी शामिल करें। यदि आउटपुट एक नई-लाइन-अलग स्ट्रिंग है, तो यह भी स्वीकार्य है:$N$

• जब तक आउटपुट का दृश्य स्वरूप नहीं बदलता है, अग्रणी / अनुगामी व्हाट्सएप होता है
• एक सुसंगत राशि रिक्त स्थान या पंक्तियों का उपयोग करके अलग करें

आप इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स में आप अपनी पसंद की भाषा में कार्य को पूरा करने का प्रयास कर सकते हैं ।

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

65:

655
555
555

---------------

203:

200333
000333
000333
333333
333333
333333

--------------

233:

233333
333333
333333
333333
333333
333333

---------------

5202:

5220002222
2220002222
2220002222
0000002222
0000002222
0000002222
2222222222
2222222222
2222222222
2222222222

---------------

12345:

122333444455555
222333444455555
222333444455555
333333444455555
333333444455555
333333444455555
444444444455555
444444444455555
444444444455555
444444444455555
555555555555555
555555555555555
555555555555555
555555555555555
555555555555555

Comments

क्या हमारे पास एक ही अंक के दो हैंडल एक दूसरे के बगल में हैं?

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

@DomHastings हां, आपको उन्हें संभालना होगा। यह दिखाते हुए एक परीक्षण मामला जोड़ा गया।

— श्री Xcoder

संबंधित

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

Answer 1

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

एक स्ट्रिंग के रूप में इनपुट लेता है। अनुगामी लाइनफीड के साथ एक स्ट्रिंग लौटाता है।

s=>(g=x=>(c=s[(x>y?x:y)**.5-1>>1])?c+g(x+8):x>y?`
`+g(1,y+=8):'')(y=1)

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

कैसे?

तरीका

हम एक वर्ग मैट्रिक्स के माध्यम से चलने और प्रत्येक सेल को एक इंडेक्स में इनपुट स्ट्रिंग में परिवर्तित करके चरित्र द्वारा आउटपुट चरित्र का निर्माण करते हैं ।$i_{x,y}$

स्ट्रिंग इंडेक्स के लिए निर्देशांक

ऊपरी बाध्य की अंकों क्षेत्र (0 अनुक्रमित) के साथ प्रत्येक अक्ष द्वारा दिया जाता है A000096 : एन टी $u_{n}$$n^{th}$

यू0=0,यू1=2,यू2=5,यू3=9,यू4=14,यू5=20,

$$u_{n} = \frac{n(n+3)}{2}$$ $$u_{0}=0,u_{1}=2,u_{2}=5,u_{3}=9,u_{4}=14,u_{5}=20,\dots$$

पूर्णांक को देखते हुए , हम यह पता लगा सकते हैं कि किस क्षेत्र में यह हल करके स्थित है:n = ⌊ x ⌋ + $k$$n=\lfloor{x}\rfloor+1$

$$x²+3x-2k=0$$

के लिए अग्रणी:

n=⌊

$$x = \frac{\sqrt{1+8k}-3}{2}$$ $$n = \left\lfloor\frac{\sqrt{1+8k}-3}{2}\right\rfloor+1=\left\lfloor\frac{\sqrt{1+8k}-1}{2}\right\rfloor$$

प्रत्येक सेल , हम परिभाषित करते हैं:$(x, y)$

$$v_{x,y} = \max(1+8x,1+8y)$$

ये मान में सूचकांक बदल रहे हैं करके इनपुट स्ट्रिंग में: i x , $v_{x,y}$$i_{x,y}$

$$i_{x,y} = \left\lfloor\frac{\sqrt{v_{x,y}}-1}{2}\right\rfloor$$

 v(x,y) |  0  1  2  3  4  5  6  7  8  9        i(x,y) |  0  1  2  3  4  5  6  7  8  9
--------+-------------------------------      --------+-------------------------------
    0   |  1  9 17 25 33 41 49 57 65 73           0   |  0  1  1  2  2  2  3  3  3  3
    1   |  9  9 17 25 33 41 49 57 65 73           1   |  1  1  1  2  2  2  3  3  3  3
    2   | 17 17 17 25 33 41 49 57 65 73           2   |  1  1  1  2  2  2  3  3  3  3
    3   | 25 25 25 25 33 41 49 57 65 73           3   |  2  2  2  2  2  2  3  3  3  3
    4   | 33 33 33 33 33 41 49 57 65 73   -->     4   |  2  2  2  2  2  2  3  3  3  3
    5   | 41 41 41 41 41 41 49 57 65 73           5   |  2  2  2  2  2  2  3  3  3  3
    6   | 49 49 49 49 49 49 49 57 65 73           6   |  3  3  3  3  3  3  3  3  3  3
    7   | 57 57 57 57 57 57 57 57 65 73           7   |  3  3  3  3  3  3  3  3  3  3
    8   | 65 65 65 65 65 65 65 65 65 73           8   |  3  3  3  3  3  3  3  3  3  3
    9   | 73 73 73 73 73 73 73 73 73 73           9   |  3  3  3  3  3  3  3  3  3  3

रुकने की स्थिति

हम जानते हैं कि हम पहुँच चुके हैं:

• मैट्रिक्स की सही सीमा जब पर वर्ण मौजूद नहीं है और हमारे पास x > $i_{x,y}$$x > y$

• मैट्रिक्स की नीचे की सीमा जब चरित्र मौजूद नहीं है और हमारे पास$x \le y$

Answer 2

जे , 16 15 बाइट्स

-1 बाइट फ्रोवेफ्रॉग के लिए धन्यवाद!

{~#\<:@>./~@##\

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

Nएक तार के रूप में लेता है ।

वें प्रारंभिक समाधान की व्याख्या:

              #\   finds the length of the successive prefixes of the input (1 2 3...)
            #~     copies each digit as many times (1 2 2 3 3 3...)  
       >./~@       and creates a table of the max of the row/col numbers
  [:<:@            then subtract 1 from each element (for indexing)
{~                 select the corresponding digit from the input

इनपुट के साथ टेस्ट सत्र 203:

   #\ '203'
1 2 3

   #~#\ '203'
1 2 2 3 3 3

   >./~@#~#\ '203'
1 2 2 3 3 3
2 2 2 3 3 3
2 2 2 3 3 3
3 3 3 3 3 3
3 3 3 3 3 3
3 3 3 3 3 3

   <:@>./~@#~#\ '203'
0 1 1 2 2 2
1 1 1 2 2 2
1 1 1 2 2 2
2 2 2 2 2 2
2 2 2 2 2 2
2 2 2 2 2 2

   ({~[:<:@>./~@#~#\) '203'
200333
000333
000333
333333
333333
333333

Comments

हह, की नियुक्ति के अलावा ), आपका एपीएल उत्तर भी मेरी-की-जैसी ही होगा।

— आउटगोल्फर

मैं वास्तव में जे को बिल्कुल नहीं जानता, लेकिन [:<:@काफी महंगा लगता है। इसके बजाय आप उस सूची में कुछ प्रस्तुत कर सकते हैं जिसे आप 1-इंडेक्सिंग के लिए खाते में अनुक्रमित कर रहे हैं (उदाहरण के लिए प्रत्येक आवश्यक तत्व 1 स्थिति को दाईं ओर ले जाने के लिए 0 को प्रीपेन्ड करें)?

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

@ Mr.Xcoder मैं उस बारे में सोच रहा था। मैं यह देखने की कोशिश करूंगा कि क्या यह कुछ बाइट्स को बचाएगा।

— गालेन इवानोव

@EriktheOutgolfer {⍵[∘.⌈⍨(/⍨)⍳⍴⍵]} ?

— गैलेन इवानोव

@GalenIvanov हां, वह।

— एरिक द आउटगलर

Answer 3

हास्केल , 60 59 58 बाइट्स

f x|s<-do(n,_)<-zip[0..]x;n<$[0..n]=[(x!!).max a<$>s|a<-s]

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

---

बिंदु मुक्त संस्करण (68 बाइट्स)

(map=<<(.((snd.).max)).flip map).((\t@(n,c)->t<$[1..n])=<<).zip[1..]

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

Answer 4

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

i=j=0;r=''
for x in input():i+=1;r+=x*i
for c in r:print j*c+r[j:];j+=1

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

पहले पहली पंक्ति उत्पन्न करता है r, फिर rप्रत्येक पंक्ति को प्रिंट करने के लिए पुनरावृत्त करता है।

Answer 5

आर , 59 बाइट्स

function(a){m=outer(x<-rep(g<-seq(a),g),x,pmax);m[]=a[m];m}

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

• मैंने देखा कि अंकों का एक वेक्टर लेना स्वीकार्य है, और इसने मुझे 21 बाइट्स बचाने की अनुमति दी :)
• केवल वर्ण वेक्टर को स्वीकार करने के लिए @Giuseppe सुझाव के लिए -2 बाइट्स धन्यवाद
• -2 बाइट्स तर्कों में परिभाषा देना

Comments

आप aवर्णों के वेक्टर के रूप में ले सकते हैं , जिससे आप g=seq(a)सीधे सेट कर सकते हैं।

— ग्यूसेप

@Giuseppe: यह सही है!

— DigEmAll

Answer 6

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

Jx`»þ`ị

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

स्पष्ट उत्पादन।

Answer 7

05AB1E , 14 11 10 बाइट्स

मैजिक ऑक्टोपस यूरन / अदनान के लिए 1 बाइट धन्यवाद

ƶJDv¬N×?=¦

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

व्याख्या

ƶ            # repeat each element its index (1-based) times 
 J           # join to string
  Dv         # for N in [0 ... len(string)-1] do
    ¬N×      # push the head repeated N times
       ?     # print without newline
        =    # print the rest of the string without popping
         ¦   # remove the head

Comments

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

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

मुझे कोई श्रेय नहीं है, हालांकि क्रेडिट अदनान है: codegolf.stackexchange.com/a/87074/59376

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

@MagicOctopusUrn: आह, यह शानदार है! आप दोनों को धन्यवाद;)

— एमिगना

Answer 8

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

{⍵[∘.⌈⍨(/⍨⍳⍴⍵)]}

मैं अपने जे उत्तर के साथ पोस्ट से इस समाधान को अलग कर रहा हूं, जैसा कि जो किंग द्वारा सुझाया गया है

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

Answer 9

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

i=1;a=[]
for c in input():exec"a=zip(*a+[c*-~len(a)]);"*i;i+=2+i%2
print a

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

Answer 10

एक्सेल VBA, 95 बाइट्स

अनाम VBE तत्काल विंडो फ़ंक्शंस जो [A1]कंसोल से इनपुट और आउटपुट को लेता है

n=[len(A1)]:For y=1To n:For l=1To y:?:For x=1To n:?String(x,Mid([A1],IIf(x>y,x,y)));:Next x,l,y

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

n=[len(A1)]                         ''  Get Length
For y=1To n                         ''  Iterate down input
For l=1To y                         ''  Iterate down repeat lines
?                                   ''  Print Newline
For x=1To n                         ''  Iterate accross input
?String(x,Mid([A1],IIf(x>y,x,y)));  ''  Print x of the `max(x,y)`th digit in input
Next x,r,y                          ''  Loop, Loop, Loop

Answer 11

MATL , 15 12 बाइट्स

tftY"t!2$X>)

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

मुझे संदेह है कि इसे छोटा किया जा सकता है, लेकिन यह इतना बुरा नहीं है ...

          % implicit input, '230'
t         % duplicate input. Stack: ['230','230']
f         % indices of nonzero values. Stack: ['230',[1,2,3]]
t         % duplicate. Stack: ['230',[1,2,3],[1,2,3]]
Y"        % run-length decoding. Stack: ['230',[1,2,2,3,3,3]]
t         % duplicate. Stack: ['230',[1,2,2,3,3,3],[1,2,2,3,3,3]]
!         % transpose. Stack: ['230',[1,2,2,3,3,3],[1;2;2;3;3;3]]
2$X>      % elementwise maximum of 2 inputs, with broadcast.
          % Stack:
          % ['230',
          % [1, 2, 2, 3, 3, 3;
          %  2, 2, 2, 3, 3, 3;
          %  2, 2, 2, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3;
          %  3, 3, 3, 3, 3, 3]]
 )        % index into G
          % implicit end, display stack contents

Answer 12

++ , 35 बाइट्स जोड़ें

L,bLRdBcB]£X¦Ω+d‽b>1€Ω_A€Ω:AbLR¦+$T

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

यह काम किस प्रकार करता है

हम इनपुट को अंकों की एक सूची के रूप में लेते हैं, जबकि हमें ए से अंक के लिए डाली जाने से रोकता है BD, और अंकों को बचाने के लिए होने से भी, जो दो बाइट्स लेता है।

सबसे पहले, हम [1 ... लेन (इनपुट)] से एक सीमा उत्पन्न करते हैं bLR, फिर हम प्रत्येक तत्व को रेंज बार में दोहराते हैं । जैसा कि Add ++ में स्वचालित वेक्टराइज़ेशन मौजूद नहीं है, हम जोड़ियों की सूची बनाने के लिए, को स्वयं के साथ ज़िप करते हैं । हम फिर स्टॉर्मैप लागू करते हैं , जोड़े पर पुनरावृत्ति के साथ युग्मित: उन्हें एक सपाट सरणी ( ) में समेटने से पहले ।n [ [ १ , १ ] , [ २ , २ ] । । । [ एन , एन ] $n$$n$dBcB]$[[1, 1], [2, 2] ... [n, n]]$£X¦Ω+

अगला, हम इस सरणी को डुप्लिकेट करते हैं और इसे अधिकतम द्वारा तालिकाबद्ध करते हैं d‽b>,। यानी सरणी में प्रत्येक तत्व को दूसरे सरणी से एक दूसरे तत्व के साथ जोड़ा जाता है और जोड़ी पर डाइएडिक अधिकतम कमांड चलाया जाता है। [६ ५] के एक उदाहरण इनपुट के लिए , यह एरी बनाता है [१ २ २ २ २ २ २ २ २ २ २] , जो सरणी के लिए अनुक्रमित के रूप में मोज़ेक का एक चपटा संस्करण है। दुर्भाग्य से, Add ++ 0-अनुक्रमित सरणियों का उपयोग करता है, इसलिए हमें प्रत्येक तत्व को घटाना होगा 1€Ω_:।

फिर, हम इनपुट सूची में इनपुट को फिर से धक्का देकर इंडेक्स करते हैं ( A), जो फिर से एक सूची के रूप में इनपुट लेकर बाइट्स को बचाता है। €Ω:उचित रूप से लम्बे टुकड़ों में सरणी को काटने से पहले सूची में सूचकांक । यदि इनपुट में अंकों की संख्या को द्वारा निरूपित किया जाता है , तो टुकड़ा आकार है$x$

$$\frac{x(x - 1)}{2}$$

या त्रिकोणीय संख्या । हम उस इनपुट की लंबाई को धक्का देकर, उस मान से 1 की सीमा की गणना करते हैं , फिर राशि लेते हैं । अब, स्टैक, [6 5] के इनपुट के लिए , [[6 5 5 5 5 5 5 5 5] 3] की तरह दिखता है । सरणी को आकार टुकड़ों में , लेकिन तर्क वर्तमान में गलत क्रम में हैं, इसलिए हम उन्हें काटने से पहले स्वैप करते हैं और साथ लौटते हैं ।$x^{th}$ AbLR¦+T$n$$T

Answer 13

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

Ｆ⮌…ＬθＵＯ⊕⊘×ι⁺³ι§θι

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

Ｆ⮌…Ｌθ

वर्णों के सूचकांकों को विपरीत क्रम में लूप करें।

⊕⊘×ι⁺³ι

वर्ग के आकार की गणना करें।

ＵＯ...§θι

वर्तमान चरित्र का उपयोग करके वर्ग बनाएं।

Answer 14

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

ø╶｛；ｌ└²＋：＊；ｎ

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

Answer 15

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

-3 बाइट्स लिन का धन्यवाद ।

l=0;m=[]
for k in input():l+=1;m=[r+l*k for r in m]+l*[l*-~l/2*k]
print m

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

Answer 16

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

Ｅ⭆θ×⊕κι×⊕κι‖Ｏ↗

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

कैसे?

Ｅ⭆θ×⊕κι×⊕κι‖Ｏ↗ - implicitly print the result of...
Ｅ                - map:
  ⭆              -   over: string map:       
    θ             -     over: first input
     ×            -     using: repeat
        ι         -       what: ι (loop value)
      ⊕κ          -       by: incremented κ (loop counter)
         ×        -   using: repeat
            ι     -     what: ι (loop value)
          ⊕κ      -     by: incremented κ (loop counter)
             ‖Ｏ  - Reflect with overlap:
                ↗ -   direction: up-right

... क्या इस विधि को गोल्फ किया जा सकता है?

Comments

"... क्या यह तरीका गोल्फ हो सकता है?" यहां तक ​​कि नील का समाधान भी लंबा है, इसलिए मुझे यहां कोई उम्मीद नहीं है। : पी

— एरिक आउटगॉल्फ

×⊕κιहालांकि दो बार।

— जोनाथन एलन

बात यह है, यह एक चर के लिए आवंटित करने के लिए आसान नहीं है, क्योंकि मूल्यों ιऔर κ,ach लूप के हर पुनरावृत्ति पर बदलते हैं।

— आउटगोल्फ

यह एक समारोह होने की जरूरत है, लेकिन मुझे नहीं पता कि क्या यह संभव है।

— जोनाथन एलन

यह पूछने के लिए कि क्या यह 3 (या 5, फ़ंक्शन कैसे परिभाषित है) के आधार पर बाइट्स या उससे कम है। ;) (स्पष्ट उत्तर है, निश्चित रूप से, नहीं।)

— एरिक आउटगोल्फर

Answer 17

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

ü°√¿«│⌠º₧@\τ

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

इस एल्गोरिथ्म का उपयोग करना ।

स्पष्टीकरण:

c%R:BXm]i*xit+ Full program, implicit input
c%             Length of input
  R            1-based range
   :B          Repeat each element according to the range ("123" -> "122333")
     X         Save to X register
      m        Map:
       ]         Character -> string
        i*       Repeat by iteration index
          xit    Trim first <iteration index> elements from X
             +   Concatenate
                 Implicit output with newline

स्टैक्स , 20 19 18 16 बाइट्स

ù↔‼i,ÑΓæ☺=╘‼æ↕4╝

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

स्पष्टीकरण:

c%R:BX%mYx%{y|Mvx@m Full program, implicit input
c%                  Length of input
  R                 1-based range
   :B               Repeat each element according to the range ("123" -> "122333")
     X              Save to X register
      %             Length
       m            Map over 1-based range:
        Y             Save index to Y register
         x%           Push length of X register
           {      m   Map over 1-based range:
            y|M         Maximum of both indices
               v        1-based -> 0-based (decrement)
                x@      Index into X register
                      Implicit output with newline

Answer 18

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

{_[Table[Max,Flat!{_&_}=>1:#_]-1]}

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

व्याख्या

गैलेन इवानोव के जे जवाब के समान काम करता है ।

{_[Table[Max,Flat!{_&_}=>1:#_]-1]}
{                                }   anonymous function: _ is input, array of digits
                                     example: _ := [2, 0, 3]
                         1:#_        the range 1 to Size[_]
                                     > e.g.: [1, 2, 3]
                  {   }=>            over each number N:
                   _&_                   map to N repeated N times
                                     > e.g.: [[1], [2, 2], [3, 3, 3]]
             Flat!                   flatten it
                                     > e.g.: [1, 2, 2, 3, 3, 3]
   Table[Max,                ]       create a "max" table with it
                                     > e.g.:
                                       1 2 2 3 3 3
                                       2 2 2 3 3 3
                                       2 2 2 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                              -1     subtract 1 from each
                                     > e.g.:
                                       0 1 1 2 2 2
                                       1 1 1 2 2 2
                                       1 1 1 2 2 2
                                       2 2 2 2 2 2
                                       2 2 2 2 2 2
                                       2 2 2 2 2 2
 _[                             ]    index the original array with this matrix
                                     > e.g.:
                                       2 0 0 3 3 3
                                       0 0 0 3 3 3
                                       0 0 0 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3
                                       3 3 3 3 3 3

Answer 19

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

{x@i|\:i:&1+!#x}

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

Answer 20

सी (जीसीसी) , 130 बाइट्स

जब आप bruteforce कर सकते हैं, तो फैंसी गणित की आवश्यकता कौन है

n,l;R(n,c){for(;n--;)putchar(c);}f(s){for(char*p=s,*q;*p++;)for(n=l=p-s;l--;R(1,10))for(R(n*n+n>>1,p[-1]),q=p;*q;q++)R(q-s+1,*q);}

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

Answer 21

QBasic 1.1 , 127 बाइट्स

INPUT S$
FOR X=1TO LEN(S$)
K=K+X
R$=R$+STRING$(X,MID$(S$,X,1))
NEXT
FOR C=1TO K
?STRING$(C-1,MID$(R$,C,1))RIGHT$(R$,K-C+1)
NEXT

-4 DLosc को धन्यवाद ।

Xnor के पायथन 2 एल्गोरिथ्म के संशोधित संस्करण का उपयोग करता है ।

इनपुट एक निर्विवाद स्ट्रिंग है। आउटपुट \nअतिरिक्त स्थानों या \ns के बिना -separated है ।

Answer 22

QBasic , 111 बाइट्स

एक अनाम फ़ंक्शन जो कंसोल के लिए इनपुट और आउटपुट के लिए संकेत देता है।

INPUT s$
n=LEN(s$)
FOR y=1TO n
FOR l=1TO y
?
FOR x=1TO n
z=x
IF y>x THEN z=y
?STRING$(x,MID$(s$,z));
NEXT x,l,y

Comments

अच्छा लगता है - लेकिन क्या आपका मतलब "पूर्ण कार्यक्रम" नहीं है? मुझे नहीं लगता कि QBasic के "अनाम कार्य" हैं।

— DLosc

Answer 23

पीएचपी 7.1 , 163 बाइट्स

तर्क के रूप में संख्या प्रदान करने वाली वाया सीएलआई:

<?foreach(str_split($argv[1])as$k=>$d)$a[]=array_fill(0,$s+=$k+1,array_fill(0,$s,$d));foreach(array_replace_recursive(...array_reverse($a))as$v)echo join($v)."\n";

इतना गोल्फ नहीं:

$n = 123;

foreach(str_split($n) as $k => $d) {
    $s += $k + 1;
    $a[] = array_fill(0, $s, array_fill(0, $s, $d));
}

foreach(array_replace_recursive(...array_reverse($a)) as $v)
    echo implode('', $v) . "\n";

आउटपुट:

122333
222333
222333
333333
333333
333333

तरीका:

मूल रूप से अंकों से मिलकर बहुआयामी सरणी वर्गों का निर्माण करते हैं, और फिर उनमें से सभी को समाहित करते हैं (array_replace_recursor)।

(हां, मुझे पता है कि यह बहुत शर्मनाक है।)

Comments

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

— प्रोग्रोक

Answer 24

रूबी , 80 बाइट्स

->n{s=(1..n.size).map{|i|n[i-1]*i}*"";(0...s.size).map{|i|s[i]*i+s[i..-1]}*"\n"}

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

ओवेस जवाब के समान

Answer 25

जाप, 12 बाइट्स

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

Ë+pE
¬£h°YçX

कोशिश करो

---

व्याख्या

            :Implicit input of string U
Ë           :Map each character D at 0-based index E
  pE        :  Repeat D E times
 +          :  Append to D
\n          :Reassign to U
¬           :Split to character array
 £          :Map each element X at 0-based index Y
   °Y       :  Increment Y
     çX     :  Repeat X Y times
  h         :  Replace the first Y characters in U with that

Answer 26

uBASIC , 120 बाइट्स

एक अनाम फ़ंक्शन जो इनपुट foprm STDIN लेता है और STDOUT को आउटपुट करता है

0Input"",S$:N=Len(S$):ForY=1ToN:ForL=1ToY:ForX=1ToN:ForC=1ToX:Z=X:IfY>XThenZ=Y
1?Mid$(s$,z,1);:NextC:NextX:?:NextL:NextY

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

Answer 27

विजुअल बेसिक .NET (VBC) , 198 बाइट्स

एक Subदिनचर्या जो STDIN से इनपुट लेती है और STDOUT को आउटपुट देती है।

काम करने के लिए StrDup पाने के लिए प्रतीत नहीं कर सकता: /

Module M
Sub Main
Dim c,s,n,l,x,y
s=Console.readLine()
n=Len(s)
For y=1To n
For l=1To y
For x=1To n
For c=1To x
Console.Write(Mid(s,IIf(x>y,x,y),1)&IIf(c=n,vbLf,""))
Next c,x,l,y 
End Sub
End Module

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

Answer 28

लूआ, 149 140 बाइट्स

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

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

function(a)F,s=0,""for b=1,#a do s=s..a[b]:rep(b)end;for b=1,#a do io.write((s.."\n"):rep(b))F,z=F+b,a[b+1]or""s=z:rep(F)..s:sub(F+1)end end

Ungolfed:

G = function(p)
    F,s = 0,""
    for i=1,#p do
        s=s..p[i]:rep(i)
    end
    for i=1, #p do
        io.write((s.."\n"):rep(i))
        F,z = F+i, p[i+1]or""
        s = z:rep(F)..s:sub(F+1)
    end
end
-- allows to pass the argument list from stdin
-- example: {"1", "2", "3", "4", "5"}
G(load("return " .. io.read())())

Answer 29

पर्ल 5 + -nalF -M5.010, 67 बाइट्स

s/./$&x++$-/ge;eval'eval"say;"x++$i;$x+=$i;s/.{$x}/$F[$i]x$x/e;'x@F

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

Answer 30

याबेसिक , 108 बाइट्स

एक अनाम फ़ंक्शन जो STDIN से इनपुट लेता है और STDOUT को आउटपुट करता है

Input""s$
n=len(s$)
For y=1To n
For r=1To y
For x=1To n
For c=1To x?Mid$(s$,max(x,y),1);Next
Next
?Next
Next

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