मैंने पहले वह नंबर नहीं देखा है!

Question

एक प्रोग्राम लिखें जो गैर-व्हाट्सएप वर्णों की एक स्ट्रिंग से गुजरता है (आप मान सकते हैं कि वे अंक 0हैं 9, लेकिन जिस तरह से उन्हें संसाधित किया जाना है उस पर कुछ भी निर्भर नहीं करता है) और निम्नलिखित नियमों के अनुसार रिक्त स्थान जोड़ता है।

1. बता दें कि वर्तमान टोकन खाली स्ट्रिंग है, और पहले से उत्सर्जित टोकन एक खाली सेट है।
2. स्ट्रिंग के पात्रों के माध्यम से Iterate। प्रत्येक चरित्र के लिए, पहले चरित्र को वर्तमान टोकन में जोड़ें। फिर यदि वर्तमान टोकन पहले से उत्सर्जित टोकन के सेट में नहीं है, तो उस सेट में वर्तमान टोकन जोड़ें और नए वर्तमान टोकन को खाली स्ट्रिंग होने दें।
3. यदि आप स्ट्रिंग के अंत तक पहुंचते हैं तो वर्तमान टोकन खाली है, उत्सर्जन के क्रम में पहले से उत्सर्जित टोकन का उत्पादन करता है, एक अंतरिक्ष वर्ण द्वारा अलग किया जाता है। अन्यथा मूल स्ट्रिंग शब्दशः उत्पादन।

इनपुट

एसटीडीआईएन में इनपुट अंकों का एक क्रम होना चाहिए।

उत्पादन

कार्यक्रम को चरण 3 में निर्दिष्ट परिणाम को प्रिंट करना चाहिए।

नमूने

नमूना इनपुट

2015
10101010
4815162342
101010101010
3455121372425
123456789101112131415
314159265358979323846264338327950288419716939937

नमूना आउटपुट

2 0 1 5
10101010
4 8 1 5 16 2 3 42
1 0 10 101 01 010
3 4 5 51 2 1 37 24 25
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
3 1 4 15 9 2 6 5 35 8 97 93 23 84 62 64 33 83 27 95 0 28 841 971 69 39 937

---

यह कोड गोल्फ है, इसलिए मानक सीजी नियम लागू होते हैं। बाइट्स जीत में सबसे छोटा कार्यक्रम।

(कृपया टिप्पणियों में किसी भी स्पष्टीकरण का अनुरोध करें। मैं अभी भी इसके लिए नया हूं। धन्यवाद!)

Comments

4815162342मैं देखता हूं कि आपने वहां क्या किया था, ब्रोथा ।

— घातक

प्रस्तावित OEIS प्रविष्टि: संख्या जो इस प्रक्रिया द्वारा कम से कम दो खंडों में विभाजित होती है।

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

@IsmaelMiguel चरण 5 (किसी भी अन्य चरण के रूप में) एक समय में केवल एक अंक को आगे बढ़ा सकता है । एक बार जब आप मिल जाते हैं 1 0 10 , तो अगला पुनरावृत्ति मिलेगा 1(पहले से उपयोग किया गया), फिर एक को खोजने के लिए अग्रिम 10(पहले से उपयोग किया गया), फिर एक को खोजने के लिए अग्रिम करें 101, जो नया है और 'जोड़ा' जाएगा। यह तब एक स्थान जोड़ देगा और आपको एक नया मिलेगा 0, जिसका उपयोग पहले ही किया जा चुका है, लेकिन यहां स्ट्रिंग के अंत में है। इसलिए, आउटपुट होगा 1 0 10 101 0, जो अमान्य है ( 0दोहराया जाता है), और स्क्रिप्ट को फिर इनपुट स्ट्रिंग को आउटपुट करना होगा। यह केवल तभी बना सकता है 1010जब 101पहले से ही इस्तेमाल किया गया हो।

— Janus Bahs Jacquet

@kasperd नहीं If a unique number cannot be formed at the end of the string, then the input should be printed verbatim10101010 को विभाजित नहीं किया जा सकता है, इसलिए यह इस प्रकार मुद्रित होता है।

— edc65

लेकिन जब आप चरण 5 में प्रवेश करते हैं , तो अंतरिक्ष उसके बाद होगा 1, जो एक दोहराव होगा। इसलिए इसके बजाय आप अंतरिक्ष 5 में सही एक को स्थानांतरित करते हैं, और फिर आप चरण 4 में फिर से एक को स्थानांतरित करते हैं, और आप फिर से चरण 5 में प्रवेश करते हैं और बनाते हैं 101।

— पीटर टेलर

Answer 1

पायथ, 22 बाइट्स

 faW!}=+kTYY~kdz?tkzsY

अग्रणी स्थान महत्वपूर्ण है।

Answer 2

रेटिना , 68 61 बाइट्स

