No A, solo BLOQ MAYÚS

197

¿Qué sucede cuando la CapsLocktecla de su teclado no tiene una muesca?

"Esto pasa".

El objetivo de este programa es emular constantemente las fallas del teclado donde Ase reemplaza cada pulsación CapsLock. Las 'A' mayúsculas de la fuente deberían producir el mismo efecto. Cuando CapsLockestá habilitado, se invierte la capitalización.

Casos de prueba

"The quick brown fox jumps over the lazy dog."
-> "The quick brown fox jumps over the lZY DOG."

"Compilation finished successfully."
-> "CompilTION FINISHED SUCCESSFULLY."

"What happens when the CapsLock key on your keyboard doesn't have a notch in it?"
-> "WhT Hppens when the CPSlOCK KEY ON YOUR KEYBOrd doesn't hVE  notch in it?"

"The end of the institution, maintenance, and administration of government, is to secure the existence of the body politic, to protect it, and to furnish the individuals who compose it with the power of enjoying in safety and tranquillity their natural rights, and the blessings of life: and whenever these great objects are not obtained, the people have a right to alter the government, and to take measures necessary for their safety, prosperity and happiness."
-> "The end of the institution, mINTENnce, ND dministrTION OF GOVERNMENT, IS TO SECURE THE EXISTENCE OF THE BODY POLITIC, TO PROTECT IT, nd to furnish the individuLS WHO COMPOSE IT WITH THE POWER OF ENJOYING IN Sfety ND TRnquillity their nTURl rights, ND THE BLESSINGS OF LIFE: nd whenever these greT OBJECTS re not obtINED, THE PEOPLE Hve  RIGHT TO lter the government, ND TO Tke meSURES NECESSry for their sFETY, PROSPERITY nd hPPINESS."

"aAaaaaAaaaAAaAa"
-> "" (Without the notch, no one can hear you scream)

"CapsLock locks cAPSlOCK"
-> "CPSlOCK LOCKS CPSlOCK"

"wHAT IF cAPSlOCK IS ALREADY ON?"
-> "wHt if CPSlOCK IS lreDY ON?"

El criterio ganador es, como de costumbre, el tamaño del código fuente del programa enviado.

Broadwell
fuente
110
Bienvenido al sitio! Este es un buen primer desafío, y desafortunadamente es muy fácil de identificar para mí y mis dedos.
DJMcMayhem
55
caso de prueba sugerido:teSTateSTateSTateST
Rod
88
Si solo la tecla enter también tuviera una muesca, entonces esto no
sería
75
No suceda .......
12Me21
22
Literalmente se unió a este sitio para votar "Sin la muesca, nadie puede oírte gritar"
lucasvw

Respuestas:

115

AutoHotKey , 7 bytes

a::vk14

// ¿Es esto válido? Esto realmente hace lo que OP quiere: reemplazar apor CapsLock (vk14).

Ejecute este programa y escriba la entrada desde el teclado.

tsh
fuente
44
"¿Es esto válido?" OP no especificó restricciones de entrada o salida, así que lo consideraría válido.
Nefrin
55
¡No veo demasiadas respuestas ahk!
HaveSpacesuit
57
ES GENIAL, pero ¿cómo lo deshabilito?
RobbG
69
@RobbG simplemente escribe "killLL utohotkey" ... oh wIT
Nefrin
55
@tsh Creo que te has perdido el chiste aquí ...
RobbG
32

V , 9 bytes

ò/ãa
xg~$

Pruébalo en línea!

Hexdump:

00000000: f22f e361 0a78 677e 24                   ./.a.xg~$

Explicación:

ò       " Recursively:
 /ãa    "   Move forward to the next 'a' (upper or lowercase)
        "   This will break the loop when there are no more 'a's
x       "   Delete the 'a'
 g~$    "   Toggle the case of every character after the cursor's position.
DJMcMayhem
fuente
21

Vim, 16 bytes

qq/\ca
xg~$@qq@q

Asume que la entrada está en una sola línea

Explicación

qq            Start a loop
 /\ca␊         Find the first occurence of an a, end the loop if there are none left
 xg~$          Remove it and invert the case of the rest of the file
@qq@q         End the loop 
Herman L
fuente
¿Es este caso insensible el hallazgo de 'a'?
Gnudiff
@Gnudiff \cen cualquier parte de una búsqueda de expresiones regulares permite la insensibilidad a mayúsculas y minúsculas
Herman L
¿Necesita establecer una bandera específica para g~$trabajar? Porque para mí solo invierte mayúsculas y minúsculas hasta el final de la línea, no todo el archivo, por lo que esto realmente no funciona para archivos multilínea para mí.
Cubic
1
@Cubic Como escribí en la respuesta, "asume que la entrada está en una sola línea"
Herman L
@Cubic Si desea que vaya al final del archivo y admita entradas en varias líneas, puede hacer g~vGo vG~.
DJMcMayhem
15

C, 72 bytes

