विस्फोट प्रत्यय

Question

ASCII स्ट्रिंग को देखते हुए, इसके विस्फोटित प्रत्ययों का उत्पादन करता है। उदाहरण के लिए, यदि स्ट्रिंग होती, तो abcde5 प्रत्यय होते हैं, जो सबसे लंबे समय तक क्रमबद्ध होता है:

abcde
bcde
cde
de
e

प्रत्येक प्रत्यय को तब विस्फोटित किया जाता है , जिसका अर्थ है कि प्रत्येक वर्ण को उस प्रत्यय में उसके एक-अनुक्रमित स्थान के रूप में कई बार कॉपी किया जाता है। उदाहरण के लिए, के प्रत्ययों का विस्फोट करना abcde,

abcde
12345
abbcccddddeeeee

bcde
1234
bccdddeeee

cde
123
cddeee

de
12
dee

e
1
e

कुल मिलाकर, विस्फोट के प्रत्यय abcdeहैं

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

नियम

• यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।
• इनपुट में मुद्रण योग्य ASCII वर्ण शामिल होंगे। (इसमें नई सूचियों को शामिल किया गया है लेकिन इसमें स्थान शामिल हैं।)
• आउटपुट में प्रत्येक स्ट्रिंग एक अलग लाइन पर होगी।
• अनुगामी रिक्त स्थान को प्रत्येक पंक्ति पर अनुमति दी जाती है और अंत में एक अतिरिक्त नई रेखा हो सकती है।

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

''

'a'
a

'bc'
bcc
c

'xyz'
xyyzzz
yzz
z

'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f

's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

Comments

संबंधित, Sorta

— लिन

सम्बंधित। सम्बंधित। सम्बंधित।

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

'Ccodegolf' में क्या होता है?

— RosLuP

Answer 1

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

ṫJxJY

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

ṫJxJY  Main link. Argument: s (string)

 J     Indices; yield I := [1, ..., len(s)].
ṫ      Tail; get the suffixes of s starting at indices [1, ..., len(s)].
   J   Indices; yield I again.
  x    Repeat. The atom 'x' vectorizes at depth 1 (1D arrays of numbers/characters)
       in its arguments. This way, each suffix t gets repeated I times, meaning
       that the first character of t is repeated once, the second twice, etc.
       If left and right argument have different lengths, the longer one is
       truncated, so I can safely be applied to all suffixes.
    Y  Join, separating by linefeeds.

Answer 2

जे, 22 12 8 बाइट्स

14 बाइट बचाने के लिए मीलों के लिए धन्यवाद!

