डुप्लिकेट और स्विच किए गए मामले को निकालें


27

लक्ष्य

इस चुनौती का लक्ष्य है: इनपुट के रूप में एक स्ट्रिंग दिया जाता है, अक्षरों के डुप्लिकेट जोड़े को हटा दें, यदि जोड़ी में दूसरा आइटम विपरीत पूंजीकरण का है। (यानी अपरकेस लोअरकेस और इसके विपरीत हो जाता है)।

जोड़े को बाएं से दाएं से बदला जाना चाहिए। उदाहरण के लिए, aAaबनना चाहिए aaऔर नहीं aA

उदाहरण

निवेश निर्गम:

Input:         Output:  
bBaAdD         bad     
NniIcCeE       Nice    
Tt eE Ss tT    T e S t 
sS Ee tT       s E t   
1!1!1sStT!     1!1!1st!
nN00bB         n00b    
(eE.gG.)       (e.g.)  
Hh3lL|@!       H3l|@!
Aaa            Aa
aaaaa          aaaaa
aaAaa          aaaa

इनपुट में मुद्रण योग्य ASCII प्रतीक शामिल हैं।

आपको डुप्लिकेट अंकों या अन्य गैर-अक्षर वर्णों को नहीं निकालना चाहिए।

अभिस्वीकृति

यह चुनौती @nicael के "डुप्लीकेट और स्विच केस" के विपरीत है । क्या आप इसे उल्टा कर सकते हैं?

सैंडबॉक्स से सभी योगदानकर्ताओं के लिए धन्यवाद !

सूची

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


4
Haha, कि NniIcCeE :)
nicael

@nicael मुझे खुशी है कि आप मंजूर हैं :)
aloisdg

के लिए उत्पादन क्या है abB:? abBया ab?
डाउनगेट

@Downgoat abBको आउटपुट देना चाहिएab
aloisdg का कहना है कि Reicaate Monica

1
@raznagul क्यों होगा? इसे विभाजित करें aa:; aA; AA, केवल मध्य जोड़ी पैटर्न से मेल खाती है और बन जाती है a, इसलिए aa; a; AA
LLAMAMYP

जवाबों:


12

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

ṛŒsḟḟȧµ\

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

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

ṛŒsḟḟȧµ\  Main link. Argument: s (string)

      µ   Convert all links to the left into a chain (unknown arity) and begin a
          new chain.
       \  Do a cumulative reduce by the chain to the left.
          Left argument:   r (previous result or first character)
          Right argument:  c (next character)
ṛ           Set the return value to c.
 Œs         Swap c's case.
    ḟ       Remove c from r (if present).
            This yields an empty string if c and r are identical (repeated letter
            with the same case or non-letter) and r otherwise.
            Note that r will be empty if the previous character has been removed.
   ḟ        Remove the resulting characters (if any) from c with swapped case.
            This yields c with swapped case if the result to the right does not
            contain c; otherwise, it yields the empty string.
     ȧ      Flat logical AND with c.
            Replace swapped case c with c; do not modify an empty string.

रेगेक्स लानत की तुलना में कम!
aloisdg का कहना है कि मोनिका

2
एक पर रेटिना मारो स्ट्रिंग चुनौती ._।
TuxCrafting

11

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

(.)(?!\1)(?i)\1
$1

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

व्याख्या

यह एकल (और काफी सरल) प्रतिस्थापन है जो प्रासंगिक जोड़े से मेल खाता है और उन्हें केवल पहले चरित्र के साथ बदल देता है। पैटर्न के माध्यम से केस-असंवेदनशीलता को सक्रिय करके जोड़े का मिलान किया जाता है:

(.)     # Match a character and capture it into group 1.
(?!\1)  # Use a negative lookahead to ensure that the next character *isn't* the same
        # as the character we just captured. This doesn't advance the position of the
        # regex engine's "cursor".
(?i)    # Now activate case-insensitivity for the remainder of the pattern.
\1      # Match the second character with a backreference to the first. With the i
        # modifier activated, this will match if the two characters only differ
        # by case.

प्रतिस्थापन केवल उस चरित्र को वापस लिखते हैं जिसे हमने पहले ही समूह में 1वैसे भी कैप्चर किया था ।


1
अच्छा जवाब! डीबगेज इस के साथ बहुत अच्छा काम करता है!
aloisdg का कहना है कि Monica

5

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

.v|.l1|hA,?bhB(@uA;A@uB),?bb&~b.hA|?b&~b.h~h?

Brachylog का कोई नियमित अभिव्यक्ति नहीं है।

व्याख्या

    .v          Input = Output = ""
