Dada una cadena de entrada que solo contiene los caracteres A-Z, a-zy espacios, elimine todas las apariciones de las versiones en mayúsculas y minúsculas del primer carácter de la cadena (si el primer carácter es Aeliminar todos los Asy as, si el primer carácter es (espacio) eliminar todos los espacios) e imprima la salida.

Ejemplos de casos:

• 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 es el código de golf , el código más corto en bytes gana.

Notas:

• La entrada siempre será de 2 o más caracteres válidos.
• La salida nunca será una cadena vacía.

Pyth, 7 bytes

-zrBhz2

Pruébelo en línea: Demostración o conjunto de pruebas

Agradable. El nuevo operador bifurcado (solo 8 días de antigüedad) ayuda aquí a ahorrar un carbón. Creo que este es el primer código que usa esta función.

Explicación

-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

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

(Requiere cinta que permita que el puntero vaya a los negativos o bucles hasta el final si lo intenta. También requiere ,devolver 0 en EOF. En mi experiencia, la mayoría de los intérpretes cumplen estos requisitos de forma predeterminada).

¡Esto en realidad resultó ser bastante fácil! No me sorprendería si es golfable (tengo alguna idea de dónde podría haber bytes desperdiciados, pero no estoy muy seguro de si funcionará). Aún así, hacerlo funcionar no fue realmente un desafío en absoluto.

Este código trata todo con un valor ASCII por debajo de 97 como un carácter en mayúscula. Si el primer carácter es el espacio, intentará eliminar cualquier aparición de un "espacio en minúscula" (es decir chr(32+32), es decir @) de la cadena. Esto está bien, porque solo las letras y los espacios estarán presentes.

Con comentarios:

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 el shebang como uno, la entrada se toma de stdin.

Uso de muestra

$ 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^+-

Pruébelo en línea en el intérprete de CJam .

Cómo 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.

Pyth, 8 bytes

-zr*2hz3

Pruébalo en línea

Utiliza la versión de Python de Python str.titlepara convertir una cadena de la primera letra dos veces en el formulario "<Upper><Lower>". Luego, elimina cada elemento de la entrada que está en esa cadena. Los espacios funcionan bien porque no se ven afectados por ellos str.title.

MATLAB, 28 bytes

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

JavaScript (ES6), 38 36 bytes

Esto no depende del flagsparámetro específico de Mozilla.

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

CoffeeScript, 39 37 bytes

¡Por una vez es más corto en JS que CoffeeScript!

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

PHP, 41 bytes

Toma un argumento de línea de comandos . Las etiquetas abiertas cortas deben estar habilitadas para PHP <5.4.

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

Perl, 27 bytes

Este es un programa completo, aunque solo se basa en 2 expresiones regulares que probablemente podrían copiarse en un programa Retina para guardar bytes en E / S.

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

Editar: Parece que esto ya ha sido golpeado con alguien que usa la -popción. Ah, y usando en $&lugar de $1.

Minkolang 0.9 , 23 33 bytes

De ninguna manera esto ganará, pero eh, ¡es divertido!

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

Pruébalo aquí

Explicación

" 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

(Esto puede fallar en algunos casos extremos, como si el primer carácter es un símbolo).

TECO , 15 14 bytes

¿Edición de texto? En caso de duda, utilice el editor de texto y el corrector.

Después de mucho ensayo y error (principalmente error), creo que este es el programa TECO genérico más corto que hará el trabajo.

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

O, en forma legible 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 la tecla de escape, y ^E representa la secuencia CTRL+ E. Dependiendo del sabor de TECO que esté usando, puede reconocer estas sustituciones ASCII, o puede que no.

De acuerdo con el manual, algunos dialectos de TECO aceptan esta versión de 13 bytes (usando un comando de buscar y eliminar en lugar de los comandos separados "buscar" y "eliminar") en su lugar:

0,1XA<FD^EQA$>

