क्या आपको उन विस्फोट-दृश्य आरेखों से प्यार नहीं है जिनमें एक मशीन या वस्तु को उसके सबसे छोटे टुकड़ों में ले जाया जाता है?

चलो एक स्ट्रिंग करने के लिए!

चुनौती

एक कार्यक्रम या फ़ंक्शन लिखें

इनपुट केवल स्ट्रिंग करने योग्य ASCII वर्ण युक्त एक इनपुट ;
गैर-अंतरिक्ष समान वर्णों के समूहों में स्ट्रिंग को विच्छेदित करता है (स्ट्रिंग के "टुकड़े");
समूहों के बीच कुछ विभाजक के साथ उन समूहों को किसी भी सुविधाजनक प्रारूप में आउटपुट करता है ।

उदाहरण के लिए, स्ट्रिंग दी गई है

Ah, abracadabra!

आउटपुट निम्न समूह होंगे:

!
,
ए
aaaaa
bb
सी
घ
ज
rr

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

नियम

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

आप मान सकते हैं कि इनपुट में कम से कम एक गैर-स्थान वर्ण है ।

उत्पादन होने चाहिए वर्ण (इनपुट ASCII कोड के माध्यम से है, भले ही)। समूहों के बीच एक स्पष्ट विभाजक होना चाहिए , जो कि इनपुट में दिखाई देने वाले किसी भी गैर-अंतरिक्ष चरित्र से अलग हो सकता है।

यदि आउटपुट फ़ंक्शन रिटर्न के माध्यम से होता है, तो यह एक सरणी या स्ट्रिंग्स भी हो सकता है, या चार्ट की सरणियों का एक सरणी, या इसी तरह की संरचना हो सकती है। उस मामले में संरचना आवश्यक अलगाव प्रदान करती है।

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

इसके अलावा, प्रारूप लचीला है। यहाँ कुछ उदाहरण हैं:

समूहों को नई कहानियों द्वारा अलग किए गए तार हो सकते हैं, जैसा कि ऊपर दिखाया गया है।
समूहों को किसी भी गैर-एएससीआईआई चरित्र द्वारा अलग किया जा सकता है, जैसे कि ¬। उपरोक्त इनपुट के लिए आउटपुट स्ट्रिंग होगा:
```
!¬,¬A¬aaaaa¬bb¬c¬d¬h¬rr
```
समूहों को n > 1 स्थान से अलग किया जा सकता है (भले ही n परिवर्तनशील हो), प्रत्येक समूह के बीच एक एकल स्थान द्वारा अलग किए गए वर्णों के साथ:
```
!  ,    A   a a a a a    b b  c       d   h  r r
```
आउटपुट एक सरणी या किसी फ़ंक्शन द्वारा लौटाए गए तारों की सूची भी हो सकती है:
```
['!', 'A', 'aaaaa', 'bb', 'c', 'd', 'h', 'rr']
```

या चार सरणियों की एक सरणी:

[['!'], ['A'], ['a', 'a', 'a', 'a', 'a'], ['b', 'b'], ['c'], ['d'], ['h'], ['r', 'r']]

नियमों के अनुसार, जिन स्वरूपों की अनुमति नहीं है, उनके उदाहरण:

अल्पविराम का उपयोग विभाजक ( !,,,A,a,a,a,a,a,b,b,c,d,h,r,r) के रूप में नहीं किया जा सकता है , क्योंकि इनपुट में अल्पविराम हो सकते हैं।
इसे समूहों के बीच विभाजक को छोड़ना स्वीकार नहीं है ( !,Aaaaaabbcdhrrया समूहों के भीतर और समूहों के बीच एक ही विभाजक का उपयोग करना ! , A a a a a a b b c d h r r)।

समूह आउटपुट में किसी भी क्रम में दिखाई दे सकते हैं । उदाहरण के लिए: वर्णमाला क्रम (ऊपर दिए गए उदाहरणों में), स्ट्रिंग में पहली उपस्थिति का क्रम, ... आदेश को सुसंगत या नियतात्मक नहीं होना चाहिए।

