जोड़ो और मिटाओ

14

एक पंक्ति को देखते हुए जिसमें केवल अक्षर होते हैं, निम्नलिखित प्रक्रिया करें:

  • आप एक स्ट्रिंग बनाए रखें जो शुरुआत में खाली हो।
  • यदि अगला इनपुट चरित्र स्ट्रिंग में है, तो इसे स्ट्रिंग से हटा दें।
  • यदि अगला इनपुट वर्ण स्ट्रिंग में नहीं है, तो इसे स्ट्रिंग में जोड़ें।

स्ट्रिंग की अंतिम स्थिति का उत्पादन।

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

स्यूडोकोड (इसे गोल्फ के लिए स्वतंत्र महसूस करें):

str = EMPTY
for each character ch in input
  if ch exists in str
    remove all ch from str
  else
    append ch to str
print str

इनपुट नियमित अभिव्यक्ति से मेल खाता है ^[A-Za-z]+$।

नमूना परीक्षण के मामले:

ABCDBCCBE -> ADCBE
ABCXYZCABXAYZ -> A
aAABBbAbbB -> aAbB
GG -> (empty)

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

प्रत्येक भाषा में सबसे छोटा कार्यक्रम जीतता है!

अतिरिक्त (वैकल्पिक): कृपया बताएं कि आपका कार्यक्रम कैसे काम करता है। धन्यवाद।

code-golf  string 
— iBug
स्रोत
क्या लाइन खाली हो सकती है?
— 15:20 बजे user202729
1
@ user202729 नहीं। मैं थोड़ा बदल गया (यह किसी भी जवाब को अमान्य नहीं करता है) इसलिए इनपुट कभी खाली नहीं होता है।
— 16
1
तो आपने ais523 के संपादित सुझाव (लिंक) को अस्वीकार क्यों किया ?
— user202729

जवाबों:

10

हास्केल , 44 42 बाइट्स

foldl(#)""
s#x|z<-filter(/=x)s=z++[x|z==s]

इसे ऑनलाइन आज़माएं! संपादित करें: -2 बाइट्स जर्ब के लिए धन्यवाद!

स्पष्टीकरण:

दूसरी पंक्ति एक फ़ंक्शन को परिभाषित करती है (#)जो एक स्ट्रिंग sऔर एक चरित्र लेती है xऔर या तो रिमूव या एपेंड करती है। यह द्वारा हासिल की है filterकी प्रत्येक पुनरावृत्ति बाहर ing xमें s, स्ट्रिंग में जिसके परिणामस्वरूप z। यदि अंदर xनहीं होता है s, तो zबराबर है sऔर z++[x|z==s]पैदावार के साथ मूल स्ट्रिंग देता xहै। अन्यथा [x|z==s]खाली स्ट्रिंग की पैदावार और केवल फ़िल्टर किए गए स्ट्रिंग को लौटाया जाता है।

foldl(#)""एक अनाम फ़ंक्शन है जो एक स्ट्रिंग लेता है और ""फ़ंक्शन के साथ शुरू में खाली स्ट्रिंग के बाद एक वर्ण जोड़ता है (#)।

— Laikoni
स्रोत
2
फिल्टर का पुन: उपयोग करके 42 बाइट्स ।
— जर्बर्ग
9

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

œ^/

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

पूरा कार्यक्रम।

— आउटगोल्फ को एरिक करें
स्रोत
क्यों œ^/पर्याप्त नहीं है?
— जोनाथन एलन
@JonathanAllan कार्यक्रम को एक त्रुटि के साथ बाहर नहीं निकलना चाहिए ।
— निकोलगर्फ़
the input is never emptyखैर, अब यह काम करता है।
— user202729
8

जे , 21 19 बाइट्स

#~~:&.|.(2|*)1#.=/~

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

=/~ - स्ट्रिंग में वर्णों की समानता की तालिका बनाता है:

   a =. 'ABCXYZCABXAYZ'
   ]b =: =/~ a 
1 0 0 0 0 0 0 1 0 0 1 0 0
0 1 0 0 0 0 0 0 1 0 0 0 0
0 0 1 0 0 0 1 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 1 0 0 0
0 0 0 0 1 0 0 0 0 0 0 1 0
0 0 0 0 0 1 0 0 0 0 0 0 1
0 0 1 0 0 0 1 0 0 0 0 0 0
1 0 0 0 0 0 0 1 0 0 1 0 0
0 1 0 0 0 0 0 0 1 0 0 0 0
0 0 0 1 0 0 0 0 0 1 0 0 0
1 0 0 0 0 0 0 1 0 0 1 0 0
0 0 0 0 1 0 0 0 0 0 0 1 0
0 0 0 0 0 1 0 0 0 0 0 0 1

1#. - आधार 1 रूपांतरण द्वारा प्रत्येक पंक्ति का योग (अक्षर कितनी बार होता है)

   ]c =: 1#. b
3 2 2 2 2 2 2 3 2 2 3 2 2

~:&.|- रिवर्स, फिर नब छलनी (चार अद्वितीय है) और फिर से रिवर्स लागू करें। इस प्रकार मैं स्ट्रिंग में वर्णों की अंतिम घटनाओं को पाता हूं:

   ]d =. ~:&.|. a