Pip, 8 bytes

aR-Xa@0x

Toma la cadena como un argumento de línea de comandos (deberá ser citado si contiene espacios). Explicación:

          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 solución tiene la ventaja adicional de trabajar en cadenas que contengan cualquier caracteres ASCII imprimibles. (La Xbarra diagonal inversa del operador escapa a todo lo que no sea alfanumérico).

Python, 66 char

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

Julia, 34 bytes

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

Esto crea una función sin nombre que acepta una cadena y devuelve una cadena. Construye una expresión regular que no distingue entre mayúsculas y minúsculas a partir del primer carácter en la entrada y reemplaza todas las apariciones de eso con una cadena vacía.

Mathematica, 47 bytes

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

R, 43 bytes

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

Este es un programa completo que lee una línea de STDIN y escribe el resultado modificado en STDOUT.

Sin golf:

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

Rubí, 25 bytes

Función anónima:

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

Programa completo, 29 bytes:

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

Python, 61 bytes (demasiados)

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

Me imagino que hay una mejor manera de hacerlo, pero parece que no puedo encontrarlo. ¿Alguna idea sobre cómo eliminar el "".join(...)?

Ouroboros , 61 bytes

¡Hola, es más corto que C ++! Decir ah.

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

En Ouroboros, cada línea del programa representa una serpiente con la cola en la boca. El flujo de control se logra comiendo o regurgitando secciones de la cola, con una pila compartida para sincronizar entre las serpientes.

Serpiente 1

