Étant donné une chaîne d'entrée contenant uniquement les caractères A-Z, a-zet les espaces, supprimez toutes les occurrences des versions majuscules et minuscules du premier caractère de la chaîne (si le premier caractère est Asupprimé, tous les As et as, si le premier caractère est (espace), supprimez tous les espaces) et imprimez la sortie.

Exemples de cas:

• 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

C'est le code-golf , le code le plus court en octets gagne!

Remarques:

• L'entrée sera toujours composée d'au moins 2 caractères valides.
• La sortie ne sera jamais une chaîne vide.

Pyth, 7 octets

-zrBhz2

Essayez-le en ligne: démonstration ou suite de tests

Agréable. Le nouvel opérateur bifurqué (âgé de seulement 8 jours) aide ici à enregistrer un caractère. Je pense que c'est le premier code qui utilise cette fonctionnalité.

Explication

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

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

(Nécessite une bande qui permet au pointeur d'aller aux négatifs ou aux boucles jusqu'à la fin s'il essaie. Nécessite également ,de retourner 0 à EOF. D'après mon expérience, la plupart des interprètes répondent à ces exigences par défaut.)

En fait, cela s'est avéré assez facile! Je ne serais pas surpris s'il est jouable au golf (j'ai une idée de l'endroit où il pourrait y avoir des octets gaspillés, mais je ne suis pas très sûr si cela se déroulera). Pourtant, le faire fonctionner n'était pas vraiment un défi du tout.

Ce code traite tout avec une valeur ASCII inférieure à 97 en tant que caractère majuscule. Si le premier caractère est un espace, il essaiera de supprimer toutes les occurrences d'un "espace en minuscules" (ie chr(32+32), ie @) de la chaîne. C'est bien, car seules les lettres et les espaces seront toujours présents.

Avec commentaires:

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 octets

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

En comptant le shebang comme un, l'entrée provient de stdin.

Exemple d'utilisation

$ 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 octets

q(_32^+-

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça marche

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 octets

-zr*2hz3

Essayez-le en ligne

Utilise la version Pyth de python str.titlepour convertir une chaîne de la première lettre deux fois dans le formulaire "<Upper><Lower>". Ensuite, il supprime chaque élément de l'entrée qui se trouve dans cette chaîne. Les espaces fonctionnent bien car ils ne sont pas affectés par str.title.

MATLAB, 28 octets

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

JavaScript (ES6), 38 36 octets

Cela ne dépend pas du flagsparamètre spécifique à Mozilla.

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

CoffeeScript, 39 37 octets

Pour une fois, il est plus court en JS que CoffeeScript!

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

PHP, 41 octets

Prend un argument de ligne de commande . Les balises ouvertes courtes doivent être activées pour PHP <5.4.

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

Perl, 27 octets

Il s'agit d'un programme complet, bien qu'il soit simplement basé sur 2 expressions régulières qui pourraient probablement être copiées dans un programme Retina pour économiser des octets sur les E / S.

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

Edit: On dirait que cela a déjà été battu avec quelqu'un utilisant l' -poption. Oh, et en utilisant $&au lieu de $1.

Minkolang 0.9 , 23 33 octets

Pas question que ça gagne mais hein, c'est amusant!

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

Essayez-le ici.

Explication

" 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

(Cela peut échouer dans certains cas marginaux, comme si le premier caractère est un symbole.)

TECO , 15 14 octets

Modification du texte? En cas de doute, utilisez l'éditeur de texte et le correcteur!

Après beaucoup d'essais et d'erreurs (principalement des erreurs), je pense que c'est le programme TECO générique le plus court qui fera le travail.

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

Ou, sous une forme lisible par l'homme

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.                                      !

$représente la touche d'échappement et ^Ereprésente la séquence CTRL+ E. Selon la saveur de TECO que vous utilisez, il peut reconnaître ces substitutions ASCII, ou non.

Selon le manuel, certains dialectes de TECO acceptent cette version à 13 octets (en utilisant une commande find-and-delete au lieu de commandes "find" et "delete" séparées) à la place:

0,1XA<FD^EQA$>

Pip, 8 octets

aR-Xa@0x

Prend la chaîne comme argument de ligne de commande (devra être citée si elle contient des espaces). Explication:

          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)

Cette solution a l'avantage supplémentaire de travailler sur des chaînes contenant des caractères ASCII imprimables. (L' Xopérateur barre oblique inverse tout ce qui n'est pas alphanumérique.)

Python, 66 caractères

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

Julia, 34 octets

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

Cela crée une fonction sans nom qui accepte une chaîne et renvoie une chaîne. Il construit une expression régulière insensible à la casse à partir du premier caractère de l'entrée et remplace toutes les occurrences de celle-ci par une chaîne vide.

Mathematica, 47 octets

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

R, 43 octets

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

Il s'agit d'un programme complet qui lit une ligne depuis STDIN et écrit le résultat modifié dans STDOUT.

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

Rubis, 25 octets

Fonction anonyme:

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

Programme complet, 29 octets:

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

Python, 61 octets (beaucoup trop)

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

J'imagine qu'il existe une meilleure façon de procéder, mais je n'arrive pas à la trouver. Des idées sur la suppression du "".join(...)?

Ouroboros , 61 octets

Hé, c'est plus court que C ++! Ha.

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

À Ouroboros, chaque ligne du programme représente un serpent avec sa queue dans sa bouche. Le contrôle du flux est accompli en mangeant ou en régurgitant des sections de queue, avec une pile partagée pour synchroniser entre les serpents.

Serpent 1

