Não A, apenas CAPS LOCK


197

O que acontece quando a CapsLocktecla do teclado não possui um entalhe?

"Isso hPPENS."

O objetivo deste programa é emular consistentemente as falhas do teclado onde cada Apressionamento é substituído CapsLock. A's maiúsculos da fonte devem produzir o mesmo efeito. Quando CapsLockestá ativado, a capitalização é revertida.

Casos de teste

"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?"

O critério vencedor é, como sempre, o tamanho do código fonte do programa enviado.


110
Bem vindo ao site! Este é um bom primeiro desafio e, infelizmente, é muito relacionável para mim e meus dedos do pé.
DJMcMayhem

5
caso de teste sugeriu:teSTateSTateSTateST
Rod

88
Se apenas a chave de entrada também tinha um entalhe nele para este wouldn'
12Me21

75
Isso

22
Literalmente, juntei-se a este site para votar "Sem o entalhe, ninguém pode ouvir você gritar"
lucasvw 15/03/18

Respostas:


115

AutoHotKey , 7 bytes

a::vk14

// Isso é válido? Isso realmente faz o que o OP deseja - substitua apor CapsLock (vk14).

Execute este programa e digite a entrada do teclado.


4
"Isso é válido?" O OP não especificou restrições de entrada ou saída, por isso considero isso válido.
Nrevin 15/03

5
Não veja muitas respostas ahk!
HaveSpacesuit

57
Isso é ótimo, mas como faço para desabilitá-lo?
RobbG

69
@RobbG basta digitar "killLL utohotkey" ... oh wIT
Nefrin

5
@tsh Acho que você perdeu a piada aqui ...
RobbG

32

V , 9 bytes

ò/ãa
xg~$

Experimente online!

Hexdump:

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

Explicação:

ò       " 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.

21

Vim, 16 bytes

qq/\ca
xg~$@qq@q

Assume que a entrada está em uma única linha

Explicação

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 

A descoberta não sensível a maiúsculas e minúsculas de 'a'?
Gnudiff

@Gnudiff \cqualquer lugar em um regex-de pesquisa permite caso insensibilidade
Herman L

Você precisa definir um sinalizador específico para g~$funcionar? Porque, para mim, apenas inverte o caso até o final da linha, não o arquivo inteiro, então isso realmente não funciona para arquivos com várias linhas para mim.
Cubic

11
@ Cubic Como escrevi na resposta, ela "pressupõe que a entrada esteja em uma única linha"
Herman L

@Cubic Se você queria ir o fim das entradas de arquivo e de suporte em várias linhas, você poderia fazer g~vGou vG~.
DJMcMayhem

15

C, 72 bytes

Agradecemos a @Ton Hospel por ajudar a salvar 16 bytes!

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

Experimente online!


2
Você pode trocar o caso das cartas usando um xor com 32
Ton Hospel

Provavelmente, você pode economizar ainda mais por ter tser 0/32em vez de par / ímpar (xor t com 32 para cada a) e, em seguida, letras XOR diretamente comt
Ton Hospel

2
Boa maneira de detectar a's
Ton Hospel 14/03/18

11
As funções do @TonHospel precisam ser reutilizáveis , e não acho que seja reutilizável se você precisar de código externo para utilizá -lo novamente após cada chamada.
Steadybox

11
6305%cé 0 se cé 13.
Rosie F

11

Casca , 11 bytes

Γ·§?m\:€"Aa

Experimente online!

Explicação

Estou usando a sobrecarga um tanto obscura de Γchamada listNF, que constrói funções recursivas que operam em listas. Corresponde ao seguinte padrão Haskell:

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

A idéia é que listNFpega uma função auxiliar fe retorna uma nova função g, que pega uma lista. A função fpega uma função, que sempre será g, e o cabeçalho xe o final xsda lista, e faz algo com eles. Em nossa aplicação, fchama grecursivamente xs. O programa é interpretado assim:

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

3
Wow, coisa boa que eu atualizado antes de eu postei a minha solução de 12 byte: Ḟ·+m\ṁx'Ax'a. Poderíamos obter uma explicação? Não consigo encontrar nenhuma informação sobre o que Γfaz exatamente e isso parece ser uma boa chance de aprender.
Sophia Lechner