+`\b(\w+?)(?<!\b\1 .*)(\w+)$
$1 $2
(?=.* (.+)$(?<=\b\1 .+)) 
<empty>

<empty>एक खाली लाइन है। लाइन पर अनुगामी स्थान को नोट करें 3. आप -sध्वज के साथ एक फ़ाइल से उपरोक्त कोड चला सकते हैं ।

व्याख्या

+`\b(\w+?)(?<!\b\1 .*)(\w+)$
$1 $2

यह पहला चरण नियम 1 से 6. लागू करता है। यह एक रेगेक्स प्रतिस्थापन है जो बार-बार लागू होता है जब तक स्ट्रिंग बदलना बंद नहीं होता (यही वह है जो इसके +लिए है)। प्रत्येक चरण में हम बाएं से दाएं (चुनौती के नियमों का पालन करते हुए) स्ट्रिंग में एकल स्थान जोड़ते हैं। रेगेक्स अंकों के सबसे छोटे तार से मेल खाता है जो स्ट्रिंग के पहले से ही संसाधित भाग में प्रकट नहीं हुआ है। हम यह सुनिश्चित करते हैं कि हम शब्द \bऔर सीमा के साथ शेष स्ट्रिंग के एक उपसर्ग को देख रहे हैं और यह जांच कर रहे हैं कि हम स्ट्रिंग के अंत तक बिना रिक्त स्थान के साथ पहुंच सकते हैं (\w+)$। उत्तरार्द्ध यह भी सुनिश्चित करता है कि हम प्रति चरण केवल एक प्रतिस्थापन करते हैं।

(?=.* (.+)$(?<=\b\1 .+)) 
<empty>

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

Answer 3

Pyth, 24 23 बाइट्स

VzI!}=+kNYaY~k"";?kzjdY

इसे यहाँ आज़माएँ ।

VzI!}=+kNYaY~k"";?kzjdY    Implicit: z=input(), k='', Y=[], d=' '
Vz              ;          For N in z:
     =+kN                    Append N to k
  I!}    Y                   Is the above not in Y?
          aY k               Append k to Y
            ~k""             After append, reset k to ''
                 ?k        Is k truthy (i.e. not '')
                   z       Print original input
                    jdY    Otherwise print Y joined on spaces

बाइट बचाने के लिए @FryAmTheEggman को धन्यवाद: ओ)

Comments

@FryAmTheEggman एक अच्छी कॉल, मैं कश्मीर के मूल मूल्य को संरक्षित करने की कोशिश में बहुत फंस गया

— Sok

Answer 4

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

i,n,*o=input(),""
for c in i:n+=c;o,n=[o+[n],o,"",n][n in o::2]
print([" ".join(o),i][n>""])

मूल रूप से @ विलेम के समाधान का एक भारी गोल्फ संस्करण है।

Comments

[" ".join(o),i][n>""]

— FryAmTheEggman

@FryAmTheEggman आह शांत, मैंने कोशिश की थी कि bool(n)लेकिन मैं इसके बारे में नहीं सोचा था n>""।

— orlp

Answer 5

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

o=[];n="";i=input()
for c in i:
 n+=c
 if not n in o:o.append(n);n=""
print(i if n else" ".join(o))

Comments

मैंने आपकी बाइट गिनती तय की। इसके अलावा, आपको अंतरिक्ष को हटा देना चाहिए else "।

— mbomb007

कुछ सामान्य गोल्फ भी, आपका मूल स्कोर 100 बाइट्स था, मुझे लगता है।

— FryAmTheEggman

अच्छा है धन्यवाद! मुझे नहीं पता था कि "और" के बाद की जगह को हटाया जा सकता है। एक और दिन रहता था, एक और दिन सीखा :)

— विलेम

Answer 6

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

