Dada uma cadeia de entrada contendo apenas os personagens A-Z, a-ze espaços, remova todas as ocorrências das versões maiúsculas e minúsculas do primeiro caractere da string (se o primeiro caractere é Aremover todos os As e as, se o primeiro personagem é (espaço) remove todos os espaços) e imprima a saída.

Casos de exemplo:

• Testing Testing One Two Three -> esing esing One wo hree
• Programming Puzzles and Code Golf -> rogramming uzzles and Code Golf
• How much wood would a woodchuck chuck if a woodchuck could chuck wood -> ow muc wood would a woodcuck cuck if a woodcuck could cuck wood
• {space}hello world -> helloworld
• welcome to WATER WORLD -> elcome to ATER ORLD

Este é o código-golfe , o código mais curto em bytes vence!

Notas:

• A entrada sempre terá 2 ou mais caracteres válidos.
• A saída nunca será uma sequência vazia.

Pitão, 7 bytes

-zrBhz2

Experimente on-line: Demonstration or Test Suite

Agradável. O novo operador de bifurcação (com apenas 8 dias) ajuda aqui a economizar um caractere. Eu acho que este é o primeiro código, que usa esse recurso.

Explicação

-zrBhz2   implicit: z = input string
    hz    take the first character of z
  rB  2   B generates a list, containing the original char and the  
          result of r.2 applied to the char, which swaps the case
-z        remove these two chars from z and print the result 

brainfuck, 219 bytes

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

(Requer fita que permita que o ponteiro vá para os negativos ou faça um loop até o fim, se tentar. Também exige ,retornar 0 no EOF. Na minha experiência, a maioria dos intérpretes atende a esses requisitos por padrão.)

Isso acabou sendo bastante fácil! Eu não ficaria surpreso se fosse jogável (tenho uma idéia de onde pode haver bytes desperdiçados, mas não tenho muita certeza se isso ocorrerá). Ainda assim, fazê-lo funcionar não foi realmente um desafio.

Esse código trata tudo com um valor ASCII abaixo de 97 como um caractere maiúsculo. Se o primeiro caractere for espaço, ele tentará remover quaisquer ocorrências de um "espaço em minúsculas" (ou chr(32+32)seja @) da string. Tudo bem, porque apenas letras e espaços estarão presentes.

Com comentários:

to make comments shorter: everywhere it says "fc" means "first character"

#################################### GET FC ####################################

+[+[>+<+<]>]        shortest way to get 96
                    any number above 89 and less than 97 would work because this
                    is only for figuring out if the first character is capital

,[<+<+>>-]          create two copies of the first character


### current tape: | fc | fc | 000 | 096 | ###
###      pointer:              ^          ###

########################### FIND MAX(FC MINUS 96; 0) ###########################


>[                  96 times:

  <<                  go to the cell with the first char

  [->]                if not 0: sub one and move right


  ### current tape: | fc | char being worked on | 000 | 096 | ###
  ###      pointer:                           ^ OR ^          ###      


  >[<]>               collapse the wavefunction; sync the branches

-]


### current tape: | fc | fc is lowercase ? nonzero : zero | 000 | 000 | ###
###      pointer:                                                  ^    ###

############################# GET BOTH CASES OF FC #############################

++++[<++++++++>-]   get 32 (add to uppercase character to get lowercase)

<<[                 if the character is already lowercase:

  [-]                 clear the lowercase flag

  ----[>-<----]>-     sub 64 from the cell with 32

<]

<[>+>+<<-]          add fc to the 32 or minus 32 to get both cases


### current tape: | 000 | fc | other case of fc | ###
###      pointer:    ^                            ###

###################### LOOP THROUGH REMAINING CHARACTERS #######################

<,[                 for each character:

  [>+>>>+>>+>+<<<<<<<-]
                      make four copies
                      (only 3 are strictly needed; 4th will resync a branch)

  >>                  go to the first case of fc

  [<<+>>-]<<[>->+<<-] subtract one case of fc from one copy

  >[[-]+<]            if the result is nonzero set it to 1

  >[>]<<              go to the other case of fc (and resync branches)

  [>>+<<-]>>[<-<+>>-] subtract other case of fc from other copy

  <[[-]+>]            if the result is nonzero set it to 1

  >>[<]               resync branches using extra copy

  <<<<[>>>+<<<-]>>>   add results together

  -                   subtract 1

   if the character exactly matched either case: 1 plus 0 minus 1 = 0
  if the character exactly matched neither case: 1 plus 1 minus 1 = 1
    if the character exactly matched both cases: impossible

  [                   if the result is 1:

    >>.<<               output character

    -                   set cell to 0 to kill loop

  ]

  >>>[[-]<]           clean up remaining copies

  <<<<<,              get next character; or end loop if done

]

