Entfernen Sie alle Vorkommen des ersten Buchstabens einer Zeichenfolge aus der gesamten Zeichenfolge

24

Gegeben nur eine Eingabezeichenfolge die Zeichen enthält A-Z, a-zund Leerzeichen, entfernen Sie alle Vorkommen der Groß- und Klein Versionen des ersten Zeichens der Zeichenkette (wenn das erste Zeichen Aentfernen Sie alle As und as, wenn das erste Zeichen (Leerzeichen) entfernen alle Räume), und drucken Sie die Ausgabe.

Beispielfälle:

  • 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

Das ist Code-Golf , der kürzeste Code in Bytes gewinnt!

Anmerkungen:

  • Die Eingabe besteht immer aus 2 oder mehr gültigen Zeichen.
  • Die Ausgabe wird niemals eine leere Zeichenfolge sein.
code-golf string parsing GamrCorps
quelle
Müssen wir den Fall behandeln, in dem die Ausgabe eine leere Zeichenfolge ist? Was passiert , wenn Eingang ist die leere Zeichenkette?
Lirtosiast
@ ThomasKwa Sie können davon ausgehen, dass die Ausgabe immer 2 oder mehr Zeichen sein wird
GamrCorps
@ ThomasKwa und Ausgabe wird nie leer sein
GamrCorps

Antworten:

9

Pyth, 7 Bytes

-zrBhz2

Probieren Sie es online aus: Demo oder Test Suite

Nett. Der neue Gabeloperator (nur 8 Tage alt) hilft hier, ein Zeichen zu sparen. Ich denke, dies ist der erste Code, der diese Funktion verwendet.

Erläuterung

-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
Jakube
quelle
2
Ordentlich, wusste nichts davon. +1
FryAmTheEggman
14

Brainfuck, 219 Bytes

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

(Benötigt ein Band, bei dem der Zeiger entweder auf das Negativ zeigt oder in einer Schleife zum Ende zeigt, wenn dies versucht wird. Erfordert auch ,die Rückgabe von 0 bei EOF. Nach meiner Erfahrung erfüllen die meisten Interpreter diese Anforderungen standardmäßig.)

Das stellte sich tatsächlich als ziemlich einfach heraus! Es würde mich nicht wundern, wenn es golffähig ist (ich habe eine Vorstellung davon, wo es verschwendete Bytes geben könnte, aber ich bin mir nicht sicher, ob es herauskommt). Trotzdem war es keine wirkliche Herausforderung, es zum Laufen zu bringen.

In diesem Code wird alles mit einem ASCII-Wert unter 97 als Großbuchstabe behandelt. Wenn das erste Zeichen ein Leerzeichen ist, wird versucht, alle Vorkommen eines "Leerzeichens in Kleinbuchstaben" ( chr(32+32)dh @) aus der Zeichenfolge zu entfernen . Dies ist in Ordnung, da immer nur Buchstaben und Leerzeichen vorhanden sein werden.

Mit Kommentaren:

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

]
untergrundbahn
quelle
Bitte nicht zu viel Golf spielen . c: Ich habe so hart gearbeitet ...
Addison Crump
13

Perl, 13 Bytes

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

Zählt man den Shebang als einen, wird die Eingabe von stdin übernommen.

Beispielnutzung

$ 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
primo
quelle
Nett. Ich habe darüber nachgedacht, wie sich Perl aufgrund der Notwendigkeit zu schreiben wahrscheinlich schlecht schlagen würde, substraber Sie haben sich natürlich einen viel besseren Weg ausgedacht!
Hobbs
Warum zählt man Hashbang als ein Byte?
Zereges
@Zereges die Shebang-Linie ist nicht notwendig, wenn das Skript als aufgerufen wird perl -p script.pl. Befehlszeilenoptionen werden normalerweise als jeweils ein Byte gezählt, zumindest auf dieser Site.
Primo
@primo Ich verstehe, danke.
Zereges
10

CJam, 8 Bytes

