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

उदाहरण

"mississippi" → ["m","i","ssissi","ppi"]

"P P & C G" → ["P"," P ","& ","C ","G"]

"AAA" → ["AAA"]

"Adam" → ["A","d","a","m"]

"" → []

^{किस्सा : परिणाम 0 और 95 तत्वों के बीच होगा। 95 ^वें उप-स्ट्रिंग आवश्यक रूप से अंत तक जारी रहेगी क्योंकि उस बिंदु पर, सभी मुद्रण योग्य ASCII वर्णों ने एक उप-स्ट्रिंग शुरू कर दिया है, इसलिए हर अतिरिक्त चरित्र पहले हुआ होगा और इस तरह एक नया उप-स्ट्रिंग शुरू करने का कारण नहीं बन सकता है।}

code-golf string text-processing

— एडम
स्रोत

1

एक उदाहरण से युक्त "और 'एक अच्छा विचार की तरह लगता है।

— इमीना

क्या ""→ [""]स्वीकार्य होगा ?

— Arnauld

5

@Emigna कि उदाहरण के उत्पादन प्रारूप के साथ कोई और स्पष्टता लाए बिना गड़बड़ करता है।

— Adám

1

यदि एक newline- अलग स्ट्रिंग के रूप में outputting, वहाँ एक अग्रणी / अनुगामी newline हो सकता है?

— बंजर भूमि

2

@wastl उह, मैं इसे इस मामले में अनुमति दूंगा क्योंकि यह खाली खंडों को इंगित नहीं कर सकता है, हालांकि यह [""]अमान्य होने के मेरे पहले के फैसले से टकराता है। आह।

— एडम

22

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

QƤĠị

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

व्याख्या

QƤĠị  Input is a string, say s = "adam"
 Ƥ    For each prefix of s: ["a","ad","ada","adam"]
Q     remove duplicates: ["a","ad","ad","adm"]
  Ġ   Group indices by equal values: [[1],[2,3],[4]]
   ị  Index into s: ["a","da","m"]

स्ट्रिंग्स का आंतरिक प्रतिनिधित्व, जो TIO लिंक प्रदर्शित करता है, थोड़ा अलग है।

— Zgarb
स्रोत

10

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