:_:_{h:0<|bhN,?hh:NrcH,?hB(l1,-1=A;BbA),?rhL:I(mH:Ar:[L]c:1&;:[H]:\"~w \"w,L:[H]c:_:Ar:1&)}

इससे मुझे एहसास हुआ कि सिंटैक्स के बारे में बहुत सी चीजें हैं जिन्हें मुझे बदलना होगा ...

व्याख्या

:_:_              § Creates a list [Input,[],[]] 
{...}             § Define a new predicate between the brackets and call it with the previous list as input
h:0<              § If the head of the input is negative, stop
|                 § Else
bhN,              § Second element of Input is called N
?hh:NrcH,         § N concatenated with the first element of Input is H
?hB(l1,-1=A;BbA), § Remaining digits A are either -1 if there's only one digit left or all the digits but the head otherwise
?rhL:I            § List of used integers is called L
(
   mH:Ar:[L]c:1&  § If H is already in L, call the predicate with input [A,H,L]
   ;              § Else
   :[H]:\"~w \"w, § Print H followed by a space
   L:[H]c:_:Ar:1& § Call the predicate with input [A,[],M] where M is L with H appended to it
)

Answer 7

सीजेएम, 26 बाइट्स

LLq{+_a2$&{a+L}|}/:X+X!S**

इसका परीक्षण यहां करें।

व्याख्या

L        e# Push an empty array to keep track if the previous segments.
L        e# Push an empty array to build the current segment.
q{       e# For each character in the input...
  +      e#   Add it to the current segment.
  _a2$&  e#   Duplicate and check if it's already in the segment list.
  {      e#   If not...
    a+L  e#     Add it to the list and push a new empty array for the next segment.
  }|
}/
:X+      e# Store the trailing segment in X and add it's *characters* to the list.
         e# For valid splittings, this trailing segment will be empty, so that the
         e# list remains unchanged.
X!       e# Push X again and take the logical NOT.
S*       e# Get that many spaces, i.e. 1 for valid segments and 0 otherwise.
*        e# Join the list with this string between elements.

Answer 8

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

मेरा आउटपुट फॉर्मैट खोज में आउटपुट नमूनों के बिल्कुल समान नहीं है (एक अग्रणी स्थान है)। मैं यह नहीं देखता कि एक दोष के रूप में, आउटपुट स्वरूप निर्दिष्ट नहीं है (बस प्रोग्राम को नंबर के बाद नंबर प्रिंट करना चाहिए ... )

एक EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करें। फ़ायरफ़ॉक्स के साथ विकसित, परीक्षण और नवीनतम क्रोम पर चल रहा है।

/* Test: redirect console.log */ console.log=x=>O.innerHTML+=x+'\n';

F=s=>{for(z=s,b=l=o=' ';s[+l];)~o.search(b+(n=s.slice(0,++l)+b))||(s=s.slice(l),o+=n,l=0);console.log(s?z:o)}

/* Test cases */
test = [
  '2015',
,'10101010'
,'4815162342'
,'101010101010'
,'3455121372425'
,'123456789101112131415'
,'11312123133'
,'314159265358979323846264338327950288419716939937']

test.forEach(t=>{console.log('\n'+t);F(t)})

<pre id=O></pre>

Answer 9

GNU sed, 83 77 73 71 बाइट्स

(स्कोर एक अतिरिक्त क्योंकि हमें -rध्वज की आवश्यकता है )

h
s/./&_/
:
/(\b[^ ]+).*\b\1_/{
s/_(.)/\1_/
t
g
}
s/_(.)/ \1_/
t
s/_//

आंतरिक लूप एक दोहराया अनुक्रम के लिए परीक्षण करता है और जब तक विभाजक के बाद एक अद्वितीय संख्या प्रकट होती है तब तक पात्रों को आवश्यकतानुसार जोड़ता है _। बाहरी लूप _साथ चलता है।

विस्तारित, एनोटेट संस्करण:

#!/bin/sed -rf

# Stash original in hold space
h

# Add separator
s/./&_/

:
# If current candidate is a duplicate, ...
/(\b[^ ]+).*\b\1_/{
#  ...then attempt to lengthen it ...
s/_(.)/\1_/
# ... and repeat if we succeeded, ...
t
# ... otherwise, restore original string
g
}
# Insert a space, and move our separator along
s/_(.)/ \1_/
t

# Remove the separator if we still have it
s/_//

Comments

आप दोनों tको एक में जोड़ सकते हैं ।

— यूजर 112638726

इसके अलावा , 2 कैप्चर समूहों के लिए कोई कारण नहीं /((\b[^ ]+).*\b\2)_/{लिखा जा सकता है /(\b[^ ]+).*\b\1_/{।

— User112638726

कोई समस्या नहीं :), आपको संदर्भ को बदलने की आवश्यकता है \1!

— User112638726

Answer 10

रूबी, 57 + 1 = 58 बाइट्स

s=''
l={}
$_.chars{|c|l[s<<c]||=s=''}
l[s]||$_=l.keys*' '

कमांड लाइन ध्वज का उपयोग करता है -p(या plयदि आपके इनपुट में एक अनुगामी न्यूलाइन है)। रूबी हैश शब्दकोशों के कई लक्षणों को उजागर करता है: आप सुरक्षित रूप से उस स्ट्रिंग को म्यूट कर सकते हैं जिसे आप एक कुंजी को परिभाषित करने के लिए उपयोग करते थे, जो कुंजी को बदलने के बिना काम करता है (जो अन्य उत्परिवर्तनीय प्रकारों के लिए काम नहीं करता है), .keysकुंजी को उस क्रम में लौटाता है जिसे उन्होंने डाला था, और []||=ऑपरेटर किसी दिए गए कुंजी पहले से ही है कि क्या वहाँ पर शाखाओं में बंटी का एक तरीका प्रदान करता है।

Answer 11

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

f क्या यह।

e""s""=unwords s
e t s""=concat s++t
e t s(c:r)|t&c`elem`s=e(t&c)s r|0<1=e""(s&(t&c))r
a&b=a++[b]
f=e""[]

Answer 12

PHP - 148 बाइट्स

शांत चुनौती, बहुत मज़ा!

$x=fgets(STDIN);$w=array();$k='';$l='';for($i=0;$i<strlen($x);$i++){$k.=$x[$i];if(!isset($w[$k])){$l.=$k.' ';$w[$k]=1;$k='';}}echo strlen($k)?$x:$l;