যোগ করুন এবং মুছুন

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)

ইনপুটটি যেকোন প্রযোজ্য উপায়ে দেওয়া যেতে পারে তবে এটি অবশ্যই স্ট্রিং হিসাবে গণ্য হবে এবং আউটপুট হিসাবে একই treated প্রোগ্রামটি ত্রুটি সহ প্রস্থান করা উচিত নয় ।

প্রতিটি ভাষায় সংক্ষিপ্ততম প্রোগ্রামটি জয়ী হয়!

অতিরিক্ত (ptionচ্ছিক): আপনার প্রোগ্রামটি কীভাবে কাজ করে তা দয়া করে ব্যাখ্যা করুন। ধন্যবাদ.

code-golf  string 
— iBug
সূত্র
লাইন ফাঁকা হতে পারে?
— ব্যবহারকারী 202729
1
@ ব্যবহারকারী202729 নং আমি কিছুটা পরিবর্তন করেছি (এটি কোনও উত্তরই বাতিল করে না) তাই ইনপুটটি কখনও ফাঁকা থাকে না empty
— iBug
1
তাহলে আপনি কেন আইআইএস ২৩৩ এর সম্পাদনা পরামর্শ (লিঙ্ক) প্রত্যাখ্যান করলেন ?
— ব্যবহারকারী 202729

উত্তর:

10

হাস্কেল , 44 42 বাইট

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

এটি অনলাইন চেষ্টা করুন! সম্পাদনা করুন: -২ বাইট জাগরবকে ধন্যবাদ!

ব্যাখ্যা:

দ্বিতীয় লাইন একটি ফাংশন সংজ্ঞা দেয় (#)যা একটি স্ট্রিং sএবং একটি অক্ষর নেয় xএবং মুছে ফেলা বা সংযোজন সম্পাদন করে। এই করে এটা করা যায় filterপ্রতিটি সংঘটন আউট ing xমধ্যে s, স্ট্রিং ফলে z। যদি xনা হয়s তবে zতার সমান হয় sএবং সংযোজন z++[x|z==s]সহ মূল স্ট্রিং দেয় x। অন্যথায় [x|z==s]খালি স্ট্রিং দেয় এবং কেবল পরিশোধিত স্ট্রিংই ফিরে আসে।

foldl(#)""একটি বেনাম ফাংশন যা একটি স্ট্রিং নেয় এবং ""ফাংশনটির সাথে প্রাথমিকভাবে খালি স্ট্রিংয়ের পরে অন্য একটি অক্ষর যুক্ত করে(#) ।

— Laikoni
সূত্র
2
ফিল্টার পুনরায় ব্যবহার করে 42 বাইট ।
— Zgarb
9

জেলি , 3 বাইট

œ^/

এটি অনলাইন চেষ্টা করুন!

পুরো প্রোগ্রাম।

— এরিক দ্য আউটগল্ফার
সূত্র
কেন œ^/পর্যাপ্ত নয়?
— জোনাথন অ্যালান
@ জোনাথান অ্যালান প্রোগ্রামটি কোনও ত্রুটি সহ বের হওয়া উচিত নয় ।
— এরিক দি আউটগল্ফার
the input is never emptyঠিক আছে, এখন এটি কাজ করে।
— ব্যবহারকারী 202729
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

* - উপরের দ্বারা গুণিত অন্যথায় 0 দ্বারা গানের ক্ষেত্রে অক্ষরের শেষ অবস্থানের জন্য 1 দ্বারা গুণকে গুণিত করে ~:&.| 

   ]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

#~- ডান আর্গুমেন্টটি বাম দিক থেকে অনুলিপি করুন। বার (gs আর্গুমেন্টগুলির স্থানগুলি বিপরীত করে)

]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 বাইট ওভার সাশ্রয় করে ।
— janrjan জোহানসেন
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 বাইট ধন্যবাদ জহুরিওকে

ব্যাখ্যা

লজুরিও একটি forলুপ এড়িয়ে একটি দুর্দান্ত আর উত্তর সরবরাহ করেছিল - যেহেতু আর প্রোগ্রামাররা সহজাতভাবে একটি নিয়ম হিসাবে করেন (আমার অন্তর্ভুক্ত)। এখানে একটি আর উত্তর যা একটি 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সংযোজন করুনiiy
  • cat(y,sep='')- yতাদের মধ্যে কোনও স্থান ছাড়াই উপাদানগুলির মুদ্রণ করুন

