Учитывая входную строку , содержащей только символы A-Z, a-zи пробела, удалить все вхождения прописных и строчных версии первого символа строки (если первый символ Aудалить все Aс и aс, если первым символом (пробел) удалить все пробелы) и распечатайте вывод.

Примеры случаев:

• 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

Это код-гольф , выигрывает самый короткий код в байтах!

Заметки:

• Ввод всегда будет 2 или более действительных символов.
• Вывод никогда не будет пустой строкой.

Pyth, 7 байт

-zrBhz2

Попробуйте онлайн: демонстрация или тестовый набор

Ницца. Новый оператор Bifurcate (всего 8 дней) помогает здесь сохранить один символ. Я думаю, что это первый код, который использует эту функцию.

объяснение

-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 

брейкфук, 219 байт

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

(Требуется лента, которая позволяет указателю переходить к минусам или петлям до конца, если он пытается. Также требует ,возврата 0 в EOF. По моему опыту, большинство интерпретаторов удовлетворяют этим требованиям по умолчанию.)

На самом деле это оказалось довольно легко! Я не был бы удивлен, если это пригодно для игры в гольф (у меня есть некоторое представление о том, где могут быть потраченные впустую байты, но я не супер уверен, удастся ли это удастся). Тем не менее, заставить его работать на самом деле не было проблемой вообще.

Этот код обрабатывает все со значением ASCII ниже 97 как символ в верхнем регистре. Если первым символом является пробел, он будет пытаться удалить любые вхождения «строчных букв» (то есть chr(32+32), то есть @) из строки. Это нормально, потому что когда-либо будут присутствовать только буквы и пробелы.

С комментариями:

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 байт

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

Считая Шебанг как единое, ввод берется из стандартного ввода.

Образец использования

$ 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 байт

q(_32^+-

Попробуйте онлайн в интерпретаторе CJam .

Как это работает

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 байт

-zr*2hz3

Попробуйте онлайн

Использует Python-версию Python str.titleдля преобразования строки первой буквы дважды в форму "<Upper><Lower>". Затем он удаляет каждый элемент из ввода, который находится в этой строке. Пространства работают нормально, потому что они не затронуты str.title.

MATLAB, 28 байт

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

JavaScript (ES6), 38 36 байт

Это не зависит от flagsпараметра, который зависит от Mozilla.

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

CoffeeScript, 39 37 байт

На этот раз в JS короче, чем CoffeeScript!

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

PHP, 41 байт

Принимает один аргумент командной строки . Короткие открытые теги должны быть включены для PHP <5.4.

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

Perl, 27 байт

Это полная программа, хотя она основана на двух регулярных выражениях, которые, вероятно, могут быть скопированы в программу Retina для сохранения байтов при вводе / выводе.

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

Изменить: Похоже, что это уже было побито с кем-то, используя эту -pопцию. Ох, и использовать $&вместо $1.

Минколанг 0,9 , 23 33 байта

Это никоим образом не победит, но это весело!

" Z"od0c`1c*-$I[odd0c`1c*-2c=?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

(Это может дать сбой в некоторых крайних случаях, например, если первый символ является символом.)

TECO , 15 14 байтов

Редактирование текста? Если вы сомневаетесь, используйте текстовый редактор и COrrecter!

После долгих проб и ошибок (в основном ошибок), я думаю, что это самая короткая универсальная программа TECO, которая сделает эту работу.

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

Или в удобочитаемой форме

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

$представляет управляющий ключ и ^Eпредставляет последовательность CTRL+ E. В зависимости от вкуса используемого вами TECO, он может распознавать эти замены ASCII или нет.

Согласно руководству, некоторые диалекты TECO принимают эту 13-байтовую версию (используя команду поиска и удаления вместо отдельных команд «найти» и «удалить»):

0,1XA<FD^EQA$>

Пип, 8 байт

aR-Xa@0x

Принимает строку в качестве аргумента командной строки (нужно будет заключать в кавычки, если она содержит пробелы). Объяснение:

          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)

Это решение имеет дополнительный бонус работы со строками, содержащими любые печатные символы ASCII. ( XОператор с обратной косой чертой экранирует все, что не является буквенно-цифровым.)

Python, 66 знаков

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

Юлия, 34 байта

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

Это создает безымянную функцию, которая принимает строку и возвращает строку. Он создает регистронезависимое регулярное выражение из первого символа на входе и заменяет все его вхождения пустой строкой.

Mathematica, 47 байт

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

R, 43 байта

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

Это полная программа, которая читает строку из STDIN и записывает измененный результат в 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)

Рубин, 25 байт

Анонимная функция:

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

Полная программа, 29 байт:

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

Python, 61 байт (слишком много)

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

Я думаю, что есть лучший способ сделать это, но я не могу найти это. Есть идеи по удалению "".join(...)?

Уроборос , 61 байт

Эй, это короче, чем C ++! Ха.

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

В Уроборосе каждая строчка программы представляет собой змею с хвостом во рту. Управление потоком осуществляется путем поедания или регургитации участков хвоста с помощью общего стека для синхронизации между змеями.

Змея 1