(#~#\)\.

अब यह एक बहुत अच्छा समाधान है। बहुत रसीला भी।

यह इनपुट #~#\के प्रत्ययों ( \.) पर लागू होने वाला हुक है । हुक, जब इनपुट पर बुलाया जाता है y, इस प्रकार विघटित हो जाता है:

(#~#\) y
y #~ #\ y

यहाँ कुछ मध्यवर्ती परिणाम हैं:

   ]s =: 's p a c e'
s p a c e
   #\ s
1 2 3 4 5 6 7 8 9
   (quote) s
's p a c e'
   (quote;#)\ s
+-----------+-+
|'s'        |1|
+-----------+-+
|'s '       |2|
+-----------+-+
|'s p'      |3|
+-----------+-+
|'s p '     |4|
+-----------+-+
|'s p a'    |5|
+-----------+-+
|'s p a '   |6|
+-----------+-+
|'s p a c'  |7|
+-----------+-+
|'s p a c ' |8|
+-----------+-+
|'s p a c e'|9|
+-----------+-+
   1 2 3 # '123'
122333
   3 3 3 # '123'
111222333
   ]\. s
s p a c e
 p a c e
p a c e
 a c e
a c e
 c e
c e
 e
e
   quote\. s
's p a c e'
' p a c e'
'p a c e'
' a c e'
'a c e'
' c e'
'c e'
' e'
'e'
   (#~#\) s
s  ppp    aaaaa      ccccccc        eeeeeeeee
   (#~#\)\. s
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

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

   f =: (#~#\)\.
   f
(#~ #\)\.
   f ''
   f 'a'
a
   f 'bc'
bcc
c
   f 'xyz'
xyyzzz
yzz
z
   f 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f
   f 's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

   ]tc =: <;._1 '|' , '|a|bc|xyz|code-golf|s p a c e'
++-+--+---+---------+---------+
||a|bc|xyz|code-golf|s p a c e|
++-+--+---+---------+---------+
   ,. f &. > tc
+---------------------------------------------+
+---------------------------------------------+
|a                                            |
+---------------------------------------------+
|bcc                                          |
|c                                            |
+---------------------------------------------+
|xyyzzz                                       |
|yzz                                          |
|z                                            |
+---------------------------------------------+
|coodddeeee-----ggggggooooooollllllllfffffffff|
|oddeee----gggggoooooolllllllffffffff         |
|dee---ggggooooollllllfffffff                 |
|e--gggoooolllllffffff                        |
|-ggooollllfffff                              |
|goolllffff                                   |
|ollfff                                       |
|lff                                          |
|f                                            |
+---------------------------------------------+
|s  ppp    aaaaa      ccccccc        eeeeeeeee|
| pp   aaaa     cccccc       eeeeeeee         |
|p  aaa    ccccc      eeeeeee                 |
| aa   cccc     eeeeee                        |
|a  ccc    eeeee                              |
| cc   eeee                                   |
|c  eee                                       |
| ee                                          |
|e                                            |
+---------------------------------------------+

Comments

कूल, कुछ बाइट्स को बचाने का दूसरा तरीका उपसर्ग क्रियाविशेषण

— मील

@ मीलों तुम्हारा क्या मतलब है?

— कॉनर ओ'ब्रायन

आप प्रत्येक उपसर्ग की लंबाई को उस सीमा तक उत्पन्न करने के एक छोटे तरीके के रूप में प्राप्त कर सकते हैं

— मील

@ मीलों आह, बिल्कुल।

— कॉनर ओ'ब्रायन

Answer 3

अजगर, 61 बाइट्स

f=lambda s,i=0:s[i:]and-~i*s[i]+f(s,i+1)or s and'\n'+f(s[1:])

वैकल्पिक 63:

f=lambda s,b=1:s and f(s[:-1],0)+s[-1]*len(s)+b*('\n'+f(s[1:]))

Answer 4

पायथन 3, 91 68 65 बाइट्स

def f(s):f(s[1:print(''.join(i*c for i,c in enumerate(s[0]+s)))])

वांछित आउटपुट प्रिंट करने के बाद एक त्रुटि के साथ। Ideone पर इसका परीक्षण करें ।

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

इससे पहले कि एफ खुद को पुनरावर्ती कह सकता है, के सूचकांकों की s[1:...]गणना की जानी चाहिए।

सबसे पहले enumerate(s[0]+s)पैदावार सभी जोड़ों को (i, ग) वर्णों की ग की रों - अपनी पहली चरित्र के साथ दोहराया गया - और इसी सूचकांक मैं । Prepending s[0]यहां दो उद्देश्यों को पूरा करती है।

• S का पहला वर्ण एक बार दोहराया जाना है, लेकिन पहला सूचकांक 0 है ।

• एक बार सभी वर्ण संसाधित हो जाने के बाद, s[0]एक IndexError बढ़ाएंगे , जिससे f को पुनःप्राप्ति सीमा तक पहुंचने तक newlines मुद्रित करने के बजाय एक त्रुटि के साथ समाप्त किया जाएगा।

''.join(i*c for i,c in ...)प्रत्येक सी के एक फ्लैट स्ट्रिंग को बार-बार i बनाता है , जो printSTDOUT को गूँजती है।

अंत में, चूंकि कोई भी नहींprint देता है और बस है , पुनरावर्ती कॉल अपने पहले चरित्र के बिना एस के लिए उपरोक्त प्रक्रिया को दोहराता है ।s[1:None]s[1:]f(s[1:...])

Answer 5

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

m:ex/.+$/.map:{put [~] .comb Zx 1..*}

-nकमांड लाइन स्विच के लिए 37 बाइट्स + 1

उदाहरण:

$ perl6 -ne 'm:ex/.+$/.map:{put [~] .comb Zx 1..*}' <<< 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f

विस्तारित:

# -n command line switch takes each input line and places it in ｢$_｣

# You can think of it as surrounding the whole program with a for loop
# like this:
for lines() {

  # match
  m
  :exhaustive # every possible way
  / .+ $/     # at least one character, followed by the end of the string

  .map:

  {
    put           # print with newline
      [~]         # reduce using string concatenation ( don't add spaces between elements )
        .comb     # split into individual chars
        Z[x]      # zip using string repetition operator
        1 .. *    # 1,2,3,4 ... Inf
  }

}

Answer 6

ब्रेकीलॉग , 17 बाइट्स

@]Elyk:Erz:jac@w\

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

व्याख्या

@]E                 E is a suffix of the Input
   lyk              The list [0, ..., length(E) - 1]
      :Erz          The list [[0th char of E, 0], ..., [Last char of E, length(E) - 1]]
          :ja       For all elements of that list, concatenate the Ith char I times to itself
             c      Concatenate the list into a string
              @w    Write followed by a line break
                \   False: backtrack to another suffix of the Input

Answer 7

05AB1E , 13 बाइट्स

.sRvyvyN>×}J,

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

व्याख्या

.s              # push list of suffixes of input
  R             # reverse the list
   vy           # for each string
     vy   }     # for each char in string
       N>×      # repeat it index+1 times
           J,   # join and print with newline

