एक शब्द आइकल बनाओ


45

स्टैक एक्सचेंज की तकनीकी सीमाओं के कारण, शीर्षक गलत तरीके से प्रस्तुत किया गया है। सही इस चुनौती के लिए शीर्षक है

एक बनाओ

Word Icicle!
Word Icicle 
Word  cicle 
 ord  cicle 
 ord   icle 
 ord   i le 
 or    i le 
 or    i l  
 or      l  
 or         
  r         

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

  1. स्ट्रिंग की वर्तमान स्थिति मुद्रित करें।

  2. स्पेस के साथ लेक्सिकली सबसे छोटे कैरेक्टर (स्पेस के अलावा) को बदलें। यदि कोई टाई है, तो बाईं ओर के चरित्र को बदलें।

  3. लगातार लाइनों पर दोहराएं जब तक कि स्ट्रिंग में केवल 1 गैर-स्थान वर्ण न हो।

यह प्रभाव पैदा करता है कि इनपुट स्ट्रिंग ऐसा लगता है जैसे यह पिघल रहा है ...

I'm Melting!!!
I'm Melting !!
I'm Melting  !
I'm Melting   
I m Melting     
  m Melting   
  m  elting   
  m   lting   
  m   ltin    
  m   lt n    
  m    t n    
       t n    
       t      

नियम

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

  • आपके पास एक अनुगामी खाली रेखा हो सकती है , लेकिन अधिक नहीं।

  • याद रखें कि इनपुट में कई रिक्त स्थान हो सकते हैं, लेकिन ये सभी प्रभावी रूप से छोड़ दिए गए हैं। उदाहरण के लिए, इनपुट a aदेना चाहिए

    a      a
           a
    
  • यदि आप चाहते हैं तो आप स्ट्रिंग की सूची के रूप में इनपुट ले सकते हैं। आउटपुट के लिए, आप स्ट्रिंग्स की एक सूची पर वापस आ सकते हैं या प्रिंट कर सकते हैं, नए सिरे से एक स्ट्रिंग, या चार मैट्रिक्स / 2 डी सरणी। आम तौर पर, मैं अनुमेय IO प्रारूप पसंद करता हूं, इसलिए अन्य प्रारूपों को तब तक अनुमति दी जाती है जब तक वे सुसंगत हों और स्पष्ट रूप से सही आउटपुट के अनुरूप हों। यदि संदेह है, तो बेझिझक पूछें। हमेशा की तरह, पूर्ण कार्यक्रमों या कार्यों की अनुमति है।

  • याद रखें, यह किसी भी भाषा में सबसे कम उत्तर देने की प्रतियोगिता है! यदि आप जावा में उत्तर देना चुनते हैं, तो सबसे छोटा जावा उत्तर (बाइट्स में) बनाने की कोशिश करें जो आप कर सकते हैं।

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

Hello World! -->

Hello World!
Hello World 
 ello World 
 ello  orld 
 ello  orl  
  llo  orl  
   lo  orl  
    o  orl  
    o  or   
       or   
        r   


AbCdEfGhIjKlMnOpQrStUvWxYz -->

AbCdEfGhIjKlMnOpQrStUvWxYz
 bCdEfGhIjKlMnOpQrStUvWxYz
 b dEfGhIjKlMnOpQrStUvWxYz
 b d fGhIjKlMnOpQrStUvWxYz
 b d f hIjKlMnOpQrStUvWxYz
 b d f h jKlMnOpQrStUvWxYz
 b d f h j lMnOpQrStUvWxYz
 b d f h j l nOpQrStUvWxYz
 b d f h j l n pQrStUvWxYz
 b d f h j l n p rStUvWxYz
 b d f h j l n p r tUvWxYz
 b d f h j l n p r t vWxYz
 b d f h j l n p r t v xYz
 b d f h j l n p r t v x z
   d f h j l n p r t v x z
     f h j l n p r t v x z
       h j l n p r t v x z
         j l n p r t v x z
           l n p r t v x z
             n p r t v x z
               p r t v x z
                 r t v x z
                   t v x z
                     v x z
                       x z
                         z


PPCG is da BEST --> 

PPCG is da BEST
PPCG is da  EST
PP G is da  EST
PP G is da   ST
PP   is da   ST
 P   is da   ST
     is da   ST
     is da    T
     is da     
     is d      
     is        
      s        


({({})({}[()])}{}) -->