i.читает символ из ввода и дублирует его. .91<\64>*32*толкает, 32если символ был заглавной буквой, в 0противном случае. +При преобразовании этого символа в верхний регистр преобразуются строчные буквы, а строчные буквы и пробелы остаются неизменными. Все это происходит в стеке snake 1, поэтому теперь мы помещаем значение в общий стек ( m) для обработки snake 2. Наконец, 1(ест последний символ хвоста змеи 1. Так как именно там находится указатель инструкции, змея умирает.

Змея 2

)не имеет эффекта в первый раз. L!34*толкает, 34если общий стек пуст, 0иначе. Затем мы .копируем и (едим столько персонажей.

• Если общий стек был пуст, это ставит конец змеи сразу после того, как (мы только что выполнили. Таким образом, управление возвращается к началу строки, где )регургитирует только что съеденные символы (предварительно выдвинув лишнюю копию 34) и повторяет тест длины стека.
• Если общий стек не был пустым, никакие символы не съедаются, ';' отбрасывает лишнее 0, и выполнение продолжается:

Siпереключается на общий стек и вводит другой символ. .1+!24*толкает, 24если этот символ был -1 / EOF, в 0противном случае. На EOF (глотает 24 символа - включая IP - и змея умирает. В противном случае выполнение продолжается.

Yвозвращает копию вершины общего стека (символ, который мы только что прочитали) в собственный стек Snake 2 для будущего использования. Затем .@@.@=@.@32-=\@+2*вычисляется, равен ли новый символ первому символу или первому символу минус 32, нажимая, 2если так, а 0если нет. Мы .дублируем и (едим столько символов:

• Если символы совпадают, мы возвращаемся прямо к голове змеи, где (срыгивает 2 только что съеденных символа, и выполнение продолжается со следующим персонажем.
• Если нет, мы yвозвращаем символ из стека змеи 2, 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 байтов

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

Редактировать: Исправлена ​​ошибка, из-за которой нулевой байт печатался в начале

Python 2, 43

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

Это в некоторой степени основано на моем ответе Pyth, но также связано с некоторыми комментариями ThomasKwa и xnor отсюда . Главным образом, потому что я хотел, чтобы этот ответ существовал.

Vim, 30 нажатий клавиш

Извините, что обнаружили, но я не вижу никакого ответа Vim D:

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

Объяснение:

1. If<Right>xh@x.<Esc>
   Напишите (рекурсивный) макрос вокруг первого символа.
   Перемещение влево ( h) необходимо, чтобы остаться слева от следующего непрочитанного символа.
   Добавление любого символа ( .) в конце необходимо в случае удаления второго символа.
2. "xy0 Скопируйте макрос в реестр x
3. 7| Перейти к 7-му символу
4. @x Запустите макрос из x
5. 2|~ Переключите регистр первого символа (фактически на 2-й позиции)
6. 0"xd7| Вырезать макрос в реестре x
7. @x Запустите макрос из x
8. 0x Удалить заполнитель .

Haskell, 52 байта

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

TI-BASIC, 164 байта

Для графических калькуляторов серии 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 явно не подходит для работы.

• У него нет команды для удаления символов, поэтому нам нужно перебрать строку и добавить символы, если они не соответствуют тому, что должно быть удалено.
• Он не поддерживает пустые строки, поэтому нам нужно начать строку с двух букв, которые будут удалены, построить вывод в конце и отрезать первые два символа.
• У него нет команд смены регистра, поэтому нам нужно жестко закодировать весь алфавит ...
  • дважды...
  • Я упоминал, что строчные буквы занимают по два байта в кодировке TI-BASIC?

Я не уверен на 100%, но я потратил на это более шести часов, и это, кажется, самое короткое из возможных решений.

Чтобы проверить это с помощью ввода не прописными буквами (или ввести его в свой калькулятор), создайте другую программу с содержимым AsmPrgmFDCB24DEC9и запустите ее, Asm([whatever you named it]чтобы включить режим ввода строчных букв.

Луа, 93 78 байт

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

Прокляните эти длинные имена функций (и скобки (но я все равно люблю их (: 3))).

C 65 61 байт

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

Компилируется с предупреждениями. Читает строку из argv[1]. Интернет пример

C ++, 100 99 98 байт

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

Еще один байт, чтобы получить меньше 100. getchar()возвращается, -1когда он читает конец потока, поэтому он ~находится в forцикле. ( ~-1 == 0)

Ungolfed

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

AppleScript, 209 201 байт

Мое единственное утешение в том, что я победил Брейнфак.

установить a (отобразить диалог "" ответ по умолчанию "") возвращаемый текст
установить n в число символов а
установить в ""
повторить н
если не символ a, то n = символ 1, тогда установите o в символ a n & o.
установите n в n-1
конец
о

Как это работает, я принимаю ввод a, получаю длину aи отмечаю ее как n, и устанавливаю выходную переменную o. Для каждого найденного символа, который не содержит первый символ ( a's character 1), я присоединяю его к o. Последняя строка печатается o.

Примечание: это автоматически поддерживает все Unicode. с:

Сетчатка , 16 байт

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

Сохраните код с завершающим переводом строки и запустите его с -sфлагом.

Как это работает: завершающий перевод строки делает это этапом замены, так что любые совпадения данного регулярного выражения заменяются пустой строкой. В iочереди на режиме без учета регистра , который также делает обратные_связь нечувствительна к регистру. Наконец, регулярное выражение просто сопоставляет и захватывает отдельные символы, а затем проверяет, является ли первый символ в строке одинаковым (с учетом регистра), используя обратную ссылку.