ध्यान दें कि इनपुट न्यू लाइन वर्ण नहीं हो सकते हैं, और Aऔर aविभिन्न चरित्र (समूह है मामला-sentitive )।

बाइट्स में सबसे छोटा कोड जीतता है।

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

प्रत्येक परीक्षण के मामले में, पहली पंक्ति इनपुट है, और शेष लाइनें आउटपुट हैं, जिसमें प्रत्येक समूह एक अलग लाइन में है।

टेस्ट केस 1:

आह, अब्रकदबरा!
!
,
ए
aaaaa
bb
सी
घ
ज
rr

टेस्ट केस 2:
```
\ O / \ o / \ o /
///
\\\
OOO
```

टेस्ट केस 3:

एक आदमी, एक योजना, एक नहर: पनामा!
!
,,
:
ए
पी
aaaaaaaaa
सी
डालूँगा
मिमी
NNNN
पी

टेस्ट केस 4:

"मुझे दिखाओ कि तुम उस चाल को कैसे करते हो, जो मुझे चिल्लाती है" उसने कहा
""
,
एस
aaaaa
सीसी
dd
eeeeeee
hhhhhh
ii
के.के.
mmmm
n
ooooo
rr
ssss
tttttt
यू
ww
y

code-golf string

— लुइस मेंडो
स्रोत

1

यदि हम "AS" जैसे गैर-ASCII प्रतीकों को विभाजक के रूप में उपयोग करते हैं, तो क्या इसे 1 बाइट के रूप में गिना जा सकता है?

— लीकी नून

5

@LeakyNun नहीं, इसे तब तक गिना जाएगा जब यह स्रोत कोड के लिए उपयोग किए जाने वाले एन्कोडिंग पर निर्भर करता है, हमेशा की तरह

— लुइस मेंडू

क्या अंतिम समूह के बाद एक अनुगामी न्यूलाइन स्वीकार्य है?

— जस्टिनएम -

क्या आउटपुट की एक अग्रणी नईलाइन स्वीकार्य है?

— DJMcMayhem

1

@ रोहन झुनझुनवाला अच्छा किया! :-) हाँ, विभाजकों के रूप में कई नई

— लुइस मेंडो

11

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

ḟ⁶ṢŒg

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

यह एक सरणी लौटाता है, बस जब इसे STDOUT में मुद्रित किया जाता है, तो विभाजक चला जाता है।

यह वास्तव में एक फ़ंक्शन है जिसे इस तरह से कहा जा सकता है (जेली में, प्रत्येक पंक्ति एक फ़ंक्शन है)।

ḟ⁶ṢŒg
ḟ⁶      filter out spaces
  Ṣ     sort
   Œg   group

— लीक नन
स्रोत

23

पायथन 3.5+, 77 46 44 41 बाइट्स

lambda s:[a*s.count(a)for a in{*s}-{' '}]

बहुत साधारण। स्ट्रिंग में अद्वितीय वर्णों के माध्यम से इसे एक सेट में परिवर्तित करके चला जाता है (पायथन 3.5 के विस्तारित पुनरावृत्ति unpacking का उपयोग करके), फिर प्रत्येक वर्ण स्ट्रिंग में होने वाली संख्या की गणना करके विस्फोटित आरेखों के निर्माण के लिए एक सूची समझ का उपयोग करता है str.count। हम उन्हें सेट से हटाकर रिक्त स्थान फ़िल्टर करते हैं।

आउटपुट का क्रम रन से अलग-अलग हो सकता है; सेट अनियंत्रित होते हैं, इसलिए उनके आइटम संसाधित किए जाने वाले आदेश और इस प्रकार यह उत्तर आउटपुट की गारंटी नहीं दी जा सकती है।

यह एक लंबोदर अभिव्यक्ति है; इसका उपयोग करने के लिए, उपसर्ग के lambdaसाथ f=।

~~Ideone पर यह कोशिश करो!~~ आइडॉन पायथन 3.4 का उपयोग करता है, जो पर्याप्त नहीं है।

उपयोग उदाहरण:

>>> f=lambda s:[a*s.count(a)for a in{*s}-{' '}]
>>> f('Ah, abracadabra!')
[',', 'A', 'aaaaa', 'd', '!', 'bb', 'h', 'c', 'rr']

3 बाइट्स @shooqie की बदौलत सहेजे गए!

— तांबा
स्रोत

3

1k पर बधाई!

— लुइस मेंडो

2

अजगर में> 3.5 आप कर सकते हैं {*s}के लिए set(s)।

— शौकी

11

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

O`.
!`(\S)\1*

छंटाई बहुत आसान है (यह एक बिलिन है), यह 9 बाइट्स वाले अक्षरों को अलग कर रहा है। इसे ऑनलाइन आज़माएं!

पहली पंक्ति एस Oने रेगेक्स .(जो हर चरित्र है) के सभी मैचों को आरटीएस दिया, जो हमें दे रहा है !,Aaaaaabbcdhrr।

मैच एक कार्यक्रम की अंतिम पंक्ति के लिए डिफ़ॉल्ट चरण है, और !यह रेगेक्स के मैचों की लाइनफीड-सेपरेटेड सूची को प्रिंट करता है। रेगेक्स एक पंक्ति में एक गैर-अंतरिक्ष चरित्र के एक या अधिक उदाहरणों की तलाश करता है।

— NinjaBearMonkey
स्रोत

इससे क्या होता है ! करना?

— डाउनगेट

@Downgoat यह डिफ़ॉल्ट गणना के बजाय, रेगेक्स के सभी मैचों की एक पंक्ति-अलग-अलग सूची प्रिंट करता है।

— निन्जाबिएरमेन्की

8

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

*.comb(/\S/).Bag.kv.map(*x*)

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

स्पष्टीकरण:

# Whatever lambda ｢*｣


# grab the characters
*.comb(
  # that aren't white-space characters
  /\S/
)
# ("A","h",",","a","b","r","a","c","a","d","a","b","r","a","!")


# Turn into a Bag ( weighted Set )
.Bag
# {"!"=>1,","=>1,"A"=>1,"a"=>5,"b"=>2,"c"=>1,"d"=>1,"h"=>1,"r"=>2}


# turn into a list of characters and counts
.kv
# ("!",1,",",1,"A",1,"a",5,"b",2,"c",1,"d",1,"h",1,"r",2)


# map over them 2 at a time
.map(
  # string repeat the character by the count
  * x *
)
# ("!",",","A","aaaaa","bb","c","d","h","rr")

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

7

विम, 50 , 46 बाइट्स

i <esc>:s/./&\r/g
:sor
qq:%s/\v(.)\n\1/\1\1
@qq@qD

स्पष्टीकरण / जिफ बाद में आएगा।

— DJMcMayhem
स्रोत

1

एक बार के लिए, Emacs और विम समाधान एक जैसे दिखते हैं।

— YSC

7

अजगर, ६

.gk-zd

इसे यहां आज़माएं या टेस्ट सूट चलाएं ।

बहुत सरल, -zdइनपुट से रिक्त स्थान को निकालता है, और .gkप्रत्येक शेष तत्व को उसके मूल्य से समूहित करता है। दुर्भाग्य से, मुझे स्वत: भरण चर का उपयोग करने का कोई तरीका नहीं मिला है। ध्यान दें कि आउटपुट को पायथन स्ट्रिंग्स के रूप में दिखाया गया है, इसलिए कुछ निश्चित अक्षर (पढ़ें: बैकस्लैश) बच जाते हैं। यदि आप चाहते हैं कि यह अधिक पठनीय हो, jतो कोड की शुरुआत में जोड़ें ।

— FryAmTheEggman
स्रोत

7

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

f s=[filter(==c)s|c<-['!'..],elem c s]

मूल रूप से निम्मी का समाधान , लेकिन स्पष्ट रूप से स्ट्रिंग में दिखाई देने वाले अक्षरों की जांच करना।

— XNOR
स्रोत

6

2sable , 7 बाइट्स

कोड:

Úð-vyÃ,

स्पष्टीकरण:

