Supprimer toutes les occurrences de la première lettre d'une chaîne de la chaîne entière


24

É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 , 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.

Avons-nous besoin de gérer le cas où la sortie est la chaîne vide? Que faire si l'entrée est une chaîne vide?
lirtosiast

@ThomasKwa, vous pouvez supposer que la sortie comportera toujours 2 caractères ou plus
GamrCorps

@ThomasKwa et la sortie ne seront jamais vides
GamrCorps

Réponses:


9

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 

2
Neat, je n'en savais rien. +1
FryAmTheEggman

14

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

]

Veuillez ne pas trop jouer au golf . c: J'ai travaillé si dur ...
Addison Crump

13

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

Agréable. Je pensais à la façon dont Perl ferait probablement mal à cause de la nécessité d'écrire, substrmais bien sûr, vous avez trouvé une bien meilleure façon!
Hobbs

Pourquoi comptez-vous le hashbang comme un octet?
Zereges

@Zereges la ligne shebang n'est pas nécessaire, si le script est appelé comme perl -p script.pl. Les options de ligne de commande sont généralement comptées comme un octet chacune, au moins sur ce site.
Primo

@primo je vois, merci.
Zereges

10

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.

J'ai à l'origine créé ce défi pour apprendre CJam, et je n'ai jamais connu la chose XOR!
GamrCorps

2
Personnellement, je trouve surprenant que n'importe quelle langue - à l'exception peut-être de sed - puisse battre perl dans ce défi.
primo

@primo - Vous n'avez pas remarqué que CJam et / ou Pyth gagnent à peu près 99% de ceux-ci? Perl s'en est plutôt bien sorti, étant donné qu'il est le seul à ne pas être spécifiquement conçu comme langage de golf.
Darrel Hoffman

La surcharge des opérateurs de Pyth et CJam est ridicule. moins (chaîne, chaîne) effectuant la suppression par caractère n'est pas une opération principale dans toute autre langue que j'ai rencontrée.
Sparr

@Sparr APL a le même intégré. (Cela s'appelle ~cependant.)
Dennis

7

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.



5

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

3
Au moins dans les navigateurs que j'ai essayés, newc'est facultatif, donc RegExp(x[0],'gi')plus court.
Neil


3

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.


1
Même si le shebang entier est compté (c'est-à-dire un programme "complet"), il #!perl -pest toujours deux octets plus court que $_=<>;print.
primo

@primo Je n'ai jamais utilisé aucune des options de mes golfs. Je viens de googler ce que fait l' -poption. Il n'y a pas vraiment de modifications que je puisse apporter à ma réponse sans la rendre identique à la vôtre.
PhiNotPi

3

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


3

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

3

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


3

Python, 66 caractères

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

5
@ThomasKwa que diriez-vous non.
TheDoctor du

3

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.



2

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)

2

Rubis, 25 octets

Fonction anonyme:

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

Programme complet, 29 octets:

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

2

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(...)?


1
@ThomasKwa vous devriez peut-être soumettre cela comme votre propre réponse; il semble trop différent du mien pour compter comme ma soumission.
cole

@ThomasKwa Plus court à faire x[0]+x[0].swapcase().
2015 à 8h08

1
Ou @ThomasKwa, le vol de la solution Pyth de FryAmTheEggman, (x[0]*2).title().
2015

@xnor ouais, j'ai trouvé ça quand j'ai lu le leur il y a quelques heures.
lirtosiast

lambda x:x.replace(x[0].upper(),'').replace(x[0].lower(),'')- 60 octets
Mego

2

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


2

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


compile-t-il même?
Abr001am

1
Oui. Il compile sur ma machine (avec avertissements) et fonctionne. Vous pouvez également le tester sur cette page: golf.shinh.org/check.rb
xsot

Oui; +1
Abr001am

2

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.


2

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 .

1
:DJe vote toujours Vim!
DJMcMayhem

1

Haskell, 52 octets

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

2
Liste compréhension permet d' économiser 1 octet: r(h:s)=[c|c<-s,t c/=t h].
nimi

1

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.


1

Lua, 93 78 octets

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

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


1

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


1
Vous pouvez raccourcir main(int c,char**v)vers main(c,v)char**v;et (**v-c)%32vers **v-c&31.
Dennis

1

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

Vous ne pouvez pas utiliser à la &&putchar(c)place de ?putchar(c):0?
Neil

@Neil Merci, maintenant j'ai moins de 100 octets!
Zereges

@ThomasKwa Bien sûr que je peux, merci.
Zereges

1
Pouvez-vous faire f-c&31comme dans la réponse C?
lirtosiast

1

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:


3
My only consolation is that I beat Brainfuck. looks like i'd better get golfing ;)
undergroundmonorail

1

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.