删除重复和已切换的案例

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的“复制和切换案例”相反。你可以逆转吗？

感谢您对沙盒的所有贡献！

目录

这篇文章底部的Stack Snippet从答案a）生成目录，答案是每种语言的最短解决方案列表，b）则是总体排行榜。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

## 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说恢复莫妮卡
source
4
哈哈，那是NniIcCeE :)
— nicael
@nicael我很高兴您批准:)
— aloisdg说恢复莫妮卡
输出的内容是abB什么？abB还是ab？
— Downgoat
@Downgoat abB应该输出ab
— aloisdg说恢复莫妮卡
1
@raznagul为什么会呢？拆分起来：aa; aA; AA，只有中间对匹配模式并成为a，因此aa; a; AA
— LLlAMnYP '16

Answers:

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.
— 丹尼斯
source
比正则表达式该死的还短！
— aloisdg说恢复莫妮卡
2
在弦乐挑战._ 上击败Retina 。
— TuxCrafting's
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无论如何，替换只是写回我们已经在组中捕获的字符。

— 马丁·恩德
source
1
好答案！Debuggex可以很好地配合这一工具！
— aloisdg说恢复莫妮卡
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
— 致命
source
5

C＃，87 75字节

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

来自Martin Ender 的强大正则表达式。C＃lambda输入和输出为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＃lambda输入和输出为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说恢复莫妮卡
source
@TùxCräftîñg的确如此，但很容易阅读。检查我的高尔夫球版本，以得到较不冗长的答案:)
— aloisdg说莫妮卡
4

Perl，40个 24 + 1 = 25个字节

使用与Martin相同的正则表达式。
使用-p标志

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

在ideone上测试

— Tux工艺
source
如果使用-p标志，则可以删除除s ///之外的几乎所有代码，以节省大量时间！
— Dom Hastings
4

C，66字节

l;main(c){for(;~(c=getchar());)l=l^c^32|!isalpha(c)?putchar(c):0;}
— 奥尔普
source
3

Pyth，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.
— 漏尼姑
source
3

JavaScript（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个字节。

— 尼尔
source
使用replace代替map。68.但是我太懒了，无法弄清楚如何在评论中添加“`”（技巧37）
— edc65 '16
@ edc65 `如果使用，我不需要任何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＃回答的。我的C可能有点不好。我不再使用该语言了。欢迎任何帮助！

  • 借助Lowjacker的技巧，节省了1个字节：a!=b=a^b
  • Walpen的把戏节省了1个字节：a&&b=a*b
  • Lynn的保存了12个字节 技巧并在这里受到了TùxCräftîñg的启发
  • 由于Joey Adams的节省了1个字节 把戏，并受到orlp的启发：将变量移动到全局
  • SEJPM通过解决我的问题节省了2个字节 (c|32)==(d|32)按位问题
  • Pietu1998保存的5个字节

码：

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

在线尝试！

— aloisdg说恢复莫妮卡
source
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 '16
@TùxCräftîñg我忘了这个。我根据林恩的答案纠正了您的主张。感谢您的帮助！
— aloisdg说恢复莫妮卡
1
我认为您可以更改s+++1为++s。
— PurkkaKoodari
@ Pietu1998确实可以！
— aloisdg说恢复莫妮卡
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'7
3

MATL，21字节

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

在线尝试！。或验证所有测试用例。

说明

这将循环处理每个字符。每次迭代都会将当前字符与前一个字符进行比较。后者存储在剪贴板K中，4默认情况下被初始化。

当前字符与前一个字符进行两次比较：首先不区分大小写，然后区分大小写。当且仅当第一个比较为true而第二个为false时，才应删除当前字符。请注意，由于剪贴板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
— 路易斯·门多
source
2

Java 7，66字节

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

使用了马丁·恩德（Martin Ender）在视网膜答案中的正则表达式。

取消测试代码：

在这里尝试。

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
— 凯文·克鲁伊森
source
2

JavaScript（ES6），61字节，57字节

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

感谢Neil节省了5个字节。

— cPu1
source
1
坏消息：您误算了，实际上是62个字节。好消息：我可以为您节省五个字节！s=>s.replace(/./g,c=>l=c!=l&/(.)\1/i.test(l+c)?'':c,l='')
— 尼尔
哦，对不起，我数过了"code".length，却没有意识到里面有一个转义序列。谢谢
— cPu1 '16
尝试使用(code).toString().length。
— 尼尔
是的，或者(code+"").length
— cPu1 '16
1

JavaScript（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
source
好我会咬 为什么===呢？
— 尼尔
0==""但不是0===""@Neil
— edc65 '16
1

凸，18个字节

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

在线尝试！

与@Leaky Nun的Pyth答案相似的方法。它构造数组["aA" "bB" ... "zZ" "Aa" "Bb" ... "Zz" '.]，按'|字符连接，并基于该正则表达式测试输入。然后，它采用每个匹配项的第一个字符。

— GamrCorps
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.