Ú       # Uniquify the string, aabbcc would result into abc
 ð-     # Remove spaces
   vy   # For each character...
     Ã  #   Keep those in the string, e.g. 'aabbcc', 'a' would result into 'aa'
      , #   Pop and print with a newline

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

3

यह बिल्कुल डेनिस की तरह नहीं लगता है :-P

— लुइस मेंडो

6

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

s=>[...s].sort().join``.match(/(\S)\1*/g)

— नील
स्रोत

क्या यह भी " "लौटे हुए सरणी में मौजूद नहीं है, साथ ही साथ एक प्रविष्टि भी होगी? निश्चित नहीं है कि अगर इसकी अनुमति है

— मान स्याही

@ValueInk बाह, मैंने इस बारे में सोचा कि जब मैंने शुरुआत की थी, लेकिन तुरंत भूल गया। अब तय हो गया।

— नील

उम्म, join()उन डबल बैकटिक्स के साथ कैसे बुलाया जा रहा है?

— तेजस काले

1

@TejasKale यह एक ES6 टेम्पलेट स्ट्रिंग है। जब आप टेम्पलेट स्ट्रिंग के लिए एक विधि को उपसर्ग करते हैं, तो यह टेम्पलेट को विधि के लिए एक सरणी के रूप में पारित करता है, इसलिए इस मामले में, यह कॉलिंग समाप्त करता है .join([''])। joinफिर उस (खाली) स्ट्रिंग में कनवर्ट करता है और सरणी तत्वों में शामिल होने के लिए इसका उपयोग करता है। सभी विधियाँ अपने पैरामीटर को स्ट्रिंग में परिवर्तित नहीं करती हैं, लेकिन यह तकनीक उन लोगों पर काम करती है जो करते हैं।

— नील

6

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

7 बाइट्स Fatalize के लिए धन्यवाद।

:@Sxo@b

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

:@Sxo@b
:@Sx     remove spaces
    o    sort
     @b  group

— लीक नन
स्रोत

1

xहटाने @S(स्थान) का उपयोग करके 7 बाइट्स । मेरा मानना है कि यह आउटपुट फॉर्मेट (स्ट्रिंग्स की सूची) वैध है

— Fatalize

5

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

f x=[v:w|d<-['!'..],v:w<-[filter(==d)x]]

प्रयोग उदाहरण: f "Ah, abracadabra!"-> ["!",",","A","aaaaa","bb","c","d","h","rr"]।

पैटर्न v:wकेवल कम से कम एक तत्व के साथ सूची से मेल खाता है, इसलिए इनपुट में सभी वर्णों को अनदेखा नहीं किया जाता है।

इसके अलावा 40 बाइट्स:

import Data.List
group.sort.filter(>' ')

— nimi
स्रोत

@ThreeFx: लेकिन groupसे Data.Listभी है। वैसे भी, मुझे लगता है कि यह वाक्य रचना ghciकेवल है और इसे REPL की आवश्यकता है, इसलिए यह इसकी अपनी एक भाषा है । मैं मानक हास्केल के साथ रहना चाहता हूं।

— nimi

4

रूबी, 41 + 1 = 42 बाइट्स

-nझंडे के लिए +1 बाइट ।

gsub(/(\S)(?!.*\1)/){puts$1*$_.count($1)}

स्टड पर इनपुट लेता है, जैसे:

$ echo 'Ah, abracadabra!' | ruby -ne 'gsub(/(\S)(?!.*\1)/){puts$1*$_.count($1)}'
A
h
,
c
d
bb
rr
aaaaa
!

— जॉर्डन
स्रोत

4

सी # 125 98 बाइट्स

using System.Linq;s=>s.GroupBy(c=>c).Where(g=>g.Key!=' ').Select(g=>new string(g.Key,g.Count())));

व्याख्या

//Using anonymous function to remove the need for a full signature 
//And also allow the implicit return of an IEnumerable
s =>

    //Create the groupings
    s.GroupBy(c => c)

    //Remove spaces
    .Where(g=> g.Key!=' ')

    //Generate a new string using the grouping key (the character) and repeating it the correct number of times
    .Select(g => new string(g.Key, g.Count()));

