Biorąc pod uwagę ciąg wejściowy tylko zawierający znaki A-Z, a-zoraz pomieszczenia, usunąć wszystkie wystąpienia wersje wielkich i małych pierwszego znaku łańcucha (jeśli pierwszym znakiem jest Ausunąć wszystkie AS i aS, jeśli pierwszy znak (spacja) usuń wszystkie spacje) i wydrukuj wynik.

Przykładowe przypadki:

• 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

To jest code-golf , wygrywa najkrótszy kod w bajtach!

Uwagi:

• Dane wejściowe zawsze będą mieć co najmniej 2 prawidłowe znaki.
• Wyjście nigdy nie będzie pustym ciągiem.

Pyth, 7 bajtów

-zrBhz2

Wypróbuj online: pakiet demonstracyjny lub testowy

Miły. Nowy operator bifurkatów (mający zaledwie 8 dni) pomaga tutaj uratować jeden znak. Myślę, że to pierwszy kod korzystający z tej funkcji.

Wyjaśnienie

-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 

pieprzenie mózgu, 219 bajtów

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

(Wymaga taśmy, która pozwala wskaźnikowi przejść do negatywów lub zapętla się do końca, jeśli spróbuje. Wymaga również ,zwrócenia wartości 0 w EOF. Z mojego doświadczenia wynika , że większość tłumaczy domyślnie spełnia te wymagania.)

To faktycznie okazało się dość łatwe! Nie zdziwiłbym się, gdyby grał w golfa (mam pojęcie, gdzie mogą być zmarnowane bajty, ale nie jestem pewien, czy to się potoczy). Jednak sprawienie, by działało, wcale nie było wyzwaniem.

Ten kod traktuje wszystko o wartości ASCII poniżej 97 jako wielkich liter. Jeśli pierwszym znakiem jest spacja, spróbuje usunąć wszelkie wystąpienia „małej litery” ( chr(32+32)tj. @) Z ciągu. To jest w porządku, ponieważ zawsze będą obecne tylko litery i spacje.

Z komentarzami:

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 bajtów

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

Licząc shebang jako jeden, dane wejściowe są pobierane ze standardowego wejścia.

Przykładowe użycie

$ 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 bajtów

q(_32^+-

Wypróbuj online w interpretatorze CJam .

Jak to działa

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 bajtów

-zr*2hz3

Wypróbuj online

Używa wersji Pythona w Pythonie str.titledo dwukrotnego przekształcenia ciągu pierwszej litery w formę "<Upper><Lower>". Następnie usuwa każdy element z danych wejściowych znajdujących się w tym ciągu. Przestrzenie działają dobrze, ponieważ nie mają na nie wpływu str.title.

MATLAB, 28 bajtów

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

JavaScript (ES6), 38 36 bajtów

Nie zależy to od flagsparametru specyficznego dla Mozilli.

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

CoffeeScript, 39 37 bajtów

Po raz pierwszy jest krótszy w JS niż CoffeeScript!

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

PHP, 41 bajtów

Bierze jeden argument wiersza polecenia . Krótkie otwarte tagi muszą być włączone dla PHP <5.4.

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

Perl, 27 bajtów

Jest to kompletny program, chociaż opiera się na 2 wyrażeniach regularnych, które prawdopodobnie można skopiować do programu Retina w celu zapisania bajtów we / wy.

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

Edycja: Wygląda na to, że ktoś już skorzystał z tej -popcji. Aha i używanie $&zamiast $1.

Minkolang 0,9 , 23 33 bajtów

Nie ma mowy, żeby to wygrało, ale eh, jest fajnie!

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

Wypróbuj tutaj.

Wyjaśnienie

" 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

(Może się to nie udać w niektórych przypadkach krawędzi, np. Jeśli pierwszy znak jest symbolem).

TECO , 15 14 bajtów

Edytujesz tekst? W razie wątpliwości skorzystaj z edytora tekstu i edytora tekstu!

Po wielu próbach i błędach (głównie błąd), myślę, że jest to najkrótszy ogólny program TECO, który wykona zadanie.

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

Lub w formie czytelnej dla człowieka

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

$reprezentuje klawisz Escape i ^Ereprezentuje sekwencję CTRL+ E. W zależności od smaku używanego TECO może on rozpoznać te substytucje ASCII lub nie.

Zgodnie z instrukcją niektóre dialekty TECO akceptują tę 13-bajtową wersję (zamiast polecenia oddzielnego „znajdź” i „usuń”):

0,1XA<FD^EQA$>

Pip, 8 bajtów

aR-Xa@0x

Bierze ciąg jako argument wiersza poleceń (będzie musiał być cytowany, jeśli zawiera spacje). Wyjaśnienie:

          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)

