중복 및 전환 된 사례 제거

27

골

이 과제의 목표는 문자열을 입력으로 지정하고 쌍의 두 번째 항목이 대문자가 아닌 경우 중복 문자 쌍을 제거하는 것입니다. (즉 대문자는 소문자가되고 반대로도됩니다).

쌍은 왼쪽에서 오른쪽으로 교체해야합니다. 예를 들어, and가 아니 aAa어야합니다 .aaaA

예

입력 및 출력 :

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의 "중복 및 전환 사례"와 반대입니다 . 당신은 그것을 되돌릴 수 있습니까?

샌드 박스의 모든 기고자 에게 감사합니다 !

목록

이 게시물의 맨 아래에있는 스택 스 니펫은 답변 a) 언어 당 가장 짧은 솔루션 목록으로, b) 전체 리더 보드로 카탈로그를 생성합니다.

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

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

코드 스 니펫 표시

code-golf  string 
— aloisdg 말한다 Reinstate Monica
소스
4
하하, 그것은 NicIcCeE입니다 :)
— nicael
@nicael 난 당신이 승인 기쁘다 :)
— aloisdg 말한다 Reinstate Monica
결과는 무엇 abB입니까? abB또는 ab?
— Downgoat
@Downgoat abB가 출력되어야 함ab
— aloisdg는 Reinstate Monica
1
@raznagul 왜 그럴까요? 나누기 : aa; aA; AA단 중간 쌍의 패턴과 일치하게된다 a그래서 aa; a; AA
— LLlAMnYP

답변:

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는 Reinstate Monica
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
좋은 대답입니다! Debuggex 는 이것으로 훌륭하게 작동합니다!
— aloisdg는 Reinstate Monica
5

Brachylog , 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

C #, 87 75 바이트

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

Martin Ender 의 강력한 정규식 으로. 입력과 출력은 C # 1 람다 string.

Martin Ender와 TùxCräftîñg가 12 바이트를 절약했습니다.

C #, 141134 바이트

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 # 1 람다 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;
};

Martin Ender 덕분에 7 바이트!

온라인으로 사용해보십시오!

— aloisdg 말한다 Reinstate Monica
소스
@ TùxCräftîñg 실제로는 다음과 같이 읽기 쉽습니다. :) 대답 자세한 덜 내 golfed 버전을 확인합니다
— aloisdg는 분석 재개 모니카 말한다
4

펄, 40 24 + 1 = 25 바이트

Martin과 같은 정규식을 사용하십시오. 깃발을
사용-p

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

이데온에서 테스트

— 턱시도
소스
-p 플래그를 사용하면 s ///를 제외한 거의 모든 코드를 제거하여 효과적으로 저장할 수 있습니다!
— Dom Hastings
4

파이썬 3, 64 59 58 바이트

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

Ideone에서 테스트하십시오 .

— 데니스
소스
4

C, 66 바이트

l;main(c){for(;~(c=getchar());)l=l^c^32|!isalpha(c)?putchar(c):0;}
— 오르프
소스
3

Pyth, 24 20 바이트

@Jakube 덕분에 4 바이트.

이것은 여전히 ​​정규 표현식을 사용하지만 토큰 화에만 사용됩니다.

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.
  • 24 바이트 버전은 여기 입니다.
— 새는 수녀
소스
3

자바 스크립트 (ES6), 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있는가 false)는 같은 글자입니다. 그러나 문자가 대소 문자를 구분하지 않기 때문에 대소 문자를 구분하지 않아야합니다.

이 알고리즘은 모든 문자를 확인한 경우에만 작동합니다. 글자를 일치시켜 단순화하려고하면 다음과 같은 것들에서 실패합니다 "a+A".

편집 : @ edc65 덕분에 3 바이트가 절약되었습니다.

— 닐
소스
맵 대신 바꾸기를 사용하십시오. 68. 그러나 주석 안에 '`'를 넣는 방법을 알아 내기에는 너무 게으르다 (좋은 속임수 37)
— edc65
@ edc65을 `사용하는 경우 s 가 필요하지 않습니다 replace. (나는 단지 일관성을 유지하려고 노력했지만 제출을 위해 편집하는 동안 내 대답을 골퍼하고 다시 일관성이 없어졌습니다. 한숨 ....)
— Neil
3

C, 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는 약간 나쁠 수 있습니다. 나는 더 이상 언어를 많이 사용하지 않습니다. 어떤 도움이라도 환영합니다!

  • Lowjacker의 트릭으로 인해 1 바이트가 절약되었습니다 . a!=b=a^b
  • Walpen의 트릭 덕분에 1 바이트가 절약되었습니다 . a&&b=a*b
  • Lynn의 트릭으로 저장 하고 TùxCräftîñg에서 영감을 얻은 12 바이트
  • Joey Adams의 비법 덕분에 1 바이트가 절약 되고 orlp에서 영감을 얻었습니다. 변수를 전역으로 이동
  • (c|32)==(d|32)비트 문제 를 해결하여 SEJPM이 2 바이트를 절약했습니다.
  • Pietu1998에 의해 5 바이트 절약

암호:

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

온라인으로 사용해보십시오!

— aloisdg 말한다 Reinstate Monica
소스
1
포인터를 증가시켜 바이트를 절약 할 수 있다고 생각합니다. :이 (테스트되지 않은) 발견f(char*s){while(*s) {char c=*s,d=s+1;putchar(c);s+=isalpha(c)&&d&&((c|32)==(d|32)&&c!=d);}}
— TuxCrafting
@ TùxCräftîñg 나는 이것에 대해 잊었다. Lynn의 답변을 바탕으로 귀하의 제안을 수정했습니다. 도와 주셔서 감사합니다!
— aloisdg는 Reinstate Monica
1
나는 당신이 바꿀 수 있다고 생각 s+++1에 ++s.
— PurkkaKoodari
@ Pietu1998 실제로 할 수 있습니다!
— aloisdg는 Reinstate Monica
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);}}작동 할 것이라고 생각 하지만 테스트되지 않았습니다.
— PurkkaKoodari
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");}

사용 그의 망막 응답에서 마틴 청산의 정규식 .

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

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

자바 스크립트 (ES6), 61 바이트 , 57 바이트

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

5 바이트를 절약 해 준 Neil 에게 감사 합니다.

— cPu1
소스
1
나쁜 소식 : 잘못 계산 한 것은 실제로 62 바이트입니다. 좋은 소식 : 5 바이트를 절약 할 수 있습니다! s=>s.replace(/./g,c=>l=c!=l&/(.)\1/i.test(l+c)?'':c,l='')
— Neil
아, 죄송합니다,를 사용하여 계산 "code".length했는데 거기에 이스케이프 시퀀스가 ​​있다는 것을 몰랐습니다. 감사합니다
— cPu1
를 사용해보십시오 (code).toString().length.
— Neil
네, 또는(code+"").length
— cPu1
1

자바 스크립트 (ES6) 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)
  }
)
스 니펫 확장

— edc65
소스
알았어. 왜 ===?
— Neil
0==""하지만 0===""@Neil
— edc65
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.