@TheLethalCoder का धन्यवाद जिसने एक अनाम फ़ंक्शन का उपयोग करने का सुझाव दिया, जिसने मुझे ToArrayकॉल हटाने की अनुमति दी और केवल एक IEnumerable वापस लौटाया जो सामूहिक रूप से 27 बाइट्स बचाता है

— जस्टिनएम - मोनिका को बहाल करें
स्रोत

आप एक के लिए यह संकलन के द्वारा 18 बाइट्स बचा सकता है (अगर मैं सही ढंग से गिना) Func<string, string[]>यानीs=>s.GroupBy....

— TheLethalCoder

@LethalCoder आपको यकीन है कि एक फ़ंक्शन के स्थान पर स्वीकार्य है, मैं हमेशा इस बात से सावधान रहा हूं क्योंकि यह इसे निष्पादित करने में सक्षम होने के लिए अतिरिक्त बायलरप्लेट का थोड़ा सा जोड़ता है, और लिनक का उपयोग करने की आवश्यकता के लिए तर्क के साथ बस लगता है ... अच्छा गलत है।

— जस्टिनएम -

एक हालिया उदाहरण जहां मैं यह कर रहा हूं ... codegolf.stackexchange.com/a/91075/38550 यह आपके सभी बॉयलरप्लेट को हटा देगा, जब तक कि फ़ंक्शन की अनुमति है

— TheLethalCoder 25'16

मेरे लिए @LethalCoder ठीक है काफी अच्छा है। :) इसने मुझे ToArray कॉल हटाने की भी अनुमति दी

— जस्टिनएम -

4

आर, 198 189 96 95 बाइट्स

for(i in unique(a<-strsplit(gsub(" ","",readline()),"")[[1]]))cat(rep(i,sum(a==i)),"\n",sep="")

अघोषित:

a<-strsplit(gsub(" ","",readline()),"")[[1]] #Takes the input from the console

for(i in unique(a)) #loop over unique characters found in variable a

cat(rep(i,sum(a==i)),"\n",sep="") # print that character n times, where n was the number of times it appeared

~~यह समाधान वर्तमान में पूरी तरह से काम नहीं कर रहा है, जब \शामिल हैं।~~
अब यह है !

102 बाइट से बाहर निकलने के लिए @JDL को बहुत-बहुत धन्यवाद !

— फ़्रेडरिक
स्रोत

@JDL: कृपया टिप्पणियों में संपादन का सुझाव दें। आपके परिवर्तन वास्तव में दिलचस्प हैं, लेकिन यह किसी और के कोड को बदलने के लिए थोड़े असभ्य है।

— Frédéric

1

उस के लिए माफी, लेकिन मैं उस समय 50 प्रतिष्ठा नहीं था और टिप्पणी नहीं कर सका। हालांकि भविष्य में करेंगे!

— JDL

@JDL: काफी साफ!

— Frédéric

एक फंक्शन के अंदर वेरिएबल को असाइन करने की कोशिश करें: for(i in unique(a=strsplit(gsub(" ","",readline()),"")[[1]]))cat(rep(i,sum(a==i)),"\n",sep="")- 2 बाइट्स बचाता है।

— आंद्रे

@ Andre @Kostyrka: यह बाइट्स को इस रूप में नहीं बचाता है क्योंकि आपको कोष्ठक के बीच पूरे a = strsplit (...) भाग को रखना है: मूल रूप से -2 + 2 अंतर है। हालाँकि, उपयोग करने <-से 1 बाइट बच जाएगी!

— Frédéric

4

स्विफ्ट, 105 91 बाइट्स

14 बाइट्स के लिए @NNNNAD को धन्यवाद :)

हाँ, मैं बहुत नई हूँ स्विफ्ट ...

func f(a:[Character]){for c in Set(a){for d in a{if c==d && c != " "{print(c)}}
print("")}}

एक समूह के भीतर वर्णों को एक नई पंक्ति द्वारा अलग किया जाता है। समूहों को दो नई सूचियों द्वारा अलग किया जाता है।

— jrich
स्रोत