বিঃদ্রঃ

আপনি যদি উপরের টিআইও লিঙ্কটিতে ক্লিক করেন তবে আপনি শিরোনামে খুঁজে পাবেন 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
@ জজুরিও - আমি জানি, এটি প্রায় কখনও হয় নি যে ল-র জন্য লুপ কোনও কিছুতে সহায়তা করবে। আপনার পরামর্শ সম্পর্কে: দুর্দান্ত ধারণা! পরামর্শটি এখন উত্তরে অন্তর্ভুক্ত করা হয়েছে।
— ডাকমায়ার
1
@ ডিঝুরিও - যথেষ্ট ফর্সা; বাদ দেওয়া অন্য বিবৃতি বাদ দিয়ে প্রবর্তিত পার্থক্যটি দেখার জন্য আমি খুব ব্যস্ত ছিলাম আপনি কীভাবে শুরুটি পরিবর্তন করেছিলেন তা আমি দেখিনি। এখন সম্পাদনা করা হচ্ছে। মহান কাজ!
— ডাকমায়ার
1
@ ডিজুরিও @ ইডুক্মায়ার এর একটি 73 বাইট সমাধান রয়েছে যা মূলত এই সমাধানটি গ্রহণ করছে এবং অক্ষর আহরণের জন্য কিছুটা ভিন্ন পদ্ধতির ব্যবহার করছে। এটি আলাদা উত্তর হিসাবে পোস্ট করার মতো সত্য আমার মনে হয়নি। এছাড়াও মনে রাখবেন ...[[1]]চেয়ে দীর্ঘতর হয় el(...)কিন্তু চেয়ে খাটো unlist(...), তবে শর্ত থাকে যে ...দৈর্ঘ্য 1. একটি তালিকা রয়েছে
— : Giuseppe
1
যে স্ক্র্যাচ, আমি একটি পাওয়া 70 বিদায় উত্তর যেহেতু 0হয় nulচরিত্র ও খালি স্ট্রিং রূপান্তরিত হয়।
— জিউসেপ
2

এমএটিএল , 6 বাইট

vi"@X~

টিআইও পরিবেশে কাজ করে না, তবে ম্যাটল্যাব বাস্তবায়নে দুর্দান্ত কাজ করে এবং একটি নতুন প্যাচকে ধন্যবাদ, আপনি এটি এমএটিএল অনলাইনে চেষ্টা করতে পারেন

X~সমান setxor, বা প্রতিসম পার্থক্য, যা চ্যালেঞ্জটি জিজ্ঞাসা করে ঠিক তাই করে। বাকীটি কেবল ইনপুটটির উপরে লুপিং করছে i"@এবং শুরুর দিকে শূন্য থাকা পুরো স্ট্যাকটি সংক্ষেপে খালি স্ট্রিং দিয়ে শুরু করা হচ্ছে (ধন্যবাদ লুইস মেন্ডো)।

— Sanchises
সূত্র
2

পাইথন 2 , 56 বাইট

-2 বাইটস xnor ধন্যবাদ। -3 বাইট ovs ধন্যবাদ।

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

এটি অনলাইন চেষ্টা করুন!

আক্ষরিকভাবে কেবল সিউডোকোডটি গল্ফ করেছে। : P: P

— totallyhuman
সূত্র
1
Save 2 bytes: s=(s+c).replace(c,c[c in s:]).
— xnor
@xnor That's some basic golfing executed very cleverly. Thanks!
— totallyhuman
1
-1 byte : s=s.replace(c,'')+c[c in s:]
— ovs
1
56 bytes using reduce
— ovs
1

JavaScript (ES6), 60 bytes

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

Test cases

Show code snippet

— Arnauld
সূত্র
I ported @MartinEnder's Retina answer and it was only 45 bytes...
— Neil
1

APL+WIN, 19 bytes

Logic similar to Galen's J solution.

(2|+⌿⌽<\⌽c∘.=c)/c←⎕
— Graham
সূত্র
1

Wolfram Language (Mathematica), 36 bytes

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

Try it online!

Takes input and output as a list of characters.

How it works

Uses //. (alias ReplaceRepeated) to find two repeated characters and delete both, until no more repeated characters exist. If the character occurs more than twice, Mathematica will always delete the first two occurrences. So if a character occurs an odd number of times, its last instance will always be the one to survive.

