CapsLock키보드 의 키에 노치가 없으면 어떻게됩니까 ?

"이 hPPENS."

이 프로그램의 목표는 각 A프레스가로 교체 되는 키보드 미스를 일관되게 모방하는 것 입니다 CapsLock. 소스의 대문자 'A'도 동일한 효과를냅니다. 때 CapsLock활성화되어, 총액은 반전됩니다.

테스트 사례

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

우승 기준은 일반적으로 제출 된 프로그램의 소스 코드 크기입니다.

AutoHotKey , 7 바이트

a::vk14

// 이것이 유효합니까? 이것은 실제로 OP가 원하는 것을 수행-대체 a합니다 CapsLock (vk14).

이 프로그램을 실행하고 키보드 입력을 입력하십시오.

V , 9 바이트

ò/ãa
xg~$

온라인으로 사용해보십시오!

16 진 덤프 :

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

설명:

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

Vim, 16 바이트

qq/\ca
xg~$@qq@q

입력이 한 줄에 있다고 가정

설명

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 

C, 72 바이트

16 바이트 절약에 도움을 주신 @Ton Hospel에게 감사드립니다!

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

온라인으로 사용해보십시오!

껍질 , 11 바이트

Γ·§?m\:€"Aa

온라인으로 사용해보십시오!

설명

나는의 다소 모호한 오버로드 사용하고 Γ호출 listNF목록에서 작동 재귀 함수를 구성한다. 다음 Haskell 패턴에 해당합니다.

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

아이디어는 listNF도우미 함수를 사용 f하고 새 함수를 반환 g하여 목록을 가져 오는 것입니다. 이 함수 f는 항상 ,리스트 g의 머리 x와 꼬리 xs인 함수를 가져 와서 무언가를 수행합니다. 우리의 애플리케이션에서에 재귀 적으로 f호출 g합니다 xs. 프로그램은 다음과 같이 해석됩니다.

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

망막 , 33 21 17 바이트

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

온라인으로 사용해보십시오

설명:

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

Martin 덕분에 -12 바이트
Leo 덕분에 -4 바이트

C # , 121 바이트

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

** 업데이트 (@John & @aloisdg 덕분에) **

C # , 69 바이트

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

자바 스크립트 (ES6), 93 88 84 82 바이트

(@Shaggy 덕분에 5 바이트, @ user81655 덕분에 4 바이트, @ l4m2 덕분에 2 바이트 절약되었습니다.)

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

테스트 사례 :

let f=

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

console.log(f("The quick brown fox jumps over the lazy dog."));
console.log(f("Compilation finished successfully."));
console.log(f("What happens when the CapsLock key on your keyboard doesn't have a notch in it?"));
console.log(f("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."));
console.log(f("aAaaaaAaaaAAaAa"));
console.log(f("CapsLock locks cAPSlOCK"));
console.log(f("wHAT IF cAPSlOCK IS ALREADY ON?"));

R , 92 바이트

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

답변을 수정 해 주신 @Giuseppe에게 감사드립니다.

설명

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

온라인으로 사용해보십시오!

PowerShell 코어 , 105 바이트

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

온라인으로 사용해보십시오!

실제 삼항 연산자가없고 화면에 인쇄하기위한 기본 별칭이없는 것은 그리 짧지 않습니다.

• % t*y| ForEach-Object -Method ToCharArrayequiv로 확장합니다 . 의"$args".ToCharArray()
• Write-Host -n 매개 변수입니다 -NoNewLine
• "$_"[char]유형을 다시 켭니다 [string](.Net에서 문자는 대문자 / 소문자가 없습니다)
• |% *per같은 이전 만에 같은 메서드 호출 바로 가기 수행 .ToUpper()과 동일.ToLower()
• ($a,$b)[boolean test] 가짜 삼항 연산자로 학대
• !!$c하는 힘은-캐스트 [bool]가 정의되지 않은 시작에 여기 $null"를 $ false 캡 잠금"으로는 존재로 강제됩니다 있도록.

펄 5 -p , 31 30 29 바이트

덕분에 -1 바이트 @nwellnhof

@ikegami 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

파이썬, 63 바이트

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

또 다른 Python 솔루션은 Python 2 및 3에서 작동합니다. 작은 입력을 제외한 모든 입력에 매우 오랜 시간이 걸립니다.

6502 머신 코드 루틴 (C64), 51 바이트

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

에서 0으로 끝나는 입력 문자열에 대한 포인터를 예상 $fc/$fd하고 화면에 출력합니다.

주석 처리 된 분해

 .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

루틴을 사용하는 예제 어셈블러 프로그램 :

온라인 데모

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        

자바 (8), 119 (108) 98 바이트

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

@ OlivierGrégoire 덕분에 -11 바이트 . @Nevay
덕분에 -10 바이트 .

설명:

온라인으로 사용해보십시오.

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

C, 167 168 158 131 바이트

코드 검토를 위해 @Martin Ender에게 감사드립니다. 재사용 가능성을 돕기 위해 문자열 처리를위한 스트림 처리를 전환했습니다. @RiaD와 @ceilingcat에게도 감사의 말을 전합니다.

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