11
@SophiaLechner Concluído. Esta versão do Γé um pouco difícil de explicar, espero que você possa entendê-lo.
Zgarb

Uau, isso é lento. É apenas TIO?
FrownyFrog

11
@FrownyFrog É Husk. A inferência de tipos de programas que contêm Γparece ser lenta em geral. Se você não está familiarizado com o Husk, um programa é interpretado percorrendo todas as estruturas possíveis do programa (essencialmente os possíveis posicionamentos entre parênteses) e todas as sobrecargas de cada built-in, e escolhendo a primeira onde o resultado é bom. digitado. O intérprete é inteligente o suficiente para rejeitar algumas possibilidades antecipadamente, mas parece que a versão recursiva Γpode mexer com essa etapa e forçá-la a percorrer várias opções.
Zgarb

@SophiaLechner Escrevi uma dica que explica Γcom mais detalhes .
Zgarb

11

Retina , 33 21 17 bytes

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

Experimente online

Explicação:

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 graças a Martin
-4 bytes graças a Leo


Surpreendentemente isso é quase tão curto quanto as soluções Pyth atuais
Ton Hospel

11
Eu acho que iT`aAlL`__Ll`a[^a]*a?também funciona para 21 bytes.
Neil

4 bytes mais curtos usando correspondências sobrepostas
Leo

Estou interessado em saber como isso funciona se você tiver tempo para adicionar a explicação. Obrigado!
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()));

** Atualização (graças a @John & @aloisdg) **

C # , 69 bytes

x=>string.Concat(x.Split('a','A').Select((a,i)=>i%2>0?a.ToUpper():a))

2
Bem-vindo ao PPCG! Boa primeira resposta!
RedClover 15/03/19

2
você pode salvar 7 bytes mudando new[] { 'a', 'A' }para'a', 'A'
John

5
Você pode fazer isso em 69 bytes com a mesma lógica! Experimente online! (use input / ouput em vez do console, remova o ToList, inverta o ternário e use o comentário @John) Esta é uma boa primeira resposta. Continue!
aloisdg

3
Ambas as versões não trocam maiúsculas e minúsculas (elas se transformam em maiúsculas) quando o CapsLock está ativado. Este é um requisito. (Veja o último caso de teste)
Broadwell 15/18

@Broadwell Como você saberia se o CapsLock está ativado? Tem certeza de que o último caso de teste está correto? Ele passa em todos os outros casos de teste, até onde posso ver. Obrigado!
Aalawlx

7

JavaScript (ES6), 93 88 84 82 bytes

(salvou 5 bytes graças a @Shaggy, 4 bytes graças a @ user81655 e 2 bytes graças a @ l4m2.)

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

Casos de teste:


11
['to${c<'a'?'Low':'Upp'}erCase']economize alguns bytes, substituindo aspas simples por reticulares.
Salsicha

Claro que sim, @Shaggy. Obrigado!
21718 Rick Ricky Hitchcock

Usar ^1para ter ua paridade pode deixá-lo inicializá-lo mais curto:s=>s.replace(u=/./g,c=>/a/i.test(c)?(u^=1,''):+u?c[`to${c<'a'?'Low':'Upp'}erCase`]():c)
user81655 18/18

Também aqui está uma outra maneira complicada para testar a carta aque é mais curto:a=>a.replace(A=/./g,c=>c in{a,A}?(A^=1,''):+A?c[`to${c<'a'?'Low':'Upp'}erCase`]():c)
user81655

Brilhante, @ user81655, especialmente usando o inoperador assim. Sempre mais 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="")

Obrigado @ Giuseppe por corrigir a resposta.

Explicação

# 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="")

Experimente online!


Talvez eu não tenha deixado claro, mas essa resposta não inverte a capitalização quando o CapsLock está ativado (apenas é executado toupper), o que é um requisito.
Broadwell

2
ooohhhhhhh isso é muito inteligente com o c(F,T), embora @Broadwell esteja certo; parece que vai ser um chartr("a-zA-Z","A-Za-z",v)[w]pouco do quetoupper
Giuseppe

@Giuseppe Thanks
Vlo 14/03

6

Núcleo do PowerShell , 105 bytes

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

Experimente online!

Com um operador ternário real e sem um alias padrão para imprimir na tela, não é tão curto assim.

  • % t*yexpande para | ForEach-Object -Method ToCharArrayequiv. do"$args".ToCharArray()
  • Write-Host -n é para o parâmetro -NoNewLine
  • "$_"[char]retorna o tipo para [string](caracteres não têm maiúsculas / minúsculas em .Net)
  • |% *perfaz o mesmo método chamar atalho como anteriormente, mas para .ToUpper(), mesmo com.ToLower()
  • ($a,$b)[boolean test] abusado como operador falso-ternário
  • !!$co force-casts para [bool]aqui começa indefinido $nulle é forçado a existir como "caps lock: $ false".

11
Esse |% t*yé um truque interessante que preciso lembrar. Mais curto que [char[]], o que eu uso muito. Eu quase diria que isso deve ir para o tópico Dicas.
21818 AdmBorkBork

94 bytes: -join($args|% t*y|%{if($_-eq'a'){$c=!$c}else{(("$_"|%("*per","*wer")[$_-in65..90]),$_)[!$c]}}). obrigado por um |% *ethodoperador!
Mazzy

6

Perl 5 -p , 31 30 29 bytes

-1 byte graças a @nwellnhof

-1 byte graças a @ikegami

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

Experimente online!


Por que não simplesmente s/a(.*?)(a|$)/uc$1/egi(22 bytes)?
Nwellnhof

@nwellnhof Porque o capslock quando alterna ativos o caso, isso não acontece apenas em maiúsculas
Ton Hospel

11
Ah entendo. Então s/a(.*?)(a|$)/$1^uc$1^lc$1/egié um byte mais curto.
Nwellnhof 16/0318

@nwellnhof Obrigado, isso é muito legal
Ton Hospel

a([^a]*)a?é menor quea(.*?)(a|$)
ikegami 18/0318

5

Python, 63 bytes

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

Outra solução Python, funciona no Python 2 e 3. Leva muito tempo para todas as entradas, exceto pequenas.


5

Rotina de código de máquina 6502 (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 que um ponteiro para uma sequência de entrada terminada em 0 seja $fc/$fdenviada para a tela.

Desmontagem comentada

 .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

Exemplo de programa assembler usando a rotina:

Demonstração online

captura de tela

Código na sintaxe 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        

Só preciso dizer que admiro que você tenha se esforçado para escrever em montagem. Eu não acho que isso tenha muito a ver com o fato de eu realmente gostar de asm, mas talvez a experiência me torne mais consciente do que isso implica. Experiência ou facilidade está além do ponto para mim. Ilumina o meu dia um pouco para ver esse entusiasmo também.
Pryftan

@Pryftan obrigado :) É apenas uma boa maneira de manter-se na prática, eu estou trabalhando em algum jogo e, recentemente, também código de demonstração para esta máquina velha nice :)
Felix Palmen

Bem, é ótimo ver! Mantem; Lembro-me de gostar de asm, mas acho que não iria gostar tanto hoje em dia (a menos que talvez eu tenha uma máquina velha como você, ou seja, mas possivelmente ainda não o seja) - C é a minha favorita de todos os tempos e é o que eu mais gosto usar. Enfim, não deixarei isso evoluir para o bate-papo - só queria dizer que apreciei a resposta!
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 graças a @ OlivierGrégoire .
-10 bytes graças a @Nevay .

Explicação:

Experimente online.

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

11
Malditos imperativos ... eles me proibiram de postar minha resposta antes da sua ... De qualquer forma, aqui está a minha resposta, 11 bytes mais curto: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 Boa resposta! E o que você quer dizer com me proibiu de publicar? Sua rede de trabalho é tão rígida?
Kevin Cruijssen 15/03/19

Minha resposta ficou pronta por um tempo: eu estava apenas polindo os casos de teste antes de postar, mas de repente reuniões intermináveis ​​aconteceram.
Olivier Grégoire

11
Não, tudo bem, eu só tenho que me culpar por não ser rápido o suficiente antes das reuniões ;-) Mas obrigado por sugerir isso!
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 17/03/19

5

C, 167 168 158 131 bytes

Obrigado a Martin Ender pela revisão do código: alterei o processamento do fluxo pelo processamento de strings para ajudar na reutilização. Também muito obrigado a @RiaD e @ceilingcat por suas sugestões.

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

Experimente online!

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[][]é onde a mágica acontece: [][0]é a função de comparação e [][1]é a função de transformação relacionada a cada estado.
  • ! é aplicado à função de comparação para forçá-la ao intervalo [0,1].

Bem-vindo ao PPCG! Infelizmente, você não pode confiar na inicialização desse dtipo porque significa que sua função não é reutilizável . Um simples d=0;deve corrigi-lo.
Martin Ender

Eu não tinha certeza se a reutilização ou manutenção do estado era mais importante nesse caso. Se a reutilização for mais importante, eu moveria as declarações de variáveis ​​dentro da função para que o início lesse void f(){int c,d=0;[...]. De qualquer forma, o fluxo morre, portanto, uma edição está em ordem!
21718 ErikF

você precisa de s no seu loop while? Ele não pode se tornou NULL a menos que você chamada com f (NULL)
Riad

d =! d para inverter o
código #

!! será ! se você inverter a ordem de t e começar d com 1
RiaD 16/18

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

Experimente online!

Explicação

Primeiro, declaramos gser a função que mapeia minúsculas para maiúsculas e maiúsculas para minúsculas. Esta é realmente a maioria do nosso número de bytes. Então definimos a função f. Se a entrada para fé da forma a:bque fazemos

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

ae Acorresponda ao primeiro padrão e, portanto, aplicamos fà entrada com seu caso invertido. Caso contrário, seguimos aem frente e aplicamos fa b.


4

Wolfram Language (Mathematica) , 70 bytes

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

Experimente online!

Toma entrada e saída como uma lista de caracteres. Por conveniência, adicionei código no rodapé para converter isso de e para uma string.

Como funciona

A parte #//.{x___,"a"|"A",y___}:>Join[{x},... {y}]&é padrão: encontramos a primeira A(maiúscula ou minúscula), maiúscula e minúscula que vem após a A, e repetimos até que não haja mais A.

A parte interessante é como invertemos o caso: a função ToUpperCase@# + ToLowerCase@# - #&. Adicionamos a versão em caixa alta da entrada e a versão em caixa baixa da entrada e subtraímos a entrada real. Por exemplo, dada a lista que {"I","n","P","u","T"}isso calcula

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

quais tópicos sobre listas como

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

e embora Mathematica não tem qualquer maneira particular de adicionar duas cordas, ele é inteligente o suficiente para simplificar a+b-aa bpara quaisquer valores de ae b, inclusive valores de cadeia, por isso esta simplifica para {"i","N","p","U","t"}.


4

Ruby , 42 41 bytes

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

Experimente online!

Um lambda aceitando uma sequência, modificando-a no lugar e retornando-a. O truque aqui é que subretorna a string (um valor verdadeiro) se uma substituição foi feita e retorna nilcaso contrário. A existência de também swapcaseé bastante útil.

-1 byte: Substitua a lógica booleana pelo operador ternário, graças 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
}

economize 1 byte . O link era muito longo se eu incluísse todos os casos de teste.
Asone Tuhid 16/03/19

@AsoneTuhid Obrigado ... Um dia desses, lembrarei de usar o operador ternário imediatamente, para que você não precise me lembrar.
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];

Execute assim:

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

Ungolfed:

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

Isso apenas percorre a seqüência de caracteres com um loop for e, em cada iteração, verifica se a letra atual é a, em caso afirmativo, inverta a caixa de toda a sequência (método daqui ) e, se não, imprima a letra atual.


11
A convenção para o código de golfe é que todo o código deve ser incluído. Isso significa que você tem que tomar entrada como parâmetro de função e realmente declarar uma função (via a palavra-chave função em php) ou ter um roteiro completo (por exemplo, usando $argn, $argv, $_GET). Portanto, no momento, essa não é uma submissão correta. O retorno deve ser echoed ou returned (permitido apenas para funções ofc).
Christoph

11
Obrigado por isso @Christoph, sou uma espécie de novato no golfe :). Atualizei minha resposta agora, deixe-me saber se há algo mais errado.
305 David

@Christoph Wow! 75! Muito agradável! Você tem o meu +1 :) #
1178 David

4

Gelatina , 14 bytes

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

Experimente online!

Programa completo.

Explicação:

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

Explicação do código?
SK19

11
@ SK19 Adicionada uma explicação.
Erik the Outgolfer

4

MATL , 23 20 bytes

'a A'Yb&Ybt2L)Yo2L(g

Experimente online!

Explicação:

'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

Resposta mais antiga (23 bytes):

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

Outros métodos que tentei:

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

3

Casca , 15 bytes

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

Experimente online!

Explicação

ω(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."

3

05AB1E , 12 bytes

õ?„AaS¡Dvć?š

Experimente online!

Explicação

õ?             # 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

3

Japt v2.0a0, 16 bytes

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

Tente


Explicação

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

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

Experimente online!

Assume uma única linha de entrada.

Um enorme 49 bytes salvos por @ninjalj !

Line Sfaz todo o trabalho, explicado abaixo:

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 


Isto dá a resposta errada (como você disse em seu comentário, caso é trocado quando CapsLock está ligado)
mbomb007

Editei a postagem para exigir a troca de maiúsculas e minúsculas (em vez de simplesmente maiúsculas) quando o CapsLock está ativado, porque nunca percebi que minha máquina faz isso.
Broadwell

@ mbomb007 ah, eu não tinha percebido que o OP havia mudado; Estou editando uma explicação agora, então incluirei isso na explicação.
Giuseppe

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

@ninjalj você também é um jogador de golfe SNOBOL ou eu sou simplesmente terrível no golfe?
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

Experimente online!

Como o Fortran não possui ferramentas "avançadas" para lidar com seqüências de caracteres, criei esse monstrinho.

Recuado e 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!

3

Stax , 12 bytes

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

Execute e depure on-line

Divide-se em uma regex e alterna alternadamente entre maiúsculas e minúsculas. Aqui está o mesmo programa, descompactado, não destruído e 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

Execute este


De alguma forma, não consigo relacionar sua explicação ao seu código.
SK19 16/03/19

Tente percorrer o comentado e observar o estado interno do intérprete. Isso ajuda?
recursivo

11
@ SK19: Ah, acho que vejo o problema. Não mencionei que os programas stax têm duas representações. Ascii e embalado. Há uma conversão sem perdas entre os dois. Ascii é fácil de digitar, mas é um desperdício para o golfe, pois existem apenas 95 símbolos. O programa de golfe é embalado, então parece diferente, mas é o mesmo programa.
recursivo

3

Javascript (ES6), 80 79 bytes

(Parcialmente baseado nesta resposta de Rick Hitchcock. Postando como uma resposta separada, porque não tenho reputação suficiente para comentar.)

(Economizou 1 byte graças à postagem de @ l4m2 aqui .)

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

Bem-vindo ao PPCG!
Laikoni

2

Sujo , 55 bytes

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

Experimente online!

Provavelmente pode ser cerca de um terço mais curto.
Vou escrever uma explicação e jogar um pouco mais quando estiver em uma mesa.


2

Python 3, 78 72 bytes

import re
lambda x:re.sub("[Aa](.*?)(a|A|$)",lambda m:m[1].swapcase(),x)

Você pode usar m[1]no lugar do m.group(1)Python 3.6+.
quer

Por que isso foi marcado como de baixa qualidade ...?
Nissa

Eu não tenho idéia ...
pppery

11
Novas postagens são sinalizadas automaticamente se forem curtas e não contiverem texto. Adicionar uma descrição geralmente impede isso.
mbomb007

E agora eu me pergunto quantos "A" deve haver em "ppperry".
Lister
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.