Answer 8

CJam , 14 बाइट्स

Sl+{_eee~n1>}h

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

व्याख्या

Sl+   e# Read input and prepend a space.
{     e# While the string is non-empty...
  _   e#   Make a copy.
  ee  e#   Enumerate. Gives, e.g. [[0 ' ] [1 'a] [2 'b] [3 'c]].
  e~  e#   Run-length decode. Gives "abbccc".
  n   e#   Print with trailing linefeed.
  1>  e#   Discard first character.
}h

Answer 9

सी #, 101 बाइट्स

f=s=>{var r="\n";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+f(s.Substring(1));};

पुनरावर्ती अनाम फ़ंक्शन, जो एक प्रमुख न्यूलाइन को भी प्रिंट करता है। यदि अग्रणी नईलाइन की अनुमति नहीं है, तो 3 अतिरिक्त बाइट्स इसे एक नई रूपरेखा में बदल देते हैं:

f=s=>{var r="";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+"\n"+f(s.Substring(1));};

पूर्ण कार्यक्रम ungolfed विधि और परीक्षण मामलों के साथ:

using System;

namespace ExplodedSuffixes
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string, string> f = null;
            f = s =>
            {
                var r = "\n";
                for (int i = 0; i < s.Length; )
                    r += new string(s[i], ++i);
                return "" == s ? r : r + f(s.Substring(1));
            };

            // test cases:
            string x = "abcde";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "a";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "bc";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "xyz";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "code-golf";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "s p a c e";
            Console.WriteLine("\'" + x + "\'" + f(x));
        }
    }
}

Answer 10

हास्केल, 48 बाइट्स

e=map(concat.zipWith replicate[1..]).scanr(:)[] 

किसी के द्वारा हस्तक्षेप किया गया है

ghc exploded_suffixes.hs -e 'e"abcde"'
ghc exploded_suffixes.hs -e 'mapM_ putStrLn.e=<<getLine' <<<code-golf
ghc exploded_suffixes.hs -e 'Control.Monad.forever$putStr.unlines.e=<<getLine'

Comments

मुझे पॉइंटफ्री-नेस पसंद है। आपको अपना 63-बाइट कोड अपने ब्लॉक में रखना चाहिए और फिर अलग से इनवोकेशन दिखाना चाहिए।

— xnor

आपको ज़रूरत नहीं है putStr., हम फ़ंक्शन आउटपुट के रूप में स्वीकार करते हैं। import Data.Listहालांकि आपको इसका उपयोग करने की आवश्यकता है tails।

— xnor

आप बदल सकते हैं uncurry ... zipसाथ zipWith: unlines.map(concat.zipWith replicate[1..]).tails।

— नौ

