Rimuovi tutte le occorrenze della prima lettera di una stringa dall'intera stringa


24

Dato una stringa di input contenente solo i caratteri A-Z, a-ze spazi, rimuovere tutte le occorrenze delle versioni maiuscole e minuscole del primo carattere della stringa (se il primo carattere è Arimuovere tutti As e as, se il primo carattere è (spazio) rimuovi tutti gli spazi) e stampare l'output.

Casi di esempio:

  • 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

Questo è , vince il codice più corto in byte!

Gli appunti:

  • L'input sarà sempre di 2 o più caratteri validi.
  • L'output non sarà mai una stringa vuota.

Dobbiamo gestire il caso in cui l'output è la stringa vuota? Cosa succede se l'input è la stringa vuota?
lirtosiast,

@ThomasKwa potresti supporre che l'output sarà sempre di 2 o più caratteri
GamrCorps,

@ThomasKwa e l'output non saranno mai vuoti
GamrCorps il

Risposte:


9

Pyth, 7 byte

-zrBhz2

Provalo online: Dimostrazione o Test Suite

Bello. Il nuovo operatore biforcuto (solo 8 giorni) aiuta qui a salvare un carattere. Penso che questo sia il primo codice che utilizza questa funzionalità.

Spiegazione

-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
Bene, non lo sapevo. +1
FryAmTheEggman,

14

brainfuck, 219 byte

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

(Richiede un nastro che consenta al puntatore di andare ai negativi o alla fine se lo tenta. Richiede anche ,di restituire 0 su EOF. Nella mia esperienza, la maggior parte degli interpreti soddisfa questi requisiti per impostazione predefinita.)

Questo in realtà si è rivelato abbastanza semplice! Non sarei sorpreso se è golfabile (ho qualche idea di dove potrebbero essere sprecati byte, ma non sono super sicuro se andrà in panico). Tuttavia, farlo funzionare non è stato affatto una sfida.

Questo codice tratta tutto con un valore ASCII inferiore a 97 come un carattere maiuscolo. Se il primo carattere è spazio, proverà a rimuovere qualsiasi occorrenza di uno "spazio minuscolo" (cioè chr(32+32), cioè @) dalla stringa. Va bene, perché saranno mai presenti solo lettere e spazi.

Con commenti:

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

]

Per favore, non golfare troppo . c: ho lavorato così duramente ...
Addison Crump,

13

Perl, 13 byte

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

Contando lo shebang come uno, l'input è preso dallo stdin.


Esempio di utilizzo

$ 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

Bello. Stavo pensando a come probabilmente Perl avrebbe fatto male a causa della necessità di scrivere, substrma ovviamente hai trovato un modo molto migliore!
Hobbs,

Perché conti hashbang come un byte?
Zereges,

@Zereges the shebang line non è necessario, se lo script è invocato come perl -p script.pl. Le opzioni della riga di comando vengono normalmente contate come un byte ciascuna, almeno su questo sito.
primo

@primo, grazie.
Zereges,

10

CJam, 8 byte