To rozwiązanie ma dodatkową zaletę pracy z łańcuchami zawierającymi dowolne znaki ASCII, które można wydrukować. ( XOperator odwrotny ukośnik unika wszystkiego, co nie jest alfanumeryczne.)

Python, 66 znaków

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

Julia, 34 bajty

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

Tworzy to nienazwaną funkcję, która akceptuje ciąg i zwraca ciąg. Konstruuje wyrażenie regularne bez rozróżniania wielkości liter od pierwszego znaku na wejściu i zastępuje wszystkie jego wystąpienia pustym łańcuchem.

Mathematica, 47 bajtów

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

R, 43 bajty

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

Jest to pełny program, który odczytuje wiersz ze STDIN i zapisuje zmodyfikowany wynik do STDOUT.

Nie golfowany:

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

Rubin, 25 bajtów

Funkcja anonimowa:

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

Pełny prgram, 29 bajtów:

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

Python, 61 bajtów (zdecydowanie za dużo)

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

Wyobrażam sobie, że jest lepszy sposób na zrobienie tego, ale nie mogę tego znaleźć. Wszelkie pomysły na usunięcie "".join(...)?

Ouroboros , 61 bajtów

Hej, jest krótszy niż C ++! Ha.

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

W Ouroboros każda linia programu przedstawia węża z ogonem w pysku. Przepływ kontroli odbywa się poprzez zjadanie lub regurgitację odcinków ogona, ze wspólnym stosem do synchronizacji między wężami.

Snake 1