온라인으로 사용해보십시오!

어떻게 작동합니까?

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

노트

• s[][]마술이 일어나는 곳 : [][0]비교 함수와 [][1]각 상태에 대한 관련 변환 함수입니다.
• ! 비교 함수에 적용되어 [0,1] 범위로 강제합니다.

하스켈 , 92 바이트

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

온라인으로 사용해보십시오!

설명

먼저 g소문자를 대문자로, 대문자를 소문자로 매핑하는 함수로 선언 합니다. 이것은 실제로 우리의 바이트 수의 대부분입니다. 그런 다음 함수를 정의합니다 f. 입력 내용 f이 다음 형식 인 a:b경우

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

aA첫 번째 패턴 과 일치하므로 f케이스를 거꾸로 입력에 적용 합니다. 그렇지 않으면 우리는 앞으로 a나가서에 적용 f합니다 b.

Wolfram Language (Mathematica) , 70 바이트

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

온라인으로 사용해보십시오!

문자 목록으로 입력 및 출력을 가져옵니다. 편의를 위해 바닥 글에 코드를 추가 하여이 문자열을 문자열로 변환합니다.

작동 원리

#//.{x___,"a"|"A",y___}:>Join[{x},... {y}]&부분은 표준입니다 : 우리가 찾아 첫 번째 A는 이후에 오는 경우 역 (대문자 또는 소문자) A, 반복 더 이상 없을 때까지A 의이 발견되지 수.

흥미로운 부분은 우리가 대소 문자를 뒤집는 방법 ToUpperCase@# + ToLowerCase@# - #&입니다. 대문자 버전의 입력과 소문자 버전의 입력을 더한 다음 실제 입력을 뺍니다. 예를 들어 목록 {"I","n","P","u","T"}이 주어지면

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

어떤 스레드를

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

Mathematica에는 두 개의 문자열을 추가하는 특별한 방법이 없지만 문자열 값을 포함하여 및의 모든 값 을 단순화 a+b-a할 b수있는 것이 현명 합니다 .ab{"i","N","p","U","t"}

루비 , 42 41 바이트

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

온라인으로 사용해보십시오!

문자열을 받아들이고 그 자리를 변경 한 후 돌려주는 람다. 여기서의 트릭은 sub대체가 이루어지면 문자열 (진실한 값)을 반환하고 nil그렇지 않으면 반환 합니다. 존재swapcase 도 꽤 편리합니다.

-1 바이트 : 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
}

PHP 101 99 바이트

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

다음과 같이 실행하십시오.

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

언 골프 드 :

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

이것은 for 루프를 사용하여 문자열을 반복하며, 각 반복에서 현재 문자가 a있는지 확인한 다음 그렇다면 전체 문자열의 케이스를 뒤집습니다 ( 여기의 방법 ), 그렇지 않은 경우 현재 문자를 인쇄하십시오.

젤리 , 14 바이트

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

온라인으로 사용해보십시오!

전체 프로그램.

설명:

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

MATL , 23 20 바이트

'a A'Yb&Ybt2L)Yo2L(g

온라인으로 사용해보십시오!

설명:

'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

이전 답변 (23 바이트) :

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

내가 시도한 다른 방법 :

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

껍질 , 15 바이트

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

온라인으로 사용해보십시오!

설명

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

05AB1E , 12 바이트

õ?„AaS¡Dvć?š

온라인으로 사용해보십시오!

설명

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

Japt v2.0a0, 16 바이트

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

시도 해봐

설명

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

SNOBOL4 (CSNOBOL4) , 141 92 바이트

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

온라인으로 사용해보십시오!

한 줄의 입력을 가정합니다.

@ninjalj가 무려 49 바이트를 절약했습니다 !

라인 S은 모든 작업을 수행하며 아래에 설명되어 있습니다.

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 

포트란 (GFortran) 307 바이트

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

온라인으로 사용해보십시오!

포트란은 문자열을 다루기위한 "고급"도구를 가지고 있지 않기 때문에이 작은 괴물을 생각해 냈습니다.

들여 쓰기 및 코멘트 :

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!

Stax , 12 바이트

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

온라인으로 실행 및 디버깅

정규 표현식으로 분할 된 다음 대소 문자를 번갈아 전환합니다. 압축을 풀고 풀고 주석 처리 한 동일한 프로그램이 있습니다.

"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

이것을 실행

자바 스크립트 (ES6), 80 79 바이트

( Rick Hitchcock의 답변 에 부분적으로 근거를두고 있습니다 . 의견이 충분하지 않기 때문에 별도의 답변으로 게시하십시오.)

(@ l4m2의 게시물 덕분에 1 바이트를 절약 했습니다 .)

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

더티 , 55 바이트

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

온라인으로 사용해보십시오!

아마도 약 세 번째 짧을 수 있습니다.
데스크톱에있을 때 설명을 작성하고 골프를 더 쓰겠습니다.

파이썬 3, 78 72 바이트

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