({({})({}[()])}{})
 {({})({}[()])}{})
 { {})({}[()])}{})
 { {}) {}[()])}{})
 { {}) {}[ )])}{})
 { {}  {}[ )])}{})
 { {}  {}[  ])}{})
 { {}  {}[  ] }{})
 { {}  {}[  ] }{} 
 { {}  {}   ] }{} 
 { {}  {}     }{} 
   {}  {}     }{} 
    }  {}     }{} 
    }   }     }{} 
    }   }     } } 
        }     } } 
              } } 
                } 

1
"lexically smallest" का अर्थ कोड बिंदु से है?
ग्यूसेप

1
@Giuseppe हाँ, छोटी से छोटी ASCII कोड बिंदु के साथ चरित्र (स्पष्ट रूप से अंतरिक्ष के अलावा अन्य)
DJMcMayhem

2
मुझे एक और चुनौती की याद दिलाती है कि हमें कहाँ होना था, मुझे लगता है कि वर्णमाला में इसके सूचकांक द्वारा एक वर्ण को दोहराते हैं।
झबरा

6
@ शैगी आप शायद कुछ वर्णमाला वर्षा करने के बारे में सोच रहे हैं ।
रेनबोल्ट

2
हालांकि MediaWiki का संदर्भ ...
को एर्गेल्फ़र से मिला

जवाबों:



8

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

/\S/+¶<~(O`.
0L$`\S
0`$\$&¶ 

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

/\S/+

इनपुट मान रिक्त नहीं होने पर दोहराएं।

¶<

वर्तमान मूल्य प्रिंट करें।

~(

मूल्य पर बाकी स्क्रिप्ट निष्पादित करें। फिर, मान पर स्क्रिप्ट के रूप में उस स्क्रिप्ट के परिणाम को निष्पादित करें।

O`.

पात्रों को क्रम में क्रमबद्ध करें।

0L$`\S
0`$\$&¶ 

पहले नॉनब्लांक चरित्र का चयन करें और एक रेटिना प्रोग्राम को आउटपुट करें जो उस स्थान के साथ पहले शाब्दिक ( $\) घटना ( $&) मूल स्थान में अनुगामी ( ) की जगह लेता है।


6

एपीएल (डायलॉग यूनिकोड) , 18 11 बाइट्स

∪∘↓∘⍉⍋∘⍋⍴⌸⊢

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

उपयोग करता है ⎕io←1; तार की एक सरणी देता है (चरित्र वैक्टर के वेक्टर)


है आवश्यक?
कृति लिथोस

@Cowsquack हाँ, अन्यथा आउटपुट की पहली कुछ पंक्तियाँ समान हो सकती हैं
ngn

@ धन्यवाद धन्यवाद, मैंने देखा कि नहीं
ngn

सौभाग्य से, इसे ठीक करने से इसका हल कम हो गया :)
ngn

एक अच्छा, वास्तव में चतुर का उपयोग ⍋∘⍋:)
Kritii Lithos

6

05AB1E , 9 बाइट्स