|               OR
    .l1         Input = Output = string of one character
|               OR
    hA,         A is the first char or the Input
    ?bhB        B is the second char of the Input
    (
        @uA         B uppercased is A
        ;           OR
        A@uB        A uppercased is B
    ),
    ?bb&        Call recursively on Input minus the first two elements
    ~b.hA       Output is the result of that call with A appended before it
|               OR
    b&          Call recursively on Input minus the first element
    ~b.h~h?     Output is the result of that call with the first element of Input appended
                  before it

5

सी #, 87 75 बाइट्स

s=>System.Text.RegularExpressions.Regex.Replace(s,@"(.)(?!\1)(?i)\1","$1");

मार्टिन एंडर से शक्तिशाली रेगेक्स के साथ । C # लंबो जहां इनपुट और आउटपुट हैं string

मार्टिन एंडर और TtesxCräftgñg द्वारा सहेजे गए 12 बाइट्स।


सी #, 141 134 बाइट्स

s=>{var r="";for(int i=0,l=s.Length;i<l;i++){var c=s[i];r+=c;if(char.IsLetter(c)&i+1<l&&(c|32)==(s[i+1]|32)&c!=s[i+1])i++;}return r;};

C # लंबो जहां इनपुट और आउटपुट हैं string। एल्गोरिदम भोला है। यह वह है जिसे मैं संदर्भ के रूप में उपयोग करता हूं।

कोड:

s=>{
    var r = "";
    for(int i = 0; i < s.Length; i++)
    {
        r+=s[i];
        if (char.IsLetter(s[i]) & i+1 < s.Length)
            if (char.ToLower(s[i])==char.ToLower(s[i+1])
              & char.IsLower(s[i])!=char.IsLower(s[i+1]))
                i += 1;
    }       
    return r;
};

मार्टिन एंडर को 7 बाइट्स धन्यवाद!


उन्हें ऑनलाइन कोशिश करो!


@ T @xCräftîñg वास्तव में लेकिन इस तरह से पढ़ना आसान है। एक कम
क्रिया के

4

पर्ल, 40 24 + 1 = 25 बाइट्स

मार्टिन के समान रेगेक्स का उपयोग करें। झंडे का
इस्तेमाल करें-p

s/(.)(?!\1)(?i)\1/\1/g

इसे आइडोन पर टेस्ट करें


यदि आप -p फ्लैग का उपयोग करते हैं, तो आप एक अच्छी बचत के लिए s /// को छोड़कर लगभग सभी कोड हटा सकते हैं!
डोम हेस्टिंग्स

4

पायथन 3, 64 59 58 बाइट्स

r=input()
for c in r:r=c[c.swapcase()==r!=c:];print(end=r)

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


4

सी, 66 बाइट्स

l;main(c){for(;~(c=getchar());)l=l^c^32|!isalpha(c)?putchar(c):0;}

3

पायथ, 24 20 बाइट्स

4 बाइट्स @Jakube की बदौलत।

यह अभी भी रेगेक्स का उपयोग करता है, लेकिन सिर्फ टोकन के लिए।

shM:zj\|+s_BVGrG1\.1

परीक्षण सूट।

shM:zj\|+s_BVGrG1\.1   input as z
         s_BVGrG1      generate ['aA', 'Aa', 'bB', 'Bb', ..., 'zZ', 'Zz']
        +        \.    add "." to the back of the array
     j\|               insert "|" between every element of the array,
                       forming a new long string, which will be our
                       tokenizer: "aA|Aa|bB|Bb|cC|Cc|...|yY|Yy|zZ|Zz|."
                       the "." at the end is to capture the remaining characters
  :z               1   return all matches of z against that regex
                       this is effectively a tokenizer
 hM                    take the first character of each token
s                      join all the transformed tokens together, and then
                       implicitly print to STDOUT.

3

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

s=>s.replace(/./g,c=>l=c!=l&&c>'0'&&parseInt(c+l,36)%37<1?'':c,l='')

स्पष्टीकरण:

s=>s.replace(/./g,c=>   Loop over each character in the string
 l=                     Save result for next loop
  c!=l&&                Check whether characters differ
  c>'@'&&               Check minimum character code
  parseInt(c+l,36)%37<1 Check if characters have same value
  ?'':c,                If so then delete this character
 l='')                  Initial empty previous character