¡Gracias a @Ton Hospel por ayudar a ahorrar 16 bytes!

t,c;f(char*s){for(t=0;c=*s++;6305%c?putchar(isalpha(c)?c^t:c):(t^=32));}

Pruébalo en línea!

Steadybox
fuente
2
Puede cambiar el caso de las letras usando un xor con 32
Ton Hospel
Usted probablemente puede ahorrar aún más por tener tser 0/32en lugar de par / impar (XOR con 32 t por cada a) y luego las cartas directamente con xort
Ton Hospel
2
Buena manera de detectar a's
Ton Hospel
1
Las funciones de @TonHospel tienen que ser reutilizables , y no creo que cuente como reutilizable si necesita un código externo para que pueda volver a utilizarse después de cada llamada.
Steadybox
1
6305%ces 0 si ces 13.
Rosie F
11

Casco , 11 bytes

Γ·§?m\:€"Aa

Pruébalo en línea!

Explicación

Estoy usando la sobrecarga un tanto oscura de Γllamada listNF, que construye funciones recursivas que operan en listas. Corresponde al siguiente patrón de Haskell:

listNF f = g
  where g (x : xs) = f g x xs
        g [] = []

La idea es que listNFtoma una función auxiliar fy devuelve una nueva función g, que toma una lista. La función ftoma una función, que siempre será g, y la cabeza xy la cola xsde la lista, y hace algo con ellas. En nuestra aplicación, fllama grecursivamente xs. El programa se interpreta así:

Γ (· (§ (?m\) : (€"Aa")))
Γ (                     )  Create a function g that takes a list (x:xs) and applies a function on x and xs.
   · (                 )   Compose g with second argument of function in parentheses.
                           Instead of x and xs, the function is called on x and the result of a recursive call of g on xs.
                (€"Aa")    Check if x is 'A' or 'a'.
        (?m\)              If it is, then swap the case of every char in g(xs).
      §       :            Otherwise, prepend x to g(xs).
Zgarb
fuente
3
Wow, bueno que refrescado antes he publicado mi solución de 12 bytes: Ḟ·+m\ṁx'Ax'a. ¿Podríamos obtener una explicación? No puedo encontrar ninguna información sobre lo que Γhace exactamente y esta parece una buena oportunidad para aprender.
Sophia Lechner
1
@SophiaLechner Hecho. Esta versión de Γes un poco difícil de explicar, espero que puedas entenderla.
Zgarb
Wow esto es lento. ¿Es solo TIO?
FrownyFrog
1
@FrownyFrog Es Husk. La inferencia de tipos de programas que contienen Γparece ser lenta en general. Si no está familiarizado con Husk, un programa se interpreta al recorrer todas las estructuras posibles del programa (esencialmente las posibles ubicaciones de paréntesis) y todas las sobrecargas de cada incorporado, y elegir la primera donde el resultado es bueno. mecanografiado. El intérprete es lo suficientemente inteligente como para rechazar algunas posibilidades antes, pero parece que la versión recursiva de Γpuede interferir con este paso y obligarlo a recorrer muchas opciones.
Zgarb
@SophiaLechner Escribí un consejo que explica Γcon cierto detalle .
Zgarb
11

Retina , 33 21 17 bytes