i.odczytuje znak z wejścia i kopiuje go. .91<\64>*32*wypycha, 32jeśli znak był wielką literą, w 0przeciwnym razie. +ing to znak konwertuje wielkie litery na małe, pozostawiając małe litery i spacje bez zmian. Wszystko to miało miejsce na stosie węża 1, więc teraz przekazujemy wartość do wspólnego stosu ( m), aby wąż 2 mógł przetworzyć. Wreszcie 1(zjada ostatnią postać ogona węża 1. Ponieważ tam znajduje się wskaźnik instrukcji, wąż umiera.

Snake 2

)nie ma wpływu za pierwszym razem. L!34*wypycha, 34jeśli wspólny stos jest pusty, w 0przeciwnym razie. Następnie .oszukujemy i (zjadamy tyle postaci.

• Jeśli współużytkowany stos był pusty, oznacza to koniec węża zaraz po tym, (jak właśnie wykonaliśmy. Dlatego kontroluj pętle z powrotem na początek wiersza, gdzie )regurgituje znaki, które właśnie zjedliśmy (wcześniej wypchnął dodatkową kopię 34) i powtórz test długości stosu.
• Jeśli wspólny stos nie był pusty, nie zjadano żadnych znaków, ';' usuwa dodatkowe 0, a wykonywanie jest kontynuowane:

Siprzełącza na wspólny stos i wprowadza inny znak. .1+!24*wypycha, 24jeśli ten znak to -1 / EOF, w 0przeciwnym razie. Na EOF (połyka 24 znaki - w tym adres IP - i wąż umiera. W przeciwnym razie wykonywanie będzie kontynuowane.

Ywyrywa kopię wierzchu wspólnego stosu (postać, którą właśnie przeczytaliśmy), aby przejąć własny stos 2 do przyszłego użytku. Następnie .@@.@=@.@32-=\@+2*oblicza, czy nowy znak jest równy pierwszemu znakowi, czy pierwszemu znakowi minus 32, naciskając, 2jeśli tak, a 0jeśli nie. Mamy .powielać i (jeść tyle znaków:

• Jeśli postacie pasują do siebie, wracamy prosto do głowy węża, gdzie ( regurgituje 2 postacie, które właśnie zjedliśmy, a egzekucja przebiega z następną postacią.
• Jeśli nie, yodbijamy postać od stosu węża 2, owypisujemy ją, a następnie zapętlamy.

Zobacz to w akcji

// 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 bajtów

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

Edycja: Naprawiono błąd, który powodował, że bajt zerowy był drukowany na początku

Python 2, 43

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

Jest to nieco oparte na mojej odpowiedzi Pyth, ale jest również związane z niektórymi komentarzami ThomasKwa i xnor stąd . Głównie publikowanie, ponieważ chciałem, aby ta odpowiedź istniała.

Vim, 30 klawiszy

Przepraszam, że odkryłem, ale nie widzę żadnej odpowiedzi Vima D:

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

Wyjaśnienie:

1. If<Right>xh@x.<Esc>
   Napisz (rekurencyjne) makro wokół pierwszego znaku.
   Przesunięcie w lewo ( h) jest konieczne, aby pozostać na lewo od następnego nieprzeczytanego znaku.
   Dodawanie dowolnego znaku ( .) na końcu jest konieczne na wypadek, gdyby drugi musiał zostać usunięty
2. "xy0 Skopiuj makro do rejestru x
3. 7| Przejdź do 7. znaku
4. @x Uruchom makro z x
5. 2|~ Zmień wielkość liter pierwszego znaku (właściwie na 2 pozycji)
6. 0"xd7| Wytnij makro w rejestrze x
7. @x Uruchom makro z x
8. 0x Usuń element zastępczy .

Haskell, 52 bajty

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

TI-BASIC, 164 bajty

Do kalkulatorów graficznych serii 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 jest wyraźnie niewłaściwym narzędziem do tego zadania.

• Nie ma polecenia do usuwania znaków, więc musimy zapętlić ciąg i dołączyć znaki, jeśli nie pasują do tego, co ma zostać usunięte.
• Nie obsługuje pustych ciągów, więc musimy rozpocząć ciąg z dwiema literami do usunięcia, zbudować wynik na końcu i odciąć pierwsze dwa znaki.
• Nie ma poleceń zmiany wielkości liter, więc musimy zakodować cały alfabet ...
  • dwa razy...
  • Czy wspomniałem, że małe litery zajmują po dwa bajty w kodowaniu TI-BASIC?

Nie jestem w 100% pewien, ale spędziłem na tym ponad sześć godzin i wydaje się, że jest to najkrótsze możliwe rozwiązanie.

Aby to przetestować przy użyciu danych niewypełnionych dużymi literami (lub wpisać go do kalkulatora), stwórz inny program z zawartością AsmPrgmFDCB24DEC9i uruchom go, Asm([whatever you named it]aby włączyć tryb pisania małymi literami.

Lua, 93 78 bajtów

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

Common Lisp, 77

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

Przeklinaj te długie nazwy funkcji (i nawiasy (ale nadal je kocham (: 3))).

C, 65 61 bajtów

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

Kompiluje z ostrzeżeniami. Odczytuje ciąg z argv[1]. Przykład online

C ++, 100 99 98 bajtów

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

Jeszcze jeden bajt, aby dostać się poniżej 100. getchar()zwraca, -1gdy czyta koniec strumienia, więc dlatego ~jest wfor cyklu. ( ~-1 == 0)

Bez golfa

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

AppleScript, 209 201 bajtów

Moją jedyną pociechą jest to, że pokonałem Brainfuck.

ustaw tekst na „wyświetl okno dialogowe” „domyślna odpowiedź” „) wrócił
ustaw n na liczbę znaków a
ustaw o na „”
powtórz n
jeśli nie jest znakiem n = 1 znak a, ustaw o na znak n & o
ustaw n na n-1
koniec
o

Działa to tak, że pobieram dane wejściowe a, uzyskuję długość, azaznaczam ją jako ni ustawiam zmienną wyjściową o. Dla każdego znalezionego znaku, który nie zawiera pierwszego znaku ( a's character 1), konkatenuję go o. Drukowana jest ostatnia linia o.

Uwaga: To automatycznie obsługuje wszystkie Unicode. do:

Siatkówka , 16 bajtów

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

Zapisz kod za pomocą końcowego kanału i uruchom go z -sflagą.

Jak to działa: trax linefeed czyni ten etap zastępowania, tak że wszelkie dopasowania podanego wyrażenia regularnego są zastępowane pustym ciągiem. Do iwłącza tryb bez uwzględniania wielkości liter, które również sprawia wsteczne wielkości liter. W końcu wyrażenie regularne po prostu dopasowuje i przechwytuje pojedyncze znaki, a następnie sprawdza, czy pierwszy znak w ciągu jest taki sam (w zależności od wielkości liter), używając odwołania wstecznego.