0 0 0 0 0 0 1 0 1 1 1 1 1

* - गिनती में चरित्र की अंतिम स्थिति के लिए 1 से गिनती को 0 से गुणा करता है, अन्यथा, ऊपर से गणना की जाती है ~:&.| 

   ]e =. c * d
0 0 0 0 0 0 2 0 2 2 3 2 2

2| - मोडुलो 2 (चार्ट में 0 के पदों पर भी गिनती होती है):

   ]f =. 2| e 
0 0 0 0 0 0 0 0 0 0 1 0 0

#~- सही तर्क बाएं आर्ग कॉपी करें। समय (~ आर्ग के स्थानों को उलट देता है)

]f # a A

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

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

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

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

यह ऑनलाइन की कोशिश करो

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

, Gets first input
[ Starts loop
    <<< Go to start of string
    [ Loop over the string
        [->+>>>+<<<<] Duplicates the current char of the string
        >>>[-<+<->>] Duplicates and subtracts the inputted char from the duplicate of the string char
        <<[[-]<] If the char is different to the input, remove the difference
        > If the char is the same
        [
            [-]>>[-]>[[-<+>]>]<<[<]<< Remove the char from the string and sets the inputted char to 0
        ]
        << Moves to the next char of the string
    ]
    >>>[->+<] adds the inputted char to the string
    >>[>]>>, gets the next input
]
<<<[.<] prints the string
— मजाक कर रहा है
स्रोत
4

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

एक अन्य ब्रूस फोर्ट के लिए धूल को धन्यवाद देता है।

import Data.List
foldl1(\x y->union(x\\y)$y\\x)

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

स्ट्रिंग्स की एक सूची लेता है।

सममित अंतर कष्टप्रद है ...

— totallyhuman
स्रोत
++unionइस विधि के साथ 2 बाइट्स बचाता है ।
— अर्जन जोहान्सन
2

आर , 92 84 77 बाइट्स

for(i in el(strsplit(scan(,y<-''),y)))y=c(y[y!=i],if(!i%in%y)i);cat(y,sep='')

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

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

व्याख्या

djhurio ने forलूप से बचने के लिए एक उत्कृष्ट R उत्तर प्रदान किया - जैसा कि R प्रोग्रामर सहज रूप से एक नियम के रूप में करते हैं (स्वयं शामिल)। यहां एक आर उत्तर है जो forलूप का उपयोग करता है (और प्रक्रिया में कुछ बाइट्स बचाता है)।

  • x=scan(,''); - इनपुट को वेरिएबल में असाइन करें x
  • y=''; - नामक चर में एक खाली स्ट्रिंग बनाएं y
  • for(i in el(strsplit(x,'')))- में हर चरित्र iके लिएx
  • y=c(y[y!=i],if(!i%in%y)i)- उस के yहर तत्व को असाइन करना yबराबर नहीं है i, iअगर iपहले से ही नहीं था तो उसे जोड़नाy
  • cat(y,sep='')- yउन दोनों के बीच कोई स्थान नहीं के तत्वों को मुद्रित करें

ध्यान दें

