विस्फोट हो गया

32

परिचय

चलो स्ट्रिंग का निरीक्षण करते हैं abc। इससे बनने वाले पदार्थ निम्न हैं:

a, ab, abc, b, bc, c

अब हमें उन्हें इस तरह के प्रारंभिक स्ट्रिंग के तहत संरेखित करने की आवश्यकता है:

abc
a
 b
  c
ab
 bc
abc

स्ट्रिंग का क्रम मायने नहीं रखता है, इसलिए यह भी पूरी तरह से मान्य है:

abc
a
ab
abc
 b
 bc
  c

तो, स्ट्रिंग को स्ट्रिंग के प्रारंभिक स्ट्रिंग में स्थान के नीचे तैनात किया गया है। तो abcdefऔर प्रतिस्थापन के लिए cde, यह इस तरह दिखेगा:

abcdef
  cde

काम

कार्य 0 से अधिक की लंबाई के साथ सभी सबस्ट्रिंग को संरेखित करना है , जैसा कि ऊपर दिखाया गया है। आप यह मान सकते हैं कि स्ट्रिंग में केवल वर्णमाला वर्ण होंगे और कम से कम 1 वर्ण होगा। पैडिंग के लिए, आप एक स्थान या कुछ अन्य गैर-अल्फाबेटिक प्रिंट करने योग्य ASCII वर्ण ( 32 - 127) का उपयोग कर सकते हैं । शायद उल्लेख करने के लिए आवश्यक नहीं है, लेकिन स्ट्रिंग में केवल अद्वितीय वर्ण होंगे, इसलिए ऐसा नहीं है aba, क्योंकि aदो बार होता है।

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

इनपुट: abcde

संभावित उत्पादन:

a
ab
abc
abcd
abcde
 b
 bc
 bcd
 bcde
  c
  cd
  cde
   d
   de
    e

इनपुट: abcdefghij

संभावित उत्पादन:

a
ab
abc
abcd
abcde
abcdef
abcdefg
abcdefgh
abcdefghi
abcdefghij
 b
 bc
 bcd
 bcde
 bcdef
 bcdefg
 bcdefgh
 bcdefghi
 bcdefghij
  c
  cd
  cde
  cdef
  cdefg
  cdefgh
  cdefghi
  cdefghij
   d
   de
   def
   defg
   defgh
   defghi
   defghij
    e
    ef
    efg
    efgh
    efghi
    efghij
     f
     fg
     fgh
     fghi
     fghij
      g
      gh
      ghi
      ghij
       h
       hi
       hij
        i
        ij
         j

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!

code-golf  string 
— अदनान
स्रोत
1
खाली स्थानापन्न कहाँ है?
— लीक नून
@ केनीलाऊ ओह, हाँ, यह मुझे चुनौती में कुछ और जानकारी संपादित करने की याद दिलाता है।
— अदनान
एक अनुगामी न्यूलाइन स्वीकार्य है?
— user81655
@ user81655 हाँ, यह स्वीकार्य है।
— अदनान
तार की एक सरणी स्वीकार्य है, या क्या यह न्यूलाइन-अलग होना है?
— जर्गर्ब

जवाबों:

21

पर्ल, 32 28 24 बाइट्स

के लिए +1 शामिल है -n

कोड:

/.+(??{say$"x"@-".$&})/

STDIN पर स्ट्रिंग के साथ चलाएँ:

perl -nE '/.+(??{say$"x"@-".$&})/' <<< abcd

गोल्फिंग भाषाएँ अब तक बहुत पास हैं और अभी तक ...

व्याख्या

/.+/एक विकल्प से मेल खाता है। दुर्भाग्य से यह एक बार मिलान होने के बाद रुक जाता है। इसलिए मैं regex (??{})का विस्तार करने के लिए रनटाइम रेगेक्स कंस्ट्रक्शन का उपयोग करता हूं, इसलिए यह विफल हो जाता है और बैकट्रैकिंग निम्नलिखित विकल्प की कोशिश करेगा, अंत में घृणा में देने से पहले उन सभी की कोशिश कर रहा है।

अंदर (??{})मैं उपयोग कर रहे सबस्टेशन के ऑफसेट के रूप में कई रिक्त स्थान के रूप में उपसर्ग के वर्तमान सबस्टेशन को प्रिंट करता हूं$"x"@-"

तो बड़े करीने से दस्तावेज़ कैसे regex backtracking काम करता है:

abcd
abc
ab
a
 bcd
 bc
 b
  cd
  c
   d
— टन हास्पेल
स्रोत
1
अच्छा ग्रेवी, यह सिर्फ गूढ़ के रूप में दिखने वाला गूढ़ है। एक +1 है।
— AdmBorkBork
4
@ टिमिमद: कुछ अजीब कारणों से ऐसे लोग हैं जो कहते हैं कि गोल्फ पर्ल को एक बुरा नाम देता है ...
— टन हास्पेल
पर्ल 6 संस्करण है कि इस से प्रेरित था कार्यात्मक बहुत समान हैperl6 -ne 'm/^(.*)(.+)<{+put " "x$0.to,$1}>/'
— ब्रैड गिल्बर्ट b2gills
इनपुट पर काम नहीं करता है ab1(मुझे लगता है क्योंकि say...मूल्यांकन करता है 1)। (5.18.2 में परीक्षण किया गया।) संपादित करें: ओह! क्षमा करें, प्रश्न कहता है "आप मान सकते हैं कि स्ट्रिंग में केवल वर्णमाला वर्ण होंगे"।
— msh210
14

MATL , 20 18 बाइट्स

@ Aditsu के उत्तर द्वारा उत्पन्न सबस्ट्रिंग के पैटर्न से प्रेरित

tt!+gR*c`t3Lt3$)tn

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

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

व्याख्या

t         % implicit input. Duplicate
t!+g      % square matrix with size as input
R         % keep upper triangular part
*c        % multiply element-wise with broadcast. Convert to char
`         % do...while
  t       %   duplicate
  3Lt3$)  %   remove last row and column
  tn      %   number of remaining elements. Used as loop condition
          % implicitly end loop and display

पुराना तरीका (कार्टेशियन पावर)

यदि मैं अन्य उत्तरों के लिए प्रेरणा का काम करता हूं तो मैं इस दृष्टिकोण को रख रहा हूं

tn0:2Z^!S!2\Xu4LY)*c

ऑनलाइन संकलक में यह सबसे लंबे समय तक परीक्षण के मामले में स्मृति से बाहर चलाता है।

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

व्याख्या

यह मूल्यों के सभी पैटर्न उत्पन्न करता है 0, 1और 2बढ़ते क्रम में, और फिर रूपांतरित 2होता है 0। यह उन सभी संभावित प्रतिमानों को देता है 0और 1जहाँ 1मान सन्निहित हैं। इनका उपयोग यह चिन्हित करने के लिए किया जाता है कि कौन से अक्षर मूल स्ट्रिंग से लिए गए हैं।

एक उदाहरण के रूप में, स्ट्रिंग के 'abc'लिए पैटर्न निम्नानुसार उत्पन्न होते हैं। [0 1 2]इनपुट पात्रों की संख्या के लिए उठाए गए पहले कार्टेशियन शक्ति प्राप्त की है:

0 0 0
0 0 1
0 0 2
0 1 0
0 1 1
···
2 2 1
2 2 2

प्रत्येक पंक्ति को क्रमबद्ध करता है

0 0 0
0 0 1
0 0 2
0 0 1
0 1 1
···
1 2 2
2 2 2

(यानी ) 2में बदलने और डुप्लिकेट पंक्तियों को हटाने से अंतिम पैटर्न मिलता है0mod(...,2)

0 0 0
0 0 1
0 1 1
0 1 0
1 1 1
1 1 0
1 0 0

जिसमें प्रत्येक पंक्ति एक (सन्निहित) विकल्प के अनुरूप एक मुखौटा है। पहली पंक्ति को हटाने की आवश्यकता है क्योंकि यह खाली विकल्प से मेल खाती है।