q(_32^+-

Provalo online nell'interprete CJam .

Come funziona

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.

Inizialmente ho creato questa sfida per imparare CJam e non ho mai saputo della cosa XOR!
GamrCorps,

2
Personalmente trovo sorprendente che qualsiasi lingua , ad eccezione di forse sed, possa battere il Perù in questa sfida.
primo

@primo - Non hai notato che CJam e / o Pyth ne vincono praticamente il 99%? Perl ha fatto abbastanza bene, considerando che è l'unico non specificamente progettato come un linguaggio da golf.
Darrel Hoffman,

Il sovraccarico dell'operatore di Pyth e CJam è ridicolo. meno (stringa, stringa) che esegue la rimozione per carattere non è un'operazione principale in qualsiasi altra lingua che abbia mai incontrato.
Sparr,

@Sparr APL ha lo stesso built-in. (Si chiama ~però.)
Dennis il

7

Pyth, 8 byte

-zr*2hz3

Provalo online

Utilizza la versione di Python di Python str.titleper convertire una stringa della prima lettera due volte nel modulo "<Upper><Lower>". Quindi rimuove ogni elemento dall'input che si trova in quella stringa. Gli spazi funzionano bene perché non sono interessati da str.title.



5

JavaScript (ES6), 38 36 byte

Ciò non dipende dal flagsparametro specifico di Mozilla.

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

CoffeeScript, 39 37 byte

Per una volta è più breve in JS di CoffeeScript!

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

3
Almeno nei browser che ho provato, newè facoltativo, quindi RegExp(x[0],'gi')è più breve.
Neil,


3

Perl, 27 byte

Questo è un programma completo, sebbene sia basato solo su 2 regex che probabilmente potrebbero essere copiati in un programma Retina per salvare byte sull'I / O.

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

Modifica: sembra che questo sia già stato battuto con qualcuno usando l' -popzione. Oh, e usando $&invece di $1.


1
Anche se viene conteggiato l'intero shebang (ovvero un programma "completo") #!perl -pè ancora più breve di due byte rispetto a $_=<>;print.
primo

@primo Non ho mai usato nessuna delle opzioni nei miei campi da golf. Ho appena cercato su Google cosa fa l' -popzione. Non ci sono davvero modifiche che posso apportare alla mia risposta senza renderla identica alla tua.
PhiNotPi

3

Minkolang 0.9 , 23 33 byte

In nessun modo questo vincerà ma eh, è ​​divertente!

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

Provalo qui.

Spiegazione

" 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

(Questo potrebbe non riuscire in alcuni casi limite, come se il primo carattere fosse un simbolo.)


3

TECO , 15 14 byte

Modifica del testo? In caso di dubbi, utilizzare l'Editor di testo e COrrecter!

Dopo molti tentativi ed errori (principalmente errori), penso che questo sia il programma TECO generico più breve che farà il lavoro.

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

O, in forma leggibile dall'uomo

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

$rappresenta la chiave di escape e ^Erappresenta la sequenza CTRL+ E. A seconda del sapore di TECO che stai usando, potrebbe riconoscere queste sostituzioni ASCII, oppure no.

Secondo il manuale, alcuni dialetti di TECO accettano questa versione di 13 byte (usando un comando find-and-delete anziché i comandi separati "find" e "delete") invece:

0,1XA<FD^EQA$>

3

Pip, 8 byte

aR-Xa@0x

Accetta la stringa come argomento della riga di comando (dovrà essere citato se contiene spazi). Spiegazione:

          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)

Questa soluzione ha l'ulteriore vantaggio di lavorare su stringhe contenenti qualsiasi caratteri ASCII stampabili. (L' Xoperatore esegue una backslash per sfuggire a tutto ciò che non è alfanumerico.)


3

Python, 66 caratteri

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

5
@ThomasKwa che ne dici di no.
TheDoctor,

3

Julia, 34 byte

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

Ciò crea una funzione senza nome che accetta una stringa e restituisce una stringa. Costruisce un'espressione regolare senza distinzione tra maiuscole e minuscole dal primo carattere nell'input e sostituisce tutte le occorrenze di quella con una stringa vuota.



2

R, 43 byte

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

Questo è un programma completo che legge una riga da STDIN e scrive il risultato modificato su 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)

2

Rubino, 25 byte

Funzione anonima:

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

Programma completo, 29 byte:

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

2

Python, 61 byte (troppi)

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

Immagino che ci sia un modo migliore per farlo, ma non riesco a trovarlo. Qualche idea su come rimuovere il "".join(...)?


1
@ThomasKwa forse dovresti inviarlo come risposta personale; sembra troppo diverso dal mio per essere considerato il mio contributo.
Cole

@ThomasKwa Shorter da fare x[0]+x[0].swapcase().
xnor

1
@ThomasKwa Oppure, rubando dalla soluzione Pyth di FryAmTheEggman, (x[0]*2).title().
xnor

