Eliminar todas las apariciones de la primera letra de una cadena de toda la cadena


24

Dada una cadena de entrada que solo contiene los caracteres A-Z, a-zy espacios, elimine todas las apariciones de las versiones en mayúsculas y minúsculas del primer carácter de la cadena (si el primer carácter es Aeliminar todos los Asy as, si el primer carácter es (espacio) eliminar todos los espacios) e imprima la salida.

Ejemplos de casos:

  • 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

Este es el , el código más corto en bytes gana.

Notas:

  • La entrada siempre será de 2 o más caracteres válidos.
  • La salida nunca será una cadena vacía.

¿Necesitamos manejar el caso donde la salida es la cadena vacía? ¿Qué pasa si input es la cadena vacía?
lirtosiast

@ThomasKwa puede suponer que la salida siempre será de 2 o más caracteres
GamrCorps

@ThomasKwa y la salida nunca estará vacía
GamrCorps

Respuestas:


9

Pyth, 7 bytes

-zrBhz2

Pruébelo en línea: Demostración o conjunto de pruebas

Agradable. El nuevo operador bifurcado (solo 8 días de antigüedad) ayuda aquí a ahorrar un carbón. Creo que este es el primer código que usa esta función.

Explicación

-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, no sabía sobre eso. +1
FryAmTheEggman

14

brainfuck, 219 bytes

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

(Requiere cinta que permita que el puntero vaya a los negativos o bucles hasta el final si lo intenta. También requiere ,devolver 0 en EOF. En mi experiencia, la mayoría de los intérpretes cumplen estos requisitos de forma predeterminada).

¡Esto en realidad resultó ser bastante fácil! No me sorprendería si es golfable (tengo alguna idea de dónde podría haber bytes desperdiciados, pero no estoy muy seguro de si funcionará). Aún así, hacerlo funcionar no fue realmente un desafío en absoluto.

Este código trata todo con un valor ASCII por debajo de 97 como un carácter en mayúscula. Si el primer carácter es el espacio, intentará eliminar cualquier aparición de un "espacio en minúscula" (es decir chr(32+32), es decir @) de la cadena. Esto está bien, porque solo las letras y los espacios estarán presentes.

Con comentarios:

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

]

Por favor, no juegues demasiado al golf . c: Trabajé muy duro ...
Addison Crump

13

Perl, 13 bytes

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

Contando el shebang como uno, la entrada se toma de stdin.


Uso de muestra

$ 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

Agradable. Estaba pensando en cómo Perl probablemente lo haría mal debido a la necesidad de escribir, ¡ substrpero por supuesto se te ocurrió una forma mucho mejor!
hobbs

¿Por qué cuentas hashbang como un byte?
Zereges

@Zereges, la línea shebang no es necesaria, si el script se invoca como perl -p script.pl. Las opciones de línea de comando se cuentan habitualmente como un byte cada una, al menos en este sitio.
primo

@primo Ya veo, gracias.
Zereges

10

CJam, 8 bytes

q(_32^+-

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

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.

Originalmente creé este desafío para aprender CJam, ¡y nunca supe lo de XOR!
GamrCorps

2
Personalmente, me sorprende que cualquier idioma , con excepción de quizás sed, pueda vencer a Perl en este desafío.
primo

@primo - ¿No has notado que CJam y / o Pyth ganan casi el 99% de estos? Sin embargo, Perl lo hizo bastante bien, teniendo en cuenta que es el único que no está específicamente diseñado como lenguaje de golf.
Darrel Hoffman

La sobrecarga de operadores de Pyth y CJam es ridícula. menos (cadena, cadena) realizar la eliminación por carácter no es una operación central en ningún otro idioma que haya encontrado.
Sparr

@Sparr APL tiene el mismo incorporado. (Sin ~embargo, se llama .)
Dennis

7

Pyth, 8 bytes

-zr*2hz3

Pruébalo en línea

Utiliza la versión de Python de Python str.titlepara convertir una cadena de la primera letra dos veces en el formulario "<Upper><Lower>". Luego, elimina cada elemento de la entrada que está en esa cadena. Los espacios funcionan bien porque no se ven afectados por ellos str.title.



5

JavaScript (ES6), 38 36 bytes

Esto no depende del flagsparámetro específico de Mozilla.

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

CoffeeScript, 39 37 bytes

¡Por una vez es más corto en JS que CoffeeScript!

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

3
Al menos en los navegadores que probé, el newes opcional, por lo que RegExp(x[0],'gi')es más corto.
Neil


3

Perl, 27 bytes

Este es un programa completo, aunque solo se basa en 2 expresiones regulares que probablemente podrían copiarse en un programa Retina para guardar bytes en E / S.

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

Editar: Parece que esto ya ha sido golpeado con alguien que usa la -popción. Ah, y usando en $&lugar de $1.


1
Incluso si se cuenta todo el shebang (es decir, un programa "completo"), #!perl -p sigue siendo dos bytes más corto que $_=<>;print.
primo

@primo Nunca he usado ninguna de las opciones en mis campos de golf. Acabo de buscar en Google lo que hace la -popción. Realmente no hay modificaciones que pueda hacer a mi respuesta sin hacerla idéntica a la suya.
PhiNotPi

3

Minkolang 0.9 , 23 33 bytes

De ninguna manera esto ganará, pero eh, ¡es divertido!

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

Pruébalo aquí

Explicación

" 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

(Esto puede fallar en algunos casos extremos, como si el primer carácter es un símbolo).


3

TECO , 15 14 bytes

¿Edición de texto? En caso de duda, utilice el editor de texto y el corrector.

Después de mucho ensayo y error (principalmente error), creo que este es el programa TECO genérico más corto que hará el trabajo.

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

O, en forma legible por humanos

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

$ representa la tecla de escape, y ^E representa la secuencia CTRL+ E. Dependiendo del sabor de TECO que esté usando, puede reconocer estas sustituciones ASCII, o puede que no.

De acuerdo con el manual, algunos dialectos de TECO aceptan esta versión de 13 bytes (usando un comando de buscar y eliminar en lugar de los comandos separados "buscar" y "eliminar") en su lugar:

0,1XA<FD^EQA$>

3

Pip, 8 bytes

aR-Xa@0x

Toma la cadena como un argumento de línea de comandos (deberá ser citado si contiene espacios). Explicación:

          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)