हाँ सचमुच! zipWith replicateछोटा भी मेरे लिए हुई जब मैं जागा। दया है कि मैं tailsमें नहीं है पूरी तरह से बिना और अभी भी समकक्ष बढ़ाए बिना अंतर्निहित रूप से Preludeप्राप्त कर सकता है । बॉयलर-प्लेट के बिना शुद्धता के बारे में मैं पाठकों के स्वाद के लिए मसाला भी छोड़ दूंगा और कोई प्रदर्शन भी नहीं करूंगा । ब्लॉक को परिभाषित करने पर बाइट की गिनती होती है। tailsData.Listimport foldrIOmapM_ putStrLnunlinese=

— रोमन Czyborra

बिना योग्य नामों का उपयोग करना importsमानक हास्केल नहीं है, बल्कि उत्तर की एक विशेषता है ghci। इस तरह की बातों के आधार पर एक अलग भाषा के रूप में गिना जाता है, इसलिए मैं आपके उत्तर का शीर्षक कुछ इस तरह बदलने का सुझाव देता हूं Haskell (ghci)। ( यह मेटा चर्चा भी देखें )।

— नीमी

Answer 11

पर्ल, 36 + 1 ( -n) = 37 बाइट्स

/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/

आवश्यकताओं -nऔर -E(या -M5.010) चलाने के लिए:

perl -nE '/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/' <<< "code-golf"

ध्यान दें कि आप इसे चलाने पर हर बार केवल एक ही उदाहरण पर काम करते हैं (क्योंकि यह चर का उपयोग करता है $.जो हर बार एक पंक्ति में पढ़ा जाता है, इसलिए यह 1केवल पहली बार पकड़ता है जब एक पंक्ति पढ़ी जाती है)। (लेकिन यहां कोई समस्या नहीं है, बस ^Dइसे फिर से चलाएं!)

Answer 12

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

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