यदि आप ऊपर TIO लिंक पर क्लिक करते हैं, तो आप शीर्ष लेख में पाएंगे library(methods); यह फ़ंक्शन के संबंध में अनुभव की गई त्रुटि djhurio से निपटने के लिए el()है - फ़ंक्शन methodsपैकेज द्वारा प्रदान किया जाता है, जो कि मैंने आर के किसी भी संस्करण में उपयोग किया है, डिफ़ॉल्ट रूप से लोड किया गया है, लेकिन जो भी कारण TIO द्वारा नहीं है। यदि library(methods)हेडर से हटा दिया जाता है और इसके unlistलिए प्रतिस्थापित किया जाता है el, तो मैं चार बाइट्स प्राप्त करता हूं, लेकिन इतना djhurio होगा , क्रमशः हमारी बाइट की गिनती 96 88 और 99 पर।

— duckmayr
स्रोत
अच्छा है। लूप के लिए कभी सोचा नहीं होगा कि वह छोटा होगा। आप इसे एक और कथन छोड़ कर और भी छोटा बना सकते हैं for(i in el(strsplit(scan(,y<-''),y)))y=c(y[y!=i],if(!i%in%y)i);cat(y,sep='')।
— djhurio 15
@djhurio - मुझे पता है, यह लगभग कभी भी ऐसा नहीं होता है कि R में for लूप किसी भी चीज़ से मदद करेगा। आपके सुझाव के बारे में: महान विचार! सुझाव अब उत्तर में सम्‍मिलित है।
— duckmayr
1
@djhurio - काफी उचित; मैं बहुत व्यस्त था कि मैंने जो बयान दिया था उसे देखते हुए शुरू किए गए अंतर को देखने में व्यस्त था कि आपने शुरुआत कैसे बदली है। अब संपादन कर रहे हैं। अच्छा कार्य!
— duckmayr
1
@djhurio @duckmayr एक 73 बाइट समाधान है जो मूल रूप से इस समाधान को ले रहा है और पात्रों को निकालने के लिए थोड़ा अलग दृष्टिकोण का उपयोग कर रहा है। मुझे वास्तव में इसे एक अलग उत्तर के रूप में पोस्ट करने का मन नहीं था। यह भी ध्यान दें कि ...[[1]]लंबे समय से el(...)कम है unlist(...), बशर्ते कि ...लंबाई 1. की सूची है
— Giuseppe
1
खरोंच है कि, मैं एक 70 अलविदा उत्तर मिला क्योंकि 0यह nulचरित्र है और खाली स्ट्रिंग में परिवर्तित हो जाता है।
— Giuseppe
2

MATL , 6 बाइट्स

vi"@X~

TIO वातावरण में काम नहीं करता है, लेकिन MATLAB कार्यान्वयन पर ठीक काम करता है, और एक ताजा पैच के लिए धन्यवाद, आप इसे MATL ऑनलाइन पर आज़मा सकते हैं

X~बराबरी setxor, या सममित अंतर, जो वास्तव में चुनौती पूछता है वही करता है। बाकी केवल इनपुट पर लूपिंग है i"@और पूरे स्टैक को खाली करके एक खाली स्ट्रिंग के साथ शुरू होता है जो शुरुआत में खाली है (धन्यवाद लुइस मेंडो)।

— Sanchises
स्रोत
2

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

-2 बाइट्स एक्सनोर के लिए धन्यवाद। -3 बाइट्स ओव्स के लिए धन्यवाद।

lambda s:reduce(lambda a,c:a.replace(c,'')+c[c in a:],s)

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

शाब्दिक रूप से बस छद्मकोश को गढ़ा जाता है। : पी

— totallyhuman
स्रोत
1
2 बाइट्स सहेजें s=(s+c).replace(c,c[c in s:])।
— xnor
@xnor यह कुछ बुनियादी गोल्फ बहुत चतुराई से निष्पादित किया गया है। धन्यवाद!
— पूरी तरह से अमानवीय
1
-1 बाइट :s=s.replace(c,'')+c[c in s:]
— अंडा
1
— ovs
1

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

s=>[...s].map(c=>s=s.match(c)?s.split(c).join``:s+c,s='')&&s

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

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

— Arnauld
स्रोत
मैंने @ मार्टिनएंडर के रेटिना उत्तर को चित्रित किया और यह केवल 45 बाइट्स था ...
— नील
1

एपीएल + विन, 19 बाइट्स

गैलेन के जे समाधान के समान तर्क।

(2|+⌿⌽<\⌽c∘.=c)/c←⎕
— ग्राहम
स्रोत
1

वोल्फ्राम भाषा (गणितज्ञ) , 36 बाइट्स