i.lit un caractère de l'entrée et le duplique. .91<\64>*32*pousse 32si le caractère était une lettre majuscule, 0sinon. +en convertissant les lettres majuscules en minuscules tout en laissant les lettres minuscules et les espaces inchangés. Tout cela a eu lieu sur la pile de serpent 1, donc nous poussons maintenant la valeur vers la pile partagée ( m) pour que serpent 2 traite. Enfin, 1(mange le dernier personnage de la queue de serpent 1. Puisque c'est là que se trouve le pointeur d'instruction, le serpent meurt.

Serpent 2

)n'a aucun effet la première fois. L!34*pousse 34si la pile partagée est vide, 0sinon. Nous avons ensuite .dupé et (mangé autant de personnages.

• Si la pile partagée était vide, cela place la fin du serpent juste après ( nous venons d'exécuter. Par conséquent, les boucles de contrôle reviennent au début de la ligne, où )régurgite les caractères que nous venons de manger (après avoir poussé une copie supplémentaire de 34) et répétez le test de longueur de pile.
• Si la pile partagée n'était pas vide, aucun personnage n'est mangé, ';' laisse tomber le supplément0 et l'exécution continue:

Sibascule vers la pile partagée et entre un autre caractère. .1+!24*pousse 24si ce caractère était -1 / EOF, 0sinon. Sur EOF, (avale 24 caractères - y compris l'IP - et le serpent meurt. Sinon, l'exécution continue.

Ytire une copie du haut de la pile partagée (le personnage que nous venons de lire) dans la propre pile de serpent 2 pour une utilisation future. Calcule ensuite .@@.@=@.@32-=\@+2*si le nouveau caractère est égal au premier caractère ou au premier caractère moins 32, en poussant 2si c'est le 0cas et sinon. Nous .dupliquons et (mangeons autant de personnages:

• Si les personnages correspondent, nous retournons directement à la tête du serpent, où (régurgite les 2 personnages que nous venons de manger et l'exécution se poursuit avec le personnage suivant.
• Sinon, nous yremontons le personnage de la pile de Snake 2,o sortons puis nous bouclons.

Voyez-le en action

// 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 octets

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

Edit: correction d'un bug qui provoquait l'impression d'un octet nul au début

Python 2, 43

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

Ceci est quelque peu basé sur ma réponse Pyth, mais il est également lié à certains commentaires de ThomasKwa et xnor d' ici . Surtout parce que je voulais que cette réponse existe.

Vim, 30 frappes

Désolé de dénicher, mais je ne vois aucune réponse de Vim D:

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

Explication:

1. If<Right>xh@x.<Esc>
   Écrire une macro (récursive) autour du premier caractère
   Déplacer vers la gauche ( h) est nécessaire pour rester à gauche du caractère non lu suivant
   L'ajout d'un caractère ( .) à la fin est nécessaire au cas où le second doit être supprimé
2. "xy0 Copiez la macro dans le registre x
3. 7| Passer au 7e caractère
4. @x Exécutez la macro depuis x
5. 2|~ Changez le cas du premier caractère (en fait à la 2e position)
6. 0"xd7| Coupez la macro dans le registre x
7. @x Exécutez la macro depuis x
8. 0x Retirez la marque de réservation .

Haskell, 52 octets

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

TI-BASIC, 164 octets

Pour les calculatrices graphiques 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 est clairement le mauvais outil pour le travail.

• Il n'a pas de commande pour supprimer les caractères, nous devons donc parcourir la chaîne et ajouter des caractères s'ils ne correspondent pas à ce qui doit être supprimé.
• Il ne prend pas en charge les chaînes vides, nous devons donc commencer la chaîne avec les deux lettres à supprimer, créer la sortie à la fin et couper les deux premiers caractères.
• Il n'a pas de commandes de changement de casse, nous devons donc coder en dur l'alphabet entier ...
  • deux fois...
  • Ai-je mentionné que les lettres minuscules prenaient chacune deux octets dans l'encodage TI-BASIC?

Je ne suis pas sûr à 100%, mais j'ai passé plus de six heures à ce sujet, et cela semble être la solution la plus courte possible.

Pour tester cela avec des entrées non majuscules (ou pour le taper dans votre calculatrice), créez un programme différent avec le contenu AsmPrgmFDCB24DEC9et exécutez-le en utilisant Asm([whatever you named it]pour activer le mode de frappe en minuscules.

Lua, 93 78 octets

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

Lisp commun, 77

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

Maudissez ces longs noms de fonctions (et les parenthèses (mais je les aime quand même (: 3))).

C, 65 61 octets

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

Compile avec des avertissements. Lit la chaîne de argv[1]. Exemple en ligne

C ++, 100 99 98 octets

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

Juste un octet de plus pour passer sous 100. getchar()retourne -1quand il lit la fin du flux, c'est pourquoi le~for cycle est en cours . ( ~-1 == 0)

Non golfé

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

AppleScript, 209 201 octets

Ma seule consolation est que j'ai battu Brainfuck.

définir un texte de (afficher la boîte de dialogue "" réponse par défaut "") renvoyé
mettre n au nombre de caractères de a
mettre o à ""
répéter n
sinon, le caractère de a n = le caractère de a 1, puis définissez o sur le caractère de a n & o
définir n sur n-1
fin
o

How this works is that I take input through a, get the length of a and mark it as n, and set an output variable o. For every character that I find that does not contain the first character of a (a's character 1), I concatenate it to o. The final line prints o.

Note: This automatically supports all Unicode. c:

Retina, 16 bytes

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

Save the code with a trailing linefeed and run it with the -s flag.

How it works: the trailing linefeed makes this a replacement stage, such that any matches of the given regex are replaced with an empty string. The i turns on case-insensitive mode which also makes backreferences case-insensitive. Finally, the regex simply matches and captures a single characters and then checks whether the first character in the string is the same (up to case) using a backreference.