q(_32^+-

Versuchen Sie es online in dem CJam Dolmetscher .

Wie es funktioniert

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.
Dennis
quelle
Ich habe diese Herausforderung ursprünglich erstellt, um CJam zu lernen, und ich wusste nie etwas über XOR!
GamrCorps
2
Ich persönlich finde es überraschend, dass jede Sprache - mit Ausnahme von Sed - Perl bei dieser Herausforderung schlagen kann.
Primo
@primo - Du hast nicht bemerkt, dass CJam und / oder Pyth so ziemlich 99% davon gewinnen? Perl hat es aber ziemlich gut gemacht, wenn man bedenkt, dass es die einzige ist, die nicht speziell als Golfsprache entwickelt wurde.
Darrel Hoffman
Das Überladen von Pyth- und CJam-Operatoren ist lächerlich. Minuszeichen (Zeichenfolge, Zeichenfolge), die pro Zeichen entfernt werden, sind in keiner anderen Sprache, auf die ich gestoßen bin, eine Kernoperation.
Sparr
@Sparr APL hat das gleiche eingebaut. (Es heißt ~aber.)
Dennis
7

Pyth, 8 Bytes

-zr*2hz3

Probieren Sie es online aus

Verwendet Pyths Version von Python str.title, um eine Zeichenfolge des ersten Buchstabens zweimal in das Formular zu konvertieren "<Upper><Lower>". Anschließend wird jedes Element aus der Eingabe in dieser Zeichenfolge entfernt. Leerzeichen funktionieren einwandfrei, da sie davon nicht betroffen sind str.title.

FryAmTheEggman
quelle
5

MATLAB, 28 Bytes

@(S)S(lower(S)~=lower(S(1)))
Stewie Griffin
quelle
5

JavaScript (ES6), 38 36 Bytes

Dies hängt nicht von dem flagsParameter ab, der Mozilla-spezifisch ist.

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

CoffeeScript, 39 37 Bytes

Diesmal ist es in JS kürzer als in CoffeeScript!

f=(x)->x.replace RegExp(x[0],'gi'),''
rink.attendant.6
quelle
3
Zumindest in den Browsern, die ich ausprobiert habe, newist das optional, RegExp(x[0],'gi')ist also kürzer.
Neil
4

PHP, 41 Bytes

Nimmt ein Befehlszeilenargument an . Kurze offene Tags müssen für PHP <5.4 aktiviert sein.

<?=str_ireplace($argv[1][0],'',$argv[1]);
rink.attendant.6
quelle
1
Sie können es verkürzen, indem Sie eine Variable deklarieren, die Folgendes enthält $argv[1]:<?=str_ireplace(($a=$argv[1])[0],'',$a);
Benoit Esnard
3

Perl, 27 Bytes

Dies ist ein vollständiges Programm, obwohl es nur auf 2 regulären Ausdrücken basiert, die wahrscheinlich in ein Retina-Programm kopiert werden könnten, um Bytes bei der E / A zu sparen.

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

Bearbeiten: Sieht so aus, als wäre dies mit jemandem, der die -pOption verwendet, bereits besiegt worden . Oh, und $&stattdessen verwenden $1.

PhiNotPi
quelle
1
Auch wenn der gesamte Shebang gezählt wird (also ein "vollständiges" Programm), #!perl -psind immer noch zwei Bytes kürzer als $_=<>;print.
Primo
@primo Ich habe noch nie eine der Optionen in meinen Golfspielen verwendet. Ich habe nur gegoogelt, was die -pOption macht. Es gibt eigentlich keine Änderungen, die ich an meiner Antwort vornehmen könnte, ohne sie nur mit Ihrer identisch zu machen.
PhiNotPi
3

Minkolang 0,9 , 23 33 Bytes

Auf keinen Fall wird das gewinnen, aber es macht Spaß!

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

Probieren Sie es hier aus.

Erläuterung

" 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

(Dies kann in einigen Randfällen fehlschlagen, z. B. wenn das erste Zeichen ein Symbol ist.)

El'endia Starman
quelle
3

TABG , 15 14 Bytes

Text bearbeiten? Verwenden Sie im Zweifelsfall den Texteditor und den Korrektor!

Nach vielem Ausprobieren (meistens Fehler) denke ich, dass dies das kürzeste generische TECO-Programm ist, das die Arbeit erledigen wird.

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

Oder in lesbarer Form

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äsentiert die Escape-Taste und ^Erepräsentiert die Sequenz CTRL+ E. Abhängig von der verwendeten TECO-Version werden diese ASCII-Ersetzungen möglicherweise erkannt oder nicht.

Laut Handbuch akzeptieren einige Dialekte von TECO diese 13-Byte-Version (mit einem Such- und Löschbefehl anstelle von separaten Befehlen "Suchen" und "Löschen"):

0,1XA<FD^EQA$>
Kennzeichen
quelle
3

Pip, 8 Bytes

aR-Xa@0x

Nimmt die Zeichenfolge als Befehlszeilenargument (muss in Anführungszeichen gesetzt werden, wenn sie Leerzeichen enthält). Erläuterung:

          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)