आप [Character]इसके बजाय इनपुट लेने से 13 बाइट्स बचा सकते हैं String, क्योंकि नियम कहते हैं कि "इनपुट एक स्ट्रिंग या वर्णों का होना चाहिए।" इसके अलावा, print("")बस के साथ बदला जा सकता है print()।

— नोनाडा -

@ printबिना किसी तर्क के किसी कारण से काम नहीं किया लेकिन [Character]सुझाव ठोस था। धन्यवाद!

— २१

3

ऑक्टेव , 61 बाइट्स

@(x)mat2cell(y=strtrim(sort(x)),1,diff(find([1 diff(+y) 1])))

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

Ideone पर प्रयास करें ।

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

sortइनपुट स्ट्रिंग को सॉर्ट करें। विशेष रूप से, शुरुआत में रिक्त स्थान होंगे।
strtrim अग्रणी रिक्त स्थान को निकालता है।
diff(+y) वर्णों के बीच निरंतर अंतर की गणना करता है (समूह सीमाओं का पता लगाने के लिए) ...
... तो diff(find([1 diff(+y) 1])समूह आकार का एक वेक्टर देता है।
mat2cell फिर उन आकारों के साथ विखंडित स्ट्रिंग को विखंडू में विभाजित करता है।

— लुइस मेंडो
स्रोत

3

गणितज्ञ, 36 बाइट्स

बिल्ट-इन फ़ंक्शंस Gatherऔर Charactersअधिकांश काम यहाँ करें।

Gather@Select[Characters@#,#!=" "&]&

— ग्रेग मार्टिन
स्रोत

3

> <> , 49 बाइट्स

i:0(?v
84}0~/&{!*
v!?: <}/?=&:&:<
>&1+&}aol1-?!;^

उत्पादन में बहुत ही व्यर्थ है, लेकिन मुझे अभी भी नियमों के पालन की अनुमति दी गई है

स्पष्टीकरण:

i:0(?v           Collects text from input
84}0~/&{!*       adds 32 (first ascii starting at space) to register and 0 to stack
v!?: <}/?=&:&:<  checks all characters to the current register, if equal:
       o         prints the character and continues looping
>&1+&}aol1-?!;^  when all characters are checked, adds 1 to register, prints a newline,
                 checks the stack length to halt the program if 0, and starts looping again

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

मूल रूप से यह प्रत्येक ASCII चरित्र को अपनी नई रेखा पर रखता है, और यदि उस चरित्र में से कोई भी मौजूद नहीं है, तो रेखा रिक्त होगी

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

संपादित करें: मैं गलत था कि कोड में एक त्रुटि थी जो इनपुट में एक स्थान होने पर इसे कभी भी पूरा न करने का कारण होगा

— torcado
स्रोत

3

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

.gksc

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

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

स्पष्टीकरण:

    c    Split (implied) input on whitespace
   s     Sum together
.gk      Group by value

यदि आप इनपुट में कम से कम एक स्थान की गारंटी देते हैं, तो 4-बाइट समाधान है:

t.gk

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

स्पष्टीकरण:

 .gk (Q)  groups the characters in the string by their value
           this sorts them by their value, which guarantees that spaces are first
t         Remove the first element (the spaces)

— स्टीवन एच।
स्रोत

3

PowerShell v2 +, 44 बाइट्स

[char[]]$args[0]-ne32|group|%{-join$_.Group}

$args[0]कमांड-लाइन तर्क शाब्दिक स्ट्रिंग के रूप में इनपुट लेता है । charकास्ट के रूप में कास्ट करता है, और रिक्त स्थान (ASCII ) को बाहर निकालने के लिए -nओटी योग्यताधारी eऑपरेटर का उपयोग करता है 32। यह काम करता है क्योंकि कास्टिंग में एक उच्च क्रम की मिसाल है, और जब एक सरणी को बाएं हाथ के ऑपरेटर के रूप में दाएं हाथ के रूप में स्केलर के साथ उपयोग किया जाता है, तो यह एक फिल्टर की तरह काम करता है।