Perl, 13 bytes

#!perl -p
/./,s/$&//gi

Contando o shebang como um, a entrada é obtida de stdin.

Uso da amostra

$ echo Testing Testing One Two Three | perl remove-first.pl
esing esing One wo hree

$ echo \ Testing Testing One Two Three | perl primo-remove.pl
TestingTestingOneTwoThree

CJam, 8 bytes

q(_32^+-

Experimente online no intérprete CJam .

Como funciona

q        e# Read all input from STDIN.
 (       e# Shift out the first character.
  _32^   e# Push a copy and XOR its character code with 32.
         e#   For a letter, this swaps its case.
         e#   For a space, this pushes a null byte.
      +  e# Concatenate these two characters.
       - e# Remove all occurrences of both from the input string.

Pitão, 8 bytes

-zr*2hz3

Experimente online

Usa a versão do Pyth str.titlepara converter uma string da primeira letra duas vezes no formulário "<Upper><Lower>". Em seguida, ele remove cada elemento da entrada que está nessa sequência. Os espaços funcionam bem porque não são afetados str.title.

MATLAB, 28 bytes

@(S)S(lower(S)~=lower(S(1)))

JavaScript (ES6), 38 36 bytes

Isso não depende do flagsparâmetro específico do Mozilla.

f=x=>x.replace(RegExp(x[0],'gi'),'')

CoffeeScript, 39 37 bytes

Pela primeira vez, é mais curto em JS do que em CoffeeScript!

f=(x)->x.replace RegExp(x[0],'gi'),''

PHP, 41 bytes

Leva um argumento de linha de comando . Tags abertas curtas precisam ser ativadas para PHP <5.4.

<?=str_ireplace($argv[1][0],'',$argv[1]);

Perl, 27 bytes

Este é um programa completo, embora seja baseado apenas em 2 regexes que provavelmente poderiam ser copiados em um programa Retina para salvar bytes na E / S.

$_=<>;m/(.)/;s/$1//gi;print

Edit: Parece que isso já foi espancado com alguém usando a -popção. Ah, e usando em $&vez de $1.

Tamanho 0.9 , 23 33 bytes

De jeito nenhum isso vai ganhar, mas eh, é divertido!

" Z"od0c`1c*-$I[odd0c`1c*-2c=?O].

Experimente aqui.

Explicação

" Z"                                 Makes it easier to uppercase
    od                               Take first character of input and duplicate
      0c`1c*-                        Uppercase if needed
             $I[               ]     Loop over the input
                odd                  Take character from input and duplicate twice
                   0c`1c*-           If it's lowercase, uppercase it.
                          0c=?       Check to see if it's equal to first character
                              O      If not, output as character
                                .    Exit

(Isso pode falhar em alguns casos extremos, como se o primeiro caractere fosse um símbolo.)

TECO , 15 14 bytes

Editando texto? Em caso de dúvida, use o Editor de texto e o controlador!

Após muitas tentativas e erros (principalmente erros), acho que este é o programa TECO genérico mais curto que fará o trabalho.

0,1XA<S^EQA$-D>

Ou, de forma legível por humanos

0,1XA    ! Read the first character of the string into the text area of !
         ! Q-buffer A.                                                  !
<        ! Loop,                                                        !
S^EQA$   ! searching for the text in Q-buffer A in either lowercase or  !
         ! uppercase,                                                   !
-D       ! and deleting it,                                             !
>        ! until the search fails.                                      !

$representa a tecla de escape e ^Erepresenta a sequência CTRL+ E. Dependendo do sabor do TECO que você está usando, ele pode reconhecer essas substituições ASCII ou não.

De acordo com o manual, alguns dialetos do TECO aceitam esta versão de 13 bytes (usando um comando find-and-delete em vez de comandos "find" e "delete" separados):

0,1XA<FD^EQA$>

Pip, 8 bytes

aR-Xa@0x

Toma a string como argumento da linha de comando (precisará ser citado se contiver espaços). Explicação:

          a gets cmdline arg; x is "" (implicit)
    a@0   First character of a
   X      Convert to regex
  -       Make regex case-insensitive
aR     x  Replace all matches of that regex in a with empty string
          Autoprint (implicit)

Esta solução tem a vantagem adicional de trabalhar em seqüências contendo quaisquer caracteres ASCII imprimíveis. (O Xoperador faz uma barra invertida - escapa qualquer coisa que não seja alfanumérica.)

Python, 66 caracteres

a=raw_input()
print a.replace(a[0],'').replace(a[0].swapcase(),'')

Julia, 34 bytes

s->replace(s,Regex(s[1:1],"i"),"")

Isso cria uma função sem nome que aceita uma string e retorna uma string. Ele constrói uma expressão regular que não diferencia maiúsculas de minúsculas do primeiro caractere na entrada e substitui todas as ocorrências disso por uma sequência vazia.

Mathematica, 47 bytes

StringDelete[#,#~StringTake~1,IgnoreCase->1>0]&

R, 43 bytes

cat(gsub(substr(s,1,1),"",s<-readline(),T))

Este é um programa completo que lê uma linha de STDIN e grava o resultado modificado em STDOUT.

Ungolfed:

# Read a line from STDIN
s <- readline()

# Replace all occurrences of the first character with an empty
# string, ignoring case
r <- gsub(substr(s, 1, 1), "", s, ignore.case = TRUE)

# Write the result to STDOUT
cat(r)

Ruby, 25 bytes

Função anônima:

->s{s.gsub /#{s[0]}/i,""}

Prgram completo, 29 bytes:

puts gets.gsub /#{$_[0]}/i,""

Python, 61 bytes (muitos)

lambda x:"".join(map(lambda y:(y.lower()!=x[0].lower())*y,x))

Imagino que exista uma maneira melhor de fazer isso, mas não consigo encontrá-lo. Alguma idéia sobre como remover o "".join(...)?

Ouroboros , 61 bytes

Ei, é mais curto que C ++! Ha.

i..91<\64>*32*+m1(
)L!34*.(;Si.1+!24*(Y.@@.@=@.@32-=\@+2*.(yo

Em Ouroboros, cada linha do programa representa uma cobra com o rabo na boca. O fluxo de controle é realizado ao comer ou regurgitar seções da cauda, ​​com uma pilha compartilhada para sincronizar entre cobras.

Cobra 1

i.lê um caractere da entrada e o duplica. .91<\64>*32*empurra 32se o caractere for uma letra maiúscula, 0caso contrário. +Isso significa que o caractere converte letras maiúsculas em minúsculas, mantendo as letras minúsculas e os espaços inalterados. Tudo isso está ocorrendo na pilha da cobra 1, então agora transferimos o valor para a pilha compartilhada ( m) para a cobra 2 processar. Finalmente,1( come o último caractere do rabo da cobra 1. Como é aí que está o ponteiro das instruções, a cobra morre.

Cobra 2

)não tem efeito na primeira vez. L!34*empurra 34se a pilha compartilhada estiver vazia, 0caso contrário. Em seguida, .enganamos e (comemos tantos personagens.

• Se a pilha compartilhada estava vazia, isso coloca o fim da cobra logo após o (que acabamos de executar. Portanto, o controle volta ao início da linha, onde )regurgita os caracteres que acabamos de comer (depois de enviar uma cópia extra de34 ) e repita o teste de tamanho da pilha.
• Se a pilha compartilhada não estiver vazia, nenhum caractere será consumido, ';' descarta o extra 0e a execução continua:

Sialterna para a pilha compartilhada e insere outro caractere. .1+!24*empurra 24se esse caractere for -1 / EOF, 0caso contrário. Um de,( engole 24 caracteres - incluindo o IP - e a cobra morre. Caso contrário, a execução continuará.

Ypuxa uma cópia do topo da pilha compartilhada (o personagem que acabamos de ler) na própria pilha de 2 para uso futuro. Em seguida, .@@.@=@.@32-=\@+2*calcula se o novo caractere é igual ao primeiro caractere ou ao primeiro caractere menos 32, pressionando 2se sim e 0não. Nós .duplicar e (comer que muitos personagens:

• Se os personagens corresponderem, voltamos direto para a cabeça da cobra, onde (regurgitamos os 2 caracteres que acabamos de comer e a execução prossegue com o próximo personagem.
• Caso contrário, retiramos yo personagem da pilha de snake 2, outilizamos e depois fazemos o loop.

Veja em ação

// Define Stack class
function Stack() {
  this.stack = [];
  this.length = 0;
}
Stack.prototype.push = function(item) {
  this.stack.push(item);
  this.length++;
}
Stack.prototype.pop = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack.pop();
    this.length--;
  }
  return result;
}
Stack.prototype.top = function() {
  var result = 0;
  if (this.length > 0) {
    result = this.stack[this.length - 1];
  }
  return result;
}
Stack.prototype.toString = function() {
    return "" + this.stack;
  }

// Define Snake class
function Snake(code) {
  this.code = code;
  this.length = this.code.length;
  this.ip = 0;
  this.ownStack = new Stack();
  this.currStack = this.ownStack;
  this.alive = true;
  this.wait = 0;
  this.partialString = this.partialNumber = null;
}
Snake.prototype.step = function() {
    if (!this.alive) {
      return null;
    }
    if (this.wait > 0) {
      this.wait--;
      return null;
    }
    var instruction = this.code.charAt(this.ip);
    var output = null;
    if (this.partialString !== null) {
      // We're in the middle of a double-quoted string
      if (instruction == '"') {
        // Close the string and push its character codes in reverse order
        for (var i = this.partialString.length - 1; i >= 0; i--) {
          this.currStack.push(this.partialString.charCodeAt(i));
        }
        this.partialString = null;
      } else {
        this.partialString += instruction;
      }
    } else if (instruction == '"') {
      this.partialString = "";
    } else if ("0" <= instruction && instruction <= "9") {
      if (this.partialNumber !== null) {
        this.partialNumber = this.partialNumber + instruction; // NB: concatenation!
      } else {
        this.partialNumber = instruction;
      }
      next = this.code.charAt((this.ip + 1) % this.length);
      if (next < "0" || "9" < next) {
        // Next instruction is non-numeric, so end number and push it
        this.currStack.push(+this.partialNumber);
        this.partialNumber = null;
      }
    } else if ("a" <= instruction && instruction <= "f") {
      // a-f push numbers 10 through 15
      var value = instruction.charCodeAt(0) - 87;
      this.currStack.push(value);
    } else if (instruction == "$") {
      // Toggle the current stack
      if (this.currStack === this.ownStack) {
        this.currStack = this.program.sharedStack;
      } else {
        this.currStack = this.ownStack;
      }
    } else if (instruction == "s") {
      this.currStack = this.ownStack;
    } else if (instruction == "S") {
      this.currStack = this.program.sharedStack;
    } else if (instruction == "l") {
      this.currStack.push(this.ownStack.length);
    } else if (instruction == "L") {
      this.currStack.push(this.program.sharedStack.length);
    } else if (instruction == ".") {
      var item = this.currStack.pop();
      this.currStack.push(item);
      this.currStack.push(item);
    } else if (instruction == "m") {
      var item = this.ownStack.pop();
      this.program.sharedStack.push(item);
    } else if (instruction == "M") {
      var item = this.program.sharedStack.pop();
      this.ownStack.push(item);
    } else if (instruction == "y") {
      var item = this.ownStack.top();
      this.program.sharedStack.push(item);
    } else if (instruction == "Y") {
      var item = this.program.sharedStack.top();
      this.ownStack.push(item);
    } else if (instruction == "\\") {
      var top = this.currStack.pop();
      var next = this.currStack.pop()
      this.currStack.push(top);
      this.currStack.push(next);
    } else if (instruction == "@") {
      var c = this.currStack.pop();
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(c);
      this.currStack.push(a);
      this.currStack.push(b);
    } else if (instruction == ";") {
      this.currStack.pop();
    } else if (instruction == "+") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a + b);
    } else if (instruction == "-") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a - b);
    } else if (instruction == "*") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a * b);
    } else if (instruction == "/") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a / b);
    } else if (instruction == "%") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(a % b);
    } else if (instruction == "_") {
      this.currStack.push(-this.currStack.pop());
    } else if (instruction == "I") {
      var value = this.currStack.pop();
      if (value < 0) {
        this.currStack.push(Math.ceil(value));
      } else {
        this.currStack.push(Math.floor(value));
      }
    } else if (instruction == ">") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a > b));
    } else if (instruction == "<") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a < b));
    } else if (instruction == "=") {
      var b = this.currStack.pop();
      var a = this.currStack.pop();
      this.currStack.push(+(a == b));
    } else if (instruction == "!") {
      this.currStack.push(+!this.currStack.pop());
    } else if (instruction == "?") {
      this.currStack.push(Math.random());
    } else if (instruction == "n") {
      output = "" + this.currStack.pop();
    } else if (instruction == "o") {
      output = String.fromCharCode(this.currStack.pop());
    } else if (instruction == "r") {
      var input = this.program.io.getNumber();
      this.currStack.push(input);
    } else if (instruction == "i") {
      var input = this.program.io.getChar();
      this.currStack.push(input);
    } else if (instruction == "(") {
      this.length -= Math.floor(this.currStack.pop());
      this.length = Math.max(this.length, 0);
    } else if (instruction == ")") {
      this.length += Math.floor(this.currStack.pop());
      this.length = Math.min(this.length, this.code.length);
    } else if (instruction == "w") {
      this.wait = this.currStack.pop();
    }
    // Any instruction not covered by the above cases is ignored
    if (this.ip >= this.length) {
      // We've swallowed the IP, so this snake dies
      this.alive = false;
      this.program.snakesLiving--;
    } else {
      // Increment IP and loop if appropriate
      this.ip = (this.ip + 1) % this.length;
    }
    return output;
  }