t      % Implicitly get input. Duplicate
n      % Number of elements
0:2    % Vector [0 1 2]
Z^     % Cartesian power. Each result is a row
!S!    % Sort each row
2\     % Modulo 2: transform 2 into 0
Xu     % Unique rows
4LY)   % Remove first (corresponds to the empty substring)
*      % Element-wise multiplication by original string
c      % Convert to char. Implicitly display
— लुइस मेंडो
स्रोत
3
क्या आपका दिमाग एक बड़ी मैट्रिक्स-हेरफेर मशीन है?
— बिल्ली
@ बहुत ज्यादा मैटलैब का कई वर्षों तक उपयोग मुझे लगता है :-)
— लुइस मेंडो
14

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

3 बाइट्स बचाने और कई और अधिक के लिए मार्ग प्रशस्त करने के लिए केनी लाउ का धन्यवाद।

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

M&!r`.+
%+`( *)\S(.+)$
$&¶$1 $2

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

उत्पन्न पदार्थों का क्रम:

abcde
 bcde
  cde
   de
    e
abcd
 bcd
  cd
   d
abc
 bc
  c
ab
 b
a

व्याख्या

M&!r`.+

इससे हमें इनपुट के सभी उपसर्ग मिल जाते हैं। यह मिलान ( M) किसी भी सबस्ट्रिंग ( .+अंत से शुरू r), ओवरलैपिंग मैचों ( &) पर विचार करके और उन सभी मैचों को लाइनफीड्स ( !) के साथ जोड़कर वापस करने के द्वारा किया जाता है ।

अब हमें बस इतना करना है कि उन उपसर्गों के क्रमिक उपसर्गों (उन्हें स्थान के साथ बदलकर) को उकेरना है। हम इस चरण को एक लूप के साथ कदम से करते हैं:

%+`( *)\S(.+)$
$&¶$1 $2

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

— मार्टिन एंडर
स्रोत
हम मिल सकता है !निकलता है Mऔर की 1char संस्करणों .+और .*?
— कैलकुलेटर
स्ट्रिंग के उपसर्गों के भी उपसर्ग = एक स्ट्रिंग के उपसर्ग। शायद आपका मतलब प्रत्यय के उपसर्गों से था? (सही करने के लिए संपादित।)
— कैलकुलेटरफ्लीन
@CatsAreFluffy कोई स्पष्टीकरण सही नहीं था। जब हम उपसर्गों से उपसर्गों को हटाते हैं, तो हम सब्सट्रिंग्स प्राप्त करते हैं। अन्य सुझावों के लिए, मुझे नहीं लगता कि मैं विकल्पों को स्पष्ट रूप से चरणबद्ध करूँगा। वर्तमान में, बहुत सारे पात्रों का उपयोग केवल एक चरण प्रकार के लिए किया जाता है, जो संभवतः भविष्य में बदल जाएगा। के रूप में .+और .*मैं regex टोकन होगा, और जब मैं कुछ बिंदु पर ऐसा करने की योजना बना रहा हूं, मुझे नहीं लगता कि यह जल्द ही किसी भी समय होने वाला है (और अगर मैं करता हूं, तो मैं शायद उन विशेषताओं पर ध्यान केंद्रित करूंगा वास्तव में स्पष्टता जोड़ें)।
— मार्टिन एंडर
— लीकी नून
11

Oracle SQL 11.2, 146 बाइट्स

WITH v AS(SELECT LEVEL i FROM DUAL CONNECT BY LEVEL<=LENGTH(:1))SELECT LPAD(SUBSTR(:1,s.i,l.i),s.i+l.i-1)FROM v s,v l WHERE s.i+l.i<=LENGTH(:1)+1;

संयुक्त राष्ट्र के golfed

WITH v AS(SELECT LEVEL i FROM DUAL CONNECT BY LEVEL<=LENGTH(:1))
SELECT LPAD(SUBSTR(:1,s.i,l.i),s.i+l.i-1)
FROM   v s, v l
WHERE  s.i+l.i<=LENGTH(:1)+1
— Jeto
स्रोत
9

सीजेम, 20