@xnor sì, l'ho scoperto quando ho letto il loro poche ore fa.
lirtosiast,

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

2

Ouroboros , 61 byte

Ehi, è più corto di C ++! Ha.

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

In Ouroboros, ogni riga del programma rappresenta un serpente con la coda in bocca. Il flusso di controllo si ottiene mangiando o rigurgitando sezioni di coda, con uno stack condiviso da sincronizzare tra i serpenti.

Snake 1

i.legge un carattere dall'input e lo duplica. .91<\64>*32*spinge 32se il personaggio era una lettera maiuscola, 0altrimenti. +ing che al personaggio converte le lettere maiuscole in minuscole lasciando invariate le lettere minuscole e gli spazi. Tutto ciò è avvenuto nello stack di snake 1, quindi ora spostiamo il valore nello stack condiviso ( m) per l'elaborazione di snake 2. Infine, 1(mangia l'ultimo personaggio della coda di Snake 1. Poiché è qui che si trova il puntatore dell'istruzione, il serpente muore.

Snake 2

)non ha alcun effetto la prima volta. L!34*spinge 34se lo stack condiviso è vuoto, 0altrimenti. Quindi .inganniamo e (mangiamo tanti personaggi.

  • Se lo stack condiviso era vuoto, questo mette la fine del serpente subito dopo che (abbiamo appena eseguito. Pertanto, il controllo ritorna all'inizio della riga, dove )rigurgita i personaggi che abbiamo appena mangiato (dopo averne già premuto una copia aggiuntiva 34) e ripeti il ​​test di lunghezza dello stack.
  • Se lo stack condiviso non era vuoto, nessun personaggio viene mangiato, ';' elimina il supplemento 0e l'esecuzione continua:

Sipassa allo stack condiviso e immette un altro personaggio. .1+!24*spinge 24se quel personaggio era -1 / EOF, 0altrimenti. Su EOF, (ingoia 24 caratteri - incluso l'IP - e il serpente muore. Altrimenti, l'esecuzione continua.

Ytira una copia della parte superiore dello stack condiviso (il personaggio che abbiamo appena letto) nello stack di snake 2 per uso futuro. Quindi .@@.@=@.@32-=\@+2*calcola se il nuovo personaggio è uguale al primo o al primo carattere meno 32, spingendo in 2tal 0caso e in caso contrario. Noi .duplicare e (mangiare che molti personaggi:

  • Se i personaggi combaciano, torniamo direttamente alla testa del serpente, dove ( rigurgita i 2 personaggi che abbiamo appena mangiato e l'esecuzione procede con il personaggio successivo.
  • In caso contrario, yricolleghiamo il personaggio dallo stack di oSnake 2, lo rendiamo disponibile e quindi eseguiamo il loop.

Guardalo in azione


2

C, 60 byte

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

Modifica: risolto un bug che causava la stampa di un byte null all'inizio


compila anche?
Abr001am

1
Sì. Si compila sulla mia macchina (con avvertenze) e funziona. Puoi anche provarlo su questa pagina: golf.shinh.org/check.rb
xsot,

si lo fa; +1
Abr001am

2

Python 2, 43

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

Questo è in qualche modo basato sulla mia risposta Pyth, ma è anche correlato ad alcuni commenti di ThomasKwa e xnor da qui . Per lo più pubblicare perché volevo che questa risposta esistesse.


2

Vim, 30 sequenze di tasti

Mi dispiace scoprire, ma non vedo alcuna risposta Vim D:

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

Spiegazione:

  1. If<Right>xh@x.<Esc>
    Scrivere una macro (ricorsiva) attorno al primo carattere È necessario spostarsi a
    sinistra ( h) per rimanere alla sinistra del carattere non letto successivo
    L'aggiunta di qualsiasi carattere ( .) alla fine è necessaria nel caso in cui sia necessario rimuovere il secondo
  2. "xy0 Copia la macro nel registro x
  3. 7| Passa al 7 ° carattere
  4. @x Esegui la macro da x
  5. 2|~ Cambia il caso del primo carattere (in realtà nella seconda posizione)
  6. 0"xd7| Taglia la macro nel registro x
  7. @x Esegui la macro da x
  8. 0x Rimuovere il segnaposto .

1
:DHo sempre votato Vim!
DJMcMayhem

1

Haskell, 52 byte

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

2
Di lista consente di risparmiare 1 byte: r(h:s)=[c|c<-s,t c/=t h].
nimi,

1

TI-BASIC, 164 byte

Per calcolatrici grafiche 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 è chiaramente lo strumento sbagliato per il lavoro.

  • Non ha un comando per rimuovere i caratteri, quindi dobbiamo scorrere la stringa e aggiungere caratteri se non corrispondono a ciò che deve essere rimosso.
  • Non supporta stringhe vuote, quindi dobbiamo iniziare la stringa con le due lettere da rimuovere, costruire l'output alla fine e tagliare i primi due caratteri.
  • Non ha comandi di cambio maiuscole, quindi è necessario codificare l'intero alfabeto ...
    • due volte...
    • Ho menzionato lettere minuscole che prendono due byte ciascuna nella codifica TI-BASIC?

Non ne sono sicuro al 100%, ma ho trascorso oltre sei ore su questo e sembra essere la soluzione più breve possibile.

Per testarlo con input non maiuscoli (o per digitarlo nella tua calcolatrice), crea un programma diverso con i contenuti AsmPrgmFDCB24DEC9ed eseguilo usando Asm([whatever you named it]per abilitare la modalità di scrittura minuscola.


1

Lua, 93 78 byte

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

1

Lisp comune, 77

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

Maledici questi nomi di funzioni lunghe (e parentesi (ma comunque li adoro comunque:: 3))).


1

C, 65 61 byte

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

Compila con avvisi. Legge la stringa da argv[1]. Esempio online


1
È possibile ridurre main(int c,char**v)a main(c,v)char**v;, e (**v-c)%32al **v-c&31.
Dennis,

1

C ++, 100 99 98 byte

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

Solo un altro byte per ottenere meno di 100. getchar()ritorna -1quando legge la fine del flusso, quindi è per questo che ~è dentrofor ciclo. ( ~-1 == 0)

Ungolfed

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

Non puoi usare &&putchar(c)invece di ?putchar(c):0?
Neil,

@Neil Grazie, adesso ho meno di 100 byte!
Zereges,

@ThomasKwa Certo che posso, grazie.
Zereges,

1
Puoi fare f-c&31come nella risposta C?
lirtosiast,

1

AppleScript, 209 201 byte

La mia unica consolazione è che ho battuto Brainfuck.

impostare un testo di (visualizza la finestra di dialogo "" risposta predefinita "") restituito
imposta n sul numero di caratteri di a
impostare o su ""
ripetere n
se non il carattere di a n = carattere di a 1, imposta o sul carattere di a n & o
impostare n su n-1
fine
o

Il modo in cui funziona è che prendo l'input a, ottengo la lunghezza ae lo contrassegno come ne imposto una variabile di output o. Per ogni personaggio che trovo che non contiene il primo carattere di a ( a's character 1), lo concateno o. Viene stampata la riga finale o.

Nota: supporta automaticamente tutti gli Unicode. c:


3
My only consolation is that I beat Brainfuck.sembra che farei meglio a giocare a golf;)
undergroundmonorail

1

Retina , 16 byte

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

Salvare il codice con un avanzamento riga finale ed eseguirlo con il -sflag.

Come funziona: il trailing linefeed rende questo uno stadio di sostituzione, in modo tale che qualsiasi corrispondenza del regex dato venga sostituita con una stringa vuota. I igiri su modalità case-insensitive che rende anche backreference case-insensitive. Infine, il regex semplicemente abbina e acquisisce un singolo carattere e quindi controlla se il primo carattere nella stringa è lo stesso (fino al caso) usando un backreference.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.