हम वर्णों के उस सरणी को पास करते हैं Group-Object, जो वास्तव में ऐसा कहता है। ध्यान दें कि चूंकि हम वर्णों को पारित कर रहे हैं , तार नहीं, यह केस-संवेदनशीलता के साथ ठीक से समूहित करता है।

अब, हमें एक कस्टम ऑब्जेक्ट मिल गया है, जिसमें समूह के नाम, मायने आदि हैं, अगर हम सिर्फ यह प्रिंट करते हैं कि हमारे पास एक्सट्रॉनिक आउटपुट का होस्ट होगा। इसलिए, हमें उन सभी को एक पाश में |%{...}और प्रत्येक पुनरावृत्ति -joinको .Groupएक साथ एक स्ट्रिंग में पाइप करने की आवश्यकता है । उन परिणामी तारों को पाइपलाइन पर छोड़ दिया जाता है, और आउटपुट को कार्यक्रम पूरा होने पर निहित किया जाता है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\exploded-view-of-substrings.ps1 'Programming Puzzles and Code Golf'
PP
rr
ooo
gg
aa
mm
i
nn
u
zz
ll
ee
s
dd
C
G
f

— AdmBorkBork
स्रोत

3

दिल्लोग एपीएल , 11 बाइट्स

स्ट्रिंग की सूची लौटने का कार्य।

(⊂∩¨∪)~∘' '

(⊂∩¨∪) संपूर्णता और उसके अनूठे पात्रों के प्रतिच्छेदन

~∘' ' सिवाय रिक्त स्थान के

TryAPL ऑनलाइन!

— एडम
स्रोत

2

प्रसंस्करण, 109 बाइट्स

void s(char[] x){x=sort(x);char l=0;for(char c:x){if(c!=l)println();if(c!=' '&&c!='\n'&&c!='\t')print(c);l=c;}}

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

— कोड़ी
स्रोत

2

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करना - असंख्य) ( 78 67 बाइट्स)

 n=>_.From(n).Where(y=>y!=' ').GroupBy(x=>x).WriteLine(y=>y.Write())

लिंक ऑफ लिब: https://github.com/mvegh1/Enumerable

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

— applejacks01
स्रोत

2

MATL, 7 बाइट्स

Xz!t7XQ

MATL ऑनलाइन डेमो

— Suever
स्रोत

2

पर्ल 6, 48 47 45

slurp.comb.Bag.kv.map:{$^a.trim&&say $a x$^b}

सुधार के लिए मैनटवर्क का धन्यवाद।

— bb94
स्रोत

1

बड़ा सुधार नहीं है, लेकिन $a.trimहालत के लिए ऐसा लगता है।

— ०

लगता है कि तार्किक ऑपरेटरों को अभी भी उनके चारों ओर रिक्त स्थान की आवश्यकता नहीं है, इसलिए $^a.trim&&say $a x$^bकाम करता है। (बाइट्स द्वारा संकेत जोड़ने के लिए खेद है, लेकिन यह मेरी Perl6 पर पहली कोशिश है।)

— manatwork