// Define Program class
function Program(source, speed, io) {
  this.sharedStack = new Stack();
  this.snakes = source.split(/\r?\n/).map(function(snakeCode) {
    var snake = new Snake(snakeCode);
    snake.program = this;
    snake.sharedStack = this.sharedStack;
    return snake;
  }.bind(this));
  this.snakesLiving = this.snakes.length;
  this.io = io;
  this.speed = speed || 10;
  this.halting = false;
}
Program.prototype.run = function() {
  if (this.snakesLiving) {
    this.step();
    this.timeout = window.setTimeout(this.run.bind(this), 1000 / this.speed);
  }
}
Program.prototype.step = function() {
  for (var s = 0; s < this.snakes.length; s++) {
    var output = this.snakes[s].step();
    if (output) {
      this.io.print(output);
    }
  }
}
Program.prototype.halt = function() {
  window.clearTimeout(this.timeout);
}
var ioFunctions = {
  print: function(item) {
    var stdout = document.getElementById('stdout');
    stdout.value += "" + item;
  },
  getChar: function() {
    if (inputData) {
      var inputChar = inputData[0];
      inputData = inputData.slice(1);
      return inputChar.charCodeAt(0);
    } else {
      return -1;
    }
  },
  getNumber: function() {
    while (inputData && (inputData[0] < "0" || "9" < inputData[0])) {
      inputData = inputData.slice(1);
    }
    if (inputData) {
      var inputNumber = inputData.match(/\d+/)[0];
      inputData = inputData.slice(inputNumber.length);
      return +inputNumber;
    } else {
      return -1;
    }
  }
};
var program = null;
var inputData = null;