— Misha Lavrov
সূত্র
1

Prolog 81 byte

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)).

Non-obfuscated version:

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 ensures that its third argument unifies with its first argument, with all instances of second argument removed from it.
  2. If those turn out to be the same, we append the element (it wasn't removed).
  3. append/3 as per its name, appends an element to list.
  4. We recur on the elements of the input until we hit the [] (empty list), at which point the intermediate result will unify with desired result.

Test:

?- 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 = "".

Some Prologs treat strings in double quotes as lists, SWI can be configured to do the same, but for the sake of simplicity, I used string_codes/2 to format output nicely.

— wvxvw
সূত্র
1

R, 84 bytes

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

Try it online!

Another solution, but there are better R answers here.

R, 88 bytes

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

Try it online!

Thanks to Giuseppe for -7 bytes!

There is a shorter answer by duckmayr.

  1. scan(,"") read input from stdin.
  2. y<-el(strsplit(scan(,""),"")) split input by characters and save as y.
  3. z=table(y<-el(strsplit(scan(,""),""))) compute frequencies of each character and save resulting table as z;
  4. unique(y,,T) take unique characters from the right side.
  5. names(z[!z%%2]) select only even counts and extract names.
  6. setdiff(unique(y,,T),names(z[!z%%2])) remove characters with even count.
  7. cat(setdiff(unique(y,,T),names(z[!z%%2])),sep="") print the output.
— djhurio
সূত্র
The reason for your error is that el() comes from the methods package, which while typically loaded by default, is not by TIO (discussed in my answer below)
— duckmayr
why are you using rev(unique(rev(y)))? Wouldn't just unique(y) work? ooohhh wait I see, you want the unique characters from right to left. In that case unique(y,,T) (setting fromLast=T) will be 88 bytes.
— Giuseppe
0

Alice, 9 bytes

/X&@
\io/

Try it online!

Explanation

Basically a port of Erik's answer. Apart from a bit of IP redirection the code is really just:

i&Xo@

which does:

i   Read all input.
&X  Fold symmetric multiset difference over the input.
o   Output the result.
@   Terminate.
— Martin Ender
সূত্র
0

Ruby, 53 bytes

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

Try it online!

Input and output are both an array of chars. Test code calls .chars and .join for convenience.

Explanation

Uses the fact that the letters in the resulting string appear an odd number of times and in the order from right to left.

->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
}
— Justin Mariner
সূত্র
0

Pyth, 13 bytes

{_xD_Qf%/QT2Q

Takes in input as list of characters. Test it out!

      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
— Steven H.
সূত্র
0

Röda, 34 bytes

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

Try it online!

This is a direct translation of the pseudocode. It treats input and output as streams of characters.

Explanation:

{                    /* 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

Python 3, 73 bytes

Not the shortest, but I like this approach.

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

Try it online!

Loops through the string, keeping only those characters where:

  • (s.count(c)%2) == 0 - The character appears an even number of times.
  • (i==s.rfind(c)) - The current index is the last appearance of the character in question.
— FlipTack
সূত্র
0

REXX, 102 bytes

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

Try it online!

How it works: Take the rightmost letter, see if the number of occurrences is even or odd (which also doubles as a truth value) and if odd, add it to the output string. Then remove all occurrences of the letter from the input string. Repeat until input is depleted.

— idrougge
সূত্র
0

Java 8, 93 bytes

A lambda from String to String. Just an implementation of the pseudocode in the question.

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

Try It Online

Java 8, 182 bytes

Here's another lambda of the same type that uses streams! It's probably more efficient.

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))

Try It Online

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)
    )
— Jakob
সূত্র
0

R, 70 bytes

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

Try it online!

I was encouraged by djhurio to post this solution; djhurio's answer can be found here.

This uses the same idea as duckmayr's answer, but it leverages a numeric approach by converting the string to its codepoints rather than splitting it into characters, and is a function rather than a full program so it can return the new string rather than printing to stdout.

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
}

One important observation is that F is initialized to FALSE or 0 and utf8ToInt(0)=="", so this will succeed for the empty string as well as correctly collapsing the codepoints.

— Giuseppe
সূত্র
0

SNOBOL4 (CSNOBOL4), 97 95 bytes

	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

Try it online!

	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
— Giuseppe
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.