यह देखते हुए c>'@', के लिए एक ही रास्ता parseInt(c+l,36)37 के गुणक में होना करने के लिए दोनों के लिए है cऔर lएक ही मूल्य है करने के लिए (वे शून्य मान क्योंकि हम अंतरिक्ष और शून्य बाहर रखने के लिए नहीं कर सकते हैं, और अगर वे कोई मूल्य नहीं है तो अभिव्यक्ति के मूल्यांकन करेंगे NaN<1जो है असत्य) उनके लिए एक ही अक्षर होना है। हालांकि, हम जानते हैं कि वे समान रूप से एक ही पत्र केस-संवेदी नहीं हैं, इसलिए उन्हें एक ही मामला असंवेदनशील होना चाहिए।

ध्यान दें कि यह एल्गोरिथम केवल तभी काम करता है जब मैं हर वर्ण की जांच करता हूं; अगर मैं अक्षरों पर मेल करके इसे सरल बनाने की कोशिश करता हूं तो यह चीजों की तरह विफल हो जाएगा "a+A"

संपादित करें: सहेजे गए 3 बाइट @ edc65 के लिए धन्यवाद।


नक्शे के बजाय प्रतिस्थापित का उपयोग करें। 68. लेकिन मैं एक टिप्पणी के अंदर '`' का पता लगाने के लिए बहुत आलसी हूं (अच्छी चाल mod 37)
edc65