function resetProgram() {
  var stdout = document.getElementById('stdout');
  stdout.value = null;
  if (program !== null) {
    program.halt();
  }
  program = null;
  inputData = null;
}

function initProgram() {
  var source = document.getElementById('source'),
    stepsPerSecond = document.getElementById('steps-per-second'),
    stdin = document.getElementById('stdin');
  program = new Program(source.value, +stepsPerSecond.innerHTML, ioFunctions);
  inputData = stdin.value;
}

function runBtnClick() {
  if (program === null || program.snakesLiving == 0) {
    resetProgram();
    initProgram();
  } else {
    program.halt();
    var stepsPerSecond = document.getElementById('steps-per-second');
    program.speed = +stepsPerSecond.innerHTML;
  }
  program.run();
}

function stepBtnClick() {
  if (program === null) {
    initProgram();
  } else {
    program.halt();
  }
  program.step();
}

.container {
  width: 100%;
}
.so-box {
  font-family: 'Helvetica Neue', Arial, sans-serif;
  font-weight: bold;
  color: #fff;
  text-align: center;
  padding: .3em .7em;
  font-size: 1em;
  line-height: 1.1;
  border: 1px solid #c47b07;
  -webkit-box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
  text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
  background: #f88912;
  box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
}
.control {
  display: inline-block;
  border-radius: 6px;
  float: left;
  margin-right: 25px;
  cursor: pointer;
}
.option {
  padding: 10px 20px;
  margin-right: 25px;
  float: left;
}
h1 {
  text-align: center;
  font-family: Georgia, 'Times New Roman', serif;
}
a {
  text-decoration: none;
}
input,
textarea {
  box-sizing: border-box;
}
textarea {
  display: block;
  white-space: pre;
  overflow: auto;
  height: 40px;
  width: 100%;
  max-width: 100%;
  min-height: 25px;
}
span[contenteditable] {
  padding: 2px 6px;
  background: #cc7801;
  color: #fff;
}
#stdout-container,
#stdin-container {
  height: auto;
  padding: 6px 0;
}
#reset {
  float: right;
}
#source-display-wrapper {
  display: none;
  width: 100%;
  height: 100%;
  overflow: auto;
  border: 1px solid black;
  box-sizing: border-box;
}
#source-display {
  font-family: monospace;
  white-space: pre;
  padding: 2px;
}
.activeToken {
  background: #f88912;
}
.clearfix:after {
  content: ".";
  display: block;
  height: 0;
  clear: both;
  visibility: hidden;
}
.clearfix {
  display: inline-block;
}
* html .clearfix {
  height: 1%;
}
.clearfix {
  display: block;
}