q{__,{\_N+oSt}/;W<}h

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

स्पष्टीकरण:

q           read the input (initial string)
{…}h        do … while
  _         copy the current string
  _,        copy and get the length
  {…}/      for each value (say i) from 0 to length-1
    \       bring the string to the top
    _N+o    make a copy, append a newline and print
    St      set the i'th element to S=" "
  ;         pop the last result (array full of spaces)
  W<        remove the last character of the current string
             if the string is empty, the do-while loop terminates
— aditsu
स्रोत
8

पायथन, 57 बाइट्स

f=lambda s,p='':set(s)and{p+s}|f(s[1:],' '+p)|f(s[:-1],p)

setजैसे आउटपुट {' b', 'a', 'ab'}। विचार यह है कि पहले या अंतिम चरित्र को काट देने वाले दो शाखीयों को फिर से बनाया जाए। निरर्थक आउटपुट देता है, लेकिन setस्वचालित रूप से डुप्लिकेट को हटा देता है। संरेखण के लिए, हर बार पहले वर्ण को काट दिया जाता है, उपसर्ग में एक स्थान जोड़ा जाता है p, जिसे सामने की ओर समतल किया जाता है।

— XNOR
स्रोत
7

PowerShell v2 +, 69 बाइट्स

param($a)0..($b=$a.length-1)|%{($i=$_)..$b|%{" "*$i+-join$a[$i..$_]}}

इनपुट लेता है $a, लंबाई पर लूप लेता है ( $bबाद में उपयोग के लिए प्रक्रिया में सेटिंग )। प्रत्येक बाहरी लूप, हम $bफिर से लूप करते हैं, $iबाद में उपयोग के लिए सेट करते हैं। प्रत्येक आंतरिक लूप, हम $iइनपुट स्ट्रिंग के एक स्लाइस के साथ रिक्त स्थान की संख्या को आउटपुट करते हैं। चूंकि हम केवल स्ट्रिंग के माध्यम से लूपिंग कर रहे हैं, यह वास्तव में किसी भी मनमाने स्ट्रिंग (डुप्लिकेट पत्र, रिक्त स्थान, जो भी हो) को संभाल लेगा।

उदाहरण

PS C:\Tools\Scripts\golfing> .\exploded-substrings.ps1 "Golfing"
G
Go
Gol
Golf
Golfi
Golfin
Golfing
 o
 ol
 olf
 olfi
 olfin
 olfing
  l
  lf
  lfi
  lfin
  lfing
   f
   fi
   fin
   fing
    i
    in
    ing
     n
     ng
      g
— AdmBorkBork
स्रोत
7

सी #, 136 132 131 बाइट्स

golfed

String m(String s){String o="",e=o;for(int i=0,a,l=s.Length;i<l;i++,e+=" ")for(a=1;a+i<=l;a++)o+=e+s.Substring(i,a)+"\n";return o;}

Ungolfed

String m( String s ) {
    String o = "", e = o;

    for (int i = 0, a, l = s.Length; i < l; i++, e += " ")
        for (a = 1; a + i <= l; a++)
            o += e + s.Substring( i, a ) + "\n";

    return o;
}

पूर्ण कोड

    using System;
using System.Collections.Generic;

namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            List<String> ls = new List<String>() {
                    "abcde",
                    "abcdefghijklmnop",
                    "0123456789",
                };

            foreach (String s in ls) {
                Console.WriteLine( s );
                Console.WriteLine( m( s ) );
                Console.WriteLine( "" );
            }

            Console.ReadLine();
        }

        static String m( String s ) {
            String o = "", e = o;

            for (int i = 0, a, l = s.Length; i < l; i++, e += " ")
                for (a = 1; a + i <= l; a++)
                    o += e + s.Substring( i, a ) + "\n";

            return o;
        }
    }
}