#//.{a___,x_,b___,x_,c___}:>{a,b,c}&

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

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

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

दो बार दोहराए गए वर्णों को खोजने और दोनों को हटाने के लिए उपयोग //.(उपनाम ReplaceRepeated), जब तक कि कोई और दोहराया वर्ण मौजूद न हो। यदि चरित्र दो बार से अधिक होता है, तो गणितज्ञ हमेशा पहले दो घटनाओं को हटा देगा। इसलिए यदि कोई चरित्र कई बार विषम संख्या में होता है, तो इसका अंतिम उदाहरण हमेशा जीवित रहने वाला होगा।

— मिशा लावरोव
स्रोत
1

प्रस्तावना 81 बाइट

a([],O,O).
a([I|J],K,O):-delete(K,I,F),(K=F->append(K,[I],M),a(J,M,O);a(J,F,O)).

गैर-बाधित संस्करण:

append_and_eraze([], Output, Output).
append_and_eraze([I | Input], Interim, Output) :-
    delete(Interim, I, Filtered),
    ( Interim = Filtered ->
      append(Interim, [I], Interim1),
      append_and_eraze(Input, Interim1, Output)
    ;
    append_and_eraze(Input, Filtered, Output)
    ).
  1. delete/3 यह सुनिश्चित करता है कि इसका तीसरा तर्क इसके पहले तर्क के साथ एकीकृत होता है, इसके साथ दूसरे तर्क के सभी उदाहरणों को हटा दिया जाता है।
  2. यदि वे समान होते हैं, तो हम तत्व को जोड़ते हैं (इसे हटाया नहीं गया था)।
  3. append/3 अपने नाम के अनुसार, सूची में एक तत्व जोड़ता है।
  4. हम इनपुट के तत्वों पर पुनरावृत्ति करते हैं जब तक हम [](खाली सूची) को हिट नहीं करते हैं , जिस बिंदु पर मध्यवर्ती परिणाम वांछित परिणाम के साथ एकीकृत होगा।

परीक्षा:

?- append_and_eraze(`ABCDBCCBE`, [], X), string_codes(Y, X).
X = [65, 68, 67, 66, 69],
Y = "ADCBE".

?- append_and_eraze(`ABCXYZCABXAYZ`, [], X), string_codes(Y, X).
X = [65],
Y = "A".

?- append_and_eraze(`aAABBbAbbB`, [], X), string_codes(Y, X).
X = [97, 65, 98, 66],
Y = "aAbB".

?- append_and_eraze(`GG`, [], X), string_codes(Y, X).
X = [],
Y = "".

कुछ प्रोलॉग्स सूची के रूप में दोहरे उद्धरणों में तार का इलाज करते हैं, SWI को ऐसा करने के लिए कॉन्फ़िगर किया जा सकता है, लेकिन सादगी के लिए, मैं string_codes/2आउटपुट को अच्छी तरह से प्रारूपित करता था।

— wvxvw
स्रोत
1

आर , 84 बाइट्स

y=el(strsplit(scan(,""),""));cat(unique(y[colSums(outer(y,y,"=="))%%2>0],,T),sep="")

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

एक और समाधान, लेकिन यहां बेहतर आर उत्तर हैं।

आर , 88 बाइट्स

z=table(y<-el(strsplit(scan(,""),"")));cat(setdiff(unique(y,,T),names(z[!z%%2])),sep="")

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

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

Duckmayr द्वारा एक छोटा जवाब है ।

  1. scan(,"") स्टड से इनपुट पढ़ें।
  2. y<-el(strsplit(scan(,""),""))वर्णों द्वारा विभाजित इनपुट और के रूप में सहेजें y।
  3. z=table(y<-el(strsplit(scan(,""),"")))प्रत्येक वर्ण की आवृत्तियों की गणना करें और परिणामस्वरूप तालिका को सहेजें z;
  4. unique(y,,T) दाईं ओर से अद्वितीय वर्ण लें।
  5. names(z[!z%%2]) यहां तक ​​कि केवल गिने चुने और नाम निकालें।
  6. setdiff(unique(y,,T),names(z[!z%%2])) यहां तक ​​कि गिनती के साथ वर्ण हटाएं।
  7. cat(setdiff(unique(y,,T),names(z[!z%%2])),sep="") आउटपुट प्रिंट करें।