लिटिल टाइपो, आपने गलती से उद्घाटन को हटा दिया {।

— मैनटवर्क

1

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

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

->s{(s.chars-[' ']).uniq.map{|c|c*s.count(c)}}

मेरा मूल पूर्ण कार्यक्रम संस्करण, nध्वज जोड़ने के बाद 48 बाइट्स :

p gsub(/\s/){}.chars.uniq.map{|c|c*$_.count(c)}

— मूल्य स्याही
स्रोत

आप के .count(c)साथ बदल सकते हैं .count c?

— साइओस

@ कैओस नं, क्योंकि *ऑपरेटर पास में मौजूद है इसलिए पार्सर शिकायत करेगा।

— वैल्यू इंक

s.chars- [''] | [] कोष्ठक के अंदर uniq से बचना होगा

— GB

@ जीबी यह होगा, लेकिन अगर हम इसे आगे बढ़ा रहे हैं mapतो इसके लिए अतिरिक्त पार्न की आवश्यकता होती है, और ((s.chars-[' '])|[]).mapइसमें उतने ही अक्षर होते हैं जितने कि होते हैं (s.chars-[' ']).uniq.map। और दूसरा, अद्वितीय वर्णों की जांच करने का छोटा तरीका (रेगेक्स के माध्यम से) पहले से ही एक और उत्तर में @ जोर्डन द्वारा कवर किया गया है

— वैल्यू इंक

यह कोष्ठक के अंदर काम करता है , आपको अतिरिक्त कोष्ठक की आवश्यकता नहीं है क्योंकि '-' की पूर्वता अधिक है।

— GB

1

अजगर, १०th

मेमने द्वारा छोटा किया जा सकता है, लेकिन बाद में

x=sorted(input())
i=0
while i<len(x):x[i:]=['  '*(x[i]!=x[i-1])]+x[i:];i-=~(x[i]!=x[i-1])
print("".join(x))

— विनाशकारी नींबू
स्रोत

1

सीजाम, 10 बाइट्स

{S-$e`::*}

एक अनाम ब्लॉक जो स्ट्रिंग के शीर्ष पर स्ट्रिंग की अपेक्षा करता है और इसे स्ट्रिंग की सूची के साथ बदल देता है।

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

व्याख्या

S-  Remove spaces.
$   Sort.
e`  Run-length encode, gives pairs [R C], where R is the run-length and
    C is the character.
::* Repeat the C in each pair R times.

— मार्टिन एंडर
स्रोत

1

आम लिस्प, 123

(lambda(s &aux(w(string-trim" "(sort s'char<))))(princ(elt w 0))(reduce(lambda(x y)(unless(char= x y)(terpri))(princ y))w))

Ungolfed:

(lambda (s &aux (w (string-trim " " (sort s 'char<))))
  (princ (elt w 0))
  (reduce
    (lambda (x y) 
      (unless (char= x y) (terpri))
      (princ y))
  w))

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

— MatthewRock
स्रोत

1

Emacs, 36 कीस्ट्रोक्स

C-SPACE C-EM-xsort-rTABRETURN.RETURN.RETURNC-AC-M-S-%$\(.$\2*\)RETURN\1C-QC-JRETURN!

नतीजा

A man, a plan, a canal: Panama! ->

!
,,
:
A
P
aaaaaaaaa
c
ll
mm
nnnn
p

व्याख्या

C-SPACE C-E
M-x sort-rTAB RETURN .RETURN .RETURN
C-A
C-M-S-% $\(.$\2*\)RETURN\1 C-Q C-JRETURN !

इनपुट लाइन का चयन करें;
कॉल sort-regexp-fieldsतर्क के साथ .और .;
- तर्क # 1: सॉर्ट करने के लिए Regexp रिकॉर्ड्स को छोटा करना
- तर्क # 2: रिकॉर्ड के भीतर regexp कुंजी की जाँच करना
लाइन स्टार्ट पर वापसी;
सभी मैचों पर regexp प्रतिस्थापन $\(.$\2*\)-> लागू करें \1\n।

— YSC
स्रोत

एक स्ट्रिंग का विस्फोटित दृश्य

चुनौती

नियम

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

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

पायथन 3.5+, 77 46 44 41 बाइट्स

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

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

स्पष्टीकरण:

विम, 50 , 46 बाइट्स

अजगर, ६

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

2sable , 7 बाइट्स

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

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

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

रूबी, 41 + 1 = 42 बाइट्स

सी # 125 98 बाइट्स

व्याख्या

आर, 198 189 96 95 बाइट्स

स्विफ्ट, 105 91 बाइट्स

ऑक्टेव , 61 बाइट्स

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

गणितज्ञ, 36 बाइट्स

> <> , 49 बाइट्स

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

PowerShell v2 +, 44 बाइट्स

उदाहरण

दिल्लोग एपीएल , 11 बाइट्स

प्रसंस्करण, 109 बाइट्स

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करना - असंख्य) ( 78 67 बाइट्स)

MATL, 7 बाइट्स

पर्ल 6, 48 47 45

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

अजगर, १०th

सीजाम, 10 बाइट्स

व्याख्या

आम लिस्प, 123

Emacs, 36 कीस्ट्रोक्स

नतीजा

व्याख्या