विज्ञप्ति

  • v1.2 - -1 byte- 1 बाइट को बचाने के String o="",e="";लिए बदल दिया गया String o="",e=o;। विचार गैलेंट का था ( मैं पिछले अद्यतन में इस भाग को लागू करना भूल गया, मैं माफी माँगता हूँ। )।
  • v1.1 - -4 bytes- से droped कोष्ठक forछोरों और चले गए eवर अंतरिक्ष वेतन वृद्धि बाहरी की इटरेटर क्षेत्र के लिए forपाश। विचार गैलेंट का था ।
  • v1.0 - 136 bytes- प्रारंभिक समाधान।
— auhmaan
स्रोत
1
आप आंतरिक लूप पर घुंघराले ब्रेस को गिरा सकते हैं और e=o3 बाइट्स को बचाने के लिए असाइन कर सकते हैं।
— गैलेंट
अन्य के String o="",...साथ भी स्वैप कर सकते हैं var o...3.
— TyCobb
@tycobb यह बेकार परिवर्तित प्रस्तुत करना होगा String o = "", e = "";करने के लिए varके बाद से मैं उन्हें दो भागों में अलग करने के लिए, जिसका परिणाम होता है var o = ""; var e = "";जो एक ही लंबाई है एक मेरे पास है के साथ तुलना में। यह करना होगा, लेकिन निहित रूप से टाइप किए गए चर का उपयोग करते समय वीएस कई चर घोषणा की अनुमति नहीं देता है - उर्फ var। लेकिन मदद के लिए धन्यवाद। संपादित करें: वीएस ने मुझे चिल्लाते हुए कहा कि मैं ऐसा नहीं कर सकता, मैं मान रहा हूं कि यह गलत है, गलत हो सकता है।
— अनुगमन २ a
5

पायथन 2.7, 70 82 बाइट्स

मैं यह पता नहीं लगा सका कि इसे 1 पंक्ति में कैसे लाया जाए। के साथ बुलानाe("abcde",0)

def e(s,p):
 f=len(s)
 for x in range(f):print(' '*p+s[:x+1])
 if f>1:e(s[1:],p+1)
— नीला
स्रोत
4

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

रिक्त स्थान की संख्या के माध्यम से उपसर्ग के साथ लूप और फिर समाप्त होने के लिए वर्णों की संख्या।

lambda x:[print(' '*i+x[i:j+1])for i in range(len(x))for j in range(i,len(x))]

संपादित करें: लूप के लिए पहले हटाए गए स्थान।

— NonlinearFruit
स्रोत
4

MATL, 15 14 बाइट्स

यहाँ @ लुइसेंडो की टिप के कारण एक बाइट को बचाया !

tfWt2/!-RXzB*c

इतने सारे तरीके ... एक नया खोजना था। खुश बिट्स! :)

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

विस्फोट

t       % duplicate input
f       % get indices of nonzero elements in vector (i.e. 1:n)
W       % 2 raised to array, element-wise: 2^(1:n)
t       % duplicate array
2/      % divide by 2: 2^(0:n-1)
!       % transpose array 
-       % element-wise subtraction (w/singleton expansion)
R       % upper triangular part
Xz      % nonzero elements
B       % convert from decimal to binary. Produces a logical array
*       % array product (element-wise, singleton expansion)
c       % convert to character array; 0's automatically converted to spaces
— बीकर
स्रोत
3

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

document.write("<pre>"+(

s=>(a=[...s]).map((_,i)=>a.map((_,j)=>++j>i?r+=" ".repeat(i)+s.slice(i,j)+`
`:0),r="")&&r

)("abcde"))
स्निपेट का विस्तार करें

सीधे-आगे का दृष्टिकोण। आउटपुट में एक अनुगामी न्यूलाइन है।

— user81655
स्रोत
=>जावास्क्रिप्ट में क्या मतलब है? क्या यह एक बाइनरी ऑपरेटर है
— इवान डेलानॉय
@ EwanDelanoy यह एक ES6 एरो फंक्शन की घोषणा करता है ।
— user81655
3

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

s=>{for(i=j=0;s[j]||s[j=++i];)console.log(' '.repeat(i)+s.slice(i,++j))}
— edc65
स्रोत
3

पायथ, 12 11 बाइट्स

jm+*;xQdd.:

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