— djhurio
स्रोत
आपकी त्रुटि का कारण पैकेज el()से आता है methods, जो आमतौर पर डिफ़ॉल्ट रूप से लोड होने पर, TIO द्वारा नहीं है (नीचे मेरे उत्तर में चर्चा की गई है)
— duckmayr
क्यों आप उपयोग कर रहे rev(unique(rev(y)))? सिर्फ unique(y)काम नहीं करेगा ? ooohhh रुको मैं देखता हूं, आप दाएं से बाएं तक अद्वितीय चरित्र चाहते हैं। उस स्थिति में unique(y,,T)(सेटिंग fromLast=T) 88 बाइट्स होगी ।
— ग्यूसेप्पे
0

ऐलिस , 9 बाइट्स

/X&@
\io/

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

व्याख्या

मूल रूप से एरिक के उत्तर का एक बंदरगाह । आईपी ​​पुनर्निर्देशन के एक बिट के अलावा कोड वास्तव में है:

i&Xo@

जो करता है:

i   Read all input.
&X  Fold symmetric multiset difference over the input.
o   Output the result.
@   Terminate.
— मार्टिन एंडर
स्रोत
0

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

{(,⍨~∩)/⍣(≢⍵)⊖⍵}

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

यदि त्रुटियों की अनुमति थी, तो यह 9 बाइट्स होता:

(,⍨~∩)/∘⊖
— आउटगोल्फ को एरिक करें
स्रोत
त्रुटियों से आपका क्या तात्पर्य है?
— फ्राईफ्रॉग
@FrownyFrog 9-बाइट संस्करण एक DOMAIN ERRORखाली स्ट्रिंग को फेंक देगा , क्योंकि (,⍨~∩)इसमें कोई पूर्वनिर्धारित पहचान तत्व नहीं है।
— एर्ग आउटफोलर
0

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

->s{s.reverse.uniq.select{|c|s.count(c)%2>0}.reverse}

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

इनपुट और आउटपुट दोनों वर्णों की एक सरणी है। टेस्ट कोड कॉल .charsऔर .joinसुविधा के लिए।

व्याख्या

इस तथ्य का उपयोग करता है कि परिणामी स्ट्रिंग में अक्षर विषम संख्या में और दाएं से बाएं क्रम में दिखाई देते हैं।

->s{                # lambda function taking char-array argument
    s.reverse           # reverse the input
    .uniq               # get unique characters
    .select{|c|         # select only those which...
        s.count(c)%2>0      # appear in the input array an odd number of times
    }.reverse           # reverse back and return
}
— जस्टिन मेरिनर
स्रोत
0

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