M&!`.+

$.%`$*»
%+r`»($|.)
$1$1

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

Answer 13

जावा, 150 127 बाइट्स

संपादित करें:

• -23 बाइट्स बंद। @Kevin क्रूज़सेन को धन्यवाद

Snipet:

f->{String s[]=f.split(""),o="";int i=-1,j,l=s.length;for(;++i<l;)for(j=-2;++j<i;o+=s[i]);return l<1?"":o+"\n"+f.substring(1);}

Ungolfed:

public static String explodeSuff(String suff){
  char [] s = suff.toCharArray();
  String out = "";
  if(s.length==0)return "";
  for(int i=-1;++i<s.length;){
    for(int j=-2;++j<i;){
      out+=s[i];
    }
  }
  return out+"\n"+suff.subString(1);
}

Comments

नमस्ते, आप इसे बस थोड़ी सी जगह और कुछ छोटे चाल को हटाकर गोल्फ कर सकते हैं:f->{String s[]=f.split(""),o="";int i=-1,j,l=s.length;for(;++i<l;)for(j=-2;++j<i;o+=s[i]);return l<1?o:o+"\n"+f.substring(1);}

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

Answer 14

रैकेट 184 बाइट्स

(let p((l(string->list s))(ol'()))(cond[(null? l)(display(list->string(flatten ol)))]
[else(p(cdr l)(append ol(list #\newline)(for/list((i l)(n(length l)))(for/list((j(+ 1 n)))i))))]))

Ungolfed:

(define(f s)
 (let loop((l(string->list s))
             (outl '()))
    (cond
      [(null? l)
       (display
        (list->string
         (flatten outl)))]
      [else
       (loop
        (rest l)
        (append outl
                (list #\newline)
                (for/list ((i l)
                           (n (length l)))
                  (for/list ((j (add1 n)))
                    i
                    ))))]  )))


(f "abcde")
(f "xyz")

आउटपुट:

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

xyyzzz
yzz
z

Answer 15

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

f=s=>s?[s.replace(/./g,(c,i)=>c.repeat(i+1)),...f(s.slice(1))]:[]

<input oninput=o.textContent=f(this.value).join`\n`><pre id=o>

पिछले प्रयास:

67: s=>[...s].map((_,i)=>s.slice(i).replace(/./g,(c,i)=>c.repeat(i+1)))
84: s=>s.replace(/./g,`$&$'
    `).match(/.+/g).map(s=>s.replace(/./g,(c,i)=>c.repeat(i+1)))
89: f=(s,t=s.replace(/./g,(c,i)=>c.repeat(i+1)))=>t?[]:[t,...f(s,t.replace(/(.)(?=\1)/g,''))]

Answer 16

PHP, 103 बाइट्स (छोटे टैग के साथ 99)

<?php for($s=$argv[1];""!=$s[$i++];$o.="
")for($j=0;""!=$l=$s[$j+$i-1];)$o.=str_pad('',++$j,$l);echo$o;

मुझे पूरा यकीन है कि यह सबसे कम संभव जवाब नहीं है।

Answer 17

MATL , 12 बाइट्स

&+gYRYs"G@Y"

मुझे यह पसंद है जब उद्धरण चिह्न एक साथ आते हैं!

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

व्याख्या

यह एक मैट्रिक्स का निर्माण करके काम करता है जिसके स्तंभों का उपयोग किया जाता है, एक-एक करके रन-लंबाई में इनपुट को डिकोड किया जाता है। उदाहरण के लिए, इनपुट के 'abcde'लिए मैट्रिक्स है

1 0 0 0 0
2 1 0 0 0
3 2 1 0 0
4 3 2 1 0
5 4 3 2 1

कोड:

&+g    % Implicit input. NxN matrix of ones, where N is input size
YR     % Set entries above diagonal to zero
Ys     % Cumulative sum of each column. This gives the desired matrix 
"      % For each column
  G    %   Push input (for example 'abcde')
  @    %   Push current column (for example [0;0;1;2;3])
  Y"   %   Run-length decode (example output 'cddeee')
       % Implicit end
       % Implicit display

Answer 18

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

def f(s):return'\n'.join(''.join(s[j:][i]*(i+1)for i in range(len(s)-j))for j in range(len(s)))

यह आश्चर्यजनक रूप से कठिन था जितना मैंने यह होने की उम्मीद की थी। मैंने अपने पूरे फंक्शन को शायद 4 बार रिड्यूस किया।

Answer 19

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

void c(char[]a,int l,int j){if(l<1)return;c(a,--l,++j);for(int i=0,k;i<j;i++)for(k=0;k++<=i;)System.out.print(a[i+l]);System.out.println();}

Ungolfed

 void c(char[]a,int l,int j)
{
if (l < 1) 
return ;
c(a , --l , ++j) ;
for(int i = 0 , k; i < j ; i++)
for(k = 0 ; k++ <= i ;)
System.out.print(a[i+l]);
System.out.println();
}

निम्नलिखित लाइन मुझे बहुत दर्द दे रही है। मुझे नहीं पता कि मैं इसे कैसे कर सकता हूं (क्योंकि "\n"प्रिंट करने के लिए शर्त को तोड़ने के लिए दो छोर हैं )।
System.out.println();

Comments

कैसे एक उचित विधि के बारे में जो एक तर्क के रूप में सरणी लंबाई भेजने की आवश्यकता नहीं है? वर्तमान में कोई गलती से एक गलत मान भेजकर IndexOutOfBounds अपवाद को ट्रिगर कर सकता है ...

— adrianmp

Answer 20

पाइके, 12 बाइट्स

VilS],A*s
}t

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

Answer 21

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

-n+1 बाइट के लिए ध्वज का उपयोग करता है ।

(k=0;puts$_.gsub(/./){$&*k+=1};$_[0]="")while$_>$/

Answer 22

आर, 108 बाइट्स

स्टड और प्रिंट्स से स्टडआउट तक इनपुट पढ़ें

s=scan(,"");n=nchar(s);for(i in 1:n)cat(do.call("rep",list(strsplit(s,"")[[1]][i:n],1:(n-i+1))),"\n",sep="")

मुझे लगा कि do.callयहाँ का उपयोग उचित था। यह मूल रूप से दो इनपुट लेता है: 1. एक स्ट्रिंग ( repयहां) और तर्कों की एक सूची के रूप में एक फ़ंक्शन नाम और 2. पुनरावृत्त सूची में तर्कों का उपयोग करके फ़ंक्शन को कॉल करता है।

उदाहरण के लिए:

• rep("c",3) वेक्टर का उत्पादन करता है "c" "c" "c"
• do.call("rep",list(c("a","b","c"),1:3)) वेक्टर का उत्पादन करता है "a" "b" "b" "c" "c" "c"
• जो लगातार कॉल करने के बराबर है rep("a",1), rep("b",2)औरrep("c",3)

Answer 23

विम, 43 बाइट्स

qqYlpx@qq@qqr0<C-H><C-V>{$:s/\v%V(.)\1*/&\1/g<CR>@rq@r

पहला मैक्रो प्रत्ययों को अलग करता है, दूसरा मैक्रो उन्हें "विस्फोट" करता है। संभवत: मारपीट हुई। रिक्त स्थान कष्टप्रद हैं।

Answer 24

सी, 186 बाइट्स

#include <string.h>
#define S strlen
p(char* s){char *t=s;char u[999]="";for(int i=0;i<S(s);i++){for(int j=i+1;j>0;j--){sprintf(u+S(u),"%c",*t);}t++;}printf("%s\n",u);if(S(s)>1)p(s+1);}

यह शायद काफी कम किया जा सकता है, लेकिन मैं सिर्फ यह कोशिश करना चाहता था। यह गोल्फ में मेरा दूसरा प्रयास है, इसलिए आप मुझे कोई भी संकेत दे सकते हैं (* योग्य)। यह पैरामीटर के रूप में एक स्ट्रिंग लेता है और वहां से विस्फोट करता है। यू का उपयोग एक बफर के रूप में किया जाता है जो विस्फोटित स्ट्रिंग को संग्रहीत करता है।

Ungolfed:

#include <string.h>
#define S strlen 
p(char* s){
    char *t=s;
    char u[999]="";
    for(int i=0;i<S(s);i++){
        for(int j=i+1;j>0;j--){
            sprintf(u+S(u),"%c",*t);
        }
        t++;
    }
    printf("%s\n",u);
    if(S(s)>1)p(s+1);
}

Answer 25

एसीसी !!, 150 बाइट्स

स्टैड पर इनपुट की उम्मीद है, एक टैब वर्ण के साथ समाप्त किया गया।

N
Count c while _/128^c-9 {
_+N*128^(c+1)
}
Count i while _-9 {
Count j while _/128^j-9 {
Count k while j+1-k {
Write _/128^j%128
}
}
Write 10
_/128
}

व्याख्या

यह वास्तव में Acc के लिए एक बहुत अच्छा काम है !! , क्योंकि यह केवल एक स्ट्रिंग पढ़ने और कुछ नेस्टेड छोरों के साथ उस पर चलने की आवश्यकता है। हम संचयकर्ता में स्ट्रिंग को पढ़ते हैं, इसे आधार-128 अंकों के अनुक्रम के रूप में मानते हैं, कम-क्रम के अंत पर पहले चरित्र के साथ। ओपनिंग Count cलूप के बाद , संचायक मान को इस तरह से परिकल्पित किया जा सकता है ( xyzउदाहरण इनपुट के रूप में)

128^   3  2  1  0
     tab  z  y  x

(इस उदाहरण के लिए वास्तविक संचायक मान 9*128^3 + 122*128^2 + 121*128 + 120= है 20888824)

फिर हम 128 की बढ़ती शक्तियों पर पुनरावृत्ति करके स्ट्रिंग पर पुनरावृत्ति कर सकते हैं। और हम प्रत्येक पुनरावृत्ति के बाद संचायक को 128 से विभाजित करके प्रत्ययों पर पुनरावृति कर सकते हैं, एक चरित्र को काटकर।

इंडेंटेशन और टिप्पणियों के साथ:

# Initialize the accumulator with the first input character
N
# Loop until most recent input was a tab (ASCII 9)
Count c while _/128^c - 9 {
    # Input another character and add it at the left end (next higher power of 128)
    _ + N * 128^(c+1)
}

# Loop over each suffix, until only the tab is left
Count i while _ - 9 {
    # Loop over powers of 128 until the tab
    Count j while _/128^j - 9 {
        # Loop (j+1) times
        Count k while j + 1 - k {
            # Output the j'th character
            Write _ / 128^j % 128
        }
    }
    # Output a newline
    Write 10
    # Remove a character
    _/128
}