— orlp
स्रोत
जब आप निम्नतम स्तर के नक्शे के अंदर ;का उपयोग कर सकते हैं \ ।
— FryAmTheEggman 13
3

मैथेमेटिका 89 बाइट्स

r@i_:=StringReplace[i,#->" "]&/@(Complement[y,#]&/@Subsequences[y=Characters@i])//Column

व्याख्या

i इनपुट स्ट्रिंग को संदर्भित करता है

Subsequences[y=Characters@i]इनपुट के सभी अनुवर्ती (वर्णों की सूचियों का प्रतिनिधित्व) देता है। ( Subsequencesv। 10.4 में पेश किया गया था)

प्रत्येक बाद के लिए, Complement...इनपुट स्ट्रिंग से उन वर्णों को लौटाता है जो मौजूद नहीं हैं। उन पात्रों में से प्रत्येक के माध्यम से एक खाली जगह द्वारा प्रतिस्थापित किया जाता है StringReplace[i,#->" "]।

Columnएकल कॉलम में परिणाम प्रदर्शित करता है। प्रत्येक आउटपुट स्ट्रिंग में वर्णों की एक ही संख्या होती है, जिसके परिणामस्वरूप संरेखित अक्षर होते हैं।

r@"abcdefgh"

उत्पादन

— DavidC
स्रोत
10.0.4 से आपका मतलब 10.4 है, है ना? 10.3 यह नहीं है।
— कैलकुलेटरफ्लीन
हाँ। 10.4 मैं इसे सही करूँगा।
— 1
3

जे, 32 29 28 बाइट्स

(-@{.@i.|.])"1 a:>@-.~&,<\\.

यह एक राक्षसी क्रिया का मूल्यांकन करता है। इसे यहाँ आज़माएँ। उपयोग:

   f =: (-@{.@i.|.])"1 a:>@-.~&,<\\.
   f 'abe'
a  
ab 
abe
 b 
 be
  e

व्याख्या

कुछ अन्य उत्तरों के रूप में, मैं प्रत्येक प्रतिस्थापन के पहले वर्ण की घटना के सूचकांक की गणना करता हूं। सबस्ट्रिंग को अनुगामी स्थानों के साथ एक मैट्रिक्स में संग्रहीत किया जाता है, इसलिए मैं उन्हें पैडिंग की सही मात्रा प्राप्त करने के लिए उनके सूचकांक द्वारा दाईं ओर घुमाता हूं। बीच में व्हॉट्सएप का एक टुकड़ा "1और a:वास्तव में कष्टप्रद है ...

(-@{.@i.|.])"1 a:>@-.~&,<\\.  Input is y
                        <\\.  Compute suffixes of prefixes of y, and put them in boxes.
                              This gives a 2D array of substrings in boxes.
                      &,      Flatten the array of boxes,
               a:  -.~        remove all empty strings, and
                 >@           open each box. This places the strings in a 2D matrix of
                              characters, with trailing spaces to make it rectangular.
(          )"1                Do this for each line x in the matrix:
      i.                        The index of every character of x in y.
 -@{.@                          Take the first one and negate it.
        |.]                     Rotate x to the left by that amount.
                                Since we negated the index, this rotates to the right.
— Zgarb
स्रोत
a eचुनौती के रूप में परिभाषित एक विकल्प नहीं है
— टन २०१३
@ टोनहोल I ने कार्यक्रम तय किया, यह अब कल्पना का अनुसरण करता है।
— जर्गर्ब
3

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 65 63 बाइट्स

s=>[for(c of(i=0,s))for(d of(t=r=i?t+' ':'',s.slice(i++)))r+=d]

स्ट्रिंग्स की एक सरणी देता है। ES6 के रूप में यह 78 बाइट्स है:

s=>[...s].map((_,i,a)=>a.slice(i).map(c=>r.push(u+=c),t=u=i?t+' ':''),r=[])&&r
— नील
स्रोत
2

QBasic, 75 बाइट्स

INPUT s$
FOR i=1TO LEN(s$)
FOR j=1TO i
LOCATE,j
?MID$(s$,j,i+1-j)
NEXT
NEXT

बुनियादी डबल- FORलूप रणनीति, QBasic के 1-आधारित अनुक्रमण के लिए थोड़ा संशोधित हुई। मुख्य चाल है LOCATE,j, जो jमुद्रण से पहले कर्सर को वर्तमान रेखा के स्तंभ पर ले जाती है । चूंकि स्तंभ 1 पहला स्तंभ है, इसलिए यह j-1अग्रणी स्थानों को मुद्रित करने के बराबर है ।

— DLosc
स्रोत
2

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

perl6 -ne 'm/^(.*)(.+)<{+put " "x$0.to,$1}>/'
m/       # match the input line
  ^      # from the start
  ( .* ) # 0 or more characters ( $0 )
  ( .+ ) # 1 or more characters ( $1 )

  <{ # match against the result of:

    +put # print with a trailing newline:
      " " x $0.to, # add the leading spaces
      $1           # the substring
  }>
/

+पहले putका कारण इतना है कि यह 1बदले में लौटता है True, जो कि इनपुट में नहीं होने की गारंटी है, इसलिए इसे हमेशा पीछे करना पड़ता है।

$ perl6 -ne 'm/^(.*)(.+)<{+put " "x$0.to,$1}>/' <<< abcd
   d
  cd
  c
 bcd
 bc
 b
abcd
abc
ab
a

(यदि आप (.*?)(.+?)इसके बजाय विपरीत क्रम में उपयोग करना चाहते हैं (.*)(.+))

यह पर्ल 5 उत्तर से प्रेरित था ।

— ब्रैड गिल्बर्ट b2gills
स्रोत
2

जे, 35 23 22 बाइट्स

[:;#\.<@{."_1|.\."1^:2

मुझे कुछ समय लगा लेकिन मैंने आखिरकार इसे अनुकूलित कर लिया।

प्रयोग

   f =: [:;#\.<@{."_1|.\."1^:2
   f 'abcde'
abcde
abcd 
abc  
ab   
a    
 bcde
 bcd 
 bc  
 b   
  cde
  cd 
  c  
   de
   d 
    e

व्याख्या

[:;#\.<@{."_1|.\."1^:2  Input: s
             |.\."1     For each suffix of s, reverse it
                   ^:2  Repeat that twice to create all exploded substrings
   #\.                  Get the length of each suffix. This is
                        used to make the range [len(s), len(s)-1, ..., 1]
        {."_1           For each value in the range, take that many strings from
                        the list of exploded substrings. This avoids blank substrings
      <@                Box each set of strings
[:;                     Unbox and join the strings together and return
— मील की दूरी पर
स्रोत
कोष्ठक की सही जोड़ी को हटाकर आप 2 बाइट्स बचा सकते हैं। इसके अलावा, कर [:+./"1' '~:]के बजाय [:-.[:*/"1' '=]एक और 2 बाइट्स बचाता है।
— जर्गर्ब
2

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

String e(String s){int l=s.length(),a=0,i,j;for(;++a<l;)for(i=0;i<=l-a;){s+="\n";for(j=0;j++<i;)s+=" ";s+=s.substring(i,i+++a);}return s;}

प्रारूपित:

String e(String s) {
    int l = s.length(), a = 0, i, j;
    for (; ++a < l;)
        for (i = 0; i <= l - a;) {
            s += "\n";
            for (j = 0; j++ < i;)
                s += " ";
            s += s.substring(i, i++ + a);
        }
    return s;
}
— आरसीबी
स्रोत
1

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

(>>=zipWith((++).(`replicate`' '))[0..].init.tails).reverse.inits

यह जरूरी है initsऔर tailsData.List से, हालांकि। इसे आउटपुट mapM_ putStrLn.करने के लिए, फ्रंट में जोड़ें ।

अपेक्षाकृत सरल; reverseसुनिश्चित करें कि मूल स्ट्रिंग पहली बार है बनाने के लिए है।

GHCi> mapM_ putStrLn.(>>=zipWith((++).(`replicate`' '))[0..].init.tails).reverse.inits$"abcde"
abcde
 bcde
  cde
   de
    e
abcd
 bcd
  cd
   d
abc
 bc
  c
ab
 b
a
it :: ()
(0.02 secs, 0 bytes)
— Zemyla
स्रोत
2
(>>=zipWith(++)(inits$cycle" ").init.tails).inits। और कृपया import Data.List;बाइट गिनती में जोड़ें ।
— nimi
1

रूबी, 75 67 बाइट्स

अनाम फ़ंक्शन। सब्सट्रिंग संरेखित करने के लिए रेगेक्स प्रतिस्थापन का उपयोग करता है। .भराव चरित्र है।

->s{(l=s.size).times{|i|(l-i).times{|j|puts s.tr(?^+s[j,i+1],?.)}}}
— मूल्य स्याही
स्रोत
1

बैश + जीएनयू कोरुटिल्स, 109 बाइट्स

l=${#1}
for i in `seq 0 $l`;{
for j in `seq $((l-i))`;{
for k in `seq $i`;{ printf ' ';}
echo ${1:i:j}
}; }

हो सकता है कि कोई छोटा उपाय हो, लेकिन यह सबसे अच्छा है जो मेरे दिमाग में आया। Chracters की विशिष्टता यहाँ कोई फर्क नहीं पड़ता।

— rexkogitans
स्रोत
1

पीएचपी, 151 चार्ट

Ungolfed

<?php
$input = $argv[1];
foreach(str_split($input) as $p=>$letter)
{
    $spaces = str_repeat(" ", $p);
    echo $spaces.$letter."\n";
    $p++;
    for($i=$p;$i<strlen($input);$i++)
    {
        echo $spaces.$letter.substr($input, $p, $i)."\n";
    }
}
?>

golfed

<?$c=$argv[1];foreach(str_split($c)as$d=>$b){$a=str_repeat(" ",$d);echo$a.$b."\n";$d++;for($e=$d;$e<strlen($c);$e++){echo$a.$b.substr($c,$d,$e)."\n";}}

उदाहरण

php explodesub.php 'abc'
a
ab
abc
 b
 bc
  c
— timmyRS
स्रोत
1

सी ++, 145 बाइट्स

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

#include<iostream>
#define f(y,b,d) for(int y=b;r[0][y];y++){d;}
int main(int,char*r[]){f(x,0,f(y,x+1,std::cout.write(r[0],y)<<'\n')r[0][x]=32)}
— होमर सिम्पसन
स्रोत
शानदार जवाब और पीपीसीजी में आपका स्वागत है! मैं C ++ का उपयोग नहीं करता, लेकिन क्या आप std::cout<<r[0]<<y<<'\n''std :: cout.write (r [0], y) <<' \ n 'के बजाय नहीं कर सकते ? क्या आप कृपया एक संक्षिप्त विवरण जोड़ सकते हैं? धन्यवाद!
— NoOneIsHere
1

पायथन 2 (अनगुल्ड) 99 बाइट्स

t=raw_input()
l=len(t)
for j in range(l):
 for i in range(l):
  if i>=j:print j*' '+t[j:i+1]

परिणाम:

>>python codegolf.py
abc
a
ab
abc
 b
 bc
  c

>>python codegolf.py
abcdef
a
ab
abc
abcd
abcde
abcdef
 b
 bc
 bcd
 bcde
 bcdef
  c
  cd
  cde
  cdef
   d
   de
   def
    e
    ef
     f

>>python codegolf.py
lmnopqrst
l
lm
lmn
lmno
lmnop
lmnopq
lmnopqr
lmnopqrs
lmnopqrst
 m
 mn
 mno
 mnop
 mnopq
 mnopqr
 mnopqrs
 mnopqrst
  n
  no
  nop
  nopq
  nopqr
  nopqrs
  nopqrst
   o
   op
   opq
   opqr
   opqrs
   opqrst
    p
    pq
    pqr
    pqrs
    pqrst
     q
     qr
     qrs
     qrst
      r
      rs
      rst
       s
       st
        t
— स्वाधिकर सी
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.