i.lee un carácter de entrada y lo duplica. .91<\64>*32*empuja 32si el carácter era una letra mayúscula, de lo 0contrario. +Al convertir esto en caracteres, las letras mayúsculas se convierten en minúsculas y se dejan las letras minúsculas y los espacios sin cambios. Todo esto ha tenido lugar en la pila de la serpiente 1, por lo que ahora enviamos el valor a la pila compartida ( m) para que la serpiente 2 lo procese. Finalmente,1( come el último personaje de la cola de la serpiente 1. Como ahí es donde está el puntero de instrucción, la serpiente muere.

Serpiente 2

)no tiene efecto la primera vez. L!34*empuja 34si la pila compartida está vacía, de lo 0contrario. Luego nos .duplicamos y (comemos tantos personajes.

• Si la pila compartida estaba vacía, esto pone el final de la serpiente justo después del (que acabamos de ejecutar. Por lo tanto, los bucles de control vuelven al principio de la línea, donde )regurgita los caracteres que acabamos de comer (habiendo empujado previamente una copia adicional de 34) y repite la prueba de longitud de la pila.
• Si la pila compartida no estaba vacía, no se comen caracteres, ';' suelta el extra 0y la ejecución continúa:

Sicambia a la pila compartida e ingresa otro carácter. .1+!24*empuja 24si ese personaje era -1 / EOF, de lo 0contrario. En EOF, se (traga 24 caracteres, incluida la IP, y la serpiente muere. De lo contrario, la ejecución continúa.

Ytira de una copia de la parte superior de la pila compartida (el personaje que acabamos de leer) a la propia pila de la serpiente 2 para uso futuro. Luego .@@.@=@.@32-=\@+2*calcula si el nuevo personaje es igual al primer personaje o al primer personaje menos 32, presionando 2si es así y 0si no. Hemos .duplicado y (comemos ese número de caracteres:

• Si los personajes coinciden, volvemos directamente a la cabeza de la serpiente, donde ( regurgita los 2 personajes que acabamos de comer y la ejecución continúa con el siguiente personaje.
• Si no, yrecuperamos el carácter de la pila de la serpiente 2, lo opronunciamos y luego hacemos un bucle.

Véalo en acción

// 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);}

Editar: se corrigió un error que causaba que se imprimiera un byte nulo al principio

Pitón 2, 43

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

Esto está algo basado en mi respuesta de Pyth, pero también está relacionado con algunos comentarios de ThomasKwa y xnor de aquí . Principalmente publicando porque quería que esta respuesta existiera.

Vim, 30 pulsaciones de teclas

Perdón por descubrir, pero no veo ninguna respuesta Vim D:

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

Explicación:

1. If<Right>xh@x.<Esc>
   Escriba una macro (recursiva) alrededor del primer carácter
   Se hnecesita mover a la izquierda ( ) para permanecer a la izquierda del siguiente carácter no leído Se necesita
   agregar cualquier carácter ( .) al final en caso de que se deba eliminar el segundo
2. "xy0 Copie la macro en el registro x
3. 7| Moverse al séptimo personaje
4. @x Ejecute la macro desde x
5. 2|~ Cambia la caja del primer personaje (en realidad en la segunda posición)
6. 0"xd7| Cortar la macro en el registro x
7. @x Ejecute la macro desde x
8. 0x Retire el marcador de posición .

Haskell, 52 bytes

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

TI-BASIC, 164 bytes

Para calculadoras gráficas de la serie 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

TI-BASIC es claramente la herramienta incorrecta para el trabajo.

• No tiene un comando para eliminar caracteres, por lo que debemos recorrer la cadena y agregar caracteres si no coinciden con lo que se va a eliminar.
• No admite cadenas vacías, por lo que debemos comenzar la cadena con las dos letras que se eliminarán, generar la salida en el extremo y cortar los primeros dos caracteres.
• No tiene comandos de cambio de mayúsculas y minúsculas, por lo que debemos codificar todo el alfabeto ...
  • dos veces...
  • ¿Mencioné que las letras minúsculas toman dos bytes cada una en la codificación TI-BASIC?

No estoy 100% seguro, pero pasé más de seis horas en esto, y parece ser la solución más corta posible.

Para probar esto con entradas no mayúsculas (o para escribirlo en su calculadora), haga un programa diferente con el contenido AsmPrgmFDCB24DEC9y ejecútelo Asm([whatever you named it]para habilitar el modo de escritura en minúsculas.

Lua, 93 78 Bytes

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

Lisp común, 77

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

Maldecir estos nombres largos de funciones (y paréntesis (pero todavía los amo de todos modos (: 3))).

C, 65 61 bytes

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

Compila con advertencias. Lee una cadena de argv[1]. Ejemplo en línea

C ++, 100 99 98 bytes

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

Solo un byte más para obtener menos de 100. getchar()devoluciones-1 cuando lee el final de la transmisión, por eso es que ~está en forciclo. ( ~-1 == 0)

Sin golf

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

AppleScript, 209201 bytes

Mi único consuelo es que vencí a Brainfuck.

establezca el texto devuelto a (mostrar diálogo "" respuesta predeterminada "")
establecer n en el número de caracteres de a
establecer o en ""
repetir n
si no es el carácter de a n = el carácter de a 1, entonces configure o en el carácter de a n & o
establecer n en n-1
fin
o

Cómo funciona esto es que tomo información a, obtengo la longitud ay la marco como n, y establezco una variable de salida o. Por cada carácter que encuentro que no contiene el primer carácter de a ( a's character 1), lo concateno con o. La línea final se imprime o.

Nota: Esto admite automáticamente todos los Unicode. do:

Retina , 16 bytes

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

Guarde el código con un salto de línea final y ejecútelo con la -sbandera.

Cómo funciona: el avance de línea final hace que esta sea una etapa de reemplazo, de modo que cualquier coincidencia de la expresión regular dada se reemplace con una cadena vacía. Las ivueltas en el modo de mayúsculas y minúsculas que también hace referencias hacia atrás entre mayúsculas y minúsculas. Finalmente, la expresión regular simplemente coincide y captura un solo carácter y luego comprueba si el primer carácter de la cadena es el mismo (hasta el caso) utilizando una referencia inversa.