i(Tv`lL`Ll`a.*
a

Pruébalo en línea

Explicación:

i(              i is for case-insensitive, the paren makes it modify both stages
  Tv`           Transliteration, with simple overlaps (v) - 1 match at every start pos
     lL`Ll`     Replace lowercase with uppercase, and vice versa
           a.*  Every 'a' will match, overlapping to the end of the string
                This swaps the case on all letters after each 'a'
a               Replace all 'a's with nothing

-12 bytes gracias a Martin
-4 bytes gracias a Leo

mbomb007
fuente
Sorprendentemente, esto es casi tan corto como las soluciones actuales de Pyth
Ton Hospel el
1
Creo que iT`aAlL`__Ll`a[^a]*a?también funciona para 21 bytes.
Neil
4 bytes más cortos utilizando partidos superpuestas
Leo
Estoy interesado en cómo funciona esto si tienes tiempo para agregar la explicación. ¡Gracias!
seshoumara
9

C # , 121 bytes

Console.WriteLine(string.Join("",Console.ReadLine().Split(new[]{'a','A'}).Select((a,i)=>i%2==0?a:a.ToUpper()).ToList()));

** Actualización (gracias a @John & @aloisdg) **

C # , 69 bytes

x=>string.Concat(x.Split('a','A').Select((a,i)=>i%2>0?a.ToUpper():a))
Aalawlx
fuente
2
Bienvenido a PPCG! Buena primera respuesta!
RedClover
2
puede guardar 7 bytes cambiando new[] { 'a', 'A' }a'a', 'A'
John
55
¡Puedes hacerlo en 69 bytes con la misma lógica! Pruébalo en línea! (use input / ouput en lugar de consola, elimine ToList, invierta el ternario y use el comentario de @John) Esta es una buena primera respuesta. ¡Sigue adelante!
aloisdg
3
Ambas versiones no intercambian mayúsculas y minúsculas (se transforman solo a mayúsculas) cuando CapsLock está habilitado. Este es un requisito. (Ver el último caso de prueba)
Broadwell
@Broadwell ¿Cómo saber si CapsLock está habilitado? ¿Estás seguro de que el último caso de prueba es correcto? Pasa todos los demás casos de prueba, por lo que puedo ver. ¡Gracias!
Aalawlx
7

JavaScript (ES6), 93 88 84 82 bytes

(ahorró 5 bytes gracias a @Shaggy, 4 bytes gracias a @ user81655 y 2 bytes gracias a @ l4m2.)

a=>a.replace(A=/./g,c=>c in{a,A}?(A=!A,''):A?c:c[`to${c<{}?'Low':'Upp'}erCase`]())

Casos de prueba:

Rick Hitchcock
fuente
1
['to${c<'a'?'Low':'Upp'}erCase']debería ahorrarle unos pocos bytes, reemplazando las comillas simples con backticks.
Shaggy
Claro que sí, @Shaggy. ¡Gracias!
Rick Hitchcock
El uso ^1de tener ula paridad puede permitirle inicializarlo más s=>s.replace(u=/./g,c=>/a/i.test(c)?(u^=1,''):+u?c[`to${c<'a'?'Low':'Upp'}erCase`]():c)
brevemente
También aquí hay otra forma complicada de probar la carta aque es más corta:a=>a.replace(A=/./g,c=>c in{a,A}?(A^=1,''):+A?c[`to${c<'a'?'Low':'Upp'}erCase`]():c)
user81655
Brillante, @ user81655, especialmente usando el inoperador así. ¡Siempre más para aprender!
Rick Hitchcock
6

R , 92 bytes

cat(`[<-`(v<-el(strsplit(scan(,""),"a|A")),w<-c(F,T),chartr("a-zA-Z","A-Za-z",v)[w]),sep="")

Gracias a @Giuseppe por arreglar la respuesta.

Explicación

# Write
cat(
  # Replace and return, this is the function that powers
  # the R store at index operations, a[i]<-b
  `[<-`(
    # First arg - what to replace = extract first list element
    # of a string input after splitting at a or A
    v<-el(strsplit(scan(,""),"a|A")),
    # Second arg - index to replace = abuse vector recycling
    # to create infinite F, T, F, T, F, etc series
    w<-c(F,T),
    # Third arg - replacement values = replace with case toggled letters
    chartr("a-zA-Z","A-Za-z",v)[w]),
  # Write without separation
  sep="")

Pruébalo en línea!

Vlo
fuente
Quizás no lo deje claro, pero esta respuesta no invierte las mayúsculas cuando CapsLock está habilitado (solo funciona toupper), lo cual es un requisito.
Broadwell
2
ooohhhhhhh eso es muy inteligente con el c(F,T), aunque @Broadwell tiene razón; parece que va a ser un en chartr("a-zA-Z","A-Za-z",v)[w]lugar detoupper
Giuseppe
@Giuseppe Gracias
Vlo
6

PowerShell Core , 105 bytes

"$args"|% t*y|%{if($_-in97,65){$c=!$c}else{Write-Host -n($_,("$_"|%("*per","*wer")[$_-in65..90]))[!!$c]}}

Pruébalo en línea!

Sin un operador ternario real y sin un alias predeterminado para imprimir en pantalla, no es tan corto.

  • % t*yse expande a | ForEach-Object -Method ToCharArrayequiv. de"$args".ToCharArray()
  • Write-Host -n es para el parámetro -NoNewLine
  • "$_"vuelve el [char]tipo a [string](los caracteres no tienen mayúsculas / minúsculas en .Net)
  • |% *perhace el mismo método de acceso directo de llamada que antes, pero para .ToUpper(), lo mismo con.ToLower()
  • ($a,$b)[boolean test] abusado como operador ternario falso
  • !!$cforza [bool]aquí hasta que comienza indefinido, $nullpor lo que se lo obliga a existir como "bloqueo de mayúsculas: $ falso".
TessellatingHeckler
fuente
1
Es |% t*yun buen truco que tendré que recordar. Más corto que [char[]], que uso mucho. Casi diría que debería ir al hilo de Consejos.
AdmBorkBork
94: bytes -join($args|% t*y|%{if($_-eq'a'){$c=!$c}else{(("$_"|%("*per","*wer")[$_-in65..90]),$_)[!$c]}}). gracias por un |% *ethodoperador!
mazzy
6

Perl 5 -p , 31 30 29 bytes

-1 byte gracias a @nwellnhof

-1 byte gracias a @ikegami

#!/usr/bin/perl -p
s/a([^a]*)a?/$1^uc$1^lc$1/egi

Pruébalo en línea!

Ton Hospel
fuente
¿Por qué no simplemente s/a(.*?)(a|$)/uc$1/egi(22 bytes)?
nwellnhof
@nwellnhof Debido a que el bloqueo de mayúsculas cuando está activo alterna el caso, no solo en mayúscula
Ton Hospel
1
Ah, ya veo. Entonces s/a(.*?)(a|$)/$1^uc$1^lc$1/egies un byte más corto.
nwellnhof
@nwellnhof Gracias, eso está muy bien
Ton Hospel
a([^a]*)a?es más corto quea(.*?)(a|$)
ikegami
5

Python, 63 bytes

f=lambda s:s and[s[0]+f(s[1:]),f(s[1:]).swapcase()][s[0]in"aA"]

Otra solución de Python, funciona en Python 2 y 3. Toma mucho tiempo para todas las entradas menos las pequeñas.

ManfP
fuente
5

6502 rutina de código de máquina (C64), 51 bytes

A0 00 84 FE B1 FC F0 2A C9 41 F0 06 90 1A C9 C1 D0 08 A9 80 45 FE 85 FE B0 11
B0 06 C9 5B B0 08 90 04 C9 DB B0 02 45 FE 20 16 E7 C8 D0 D6 E6 FD D0 D2 60

Espera un puntero a una cadena de entrada terminada en 0 $fc/$fd, las salidas a la pantalla.

Desmontaje comentado

 .caps:
A0 00       LDY #$00
84 FE       STY $FE             ; init capslock state
 .loop:
B1 FC       LDA ($FC),Y         ; next char from string
F0 2A       BEQ .done           ; NUL -> we're done
C9 41       CMP #$41            ; compare to 'a'
F0 06       BEQ .isa            ; if equal, toggle capslock
90 1A       BCC .out            ; if smaller, direct output
C9 C1       CMP #$C1            ; compare to 'A'
D0 08       BNE .ctog           ; if not equal, check for letter
 .isa:
A9 80       LDA #$80            ; toggle bit 7 in caps lock state
45 FE       EOR $FE
85 FE       STA $FE
B0 11       BCS .next           ; and go on
 .ctog:
B0 06       BCS .cZ             ; if char larger 'A', check for 'Z'
C9 5B       CMP #$5B            ; compare with 'z'+1
B0 08       BCS .out            ; larger or equal -> direct output
90 04       BCC .tog            ; smaller -> apply capslock
 .cZ:
C9 DB       CMP #$DB            ; compare with 'Z'+1
B0 02       BCS .out            ; larger or equal -> direct output
 .tog:
45 FE       EOR $FE             ; toggle bit from capslock state
 .out:
20 16 E7    JSR $E716           ; output char
 .next:
C8          INY                 ; and loop to next char
D0 D6       BNE .loop
E6 FD       INC $FD
D0 D2       BNE .loop
.done:
60          RTS

Ejemplo de programa ensamblador utilizando la rutina:

Demostración en línea

captura de pantalla

Código en sintaxis ca65 :

.import caps ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
string:         .res    $800

.data
prompt:         .byte   $d, "input> ", $0

.code
                lda     #$17            ; set upper/lower mode
                sta     $d018

                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<string        ; read string into buffer
                sta     $fc
                lda     #>string
                sta     $fd
                jsr     readline

                lda     #>string        ; call our caps routine on buffer
                sta     $fd
                jmp     caps

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in $fc/$fd
; NO protection agains buffer overflows !!!
.proc readline
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
                lda     $fd
                sta     $2              ; initial page of string buffer
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $fb             ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     prepout         ; no -> to normal flow
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                bne     prepout         ; not zero -> ok
                lda     $2              ; otherwise check if we're in the
                cmp     $fd             ;    first page of the buffer
                beq     getkey          ; if yes, can't use backspace
prepout:        ldx     $cf             ; check cursor phase
                beq     output          ; invisible -> to output
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                cli                     ; enable interrupts
output:         lda     $fb             ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                cli                     ; enable interrupts
                lda     $fb             ; load character
store:          cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
                inc     $fd             ; otherwise advance buffer page
                bne     getkey
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                iny
                bne     termidxok       ; and advance ...
                inc     $fd
termidxok:      sta     ($fc),y         ; store terminator in buffer
                inc     $cc             ; disable cursor blinking
                rts                     ; return
backspace:      ldy     $fe             ; load buffer index
                bne     bsidxok         ; if zero
                dec     $fd             ;   decrement current page
bsidxok:        dey                     ; decrement buffer index
                sty     $fe
                bcs     getkey          ; and get next key
.endproc        
Felix Palmen
fuente
Solo tengo que decir que admiro que te hayas esforzado por escribir en asamblea. No creo que esto tenga mucho que ver con el hecho de que solía disfrutar realmente del asm, pero tal vez tener la experiencia me hace más consciente de lo que implica. La experiencia o la facilidad están fuera del punto para mí. También me alegra un poco el día ver tanto entusiasmo.
Pryftan
@Pryftan gracias :) Es una buena manera de mantener la práctica, estoy trabajando en algún juego y recientemente también en el código de demostración de esta bonita máquina antigua :)
Felix Palmen
Bueno, es genial ver! Seguid así; Recuerdo que disfruté de un asm, pero no creo que lo disfrute tanto hoy en día (a menos que tal vez tuviera una máquina vieja como la tuya, eso es, pero posiblemente ni siquiera entonces): C es mi favorito todo el tiempo y es lo que principalmente utilizar. De todos modos, no dejaré que esto se convierta en chat, ¡solo quería decir que aprecié la respuesta!
Pryftan
5

Java 8, 119 108 98 bytes

s->{int f=0,t;for(int c:s)if((t=c&95)==65)f^=1;else System.out.printf("%c",f<1|t<66|t>90?c:c^32);}

-11 bytes gracias a @ OlivierGrégoire .
-10 bytes gracias a @Nevay .

Explicación:

Pruébalo en línea.

s->{                           // Method with char-array parameter and no return-type
  int f=0,t;                   //  Flag-integer, starting at 0
  for(int c:s)                 //  Loop over the characters of the input as integers
    if((t=c&95)==65)           //   If the current character is an 'A' or 'a':
      f^=1;                    //    Toggle the flag (0→1 or 1→0)
    else                       //   Else:
      System.out.printf("%c",  //    Print integer as character
        f<1|                   //     If the flag-integer is 0,
        t<66|t>90?             //     or the current character isn't a letter:
         c                     //      Simply output the character as is
        :                      //     Else (the flag it 1 and it's a letter)
         c^32);}               //      Print it with its case reversed
Kevin Cruijssen
fuente
1
Malditos imperativos ... me prohibieron publicar mi respuesta antes que la tuya ... De todos modos, aquí está mi respuesta, 11 bytes más corta:s->{int z=0,d;for(int c:s)if((d=c&95)==65)z^=1;else System.out.printf("%c",z<1|d<66|d>90?c:c<91?c|32:c&95);}
Olivier Grégoire
@ OlivierGrégoire ¡Buena respuesta! ¿Y qué quieres decir con prohibirme publicar? ¿Es su red de trabajo tan estricta?
Kevin Cruijssen
Mi respuesta estuvo lista por un tiempo: solo estaba puliendo los casos de prueba antes de publicar, pero de repente sucedieron reuniones interminables.
Olivier Grégoire
1
No, está bien, solo tengo que culparme por no ser lo suficientemente rápido antes de las reuniones ;-) ¡Pero gracias por sugerir esto!
Olivier Grégoire
2
98 bytes:s->{int f=0,t;for(int c:s)if((t=c&95)==65)f^=1;else System.out.printf("%c",f<1|t<66|t>90?c:c^32);}
Nevay
5

C, 167 168 158 131 bytes

Gracias por @Martin Ender por la revisión del código: he cambiado el procesamiento de flujo por el procesamiento de cadenas para ayudar con la reutilización. También muchas gracias a @RiaD y @ceilingcat por sus sugerencias.

c,d;(*t[][2])()={{isupper,tolower},{islower,toupper}};f(char*s){for(d=1;c=*s++;)t[0][1](c)==97?d=!d:putchar(t[!t[d][0](c)][1](c));}

Pruébalo en línea!

¿Como funciona?

/* int c is the input character,
   int d is the Caps Lock flag (1=off, 0=on)  starting as "Off". */
int c, d;
/* array of comparison functions and transformation functions for each state */
(*t[][2])() = {{isupper, tolower}, {islower, toupper}};

f(char *s) {
  /* Loop if we haven't hit the terminator */
  for(d = 1; c = *s++;)
    t[0][1](c) == 97 ?
      /* If tolower(c)=='a' then flip the Caps Lock state */
      d=!d:
      /* Otherwise, convert character according to the following table:

                       Character case
         Caps Lock  UPPER       LOWER
                ON  tolower()   toupper()
               OFF  toupper()   tolower()
      */
      putchar(t[!t[d][0](c)][1](c));
  }
}

Notas

  • s[][]es donde ocurre la magia: [][0]es la función de comparación y [][1]es la función de transformación relacionada para cada estado.
  • ! se aplica a la función de comparación para forzarla al rango [0,1].
ErikF
fuente
Bienvenido a PPCG! Desafortunadamente, no puede confiar en la inicialización de desta manera porque significa que su función no es reutilizable . Un simple d=0;debería arreglarlo.
Martin Ender
No estaba seguro de si la reutilización o el mantenimiento del estado eran más importantes en este caso. Si la reutilización es más importante, movería las declaraciones de variables dentro de la función para que se lea el principio void f(){int c,d=0;[...]. En cualquier caso, la secuencia muere, por lo que es necesario editar.
ErikF
¿Necesitas s en tu ciclo while? No puede convertirse en NULL a menos que haya llamado con f (NULL)
RiaD
d =! d por voltear
RiaD
!! estarán ! si cambia el orden de t, y comienza d con 1
RiaD
4

Haskell , 92 bytes

import Data.Char
g x|x<'['=toLower x|1>0=toUpper x
f(a:b)|elem a"aA"=f$g<$>b|1>0=a:f b
f x=x

Pruébalo en línea!

Explicación

Primero declaramos gser la función que asigna minúsculas a mayúsculas y mayúsculas a minúsculas. Esta es en realidad la mayoría de nuestro bytecount. Luego definimos la función f. Si la entrada a fes de la forma a:bque hacemos

f(a:b)
 |elem a"aA"=f$g<$>b
 |1>0=a:f b

ay Acoincide con el primer patrón y, por lo tanto, aplicamos fa la entrada con su caso invertido. De lo contrario nos movemos aen el frente y lo aplicamos fa b.

Sriotchilism O'Zaic
fuente
4

Wolfram Language (Mathematica) , 70 bytes

#//.{x___,"a"|"A",y___}:>Join[{x},ToUpperCase@#+ToLowerCase@#-#&@{y}]&

Pruébalo en línea!

Toma entrada y salida como una lista de caracteres. Por conveniencia, he agregado código en el pie de página para convertir esto de una cadena a otra.

Cómo funciona

La parte #//.{x___,"a"|"A",y___}:>Join[{x},... {y}]&es estándar: encontramos la primera A(mayúscula o minúscula), el caso inverso que viene después de la A, y repetimos hasta que no se encuentren más A.

La parte interesante es cómo invertimos mayúsculas y minúsculas: la función ToUpperCase@# + ToLowerCase@# - #&. Sumamos la versión en mayúsculas de la entrada y la versión en minúsculas de la entrada, luego restamos la entrada real. Por ejemplo, dada la lista {"I","n","P","u","T"}esto calcula

{"I","N","P","U","T"}+{"i","n","p","u","t"}-{"I","n","P","u","T"}

que subprocesos en listas como

{"I"+"i"-"I","N"+"n"-"n","P"+"p"-"P","U"+"u"-"u","T"+"t"-"T"}

y aunque Mathematica no tiene ninguna forma particular de la adición de dos cuerdas, que es lo suficientemente inteligente como para simplificar a+b-aa bpara cualquier valor de ay b, entre ellos los valores de cadena, así que esto simplifica a {"i","N","p","U","t"}.

Misha Lavrov
fuente
4

Ruby , 42 41 bytes

->s{s.sub!(/a(.*)/i){$1.swapcase}?redo:s}

Pruébalo en línea!

Una lambda que acepta una cadena, muta la cadena en su lugar y la devuelve. El truco aquí es que subdevuelve la cadena (un valor verdadero) si se realizó una sustitución, y devuelve lo nilcontrario. La existencia de swapcasees bastante útil también.

-1 byte: Reemplace la lógica booleana con un operador ternario, gracias a Asone Tuhid

->s{
  s.sub!(/a(.*)/i){     # Replace "a" followed by anything with
    $1.swapcase         #   the case-swapped capture group
  } ? redo              # If a match was found, restart the block
    : s                 # Otherwise, return the modified string
}
benj2240
fuente
guardar 1 byte . El enlace era demasiado largo si incluía todos los casos de prueba.
Asone Tuhid
@AsoneTuhid Gracias ... Uno de estos días recordaré usar el operador ternario de inmediato, para que no tenga que recordármelo.
benj2240
4

PHP 101 99 bytes

for($s=$argn;$i<strlen($s);$i++)lcfirst($s[$i])==a?$s=strtolower($s)^strtoupper($s)^$s:print$s[$i];

Corre así:

echo '[the input]' | php -nR '[the code]'

Sin golf:

for ($s = $argn; $i < strlen($s); $i++) {
    if (lcfirst($s[$i]) == 'a') {
        $s = strtolower($s) ^ strtoupper($s) ^ $s; // Flip the whole string's case.
    } else {
        print $s[$i]; // Print the current letter.
    }
}

Esto solo recorre la cadena con un bucle for, y en cada iteración comprueba si la letra actual es a, si es así, voltea el caso de la cadena completa (método desde aquí ), y si no, imprime la letra actual.

David
fuente
1
La convención para el código de golf es que se debe incluir todo el código. Eso significa que tiene que tomar la entrada como parámetro de la función y, de hecho declarar una función (a través de la función de la palabra clave en php) o tener un guión completo (por ejemplo, utilizando $argn, $argv, $_GET). Por el momento, esta no es una presentación correcta. La devolución debe ser echoed o returned (solo se permite para funciones de c).
Christoph
1
Gracias por eso @Christoph, soy un poco nuevo en el golf :). He actualizado mi respuesta ahora, solo avíseme si hay algo más que esté mal.
Davіd
@Christoph Wow! 75! ¡Muy agradable! Tienes mi +1 :)
Davіd
4

Jalea , 14 bytes

Œu=”Aœp⁸ŒsJḤ$¦

Pruébalo en línea!

Programa completo

Explicación:

Œu=”Aœp⁸ŒsJḤ$¦ Arguments: x
Œu             Uppercase x
  =”A          ^ Equals 'A' (vectorizes)
     œp⁸       ^ Partition ⁸ [⁸=x]
             ¦ Apply link A, keep results at specific indices B
        Œs     A: Swap case
            $  B: Form a >=2-link monadic chain
          JḤ      Arguments: y
          J       Get list indices ([1, length(list)]) of y
           Ḥ      Double (vectorizes) ^
                  This way, we only "apply" link A to even indices, so every second
                  element, starting from the secondd one.
Erik el Outgolfer
fuente
¿Explicación del código?
SK19
1
@ SK19 Se agregó una explicación.
Erik the Outgolfer
4

MATL , 23 20 bytes

'a A'Yb&Ybt2L)Yo2L(g

Pruébalo en línea!

Explicación:

'a A'Yb   % form a cell array containing {'a', 'A'}
&Yb       % split input into substrings, with either of those ('a' or 'A') as delimiters
t2L)      % extract out the even positioned cells from that result
Yo        % switch the case of those substrings
2L(       % place the result back in even positioned cells of the original cell array
g         % convert cell array to matrix, concatenating all substrings in the process
          % implicit output

Respuesta anterior (23 bytes):

"H @ 'aA'm? ~ XHx} @ w ~? Yo] & h

Otros métodos que probé:

0w"@t'aA'm?x~}y?Yo]w]]xv!
t'aA'mXHYsot&y*XzcYowf([]H(
t'aA'mXHYsoy3Y2m*32*Z~c[]H(
Sundar
fuente
3

Casco , 15 bytes

ω(F·+otm\↕·≠_'a

Pruébalo en línea!

Explicación

ω(F·+(tm\)↕·≠_'a) -- example input: "Bar, baz and Foo."
ω(              ) -- apply the following, until fixpoint is reached:
          ↕       -- | split string with predicate
           · _    -- | | the lower-cased character
            ≠ 'a  -- | | is not 'a'
                  -- | : ("B","ar, baz and Foo.")
  F               -- | apply the following to the tuple
    +             -- | | join the elements with..
   · (   )        -- | | ..the second element: "ar, baz and Foo."
       m\         -- | | | swap case: "AR, BAZ AND fOO."
      t           -- | | | tail: "R, BAZ AND fOO."
                  -- | : "BR, BAZ AND fOO."
                  -- : "BR, Bz ND fOO."
ბიმო
fuente
3

05AB1E , 12 bytes

õ?„AaS¡Dvć?š

Pruébalo en línea!

Explicación

õ?             # print an empty string (to account for the special case of only A's)
  „AaS¡        # split on occurrences of "A" or "a"
       D       # duplicate
        v      # for each element in the top copy
         ć?    # extract and print the head of the other copy
           š   # switch the case of the rest of the other copy
Emigna
fuente
3

Japt v2.0a0, 16 bytes

e/a.*/i_År\l_c^H

Intentalo


Explicación

e                   :Recursively replace
 /a.*/i             :RegEx /a.*/gi
       _            :Pass each match through a function
        Å           :  Slice off the first character
         r          :  Replace
          \l        :  RegEx /[A-Za-z]/g
            _       :  Pass each match though a function
             c^     :    Bitwise XOR the character code
               H    :    With 32
Lanudo
fuente
3

SNOBOL4 (CSNOBOL4) , 141 92 bytes

	I =INPUT
S	I ANY("Aa") REM . R =REPLACE(R,&LCASE &UCASE,&UCASE &LCASE) :S(S)
	OUTPUT =I
END

Pruébalo en línea!

Asume una sola línea de entrada.

¡La friolera de 49 bytes guardada por @ninjalj !

Line Shace todo el trabajo, explicado a continuación:

I                    # in the subject string I match the following PATTERN:
 ANY("Aa")           # match A or a and
 REM . R             # match the remainder of I, assigning this to R
 =REPLACE(           # replace the PATTERN above with
          R, ...)    # R with swapped cases.
   :S(S)             # and if there was a match, goto S, else goto next line 

Giuseppe
fuente
Esto da la respuesta incorrecta (como usted indicó en su comentario, el caso se intercambia cuando CapsLock está activado)
mbomb007
Edité la publicación para requerir el intercambio de mayúsculas y minúsculas (en lugar de simplemente mayúsculas) cuando CapsLock está habilitado porque nunca me di cuenta de que mi máquina hace esto.
Broadwell
@ mbomb007 ah, no me había dado cuenta de que OP lo había cambiado; Estoy editando una explicación ahora, así que la incluiré en la explicación.
Giuseppe
I =INPUT;S I ANY("Aa") REM . R =REPLACE(R,&LCASE &UCASE,&UCASE &LCASE) :S(S); OUTPUT =I;END
ninjalj
@ninjalj ¿ también eres un golfista de SNOBOL o simplemente soy terrible jugando al golf?
Giuseppe
3

Fortran (GFortran) , 307 bytes

CHARACTER(999)F,G
G=' '
READ(*,'(A)')F
N=1
M=1
DO I=1,999
IF(F(I:I)=='a'.OR.F(I:I)=='A')THEN
M=-M
ELSEIF(M==1)THEN
G(N:N)=F(I:I)
N=N+1
ELSE
J=IACHAR(F(I:I))
SELECTCASE(J)
CASE(65:90)
G(N:N)=ACHAR(J+32)
CASE(97:122)
G(N:N)=ACHAR(J-32)
CASE DEFAULT
G(N:N)=F(I:I)
ENDSELECT
N=N+1
ENDIF
ENDDO
PRINT*,TRIM(G)
END

Pruébalo en línea!

Como Fortran no tiene herramientas "avanzadas" para lidiar con cuerdas, se me ocurrió este pequeño monstruo.

Sangrado y comentado:

CHARACTER(999)F,G	!Define input and output strings (up to 999 characters)
G=' '			!Fill output with spaces
READ(*,'(A)')F		!Take input
N=1			!Represent the position to be written in output string
M=1			!M=-1: Change case; M=1: Do not change case
DO I=1,999
	IF(F(I:I)=='a'.OR.F(I:I)=='A')THEN	!If the character is A...
		M=-M				!Ah-ha - you pressed cPS-LOCK!
	ELSEIF(M==1)THEN			!Case the character is not A, and do not need to change case...
		G(N:N)=F(I:I)			!...only copy the character
		N=N+1
	ELSE !Otherwise...
		J=IACHAR(F(I:I))			!...get ascii of current character
		SELECTCASE(J)
			CASE(65:90)			!If is upper case,
				G(N:N)=ACHAR(J+32)	!now is lower case
			CASE(97:122)			!If is lower case,
				G(N:N)=ACHAR(J-32)	!now is upper case
			CASE DEFAULT			!If do not belong to alphabet,
				G(N:N)=F(I:I)		!simply copy the character
		ENDSELECT
		N=N+1
	ENDIF
ENDDO
PRINT*,TRIM(G) !Trim out trailing spaces
END !That's all folks!
rafa11111
fuente
3

Stax , 12 bytes

ìo'½`║â↨╪U?5

Ejecútelo y depúrelo en línea

Se divide en una expresión regular, y luego alterna alternativamente mayúsculas y minúsculas. Aquí está el mismo programa, desempaquetado, sin golf y comentado.

"a|A"|s split on regex /a|A/
rE  reverse and explode array to stack
W   repeat forever...
p   print top of stack with no newline
:~p print top of stack, case inverted, with no newline

Ejecute este

recursivo
fuente
De alguna manera no puedo relacionar tu explicación con tu código.
SK19
Intente pasar por el comentado y observe el estado interno del intérprete. ¿Eso ayuda?
recursivo
1
@ SK19: Oh, creo que veo el problema. No mencioné que los programas stax tienen dos representaciones. Ascii y embalado. Hay una conversión sin pérdidas entre los dos. Ascii es fácil de escribir, pero derrochador para el golf, ya que solo hay 95 símbolos. El programa de golf está lleno, por lo que se ve diferente, pero es el mismo programa.
recursivo
3

Javascript (ES6), 80 79 bytes

(En parte basado en esta respuesta de Rick Hitchcock. Publicar como una respuesta separada porque no tengo suficiente reputación para comentar).

(Guardado 1 byte gracias a la publicación de @ l4m2 aquí ).

a=>a.replace(j=/a()|./gi,(c,o=c[`to${j^c>{}?'Low':'Upp'}erCase`]())=>(j^=!o,o))
Yair Rand
fuente
Bienvenido a PPCG!
Laikoni
2

Sucio , 55 bytes

⇙U◌␛⮕⇨'aA'⇗⭱∈⊭⋱2wẂ[⭱y⋱1wx⮕⭧]
    \   ␛◌Ẃ!w1/      \1wX/

Pruébalo en línea!

Probablemente puede ser aproximadamente un tercio más corto.
Escribiré una explicación y jugaré un poco más cuando esté en una computadora de escritorio.

Οurous
fuente
2

Python 3, 78 72 bytes

import re
lambda x:re.sub("[Aa](.*?)(a|A|$)",lambda m:m[1].swapcase(),x)
pppery
fuente
Puede usar m[1]en lugar de m.group(1)en Python 3.6+.
Bubbler
¿Por qué se marcó esto como de baja calidad ...?
Nissa
No tengo idea ...
pppery
1
Las nuevas publicaciones se marcan automáticamente si son cortas y no contienen texto. Agregar una descripción generalmente evita eso.
mbomb007
Y ahora me pregunto cuántas "A" se supone que hay en "ppperry".
Sr. Lister