q1,`.
¶$&

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

व्याख्या

प्रत्येक वर्ण ( .) का मिलान करें , बार-बार होने वाले मैचों को छोड़ें ( q), पहले मैच को त्यागें ( 1,), और प्रत्येक मैच के सामने एक लाइनफीड डालें ¶$&।

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

6

05AB1E , 11 बाइट्स

ÙSk¥sg¸«£õK

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

व्याख्या

Ù             # remove duplicates in input
 S            # split to a list of characters
  k           # get the (first) index of each character in the input
   ¥          # calculate delta's
    sg¸«      # append the length of the input
        £     # split the list into pieces of these sizes
         õK   # remove empty string (for the special case "" -> [])

— Emigna
स्रोत

1

इस उत्तर पर आने वाले किसी भी व्यक्ति के लिए, 05AB1E के नए संस्करण में ¸«हो सकता ªहै।

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

6

सी, 75 65 63 बाइट्स

10 बाइट बचाने के लिए @Digital ट्रामा के लिए धन्यवाद और प्रत्येक बाइट को बचाने के लिए @gastropner और @ l4m2 दोनों को धन्यवाद!

f(char*s){for(int l[128]={};*s;putchar(*s++))l[*s]++||puts(l);}

एक प्रमुख न्यूलाइन प्रिंट करता है।

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

एक प्रमुख नई लाइन (71 बाइट्स) के बिना:

f(char*s){int l[128]={};for(l[*s]=1;*s;putchar(*s++))l[*s]++||puts(l);}

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

— Steadybox
स्रोत

1

64 बाइट्स

— गैस्ट्रोपनर

@gastropner चतुर चाल; धन्यवाद!

— स्टेडीबॉक्स

{0}=> {}?

— l4m2

@ l4m2 हां, धन्यवाद!

— स्टेडीबॉक्स

5

पर्ल 6 , 58 52 40 बाइट्स

{$/={};.comb.classify({$+=!$/{$_}++}).sort».value».join}

कोशिश करो

*.comb.classify({$+=!(%){$_}++}).sort».value».join

कोशिश करो

*.classify({$+=!(%){$_}++}).sort».value

इसे आज़माएं
(इनपुट पात्रों की एक सूची है, और आउटपुट पात्रों की सूची की एक सूची है)

विस्तारित:

*                   # parameter for WhateverCode lambda

  .classify(        # classify that list
    {
        $           # anonymous scalar state variable (accumulator)

      +=            # increment it if:

        !           # Bool invert the following
          (
            %       # anonymous hash state variable
          ){ $_ }++ # look to see if the character was seen already
    }
  ).sort\           # sort the Pairs by key (makes the order correct)
  ».value           # get the value from each Pair

से आउटपुट classifyहै

{ # Hash
  1 => ['m'],
  2 => ['i'],
  3 => ['s','s','i','s','s','i'],
  4 => ['p','p','i'],
}

और .sortबस में बदल जाता है:

[
  1 => ['m'],
  2 => ['i'],
  3 => ['s','s','i','s','s','i'],
  4 => ['p','p','i'],
]

».value चाबियाँ निकालता है

[
  ['m'],
  ['i'],
  ['s','s','i','s','s','i'],
  ['p','p','i'],
]

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

कुंजी कभी आदेश से बाहर क्यों होगी? क्या सम्मिलन आदेश को जावा में HashMapबनाम बनाम ट्रैक नहीं किया जाता है, LinkedHashMapजहां ऑर्डर मेमोरी बनाम इन्सर्ट ऑर्डर पर आधारित है?

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

1

@MagicOctopusUrn पर्ल के किसी भी संस्करण ने हैश का आदेश नहीं दिया है। वास्तव में पर्ल 5 संस्करण 18 ने हैश को और अधिक यादृच्छिक बना दिया है जो एक निश्चित प्रकार के सेवा हमले को कम संभव बनाने में मदद करता है, और इससे छोटी गाड़ी के उपयोगकर्ता कोड का कारण भी होता है कि यह छोटी गाड़ी का व्यवहार अधिक बार करता है। अब कोई व्यक्ति (और संभावना है) एक वर्ग को लागू कर सकता है जो ट्रैक रखता है, लेकिन यह लोड करने और उपयोग करने के लिए 5 से अधिक वर्ण लेगा।

— ब्रैड गिल्बर्ट

5

जे , 7 बाइट्स

~:<;.1]

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

व्याख्या

नब छलनी का मौका चमकने का!

~: <;.1 ]
        ]  Input
~:         Nub sieve (1 if the character is the first instance in string)
    ;.1    Split input on 1s in nub sieve
   <       And box each

— गोभी
स्रोत

2

मैं बिल्कुल उसी (आश्चर्यजनक रूप से नहीं) उत्तर के बारे में पोस्ट करने वाला था, यह अच्छा है कि मैंने इससे पहले आपका सबमिशन किया :) :)

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

2

@GalenIvanov I - और मैं अधिकांश अन्य जे गोल्फरों की कल्पना करता हूं, - नब छलनी या स्व-वर्गीकृत का उपयोग करने का मौका फिर से।

— कोल

5

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

(≢¨∪\)⊆⊢

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

— NGN
स्रोत

लेकिन, लेकिन ... ओह मेरी।

— Adám

मुझे संदेह है कि आपने नए आदिम (।) के कारण इस चुनौती को पोस्ट किया होगा। जाहिर है नहीं :)

— NGN

यह एक शर्मिंदा किर्बी की तरह एक बच्चे की बोतल पकड़े हुए है।

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

हर किसी को जो "किर्बी" देखने की जरूरत है जैसे मैंने किया - यह एक जापानी वीडियो गेम से एंथ्रोपोमोर्फिक गुलाबी गेंद है

— ngn

5

05AB1E , 8 बाइट्स

Ùvyy¶ì.;

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

हमेशा 1 पूर्ववर्ती न्यूलाइन को आउटपुट करेगा, जो निरंतर है और विभाजन का संकेत नहीं है, 10-बाइट विकल्प जो पूर्ववर्ती न्यूलाइन को आउटपुट नहीं करता है Ùvyy¶ì.;}¦, आप यहां कोशिश कर सकते हैं । एडम के अनुसार एक पूर्ववर्ती या अनुगामी न्यूलाइन स्वीकार्य है।

Input      = mississippi                               | Stack
-----------#-------------------------------------------+----------------------------------
Ù          # Push unique letters of first input.       | ['misp']
 v         # Iterate through each unique letter.       | []
  yy       # Push 2 copies of the letter (or yD)       | ['m','m']
    ¶      # Push a newline char.                      | ['m','m','\n']
     ì     # Prepended to the letter.                  | ['m','\nm']
      .;   # Replace first instance with '\n + letter' | ['\nmississippi']

प्रत्येक पुनरावृत्ति के बाद हमें मिलता है:

['\nmississippi'] > ['\nm\nississippi'] > ['\nm\ni\nssissippi'] > ['\nm\ni\nssissi\nppi']

जो है:

m
i
ssissi
ppi

— जादू ऑक्टोपस Urn
स्रोत

अच्छा! मुझे एक उचित अंतर से हराया;)

— 13

@ ईमनिगा 2 दिनों के लिए आपके जवाब पर एक टिप्पणी के रूप में बैठा था, तब मैंने बस इसे पोस्ट किया b / c कोई प्रतिक्रिया नहीं haha: P।

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

अजीब, उस पर कोई अधिसूचना नहीं देखी गई। अपने स्वयं के उत्तर के लिए पर्याप्त भिन्न हालांकि :)

— एमिगॉन

@ अच्छी तरह से, मेरा मतलब है, मैंने इसे हटा दिया है हाहा।

— मैजिक ऑक्टोपस मूत्र

लूप लंघन एक बाइट बचाता है ÙSD¶ì.;। निश्चित नहीं है कि हमने इससे पहले क्यों नहीं सोचा: पी

— एमिग्ना

5

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

foldl(\s c->s++['\n'|all(/=c)s]++[c])""

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

पहली बार प्रकट होने वाले प्रत्येक वर्ण से पहले एक नई रेखा प्रतीक सम्मिलित करता है, जिसके परिणामस्वरूप एक नई पंक्ति अलग होती है, जिसमें एक प्रमुख नई रेखा होती है। lines.एक सूची तैयार करने के लिए तैयारी करें ।

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

(""%)
_%[]=[]
p%s|(a,b)<-span(`elem`s!!0:p)s=a:(a++p)%b

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

बार-बार उपसर्ग लेता है पहला चरित्र और इसके बाद गैर-अद्वितीय वर्ण।

— XNOR
स्रोत

@WheatWizard ओह, हाँ, lines।

— xnor

tail.linesअब अतिरिक्त खाली स्ट्रिंग को हटाने के लिए करना चाहूंगा कि मैं इसके बारे में सोचता हूं।

— गेहूं जादूगर

4

एपीएल (डायलॉग) , 9 बाइट्स

धन्यवाद, 1 बाइट बचाने के लिए आउटगोल्फ को एरिक!

⊢⊂⍨⍳∘≢∊⍳⍨

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

स्पष्टीकरण:

⍳⍨: प्रत्येक चरित्र के लिए, इसकी पहली घटना का सूचकांक प्राप्त करें। जैसेmississippi -> 1 2 3 3 2 3 3 2 9 9 2

⍳∘≢: इनपुट की लंबाई 1 से लेकर।

∊: सदस्यता। जैसे1 2 3 4 5 6 7 8 9 10 11∊1 2 3 3 2 3 3 2 9 9 2 -> 1 1 1 0 0 0 0 0 1 0 0

⊢⊂⍨: 1ऊपर दिए गए वेक्टर में शुरू होने वाले नए विभाजन के साथ इनपुट स्ट्रिंग को विभाजन

— H.PWiz
स्रोत

9 बाइट्स (monadic fgऔर monadic f∘gव्यवहार ही)

— एरिक Outgolfer

∊इसके बजाय क्यों =?

— आदम

लेखन के समय, मैंने विचार नहीं किया था कि सूचकांक सही स्थिति में होंगे। यद्यपि यह स्पष्ट है कि वे हैं

— H.PWiz

4

जाप , 11 बाइट्स

¬â r@=iRUbY

इसे ऑनलाइन टेस्ट करें!

व्याख्या

इस से प्रेरित था जादू ऑक्टोपस कलश की 05AB1E समाधान ।

¬â r@=iRUbY    Implicit: U = input string
¬â             Split U into chars, and keep only the first occurrence of each.
   r@          Reduce; for each char Y in this string...
        UbY      Find the first index of Y in U.
      iR         Insert a newline at this index in U.
     =           Set U to the result.
               As reduce returns the result of the last function call, this gives the
               value of U after the final replacement, which is implicitly printed.

— ETHproductions
स्रोत

1

यहाँ पर जाप पहचान का संकट है, यह किसी कारण से खुद को रूबी कह रहा है। iRUbY!

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

3

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

सहेजे गए 7 बाइट्स: एक प्रमुख नईलाइन को स्पष्ट रूप से अनुमति दी गई थी (धन्यवाद @ शिग्गी!)

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

s=>s.map(c=>s[c]=s[c]?c:`
`+c).join``

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

कोड स्निपेट दिखाएं

let f =

s=>s.map(c=>s[c]=s[c]?c:`
`+c).join``

;[
  [..."mississippi"],
  [..."P P & C G"],
  [..."AAA"],
  [..."Adam"],
  [...""]    
]
.forEach(s => console.log('{' + f(s) + '}\n'))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

अग्रणी नई सूचियों की अनुमति है ताकि आप इसे 37 बाइट्स

— झबरा

3

ब्रेनफक, 66 बाइट्स

,[>+[<[>+<<-<+>>-]>[>]<<[[+]++++++++++.>>>]<]<[>+<-]>>>[>>]<<-.>,]

प्रारूपित:

,
[
  >+
  [
    <[>+< <-<+>>-]
    >[>]
    <<[[+]++++++++++.>>>]
    <
  ]
  <[>+<-]
  >>>[>>]
  <<-.>,
]

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

आउटपुट में अग्रणी न्यूलाइन (जो केवल इनपुट के खाली होने पर प्रिंट की जाती है) xको मुख्य (सबसे बाहरी) लूप के साथ बदलकर 5 बाइट्स की कीमत पर हटाया जा सकता है .>,[x]।

— मिच श्वार्ट्ज
स्रोत

2

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

ŒQœṗ⁸Ḋ

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

— आउटग्रॉफर को एरिक करें
स्रोत

2

K4 , 19 बाइट्स

उपाय:

$[#x;(*:'.=x)_;,]x:

उदाहरण:

q)k)$[#x;(*:'.=x)_;,]x:"mississippi"
,"m"
,"i"
"ssissi"
"ppi"
q)k)$[#x;(*:'.=x)_;,]x:"P P & C G"
,"P"
" P "
"& "
"C "
,"G"
q)k)$[#x;(*:'.=x)_;,]x:"AAA"
"AAA"
q)k)$[#x;(*:'.=x)_;,]x:"Adam"
,"A"
,"d"
,"a"
,"m"
q)k)$[#x;(*:'.=x)_;,]x:""
,[""]

स्पष्टीकरण:

8 बाइट्स संभालना है ""...

$[#x;(*:'.=x)_;,]x: / the solution
                 x: / save input as variable x
$[  ;         ; ]   / $[condition;true;false]
  #x                / length of x ("" has length 0, i.e. false)
             _      / cut right at left indices
     (      )       / do together
          =x        / group x into key/value (char!indices)
         .          / return value (get indices)
      *:'           / first (*:) each
               ,    / enlist, "" => [""]

— streetster
स्रोत

2

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

def f(s):d=sorted(map(s.find,set(s)));print map(lambda a,b:s[a:b],d,d[1:])

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

— छड़ी
स्रोत

सूची के

— जोनाथन एलन

@JonathanAllan यह एक भ्रामक दुष्परिणाम है, setआदेश, प्रति-प्रमाण न रखें ->s='c'*6+'a'*100+'b'

— रॉड

मुझे पता है कि हम भविष्य के कार्यान्वयन में इस पर भरोसा नहीं कर सकते हैं, लेकिन मेरा मानना है कि पूर्णांक दिया हुआ पूर्णांक है जो पूर्णांक के हैश के कारण सेट में क्रम बनाए रखता है जो पूर्णांक है (जैसा कि आपने दिखाया है कि अन्य वस्तुओं के लिए सही नहीं है - क्या आप पा सकते हैं एक ऐसा शब्द जो मेरे विकल्प के साथ काम नहीं करता?)।

— जोनाथन एलन

@

— रॉड

आह, काफी निष्पक्ष, मेरा विश्वास गलत था!

— जोनाथन एलन

2

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

lambda s:reduce(lambda r,c:r+'\n'[c in r:]+c,s)

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

आउटपुट एक नई पंक्ति-अलग स्ट्रिंग। बमुश्किल कार्यक्रम संस्करण धड़कता है:

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

r=''
for c in input():r+='\n'[c in r:]+c
print r

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

— XNOR
स्रोत

2

पर्ल, 30 बाइट्स

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

एसटीडीआईएन पर नई अनुगामी के बिना इनपुट दें। उत्पादन भी बिना नई रेखा के पीछे है:

echo -n adam | perl -pE 's%.%$v{$&}+++!pos?$&:$/.$&%eg'; echo

आप प्रमुख और अनुगामी नई पंक्तियां इस के बारे में परवाह नहीं करते हैं 25( +3के लिए -pक्योंकि कोड शामिल ') भी काम करता है:

#!/usr/bin/perl -p
s%%$/x!$v{$'&~v0}++%eg

— टन हास्पेल
स्रोत

हमेशा की तरह महान समाधान! प्रदान किए गए परीक्षण मामलों के आधार पर, आपको अपने हैश का नाम देने की आवश्यकता नहीं है, आप कर सकते हैं ${$&}++। यह उतना मजबूत नहीं है, लेकिन इस चुनौती के लिए पर्याप्त हो सकता है? इसके अलावा, मेटा पर एक आम सहमति बन गई perl -pहै जिसे अतिरिक्त बाइट की आवश्यकता नहीं है, आपको Perl with `-p` सिर्फ पर्ल के बजाय हेडर की आवश्यकता है । मैं खुद को ऐसा करने के लिए याद करने की कोशिश कर रहा हूं ...

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

@DomHastings लगभग 95 संभावित स्ट्रिंग्स के बारे में टिप्पणी का यह तात्पर्य है कि 1यह मान्य है, जिस स्थिति में vइसकी आवश्यकता है। गिनती के बारे में, मैं ज्यादातर codegolf.meta.stackexchange.com/a/7539/51507 का अनुसरण करता हूं, जो कि मेरे लिए सबसे महत्वपूर्ण अनुरूप पोस्ट है, जो कि गिनती के बारे में है।

— टन हास्पेल

गुरु से सीखने के लिए हमेशा अच्छा होता है। विशेष रूप से, इस मामले में, &~v0पहले चरित्र को हथियाने के लिए। इस साइट से जुड़ने और अपनी लंबी विशेषज्ञता साझा करने के लिए धन्यवाद।

— msh210

आप स्ट्राबेरी पर्ल, का उपयोग करता है जो उपयोग कर सकते हैं "के बजाय 'साथ -e, और फिर आप भरोसा कर सकते हैं -ep+1 बजाय +3 के रूप में। (परीक्षण किया गया)।

— msh210

2

जावास्क्रिप्ट, 61 54 52 बाइट्स

वर्णों के एक सरणी के रूप में इनपुट लेता है।

s=>s.map(x=>a[x]?a[y]+=x:a[x]=a[++y]=x,a=[],y=-1)&&a

कोशिश करो

o.innerText=JSON.stringify((f=
s=>s.map(x=>a[x]?a[y]+=x:a[x]=a[++y]=x,a=[],y=-1)&&a
)([...i.value=""]));oninput=_=>o.innerText=JSON.stringify(f([...i.value]))

<input id=i><pre id=o></pre>

स्निपेट का विस्तार करें

— झबरा
स्रोत

2

आर , 94 87 बाइट्स

function(s,n=nchar(s),g=substring)g(s,d<-which(!duplicated(g(s,1:n,1:n))),c(d[-1]-1,n))

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

सब्सट्रिंग की एक (संभवतः खाली) सूची देता है।

7 बाइट बचाने के लिए माइकल एम का धन्यवाद!

— ग्यूसेप
स्रोत

3

function(s,n=nchar(s),g=substring)g(s,d<-which(!duplicated(g(s,1:n,1:n))),c(d[-1]-1,n))कम होगा - और निश्चित रूप से थोड़ा बदसूरत ...

— माइकल एम

substringइसके बजाय क्यों substr?

— प्लेनैपस

@MichaelM बहुत अच्छा! मुझे अभी भी if(n)वहाँ जोड़ना है क्योंकि substringखाली स्ट्रिंग इनपुट के लिए एक त्रुटि फेंकता है।

— ग्यूसेप

1

@plannapus substrअपने पहले इनपुट के बराबर लंबाई का एक वेक्टर लौटाता है, जबकि substringएक लंबाई उसके इनपुट के सबसे लंबे समय के बराबर होती है।

— ग्यूसेप

@Giuseppe: R 3.4.3 में "if (n)" ड्रॉप करने पर रिक्त इनपुट स्ट्रिंग "" टू द खाली आउटपुट स्ट्रिंग "", जो कि ठीक होनी चाहिए (?)

— माइकल M

2

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

ç↓‼►▐NVh

ऑनलाइन रन और डीबग करें

उसी कार्यक्रम का एससीआई प्रतिनिधित्व यह है।

c{[Ii=}(m

प्रत्येक वर्ण के लिए, यह विभाजित होता है जब वर्तमान चरित्र का सूचकांक वर्तमान स्थिति है।

c            copy the input
 {    }(     split the string when the result of the enclosed block is truthy
  [          duplicate the input string under the top of the stack
   I         get the character index of the current character
    i=       is it equal to the iteration index?
        m    print each substring

— पुनरावर्ती
स्रोत

2

> <> , 22 17 14 बाइट्स

-1 बाइट एमिग्ना के लिए धन्यवाद

i:::a$1g?!o1po

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

एक प्रमुख और नई अनुगामी अनुगामी प्रिंट करता है।

यह इस बात पर नज़र रखता है कि अक्षर पहले से ही pदूसरी पंक्ति पर उसी स्थान पर वर्ण की एक प्रति लगाकर प्रकट हुए हैं , और यदि उस स्थिति से प्राप्त मान एक नई रेखा को प्रिंट कर रहा है तो 1. प्रिंट करने का प्रयास करते समय त्रुटि में समाप्त होता है-1

— मजाक कर रहा है
स्रोत

के महान उपयोग g/p! 16 बाइट्स

— एमिग्ना

1

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

r#c|any(elem c)r=init r++[last r++[c]]|1<2=r++[[c]]
foldl(#)[]

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

— nimi
स्रोत

1

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

s=>s.map(c=>o[c]?t+=c:(t&&m.push(t),t=o[c]=c),t='',o=m=[])&&[...m,t]

वर्णों की सूची के रूप में इनपुट लेता है।

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

कोड स्निपेट दिखाएं

let f=
s=>s.map(c=>o[c]?t+=c:(t&&m.push(t),t=o[c]=c),t='',o=m=[])&&[...m,t]

console.log(f([...'mississippi']));
console.log(f([...'P P & C G']));
console.log(f([...'AAA']));
console.log(f([...'Adam']));
console.log(f([...'']));

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

मेरे पास एक समान समाधान था और पूछा [""]गया कि क्या पिछले परीक्षण मामले के लिए स्वीकार्य था। लेकिन ऐसा नहीं है । :-(

— अरनौलद

ओह, ठीक है, आपको वैसे भी बहुत बेहतर समाधान मिला है

— रिक हिचकॉक

1

PHP, 317 बाइट्स

function SplitOnFirstUnique($s){
    $len = strlen($s); 
    $output = [];
    $newstring = '';
    for ($i=0; $i < $len ; $i++) { 
        $newstring = $newstring.$s[$i];
        if(!in_array($s[$i] , $output  )){
            $output[] = $newstring;
            $newstring = '';
        }
    }
    return $output;
}

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

— सौरभ चंद्र पटेल
स्रोत

2

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

— एक पेड़

1

लाल , 79 बाइट्स

func[s][foreach c next unique/case append s"^@"[print copy/part s s: find s c]]

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

Ungolfed:

f: func [s] [
    b: next unique/case append s "^@"  ; append `null` to the end of the string, than
                                       ; find the unique characters and 
                                       ; store all except the first to b  
    foreach c b [                      ; for each character in b
        print copy/part s s: find s c  ; print the part of the string to
                                       ; where the character is found and
                                       ; set the beginning of the string to that position
    ]
]

— गैलेन इवानोव
स्रोत

1

SNOBOL4 (CSNOBOL4) , 115 91 77 बाइट्स

	N =INPUT
S	N LEN(1) . Y	:F(END)
	S =S Y
	N SPAN(S) . OUTPUT REM . N	:(S)
END

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

नई क्यारियों द्वारा अलग किए गए पदार्थों को प्रिंट करता है।

स्पष्टीकरण:

लाइन S(के लिए SPLIT) वास्तव में विभाजित नहीं है, लेकिन इसके बजाय के पहले चरित्र को निकालता है Nऔर इसे ( .) को बचाता है Y। पर Failure, यह करने के लिए कूदता है END। Nखाली स्ट्रिंग होने पर ही मैच फेल होना चाहिए । इस प्रकार, जब इनपुट खाली होता है, तो यह सीधे कूदता है ENDऔर कुछ भी नहीं आउटपुट करता है।

S = S Yकोनकैटेनेट्स Yपर S।

SPAN(S)लालच में पात्रों के एक रन से मेल खाता है S, और (यदि कोई हो) के अयोग्य पात्रों को यह ( .) OUTPUT, सेटिंग ( .) Nको भेजता है । फिर यह वापस कूदता है ।REMNS

— ग्यूसेप
स्रोत

1

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

{$r=@();$h=@{};[char[]]$ARGS[0]|%{if(!($h[$_]++)){$r+=""};$r[-1]+=$_};$r}

प्रयोग

PS> & {$r=@();$h=@{};[char[]]$ARGS[0]|%{if(!($h[$_]++)){$r+=""};$r[-1]+=$_};$r} "mississipi" | ConvertTo-Json -Compress
["m","i","ssissi","pi"]

— डॉन क्रूक्शांक
स्रोत

आप कुछ बाइट्स बचा सकते हैं - इसे ऑनलाइन आज़माएं!

— माज़ी

1

रूबी , 65 62 58 बाइट्स

->s,*a{s.size.times{|i|(i==s.index(c=s[i])?a:a[-1])<<c}
a}

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

एक लंबोदर एक स्ट्रिंग को स्वीकार करता है और स्ट्रिंग की एक सरणी लौटाता है।

दृष्टिकोण: प्रत्येक सूचकांक के लिए, या तो sपरिणाम सूचकांक में उस सूचकांक पर चरित्र को जोड़ दें , या परिणाम सरणी में अंतिम स्ट्रिंग के लिए। String#indexतर्क के पहले उदाहरण का सूचकांक लौटाता है।

-2 बाइट्स: aअपनी लाइन के बजाय एक स्पैट तर्क के रूप में प्रारंभ करें । धन्यवाद, मूल्य स्याही !

-1 बाइट: का प्रयोग करें c=s[i]... cके बजाय s[i]... s[i]। धन्यवाद, मूल्य स्याही !

-4 बाइट्स: .timesइसके बजाय का उपयोग करें.map

— benj2240
स्रोत

कुछ असाइनमेंट ट्रिक्स का उपयोग करके -3 बाइट्स।

— वैल्यू इंक

1

जावा 8, 193 169 155 151 बाइट्स

s->{for(int l=s.length(),i=0,j;i<l;i++)if(s.indexOf(s.charAt(i))==i){for(j=i;++j<l&&s.indexOf(s.charAt(j))!=j;);System.out.println(s.substring(i,j));}}

-14 बाइट्स @raznagul के लिए धन्यवाद (कुछ स्पष्ट के लिए मैं किसी तरह अपने आप को याद किया ..)
-3 बाइट्स @ ऑबैलेंस के लिए धन्यवाद (फिर से कुछ स्पष्ट के लिए मैं किसी तरह से खुद को याद किया ..: S)

स्पष्टीकरण:

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

s->{                    // Method with String parameter and no return-type
  for(int l=s.length(), //  The length of the input-String
          i=0,j;        //  Index integers
      i<l;i++)          //  Loop `i` from 0 to `l` (exclusive)
    if(s.indexOf(s.charAt(i))==i){
                        //   If the character at index `i` hasn't occurred yet:
      for(j=i;++j<l     //    Inner loop `j` from `i` to `l` (exclusive),
          &&s.indexOf(s.charAt(j))!=j;);
                        //     as long as the character at index `j` has already occurred
      System.out.println(//    Print:
        s.substring(i,j));}}
                        //     The substring of the input from index `i` to `j` (exclusive)

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

1

मुझे नहीं लगता कि आपको इसकी आवश्यकता है if(l<1)। अगर lहै 0पाश निष्पादित नहीं किया जाना चाहिए वैसे भी रूप में 0<0है false।

— raznagul

@raznagul मुझे यकीन नहीं हुआ कि मैं कैसे चूक गया, लेकिन आप सही हैं! ..>।>

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

आप i=0दो बार सेट कर रहे हैं । आप दूसरे को छोड़ कर 3 बाइट्स बचा सकते हैं:for(;i<l;i++)

— OOBalance

@Oobalance यकीन नहीं होता कि कैसे हुआ ..: एस लेकिन ध्यान देने के लिए धन्यवाद! :)

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

प्रत्येक वर्ण की पहली घटना पर स्प्लिट स्ट्रिंग

उदाहरण

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

व्याख्या

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

व्याख्या

05AB1E , 11 बाइट्स

सी, 75 65 63 बाइट्स

पर्ल 6 , 58 52 40 बाइट्स

विस्तारित:

जे , 7 बाइट्स

व्याख्या

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

05AB1E , 8 बाइट्स

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

एपीएल (डायलॉग) , 9 बाइट्स

स्पष्टीकरण:

जाप , 11 बाइट्स

व्याख्या

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

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

ब्रेनफक, 66 बाइट्स

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

K4 , 19 बाइट्स

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

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

पर्ल, 30 बाइट्स

जावास्क्रिप्ट, 61 54 52 बाइट्स

कोशिश करो

आर , 94 87 बाइट्स

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

> <> , 22 17 14 बाइट्स

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

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

PHP, 317 बाइट्स

लाल , 79 बाइट्स

Ungolfed:

SNOBOL4 (CSNOBOL4) , 115 91 77 बाइट्स

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

प्रयोग

रूबी , 65 62 58 बाइट्स

जावा 8, 193 169 155 151 बाइट्स

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