Diese Lösung hat den zusätzlichen Bonus auf Saiten Arbeits enthält alle druckbaren ASCII - Zeichen. (Der XOperator-Backslash maskiert alles, was nicht alphanumerisch ist.)

DLosc
quelle
3

Python, 66 Zeichen

a=raw_input()
print a.replace(a[0],'').replace(a[0].swapcase(),'')
Der Doktor
quelle
5
@ThomasKwa wie wäre es mit nein.
TheDoctor
3

Julia, 34 Bytes

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

Dadurch wird eine unbenannte Funktion erstellt, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Es erstellt aus dem ersten Zeichen in der Eingabe einen regulären Ausdruck, bei dem die Groß- und Kleinschreibung nicht berücksichtigt wird, und ersetzt alle Vorkommen durch eine leere Zeichenfolge.

Alex A.
quelle
2

Mathematica, 47 Bytes

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

R, 43 Bytes

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

Dies ist ein vollständiges Programm, das eine Zeile aus STDIN liest und das geänderte Ergebnis in STDOUT schreibt.

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)
Alex A.
quelle
2

Ruby, 25 Bytes

Anonyme Funktion:

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

Volles Programm, 29 Bytes:

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

Python, 61 Bytes (viel zu viele)

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

Ich stelle mir vor, es gibt einen besseren Weg, dies zu tun, aber ich kann ihn scheinbar nicht finden. Irgendwelche Ideen zum Entfernen der "".join(...)?

cole
quelle
1
@ThomasKwa vielleicht solltest du das als deine eigene Antwort einreichen; es scheint zu verschieden von mir zu sein, um als meine Unterwerfung zu gelten.
Cole
@ThomasKwa Kürzer zu machen x[0]+x[0].swapcase().
XNOR
1
@ThomasKwa Oder stehlen von FryAmTheEggman's Pyth-Lösung (x[0]*2).title().
Xnor
@xnor yeah, das habe ich vor ein paar Stunden beim Lesen festgestellt.
Lirtosiast
lambda x:x.replace(x[0].upper(),'').replace(x[0].lower(),'')- 60 Bytes
Mego
2

Ouroboros , 61 Bytes

Hey, es ist kürzer als C ++! Ha.

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

Auf Ouroboros repräsentiert jede Programmzeile eine Schlange mit dem Schwanz im Maul. Der Kontrollfluss wird durch Essen oder Aufstoßen von Schwanzabschnitten mit einem gemeinsamen Stapel zur Synchronisation zwischen Schlangen erreicht.

Schlange 1