Esta solución tiene la ventaja adicional de trabajar en cadenas que contengan cualquier caracteres ASCII imprimibles. (La Xbarra diagonal inversa del operador escapa a todo lo que no sea alfanumérico).


3

Python, 66 char

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

55
@ThomasKwa ¿qué tal no.
TheDoctor

3

Julia, 34 bytes

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

Esto crea una función sin nombre que acepta una cadena y devuelve una cadena. Construye una expresión regular que no distingue entre mayúsculas y minúsculas a partir del primer carácter en la entrada y reemplaza todas las apariciones de eso con una cadena vacía.



2

R, 43 bytes

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

Este es un programa completo que lee una línea de STDIN y escribe el resultado modificado en STDOUT.

Sin 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

Rubí, 25 bytes

Función anónima:

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

Programa completo, 29 bytes:

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

2

Python, 61 bytes (demasiados)

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

Me imagino que hay una mejor manera de hacerlo, pero parece que no puedo encontrarlo. ¿Alguna idea sobre cómo eliminar el "".join(...)?


1
@ThomasKwa quizás deberías enviar eso como tu propia respuesta; parece demasiado diferente al mío para contarlo como mi sumisión.
cole

@ThomasKwa Más corto que hacer x[0]+x[0].swapcase().
xnor

1
@ThomasKwa O, el robo de la solución de Pyth FryAmTheEggman, (x[0]*2).title().
xnor

@xnor sí, lo encontré cuando leí el suyo hace unas horas.
lirtosiast

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

2

Ouroboros , 61 bytes

¡Hola, es más corto que C ++! Decir ah.

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

En Ouroboros, cada línea del programa representa una serpiente con la cola en la boca. El flujo de control se logra comiendo o regurgitando secciones de la cola, con una pila compartida para sincronizar entre las serpientes.

Serpiente 1