{_xD_Qf%/QT2Q

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

      f     Q            (f)ilter input (Q)
        /QT              On how many times (/) each character (T) appears in the 
                           input (Q)
       %   2             Only allow odd numbers of occurences (when x % 2 = 1)
 _xD_Q                   Sort (D) descending (the first _) by the location (x) of 
                           the last (the second _) inde(x) of the target character
                           in the input (Q)
{                        Remove duplicates
— स्टीवन एच।
स्रोत
0

रोड़ा , 34 बाइट्स

{a=[]a-=_ if[_1 in a]else a+=_1;a}

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

यह छद्मकोश का प्रत्यक्ष अनुवाद है। यह इनपुट और आउटपुट को पात्रों की धाराओं के रूप में मानता है।

स्पष्टीकरण:

{                    /* Anonymous function                   */
    a=[]             /* initialize a                         */
                     /* For each character _1 in the stream: */
    a-=_ if[_1 in a] /*  Remove it from a if a contains it   */
    else a+=_1;      /*  Otherwise append it to a            */
    a                /* Push characters in a to the stream   */
}
— fergusq
स्रोत
0

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

सबसे छोटा नहीं है, लेकिन मुझे यह तरीका पसंद है।

lambda s:''.join(c*(s.count(c)%2)*(i==s.rfind(c))for i,c in enumerate(s))

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

स्ट्रिंग के माध्यम से लूप्स, केवल उन पात्रों को रखते हुए जहां:

  • (s.count(c)%2) == 0 - चरित्र कई बार समरूप दिखाई देता है।
  • (i==s.rfind(c)) - वर्तमान सूचकांक विचाराधीन चरित्र का अंतिम रूप है।
— FlipTack
स्रोत
0

आरईएक्सएक्स , 102 बाइट्स

a=arg(1)
s=''
do while a>''
  b=right(a,1)
  if countstr(b,a)//2 then s=b||s
  a=changestr(b,a,'')
  end
say s

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

यह कैसे काम करता है: सबसे सही अक्षर लें, देखें कि क्या घटनाओं की संख्या सम या विषम है (जो सत्य मान के रूप में दोगुनी भी है) और यदि विषम है, तो इसे आउटपुट स्ट्रिंग में जोड़ें। फिर इनपुट स्ट्रिंग से पत्र की सभी घटनाओं को हटा दें। इनपुट समाप्त होने तक दोहराएं।

— idrougge
स्रोत
0

जावा 8, 93 बाइट्स

से एक लैम्ब्डा Stringके लिए String। प्रश्न में बस छद्मकोड का कार्यान्वयन।

s->{String o="";for(char c:s.toCharArray())o=o.indexOf(c)<0?o+c:o.replace(c+"","");return o;}

यह ऑनलाइन की कोशिश करो

जावा 8, 182 बाइट्स

यहाँ उसी प्रकार का एक और मेमना है जो धाराओं का उपयोग करता है! यह शायद अधिक कुशल है।

s->s.join("",s.chars().mapToObj(c->(char)c+"").filter(c->s.replaceAll("[^"+c+"]","").length()%2>0).distinct().sorted((c,d)->s.lastIndexOf(c)-s.lastIndexOf(d)).toArray(String[]::new))

यह ऑनलाइन की कोशिश करो

Ungolfed

s ->
    s.join(
        "",
        s.chars()
            .mapToObj(c -> (char) c + "")
            .filter(c -> s.replaceAll("[^" + c + "]", "").length() % 2 < 0)
            .distinct()
            .sorted((c, d) -> s.lastIndexOf(c) - s.lastIndexOf(d))
            .toArray(String[]::new)
    )
— जेकब
स्रोत
0

आर , 70 बाइट्स

function(s){for(i in utf8ToInt(s))F=c(F[F!=i],i*!i%in%F);intToUtf8(F)}

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

मुझे इस समाधान को पोस्ट करने के लिए djhurio द्वारा प्रोत्साहित किया गया था; djhurio का उत्तर यहां पाया जा सकता है ।

यह एक विचार को डकमेयर्स के उत्तर के रूप में उपयोग करता है , लेकिन यह एक सांख्यिक दृष्टिकोण का लाभ उठाता है, जो स्ट्रिंग को उसके कोडपॉइंट्स में विभाजित करने के बजाय इसे पात्रों में विभाजित करता है, और यह एक पूर्ण कार्यक्रम के बजाय एक फ़ंक्शन है, ताकि यह स्टडआउट पर प्रिंट करने के बजाय नए स्ट्रिंग को वापस कर सके। ।

function(s) {
 for(i in utf8ToInt(s))           # convert string to codepoints and iterate over it
  F=c(F[F!=i],                    # remove duplicates and append
      i*!i%in%F)                  # 0 if in F, i otherwise
 intToUtf8(F)                     # collapse from codepoints to string
}

एक महत्वपूर्ण अवलोकन यह है कि या तो Fइनिशियलाइज़ किया जाता है और इसलिए यह खाली स्ट्रिंग के साथ-साथ कोडपॉइंट्स को सही ढंग से ढहाने में सफल होगा।FALSE0utf8ToInt(0)==""

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

SNOBOL4 (CSNOBOL4) , 97 95 बाइट्स

	S =INPUT
N	S LEN(1) . C REM . S :F(O)
	O C :S(R)
	O =O C :(N)
R	O C =:S(R)F(N)
O	OUTPUT =O
END

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

	S =INPUT			;* read input
N	S LEN(1) . C REM . S :F(O)	;* take the first character of S and assign it to C,
					;* assign the remainder to S, and if S has no characters left, goto O
	O C :S(R)			;* if C matches anything in O, goto R, otherwise go to next line
	O =O C :(N)			;* append C to O and goto N
R	O C =:S(R)F(N)			;* as long as C matches O, replace it with ''
					;* (unassigned variables default to the null string)
					;* then goto N once it fails to match
O	OUTPUT =O			;* output the string
END					;* terminate the program
— ग्यूसेप
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.