i.Liest ein Zeichen aus der Eingabe und dupliziert es. .91<\64>*32*drückt, 32wenn das Zeichen ein Großbuchstabe war, 0ansonsten. +Wenn Sie diese Option auf das Zeichen anwenden, werden Großbuchstaben in Kleinbuchstaben umgewandelt, Kleinbuchstaben und Leerzeichen bleiben unverändert. All dies hat auf dem Stapel von Schlange 1 stattgefunden, daher verschieben wir den Wert nun auf den gemeinsamen Stapel ( m), damit Schlange 2 ihn verarbeitet. Endlich,1( isst der letzte Charakter von Schlange 1's Schwanz. Da sich dort der Befehlszeiger befindet, stirbt die Schlange.

Schlange 2

)hat beim ersten mal keine wirkung durch. L!34*drückt, 34wenn der gemeinsam genutzte Stapel leer ist, 0ansonsten. Wir .dupfen und (essen dann so viele Charaktere.

  • Wenn der gemeinsam genutzte Stapel leer war, wird das Ende der Schlange direkt nach dem (gerade ausgeführten gesetzt. Aus diesem Grund )kehrt die Steuerung zum Zeilenanfang zurück, wo die Zeichen, die wir gerade gegessen haben (nachdem wir zuvor eine zusätzliche Kopie von gepusht haben 34), wieder aufflammen und den Stapellängentest wiederholen.
  • Wenn der gemeinsam genutzte Stapel nicht leer war, werden keine Zeichen ausgegeben, ';' Lässt das Extra fallen 0und die Ausführung wird fortgesetzt:

Siwechselt zum gemeinsamen Stapel und gibt ein anderes Zeichen ein. .1+!24*drückt, 24wenn das Zeichen -1 / EOF war, 0sonst. Schluckt auf EOF (24 Zeichen - einschließlich der IP - und die Schlange stirbt. Andernfalls wird die Ausführung fortgesetzt.

YZerrt eine Kopie des oberen Teils des gemeinsam genutzten Stapels (des gerade gelesenen Zeichens), um den eigenen Stapel von 2 für die spätere Verwendung zu sichern. Dann .@@.@=@.@32-=\@+2*berechnet , ob das neue Zeichen auf das erste Zeichen oder gleich auf das ersten Zeichen minus 32, Schieben , 2wenn so und 0wenn nicht. Wir .duplizieren und (essen so viele Zeichen:

  • Wenn die Zeichen übereinstimmen, kehren wir direkt zum Kopf der Schlange zurück, wo (die 2 Zeichen, die wir gerade gegessen haben, wieder aufflammen und die Ausführung mit dem nächsten Zeichen fortgesetzt wird.
  • Wenn nicht, binden wir yden Charakter vom Stapel von Schlange 2 zurück, ogeben ihn aus und wiederholen die Schleife.

Sehen Sie es in Aktion

Code-Snippet anzeigen

DLosc
quelle
2

C 60 Bytes

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

Bearbeiten: Ein Fehler wurde behoben, der dazu führte, dass am Anfang ein Null-Byte gedruckt wurde

xsot
quelle
Kompiliert es überhaupt?
26.
1
Ja. Es kompiliert auf meinem Computer (mit Warnungen) und funktioniert. Sie können es auch auf dieser Seite testen
xsot
ja tut es; +1
Abr001am
2

Python 2, 43

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

Dies basiert in gewisser Weise auf meiner Pyth-Antwort, hat aber auch mit einigen Kommentaren von ThomasKwa und xnor von hier zu tun . Meistens Posten, weil ich diese Antwort haben wollte.

FryAmTheEggman
quelle
2

Vim, 30 Tastenanschläge

Es tut mir leid, aber ich sehe keine Antwort von Vim D:

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

Erläuterung:

  1. If<Right>xh@x.<Esc>
    Schreiben Sie ein (rekursives) Makro um das erste Zeichen.
    Nach links bewegen ( h) ist erforderlich, um links vom nächsten ungelesenen Zeichen zu bleiben.
    Das Hinzufügen eines beliebigen Zeichens ( .) am Ende ist erforderlich, falls das zweite Zeichen entfernt werden muss
  2. "xy0 Kopieren Sie das Makro in das Register x
  3. 7| Gehe zum 7. Zeichen
  4. @x Führen Sie den Makro aus x
  5. 2|~ Schalten Sie den Fall des ersten Zeichens (tatsächlich an der 2. Position)
  6. 0"xd7| Schneiden Sie das Makro im Register aus x
  7. @x Führen Sie den Makro aus x
  8. 0x Entfernen Sie den Platzhalter .
user285259
quelle
1
:DIch stimme immer vim zu!
DJMcMayhem
1

Haskell, 52 Bytes

import Data.Char
t=toUpper
r(h:s)=filter((t h/=).t)s
Leif Willerts
quelle
2
Liste Verständnis spart 1 Byte: r(h:s)=[c|c<-s,t c/=t h].
nimi
1

TI-BASIC, 164 Bytes

Für Grafikrechner der 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 ist eindeutig das falsche Werkzeug für den Job.

  • Es gibt keinen Befehl zum Entfernen von Zeichen, daher müssen wir den String durchlaufen und Zeichen anhängen, wenn sie nicht mit dem übereinstimmen, was entfernt werden soll.
  • Leere Zeichenfolgen werden nicht unterstützt, daher müssen wir die Zeichenfolge mit den beiden zu entfernenden Buchstaben beginnen, die Ausgabe am Ende erstellen und die ersten beiden Zeichen abschneiden.
  • Es gibt keine Befehle zum Ändern der Groß- / Kleinschreibung, daher müssen wir das gesamte Alphabet fest codieren ...
    • zweimal...
    • Habe ich erwähnt, dass Kleinbuchstaben in der TI-BASIC-Codierung jeweils zwei Bytes benötigen?

Ich bin nicht zu 100% sicher, aber ich habe über sechs Stunden damit verbracht, und es scheint die kürzestmögliche Lösung zu sein.

Um dies mit Eingaben ohne Großbuchstaben zu testen (oder in Ihren Taschenrechner einzugeben), erstellen Sie ein anderes Programm mit dem Inhalt AsmPrgmFDCB24DEC9und führen Sie es aus Asm([whatever you named it], um den Kleinbuchstabenmodus zu aktivieren.

Lirtosiast
quelle
1

Lua, 93 78 Bytes

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

Common Lisp, 77

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

Verfluche diese langen Funktionsnamen (und Klammern (aber ich liebe sie trotzdem (: 3))).

Kerzen
quelle
1

C, 65 61 Bytes

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

Kompiliert mit Warnungen. Liest einen String aus argv[1]. Online-Beispiel


quelle
1
Sie können main(int c,char**v)nach main(c,v)char**v;und (**v-c)%32nach kürzen **v-c&31.
Dennis
1

C ++, 100 99 98 Bytes

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

Nur noch ein Byte unter 100 erhalten getchar()Rückkehr-1 wenn das Ende des Streams gelesen wird. Deshalb ~befindet sich das im forZyklus. ( ~-1 == 0)

Ungolfed

#include <ios>
int main()
{
    for (int c, f = getchar(); ~(c = getchar()); )
        tolower(c) - tolower(f) && putchar(c);
}
Zereges
quelle
Kannst du nicht &&putchar(c)statt verwenden ?putchar(c):0?
Neil
@Neil Danke, jetzt bin ich unter 100 Bytes!
Zereges,
@ ThomasKwa Natürlich kann ich, danke.
Zereges
1
Kannst du f-c&31wie in der C antworten?
Lirtosiast
1

AppleScript, 209 201 Bytes

Mein einziger Trost ist, dass ich Brainfuck besiegt habe.

set a to (Dialogfeld "" Standardantwort "" anzeigen) Der zurückgegebene Text
setze n auf die Nummer eines Zeichens
setze o auf ""
wiederhole n
wenn nicht a's Zeichen n = a's Zeichen 1, dann setze o auf a's Zeichen n & o
setze n auf n-1
Ende
O

Wie das funktioniert, ist, dass ich Eingaben durchführe a, die Länge von aund das Markieren als n, und eine Ausgabevariable setze o. Für jedes Zeichen, das ich finde und das nicht das erste Zeichen von a ( a's character 1) enthält, verkette ich es mit o. Die letzte Zeile wird gedruckt o.

Hinweis: Dies unterstützt automatisch alle Unicode. c:

Addison Crump
quelle
3
My only consolation is that I beat Brainfuck.sieht so aus, als würde ich besser Golf spielen;)
undergroundmonorail
1

Retina , 16 Bytes

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

Speichern Sie den Code mit einem nachfolgenden Zeilenumbruch und führen Sie ihn mit dem -sFlag aus.

Wie es funktioniert: Der nachfolgende Zeilenvorschub macht dies zu einer Ersetzungsphase, sodass alle Übereinstimmungen mit dem angegebenen regulären Ausdruck durch eine leere Zeichenfolge ersetzt werden. Der iModus "Groß- und Kleinschreibung wird nicht berücksichtigt" aktiviert, wodurch auch die Groß- und Kleinschreibung nicht berücksichtigt wird. Schließlich vergleicht und erfasst der reguläre Ausdruck einfach ein einzelnes Zeichen und prüft dann anhand eines Rückverweises, ob das erste Zeichen in der Zeichenfolge dasselbe ist (bis auf Groß- / Kleinschreibung).

Martin Ender
quelle