i.lee un carácter de entrada y lo duplica. .91<\64>*32*empuja 32si el carácter era una letra mayúscula, de lo 0contrario. +Al convertir esto en caracteres, las letras mayúsculas se convierten en minúsculas y se dejan las letras minúsculas y los espacios sin cambios. Todo esto ha tenido lugar en la pila de la serpiente 1, por lo que ahora enviamos el valor a la pila compartida ( m) para que la serpiente 2 lo procese. Finalmente,1( come el último personaje de la cola de la serpiente 1. Como ahí es donde está el puntero de instrucción, la serpiente muere.

Serpiente 2

)no tiene efecto la primera vez. L!34*empuja 34si la pila compartida está vacía, de lo 0contrario. Luego nos .duplicamos y (comemos tantos personajes.

  • Si la pila compartida estaba vacía, esto pone el final de la serpiente justo después del (que acabamos de ejecutar. Por lo tanto, los bucles de control vuelven al principio de la línea, donde )regurgita los caracteres que acabamos de comer (habiendo empujado previamente una copia adicional de 34) y repite la prueba de longitud de la pila.
  • Si la pila compartida no estaba vacía, no se comen caracteres, ';' suelta el extra 0y la ejecución continúa:

Sicambia a la pila compartida e ingresa otro carácter. .1+!24*empuja 24si ese personaje era -1 / EOF, de lo 0contrario. En EOF, se (traga 24 caracteres, incluida la IP, y la serpiente muere. De lo contrario, la ejecución continúa.

Ytira de una copia de la parte superior de la pila compartida (el personaje que acabamos de leer) a la propia pila de la serpiente 2 para uso futuro. Luego .@@.@=@.@32-=\@+2*calcula si el nuevo personaje es igual al primer personaje o al primer personaje menos 32, presionando 2si es así y 0si no. Hemos .duplicado y (comemos ese número de caracteres:

  • Si los personajes coinciden, volvemos directamente a la cabeza de la serpiente, donde ( regurgita los 2 personajes que acabamos de comer y la ejecución continúa con el siguiente personaje.
  • Si no, yrecuperamos el carácter de la pila de la serpiente 2, lo opronunciamos y luego hacemos un bucle.

Véalo en acción


2

C, 60 bytes

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

Editar: se corrigió un error que causaba que se imprimiera un byte nulo al principio


¿siquiera compila?
Abr001am

1
Sí. Se compila en mi máquina (con advertencias) y funciona. También puede probarlo en esta página: golf.shinh.org/check.rb
xsot

si lo hace; +1
Abr001am

2

Pitón 2, 43

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

Esto está algo basado en mi respuesta de Pyth, pero también está relacionado con algunos comentarios de ThomasKwa y xnor de aquí . Principalmente publicando porque quería que esta respuesta existiera.


2

Vim, 30 pulsaciones de teclas

Perdón por descubrir, pero no veo ninguna respuesta Vim D:

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

Explicación:

  1. If<Right>xh@x.<Esc>
    Escriba una macro (recursiva) alrededor del primer carácter
    Se hnecesita mover a la izquierda ( ) para permanecer a la izquierda del siguiente carácter no leído Se necesita
    agregar cualquier carácter ( .) al final en caso de que se deba eliminar el segundo
  2. "xy0 Copie la macro en el registro x
  3. 7| Moverse al séptimo personaje
  4. @x Ejecute la macro desde x
  5. 2|~ Cambia la caja del primer personaje (en realidad en la segunda posición)
  6. 0"xd7| Cortar la macro en el registro x
  7. @x Ejecute la macro desde x
  8. 0x Retire el marcador de posición .

1
:DSiempre voté vim!
DJMcMayhem

1

Haskell, 52 bytes

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

2
La comprensión de la lista guarda 1 byte: r(h:s)=[c|c<-s,t c/=t h].
nimi

1

TI-BASIC, 164 bytes

Para calculadoras gráficas de la 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 es claramente la herramienta incorrecta para el trabajo.

  • No tiene un comando para eliminar caracteres, por lo que debemos recorrer la cadena y agregar caracteres si no coinciden con lo que se va a eliminar.
  • No admite cadenas vacías, por lo que debemos comenzar la cadena con las dos letras que se eliminarán, generar la salida en el extremo y cortar los primeros dos caracteres.
  • No tiene comandos de cambio de mayúsculas y minúsculas, por lo que debemos codificar todo el alfabeto ...
    • dos veces...
    • ¿Mencioné que las letras minúsculas toman dos bytes cada una en la codificación TI-BASIC?

No estoy 100% seguro, pero pasé más de seis horas en esto, y parece ser la solución más corta posible.

Para probar esto con entradas no mayúsculas (o para escribirlo en su calculadora), haga un programa diferente con el contenido AsmPrgmFDCB24DEC9y ejecútelo Asm([whatever you named it]para habilitar el modo de escritura en minúsculas.


1

Lua, 93 78 Bytes

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

1

Lisp común, 77

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

Maldecir estos nombres largos de funciones (y paréntesis (pero todavía los amo de todos modos (: 3))).


1

C, 65 61 bytes

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

Compila con advertencias. Lee una cadena de argv[1]. Ejemplo en línea


1
Puedes acortar main(int c,char**v)a main(c,v)char**v;, y (**v-c)%32a **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);}

Solo un byte más para obtener menos de 100. getchar()devoluciones-1 cuando lee el final de la transmisión, por eso es que ~está en forciclo. ( ~-1 == 0)

Sin golf

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

¿No puedes usar en &&putchar(c)lugar de ?putchar(c):0?
Neil

@Neil ¡Gracias, ahora tengo menos de 100 bytes!
Zereges

@ThomasKwa Por supuesto que puedo, gracias.
Zereges

1
¿Se puede hacer f-c&31como en la respuesta C?
lirtosiast

1

AppleScript, 209201 bytes

Mi único consuelo es que vencí a Brainfuck.

establezca el texto devuelto a (mostrar diálogo "" respuesta predeterminada "")
establecer n en el número de caracteres de a
establecer o en ""
repetir n
si no es el carácter de a n = el carácter de a 1, entonces configure o en el carácter de a n & o
establecer n en n-1
fin
o

Cómo funciona esto es que tomo información a, obtengo la longitud ay la marco como n, y establezco una variable de salida o. Por cada carácter que encuentro que no contiene el primer carácter de a ( a's character 1), lo concateno con o. La línea final se imprime o.

Nota: Esto admite automáticamente todos los Unicode. do:


3
My only consolation is that I beat Brainfuck.parece que será mejor que juegue al golf;)
undergroundmonorail

1

Retina , 16 bytes

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

Guarde el código con un salto de línea final y ejecútelo con la -sbandera.

Cómo funciona: el avance de línea final hace que esta sea una etapa de reemplazo, de modo que cualquier coincidencia de la expresión regular dada se reemplace con una cadena vacía. Las ivueltas en el modo de mayúsculas y minúsculas que también hace referencias hacia atrás entre mayúsculas y minúsculas. Finalmente, la expresión regular simplemente coincide y captura un solo carácter y luego comprueba si el primer carácter de la cadena es el mismo (hasta el caso) utilizando una referencia inversa.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.