ðм{v=yð.;

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

व्याख्या

ð      # Push space
м      # Implicit input. Remove spaces
{      # Sort. Gives string of sorted, non-space chars
v      # For each char in that string
  =    #   Print latest string, without popping. The first time it prints the input
  y    #   Push current char
  ð    #   Push space
  .;   #   Replace first occurrence of current char by space
       # Implicitly end for-each loop

1
{ðKv=yð.;मेरा था, अच्छा है।
मैजिक ऑक्टोपस Urn

@MagicOctopusUrn हेह, सुंदर समान
लुइस

1
@MagicOctopusUrn वास्तव में, यह अभी भी नवीनतम 05AB1E संस्करण में एक ही 9 बाइट्स होगा .. :इसके बजाय सभी वर्णों को .;बदलता है जो पहले की जगह लेता है (यानी देखें कि आपका 7-बटर !परीक्षण मामले में क्या करता है )। इसके अलावा, चुनौती स्पष्ट रूप से रिक्त स्थान को छोड़कर बताती है, इसलिए आपका 7-बायटर कई स्थानों के साथ इनपुट के लिए काम नहीं करेगा। पुनश्च: अच्छा जवाब, लुइस! मुझ से +1। :)
केविन क्रूज़सेन

1
@ केविनक्रूजसेन ने मुझे यह भूलने के लिए छोड़ दिया कि मुझे .;पहले स्थान पर क्यों उपयोग करना था । मैं सचमुच इस साल की शुरुआत में 1 मई को उस समय से संघर्ष कर रहा हूं, जब आप इसका उल्लेख करते हैं।
मैजिक ऑक्टोपस Urn

1
@LuisMendo खैर, इस जवाब में आपके द्वारा उपयोग की गई कोई भी कमांड 05AB1E के अमृत पुनर्लेखन में नहीं बदली गई है। :)
केविन क्रूज़सेन


5

सीड -rn , 142 143 बाइट्स

:a
p
s/$/	ABCDEFGHIJKLMNOPQRSTUVWXYZ/
s	\w+$	!"#$%\&'()*+,-./0123456789:;<=>?@&[\\]^_`\L&{|}~	
:b
/(.).*	\1/!s/	./	/
tb
s/(.)(.*)	\1.*/ \2/
ta

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

(नोट: कार्यक्रम में टैब हैं)

चूंकि sed में लेक्सिकोग्राफिक ऑर्डर की कोई अवधारणा नहीं है, इसलिए मुझे मुद्रण योग्य ASCII वर्णों के सेट को हार्डकोड करना पड़ा और इसमें आधे से अधिक बायटेकाउंट लगते हैं।

Sed ४.२.२ का उपयोग करके bytecount को २ से कम कर देगा, क्योंकि अनाम लेबल के लिए अनुमति देता है, इसे ऑनलाइन आज़माएं!


-r विस्तारित नियमित अभिव्यक्ति को सक्षम करता है (गोल्फर)

-n कार्यक्रम के अंत में पैटर्न स्थान के अंतर्निहित मुद्रण को अक्षम करता है

पैटर्न स्पेस इनपुट से शुरू होता है

:aलेबल a, यह मुख्य प्रोग्राम लूप है

p पैटर्न स्पेस प्रिंट करें (बफर के लिए फैंसी नाम)

अब हम मुद्रण योग्य ASCII वर्णों को सेट करते हैं (स्थान को छोड़कर)

s/$/ ABCDEFGHIJKLMNOPQRSTUVWXYZ/ 1-बाइट सीमांकक के रूप में कार्य करने वाला एक टैब जोड़ें, उसके बाद अपरकेस वर्णमाला

s<tab>स्थानापन्न (sed किसी भी वर्ण को सीमांकक के रूप में ले जा सकता है, इस स्थिति में एक बाइट को भागने से बचाने के लिए टैब का उपयोग किया जाता है /)

  • \w+$ अपरकेस वर्णमाला हमने अभी-अभी जोड़ा है

  • <tab> साथ में

  • !"#$%\&'()*+,-./0123456789:;<=>?@&[\\]^_\`\L&{|}~<tab>बाकी वर्ण, ध्यान दें कि \L&अपरकेस वर्णमाला का निचला संस्करण है

:bलेबल b, उन आरंभ सेटों से वर्ण हटाएं जो इनपुट में मौजूद नहीं हैं

/(.).* \1/! यदि ASCII सेट से पहला वर्ण इनपुट में नहीं है

  • s/ ./ / इसे हटा दो

tbbप्रतिस्थापन विफल होने तक दोहराएं

s/(.)(.*) \1.*/ \2/ किसी स्थान के साथ इनपुट में मौजूद ASCII सेट में पहले वर्ण को बदलें, और ASCII सेट को हटा दें

ta recurse


गैर-लालची मिलान वास्तव में यहाँ मददगार होता, लेकिन मैं sedकम से कम 4 बाइट्स बचाने के लिए पर्याप्त बेवकूफ बनाने वाली चीज़ के साथ आने में सक्षम था : इसे ऑनलाइन आज़माएं!
नील

(गायों का कहना है कि मैं केवल आंशिक रूप से मूर्ख बनाने में सक्षम था, क्योंकि मैं गलत क्रम में समान पात्रों को हटाता हूं।)
नील

4

रूबी , 60 58 55 47 बाइट्स

->a{[-a]+a.scan(/\S/).sort.map{|x|a[x]=' ';-a}}

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


आप में स्वैप कर सकते हैं a-b=[' ']और a-bएक त्वरित -2 बाइट्स के लिए
benj2240

हाँ, इसके लिए धन्यवाद, लेकिन अब मैंने दृष्टिकोण को थोड़ा बदल दिया है, इसलिए अब इसका उपयोग नहीं किया जाता है।
किरिल एल।

मुझे नया तरीका पसंद है!
बेंज़ 2240

4

आर , 140 100 बाइट्स

-40 बाइट्स Giuseppe के लिए धन्यवाद!

function(x)for(i in any((z=utf8ToInt(x))<33):max(y<-rank(z,,"f"))){z[y==i]=32
cat(intToUtf8(z),"
")}

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

एक समाधान outerऔर Giuseppe का जादू ठीक से काम करने के लिए 104 बाइट्स पर है। इस उत्तर से प्रेरित ।

function(x,z=utf8ToInt(x)-32)apply(t(outer(rank(z,,"f"),(2-(min(z)>0)):nchar(x),">=")*z+32),1,intToUtf8)

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


109 बाइट्स चार्ज ऑफ़ वेक्टर के रूप में इनपुट लेते हुए
Giuseppe

1
एक स्ट्रिंग के रूप में इनपुट लेने वाले 100 बाइट्स !
ग्यूसेप

फिर भी, एक बहुत अच्छा जवाब; जब से मुझे इसके बारे में याद नहीं था तब से मेरा 200 से अधिक बाइट्स का गुब्बारा था rank!
ग्यूसेप

@Giuseppe मुझे इसके बारे में बताएं - मैंने पहली बार "ऑर्डर" की कोशिश की, जिसके परिणामस्वरूप पिघल रहा था लेकिन सही क्रम में नहीं!
JayCe

@Giuseppe और आपके पोस्ट से प्रेरित बाहरी का उपयोग करने का मेरा प्रयास केवल सभी रिक्त स्थान को निकालने में कामयाब रहा। TIO मैं एक अलग उत्तर के रूप में पोस्ट किए गए काम करने वाले बाहरी दृष्टिकोण को देखना पसंद करूंगा। अभी भी इस पर काम कर रहे हैं, लेकिन यह उतना सुरुचिपूर्ण नहीं हो सकता है।
JayCe

3

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

f=lambda a:[*a.strip()]and[a]+f(a.replace(min(a.replace(*" ~"))," ",1))

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

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


*bool({*a}-{" "})if{*a}-{" "}else[a]
RootTwo

@RootTwo में यह परिणाम नहीं होगा RecursionError?
अंडाशय

@RootTwo if/elseशॉर्टकट्स, लेकिन *boolहां नहीं, तो रिकर्सियोन्सर जैसे ओव्स ने कहा
HyperNeutrino

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

3

पायथन 2 , 70 69 66 64 बाइट्स

def f(s):print s;S=set(s)-{' '};S and f(s.replace(min(S),' ',1))

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

के बजाय का उपयोग कर के माध्यम से ovs से 2 बाइट्स के लिए ThxS and f()if S:f()


आप भूल रहे हैं ...If there is a tie, replace the leftmost character...नियम, आपको लगता है कि ठीक कर सकते हैं के साथreplace(min(...),' ',1)
रॉड

@Rod: आह! मिल गया ...
चास ब्राउन

3

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

ẋ"ỤỤ$z⁶Q

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

विचार

मूल विचार स्ट्रिंग को हेरफेर करने और सभी मध्यवर्ती परिणामों को वापस करने के बजाय, सीधे आउटपुट के वांछित स्तंभों का निर्माण करना है।

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

tee ay oh
845139276

अब, हम इस गणना में इसके सूचकांक द्वारा प्रत्येक वर्ण को दोहराते हुए स्तंभों का निर्माण करते हैं।

tee ay oh
tee ay oh
tee ay oh
tee  y oh
t e  y oh
t    y oh
t    y o 
t    y   
     y   

रिक्त स्थान को हटाने के लिए डुप्लिकेट को हटाने के लिए सभी को छोड़ दिया जाता है।

कोड

ẋ"ỤỤ$z⁶Q  Main link. Argument: s (string)

    $     Combine the two links to the left into a chain.
  Ụ       Grade up; sort the indices of s by their corresponding values.
          Let's call the result J.
          Grade up again, sorting the indices of J by the corr. values in J.
          This enumerates the positions of s as described before.
ẋ"        Repeat each character of s that many times.
     z⁶   Zip the resulting 2D array, filling missing characters with spaces.
       Q  Unique; deduplicate the array of rows.

3

पर्ल 5 -n , 37 34 बाइट्स

@TonHharma की मदद से तीन बाइट गिराए

say&&s/\Q$a/ / while($a)=sort/\S/g

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


आह, बहुत अच्छा, बहुत अच्छा दृष्टिकोण! मुझे लगता है कि आपको \Qअंतिम परीक्षण के मामले की आवश्यकता है .... मुझे याद है कि पहली बार भी!
डोम हेस्टिंग्स

आप सही हे। इसे जोड़ा।
Xcali

छोटा: say&&s/\Q$a/ / while($a)=sort/\S/g। इसके अलावा ठीक से संभालती है0
टोन हास्पेल

3

जावास्क्रिप्ट, 67 66 65 बाइट्स

क्योंकि मैंने थोड़ी देर में नशे में गोल्फ नहीं खेला है!

s=>[...t=s].sort().map(x=>x>` `?t+=`
${s=s.replace(x,` `)}`:0)&&t

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

डेनियलइंडी के लिए धन्यवाद 4 निरर्थक बाइट्स जिसमें बीयर शामिल है, इंगित करने के लिए!


आप मानचित्र में y क्यों निर्दिष्ट करते हैं? : P इसे 67 बनाया जा सकता है
डैनियलइंडी

@ डैनियलइंडी, क्योंकि बीयर! : D इसे इंगित करने के लिए धन्यवाद।
झबरा

हाँ, मुझे लगा कि ऐसा ही होगा: पी
डैनियलइंडी

3

के (ngn / k) , २६ २४ बाइट्स

{?(,x),x{x[y]:" ";x}\<x}

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


सुंदर! मेरा K प्रयास 41 में आया: `{। [X; (- 1 + # x) & x; _ci & / _ ic x _dv" ";:;"; "]} 'मैं बाइट्स को बर्बाद कर रहा है और पीछे और पीछे बाइट्स को बर्बाद कर रहा हूं; यकीन है कि यह सीमा से बाहर नहीं जाता है।
--रुगा

@ सूर्यदेव धन्यवाद अगर मैंने अनुमानों को ठीक से लागू किया होता, {@[x;y;:;" "]}तो हो सकता था @[;;:;" "]। आप किस संस्करण का उपयोग करते हैं? मैं इन से परिचित नहीं हूँ: _ci _ic _dv
ngn

मुझे लगता है कि यह 2.8-ish है? मैं उपयोग कर रहा हूँ Kona दुभाषिया, जो ऑपरेटरों को बिलिंस प्रदान करता है: char-of-int, int-of-char, delete-value।
--रुगा

2

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

var s=ReadLine();while(s.Any(c=>c!=32)){WriteLine(s);var i=s.IndexOf(s.Min(c=>c==32?(char)999:c));s=s.Remove(i,1).Insert(i," ");}

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


c!=32हो सकता है c>32; c==32हो सकता है c<33; और (char)999हो सकता है '¡'(या प्रिंट योग्य ASCII यूनिकोड रेंज से ऊपर किसी अन्य चरित्र)।
केविन क्रूज़सेन

ओह, और आप दो और बदलते बाइट्स बचा सकते हैं whileकरने के लिए forऔर रखने var s=ReadLine()और s=s.Remove(i,1).Insert(i," ")(दो अर्द्ध कोलन अब जरूरत तो) इसके अंदर।
केविन क्रूज़सेन

2

-nlF/\s|/39 बाइट्स के साथ पर्ल 5

@F=sort@F;say,s~\Q$F[$F++]~ ~ while/\S/

यह पर्ल के झंडे की सीमाओं को धकेलना हो सकता है, यदि ऐसा नहीं है, तो मैं पिछले उत्तर पर वापस आ जाऊंगा।

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


इसे केवल एक -nझंडे के साथ 35 बाइट्स तक ले जाएं
Xcali

2

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

12 बाइट्स ने लायकोनी को धन्यवाद दिया

f s|(a,_:b)<-span(/=minimum(id=<<words s))s=putStrLn s>>f(a++' ':b)

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

यह एक त्रुटि में समाप्त होता है

हास्केल , 83 79 बाइट्स

g(a,_:b)=a++' ':b
mapM_ putStrLn.(iterate$g.(span=<<(/=).minimum.concat.words))

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

यह एक त्रुटि में समाप्त होता है

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

u=concat.words
g(a,_:b)=a++' ':b
(take.length.u)<*>(iterate$g.(span=<<(/=).minimum.u))

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

हास्केल , 100 91 88 बाइट्स

u=concat.words
f x|(a,_:b)<-span(/=minimum(u x))x=a++' ':b
(take.length.u)<*>(iterate f)

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


67 बाइट्स: f s|(a,_:b)<-span(/=minimum(id=<<words s))s=putStrLn s>>f(a++' ':b) इसे ऑनलाइन आज़माएं!
लकोनी

@ लायकोनी धन्यवाद! मैं तो जैसे कुछ करने की कगार पर था और मैं सो गया। हालांकि मुझे नहीं लगता कि मैं आने के लिए होता है के साथ id=<<यह बहुत चालाक है
गेहूं जादूगर


2

K4 , 28 20 18 बाइट्स

उपाय:

?x{x[y]:" ";x}\<x:

उदाहरण:

q)k)?x{x[y]:" ";x}\<x:"PPCG is da BEST"
"PPCG is da BEST"
"PPCG is da  EST"
"PP G is da  EST"
"PP G is da   ST"
"PP   is da   ST"
" P   is da   ST"
"     is da   ST"
"     is da    T"
"     is da     "
"     is d      "
"     is        "
"      s        "
"               "

स्पष्टीकरण:

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

?x{x[y]:" ";x}\<x: / the solution
                x: / save input as x
               <   / return indices that would result in ascending sort
 x{        ; }\    / two-line lambda with scan
        " "        / whitespace
       :           / assignment
   x[y]            / x at index y
            x      / return x
?                  / distinct

2

gcc 32-बिट, 66 65 बाइट्स

char*p,i;f(a){for(i=32;i++;)for(p=a;*p;)*p==i?puts(a),*p=32:++p;}
main(){char s[]="3.1415926";f(s);}

-1 बाइट के लिए जोनाथन फ्रेच को धन्यवाद


*p==i?...:0;शायद हो सकता है *p-i?0:...;
जोनाथन फ्रीच

@JonathanFrech नहीं, यह 1 बाइट लंबी है (हालांकि *p-1||(...)एक ही लंबाई है)
l4m2

क्षमा करें, अल्पविराम अभिव्यक्ति को एक साथ रखने के महत्व को नहीं पहचाना। हालाँकि, यह 65 बाइट्स हो सकता है । मुझे यह भी पता नहीं है कि कैसे f(a)संकलित किया जाता है, जैसा aकि प्रकार का होना चाहिए char*, लेकिन मुझे लगता है कि आपके 32-बिट जीसीसी उपयोग के साथ कुछ करना है।
जोनाथन फ्रीच

@JonathanFrech मुझे लगता है कि char*p,i;f(long long a){for(i=31;++i;)for(p=a;*p;)*p==i?puts(a),*p=32:++p;}tio (64 बिट) के बारे में बता सकते हैं कि कैसे f(a)काम करता है
l4m2

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

2

MATLAB, 74 बाइट्स

यह सबसे छोटे चरित्र और इसके सूचकांक को पुनः प्राप्त करने के लिए अधिकतम () फ़ंक्शन के 2-आउटपुट फॉर्म का उपयोग करता है, जिससे स्ट्रिंग को शून्य मानों में बदल दिया गया है और मुद्रण योग्य वर्णों के लिए 256-वर्ण मान।

s=input('s');x=1;while(x);disp(s);[x,y]=max((256-s).*(s~=' '));s(y)=' ';end

1
PPCG में आपका स्वागत है! अच्छा काम!
AJFaraday

2

आम लिस्प , 240 228 224 बाइट्स

(setf s(read))(defun f(x)(setf y(char-code(elt s x)))(if(= y 32)1e9 y))(loop for _ across s do(print s)do(setf s(replace s" ":start1(position(code-char(reduce #'min (loop for i from 0 below(length s)collect i):key #'f))s))))

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

यह मेरी पहली पोस्टिंग है।
मैं लिस्प सीखने की प्रक्रिया में हूं इसलिए मुझे यकीन है कि कोई इससे कम समय के बारे में सोच सकता है।


1
साइट पर आपका स्वागत है! कुछ आम लिस्प देखने के लिए अच्छा है!
गेहूं जादूगर

1

एपीएल (Dyalog यूनिकोड) , 39 बाइट्स SBCS

{⎕←⍵⋄×≢⍵∩g' '~⍨⎕UCS256:∇' '@(⊃g⍋⍵)⊢⍵}

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

DFN।

कैसे?

{⎕←⍵⋄×≢⍵∩g' '~⍨⎕UCS256:∇' '@(⊃g⍋⍵)⊢⍵}  Main function, argument 
 ⎕←⍵⋄                                     Print 
         g' '~⍨⎕UCS256                  Assign to g every Unicode character except space
     ×≢⍵∩                :                If ⍵∩g is not empty
                                         Recursively call the function with argument:
                           ' '@          Space at
                               (⊃g⍋⍵)     The first (⊃) element in  graded up (⍋) with g
                                          The dyadic grade up function will index  according
                                          to its left argument, in this case g.


1

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

param($a)2..$a.length|%{($x=$a);[regex]$p=""+([char[]]$a-ne' '|sort)[0];$a=($p.replace($x," ", 1))}

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

इनपुट को एक स्ट्रिंग के रूप में लेता है $a। हम तो से पाश 2के लिए $a.length(यानी, आवश्यक ऊर्ध्वाधर बार की उपयुक्त संख्या सभी लेकिन एक चरित्र हटाने के लिए)। प्रत्येक पुनरावृत्ति, हम वर्तमान स्ट्रिंग को आउटपुट करते हैं और $xउसी समय आसानी से सहेजे जाते हैं । फिर हम एक नई [regex]वस्तु का निर्माण करते हैं , $pजिसमें बचे हुए पात्रों से मिलकर एटर्न अंतरिक्ष, एड, फिर ओटी के लिए अर्हता प्राप्त $aकरते हैं-nesort0 वें एक तत्संबंधी।

फिर हम $aस्ट्रिंग में .Replaceबदलने के लिए विधि के साथ रेगेक्स ऑब्जेक्ट के एक नए स्ट्रिंग के बराबर सेट करते हैं $x, $pएटर्न, एक स्थान के साथ " ", लेकिन केवल1 सेंट मैच। हाँ, यह वाक्यविन्यास अजीब है।

तारों को पाइप लाइन पर छोड़ दिया जाता है और निहित Write-Outputहमें मुफ्त में उनके बीच एक नई रेखा प्रदान करता है, साथ ही एक अनुगामी नई रेखा ।




1

MATL , 17 16 बाइट्स

tSXz"tOy@=f1)(]x

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

व्याख्या

t       % Implicit input. Duplicate
S       % Sort
Xz      % Remove spaces
"       % For each char in that string
  t     %   Duplicate last result. This is the most recent string obtained
        %   from replacing chars by spaces in the input
  O     %   Push 0
  y     %   Duplicate from below
  @     %   Push current char
  =     %   Equals? (element-wise) Gives 1 for occurrences of current char
        %   in the most recent string, 0 otherwise
  f     %   Indices of nonzeros
  1)    %   Get the first entry
  (     %   Write 0 at that position. Char 0 will be displayed as space
]       % End
x       % Delete last result, which consists only of space / char zero

1

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

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

s="Code(Mid(A$1,Row(),1))":[B1].Resize([Len(A1)])="=If("&s &"=32,1E3,"&s &")":For i=1To[Len(A1)-CountIf(B:B,1E3)]:?[A1]:[A1]=[Substitute(A1,Char(Min(B:B))," ",1)]:Next

Ungolfed और टिप्पणी की

''  run as `call icicle("Test")` or `icicle"I am the WALRUS`
Sub icicle(Optional str As String)
    If Not IsMissing(str) Then [A1] = str   ''  pipe input
    [B:B].Clear                             ''  reset between runs
    [B1].Resize([Len(A1)]) = "=If(Code(Mid(A$1,Row(),1))=32,1E3,Code(Mid(A$1,Row(),1)))"  ''  get char number for every char in input
    For i = 1 To [Len(A1)-CountIf(B:B,1E3)] ''  iterate across from 1 to length of input - number of spaces
        Debug.Print [A1]                    ''  output a single line
        [A1]=[Substitute(A1,Char(Min(B:B))," ",1)]  ''  replace minimum char with space
    Next
End Sub

1

जाप , 32 18 बाइट्स

झबरा के लिए धन्यवाद 14 बाइट्स बचा लिया!

rS ¬£=hSUbZn gYÃiN

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


लाइनों की एक सरणी वापस करके एक बाइट सहेजें: ethproductions.github.io/japt/…
झबरा

22 बाइट्स । जल्द ही मेरे जेएस समाधान के एक बंदरगाह की कोशिश करेंगे, देखें कि यह कैसे काम करता है।
झबरा

1
यह 18 बाइट्स के लिए नीचे मिला है ।
झबरा
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.