<!--
Designed and written 2015 by D. Loscutoff
Much of the HTML and CSS was taken from this Befunge interpreter by Ingo Bürk: http://codegolf.stackexchange.com/a/40331/16766
-->
<div class="container">
<textarea id="source" placeholder="Enter your program here" wrap="off">i..96<\64>*32*+m1(
)L!34*.(;Si.1+!24*(Y.@@.@=@.@32-=\@+2*.(yo</textarea>
<div id="source-display-wrapper"><div id="source-display"></div></div></div><div id="stdin-container" class="container">
<textarea id="stdin" placeholder="Input" wrap="off">Testing Testing One Two Three</textarea>
</div><div id="controls-container" class="container clearfix"><input type="button" id="run" class="control so-box" value="Run" onclick="runBtnClick()" /><input type="button" id="pause" class="control so-box" value="Pause" onclick="program.halt()" /><input type="button" id="step" class="control so-box" value="Step" onclick="stepBtnClick()" /><input type="button" id="reset" class="control so-box" value="Reset" onclick="resetProgram()" /></div><div id="stdout-container" class="container"><textarea id="stdout" placeholder="Output" wrap="off" readonly></textarea></div><div id="options-container" class="container"><div class="option so-box">Steps per Second:
<span id="steps-per-second" contenteditable>1000</span></div></div>

C, 60 bytes

n,c,d;main(){for(;read(0,&c-n,1);n=2)d-c&31&&n&&putchar(d);}

Edit: Corrigido um bug que fazia com que um byte nulo fosse impresso no início

Python 2, 43

lambda s:s.translate(None,(s[0]*2).title())

Isso é um pouco baseado na minha resposta Pyth, mas também está relacionado a alguns comentários de ThomasKwa e xnor daqui . Principalmente postando porque eu queria que essa resposta existisse.

Vim, 30 pressionamentos de tecla

Desculpe desenterrar, mas não vejo nenhuma resposta Vim D:

If<Right>xh@x.<Esc>"xy07|@x2|~0"xd7|@x0x

Explicação:

1. If<Right>xh@x.<Esc>
   Escreva uma macro (recursiva) ao redor do primeiro caractere É necessário
   mover para a esquerda ( h) para permanecer à esquerda do próximo caractere não lido.
   Adicionando qualquer caractere (. ) no final, caso o segundo precise ser removido.
2. "xy0 Copie a macro no registro x
3. 7| Mover para o sétimo caractere
4. @x Execute a macro de x
5. 2|~ Alterne entre maiúsculas e minúsculas (primeiro na segunda posição)
6. 0"xd7| Cortar a macro no registro x
7. @x Execute a macro de x
8. 0x Retire o marcador .

Haskell, 52 bytes

import Data.Char
t=toUpper
r(h:s)=filter((t h/=).t)s

TI-BASIC, 164 bytes

Para calculadoras gráficas da série TI-83 + / 84 +.

Input Str1
1→X
"sub(Str1,X,1→u
"ABCDEFGHIJKLMNOPQRSTUVWXYZ zyxwvutsrqponmlkjihgfedcba
u+sub(Ans,54-inString(Ans,u),1
For(X,2,length(Str1
If 2<inString(Ans+Str1,u
Ans+u
End
sub(Ans,3,length(Ans)-2

O TI-BASIC é claramente a ferramenta errada para o trabalho.

• Ele não possui um comando para remover caracteres, portanto, precisamos percorrer a string e acrescentar caracteres se eles não corresponderem ao que deve ser removido.
• Ele não suporta seqüências de caracteres vazias; portanto, precisamos iniciar a sequência com as duas letras a serem removidas, criar a saída até o final e cortar os dois primeiros caracteres.
• Ele não possui comandos de mudança de maiúsculas e minúsculas, portanto, precisamos codificar o alfabeto inteiro ...
  • duas vezes...
  • Mencionei que letras minúsculas ocupam dois bytes cada na codificação TI-BASIC?

Não tenho 100% de certeza, mas passei mais de seis horas nisso e parece ser a solução mais curta possível.

Para testar isso com entradas não maiúsculas (ou digitá-lo na sua calculadora), crie um programa diferente com o conteúdo AsmPrgmFDCB24DEC9e execute-o usando Asm([whatever you named it]para ativar o modo de digitação em minúsculas.

Lua, 93 78 bytes

a=io.read()m=a:sub(1,1):upper()print(({a:gsub("["..m..m:lower().."]","")})[1])

Lisp comum, 77

(princ(let((x(read-char)))(remove-if(lambda(y)(char-equal x y))(read-line))))

Amaldiçoe esses nomes de função longos (e parênteses (mas eu ainda os amo mesmo assim (: 3))).

C, 65 bytes

main(c,v)char**v;{for(c=**++v;*++*v;**v-c&31&&putchar(**v));}

Compila com avisos. Lê a string de argv[1]. Exemplo online

C ++, 100 99 98 bytes

#include<ios>
int main(){for(int c,f=getchar();~(c=getchar());)tolower(c)-tolower(f)&&putchar(c);}

Apenas mais um byte para ficar abaixo de 100. getchar()retorna -1quando lê o final do fluxo, é por isso que o ciclo ~está em forandamento. (~-1 == 0 )

Ungolfed

#include <ios>
int main()
{
    for (int c, f = getchar(); ~(c = getchar()); )
        tolower(c) - tolower(f) && putchar(c);
}

AppleScript, 209 201 bytes

Meu único consolo é que venci Brainfuck.

defina o texto de a para (exibir "" resposta padrão "") retornado
defina n como o número de caracteres de
defina o como ""
repita n
se não o caractere de a, n = o caractere 1, defina o como o caractere a, n & o
defina n para n-1
fim
o

Como isso funciona é que eu passo a entrada a, obtenho o comprimento ae o marco como n, e defino uma variável de saída o. Para cada caractere que considero que não contém o primeiro caractere de a ( a's character 1), concateno-o para o. A linha final é impressa o.

Nota: Isso suporta automaticamente todos os Unicode. c:

Retina , 16 bytes

i`(.)(?<=^\1.*)

Salve o código com um avanço de linha à direita e execute-o com o -s bandeira.

Como funciona: o avanço de linha à direita faz deste um estágio de substituição, de forma que quaisquer correspondências do regex especificado sejam substituídas por uma sequência vazia. As ivoltas no modo case-insensitive que também faz case-insensitive backreferences. Por fim, a regex simplesmente corresponde e captura um único caractere e, em seguida, verifica se o primeiro caractere da sequência é o mesmo (conforme o caso) usando uma referência anterior.