@ edc65 `अगर मुझे उपयोग करने की कोई आवश्यकता नहीं है replace। (मैं केवल उन्हें सुसंगत बनाने की कोशिश करने से पहले था, लेकिन फिर मैंने अपना जवाब देते हुए इसे प्रस्तुत करने के लिए संपादित किया और फिर से असंगत हो गया। आहें ...)
नील

3

सी, 129 127 125 107 106 105 93 92 90 88 85 78 बाइट्स

c;d;f(char*s){for(;putchar(c=*s);)s+=isalpha(c)*(d=*++s)&&(!((c^d)&95)&&c^d);}

मेरे C # उत्तर का AC पोर्ट । मेरा C थोड़ा खराब हो सकता है। मैं अब भाषा का बहुत उपयोग नहीं करता। किसी भी मदद का स्वागत है!

  • 1 बाइट ने लॉजेकर की चाल के लिए धन्यवाद बचाया : a!=b=a^b
  • 1 बाइट ने Walpen की चाल के लिए धन्यवाद बचाया : a&&b=a*b
  • लिन की चाल से 12 बाइट्स बच गए और TCxCräftgñg से प्रेरित है
  • 1 बाइट ने जॉय एडम्स की चाल के लिए धन्यवाद को बचाया और orlp द्वारा यहां प्रेरित किया: वैश्विक परिवर्तनशील चर
  • मेरी (c|32)==(d|32)बिटवाइज़ समस्या का समाधान करके SEJPM द्वारा सहेजे गए 2 बाइट्स
  • 5 बाइट्स Pietu1998 द्वारा सहेजे गए

कोड:

c;d;f(char*s) {
    for(;putchar(c=*s);)
        s+=isalpha(c)*(d=*++s)&&(!((c^d)&95)&&c^d);
}

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


1
मुझे लगता है कि आप कुछ बाइट्स को बचाने के लिए पॉइंटर को बढ़ा सकते हैं। मैंने इसे ( f(char*s){while(*s) {char c=*s,d=s+1;putchar(c);s+=isalpha(c)&&d&&((c|32)==(d|32)&&c!=d);}}
अप्राप्त

@ T @xCräftîñg मैं इस बारे में भूल गया। मैंने लिन जवाब के आधार पर आपके प्रस्ताव को सही किया। सहायता के लिए धनयवाद!
aloisdg का कहना है कि मोनिका

1
मुझे लगता है कि आप बदल सकते हैं s+++1करने के लिए ++s
पुरकाकूदरी

@ Pietu1998 वास्तव में मैं कर सकता हूँ!
अलयसडग का कहना है कि मोनिका जूल

1
cऔर dहमेशा मुद्रण योग्य ASCII होगा, इसलिए 95इसके स्थान पर काम करना चाहिए ~32। इसके अलावा, मुझे लगता है c;d;f(char*s){for(;*s;){putchar(c=*s);s+=isalpha(c)*(d=*(++s))&&(!((c^d)&95)&&c^d);}}कि काम करेगा (लेकिन निष्कलंक)।
पुरकाकूदरी

3

MATL , 21 बाइट्स

"Kk@k=K@XK=>?4XKx}K&h

इसे ऑनलाइन आज़माएं! । या सभी परीक्षण मामलों को सत्यापित करें

व्याख्या

यह प्रत्येक वर्ण को लूप में संसाधित करता है। प्रत्येक पुनरावृत्ति पिछले चरित्र के साथ वर्तमान चरित्र की तुलना करती है। उत्तरार्द्ध क्लिपबोर्ड K में संग्रहीत किया जाता है, जिसे 4डिफ़ॉल्ट रूप से आरंभ किया जाता है।

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

यदि वर्तमान वर्ण हटा दिया जाता है क्लिपबोर्ड K को रीसेट किया जाना चाहिए (ताकि अगला वर्ण रखा जाएगा); अन्यथा इसे वर्तमान चरित्र के साथ अद्यतन किया जाना चाहिए।

"            % Take input string implicitly. For each char from this string:
  K          %   Push previous char, initiallized to number 4
  k          %   Convert to lower case. For numbers it rounds down
  @          %   Push current char
  k          %   Convert to lower case. 
  =          %   True if current and previous chars are (case-insensitively) equal
  K          %   Push previous char
  @          %   Push current char
  XK         %   Update clipboard K with current char. This doesn't affect the stack
  =          %   True if current and previous chars are (case-sensitively) equal
  >?         %   If first comparison was true and second was false
    4XKx     %     Reset clipboard K to 4
  }          %   Else
    K        %     Push previous char
    &h       %     Concatenate horizontally to gradually build the output string

2

जावा 7, 66 बाइट्स

String c(String i){return i.replaceAll("(.)(?!\\1)(?i)\\1","$1");}

अपने रेटिना जवाब से मार्टिन एंडर के रेगेक्स का इस्तेमाल किया ।

Ungolfed और परीक्षण कोड:

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

class Main{
  static String c(String i){
    return i.replaceAll("(.)(?!\\1)(?i)\\1", "$1");
  }

  public static void main(String[] a){
    System.out.println(c("bBaAdD"));
    System.out.println(c("NniIcCeE"));
    System.out.println(c("Tt eE Ss tT"));
    System.out.println(c("sS Ee tT"));
    System.out.println(c("1!1!1sStT!"));
    System.out.println(c("nN00bB"));
    System.out.println(c("(eE.gG.)"));
    System.out.println(c("Hh3lL|@!"));
    System.out.println(c("Aaa"));
    System.out.println(c("aaaaa"));
    System.out.println(c("aaAaa"));
  }
}

आउटपुट:

bad
Nice
T e S t
s E t
1!1!1st!
n00b
(e.g.)
H3l|@!
Aa
aaaaa
aaaa

2

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

s=>s.replace(/./g,c=>l=c!=l&/(.)\1/i.test(l+c)?'':c,l='')

5 बाइट बचाने के लिए नील को धन्यवाद ।


1
बुरी खबर: आप गलतफहमी है, और वह वास्तव में 62 बाइट्स है। अच्छी खबर: मैं तुम्हें पाँच बाइट्स बचा सकता हूँ! s=>s.replace(/./g,c=>l=c!=l&/(.)\1/i.test(l+c)?'':c,l='')
नील

ओह, क्षमा करें, मैंने प्रयोग करके गिना "code".length, महसूस नहीं किया कि वहाँ एक भागने का क्रम था। धन्यवाद
CPU1

प्रयोग करके देखें (code).toString().length
नील

हाँ, या(code+"").length
cPu1

1

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

(s,p,q)=>s.replace(/./g,c=>p!=c&q===(d=parseInt(c,36))?q='':(q=d,p=c))

f=(s,p,q)=>s.replace(/./g,c=>p!=c&q===(d=parseInt(c,36))?q='':(q=d,p=c))

;
[['bBaAdD','bad']
,['NniIcCeE','Nice']
,['Tt eE Ss tT','T e S t']
,['sS Ee tT','s E t']
,['1!1!1sStT!','1!1!1st!']
,['nN00bB','n00b']
,['(eE.gG.)','(e.g.)']
,['Hh3lL|@!','H3l|@!']
,['Aaa','Aa']
,['aaaaa','aaaaa']
,['aaAaa','aaaa']]
.forEach(
  x=>
  {
    var i=x[0],k=x[1],r=f(i)
    console.log(k==r?'OK':'KO',i,r)
  }
)


ठीक है, मैं काटता हूँ। क्यों ===?
नील

0==""लेकिन नहीं 0===""@ @ नील
edc65

1

उत्तल, 18 बाइट्स

V±V.+'.+'|*\ô{0=}%

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

@Leaky Nun's Pyth के उत्तर के समान दृष्टिकोण । यह सरणी का निर्माण करता ["aA" "bB" ... "zZ" "Aa" "Bb" ... "Zz" '.]है, '|चरित्र द्वारा जुड़ता है , और उस रेगेक्स पर आधारित इनपुट का परीक्षण करता है। फिर यह प्रत्येक मैच का पहला चरित्र लेता है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.