Nein A, nur Feststelltaste

197

Was passiert, wenn die CapsLockTaste auf Ihrer Tastatur keine Kerbe aufweist?

"Das ist HPPENS."

Das Ziel dieses Programms ist es, Tastaturfehlschläge konsequent zu emulieren, bei denen jedes ADrücken durch ersetzt wird CapsLock. Großbuchstaben von der Quelle sollten den gleichen Effekt erzielen. Wenn CapsLockaktiviert, wird die Großschreibung umgekehrt.

Testfälle

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

Das Gewinnkriterium ist wie üblich die Größe des Quellcodes des eingereichten Programms.

Broadwell
quelle
110
Willkommen auf der Seite! Dies ist eine schöne erste Herausforderung und leider sehr zuordenbar für mich und meine fT FINGERS.
DJMcMayhem
5
Vorgeschlagener Testfall:teSTateSTateSTateST
Rod
88
Wenn nur die Eingabetaste auch eine Kerbe hätte, wäre dies nicht der Fall
12Me21
75
t happen .......
12Me21
22
Buchstäblich dieser Website beigetreten, um zu verbessern "Ohne die Kerbe kann niemand Sie schreien hören"
lucasvw

Antworten:

115

AutoHotKey , 7 Bytes

a::vk14

// Ist das gültig? Dies ist wirklich das, was der OP will - ersetzen adurch CapsLock (vk14).

Führen Sie dieses Programm aus und geben Sie die Eingabe über die Tastatur ein.

tsh
quelle
4
"Ist das gültig?" OP hat keine Eingabe- oder Ausgabeeinschränkungen angegeben, daher halte ich dies für gültig.
Nefrin
5
Sieh nicht zu viele ahk-Antworten!
HaveSpacesuit
57
Das ist toll, aber wie kann ich es deaktivieren?
RobbG
69
@ RobbG geben Sie einfach "killLL utohotkey" ... oh wit
Nefrin
5
@tsh Ich denke, Sie haben den Witz hier verpasst ...
RobbG
32

V , 9 Bytes

ò/ãa
xg~$

Probieren Sie es online!

Hexdump:

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

Erläuterung:

ò       " 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
quelle
21

Vim, 16 Bytes

qq/\ca
xg~$@qq@q

Angenommen, die Eingabe erfolgt in einer einzelnen Zeile

Erläuterung

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
quelle
Ist dies der fallunempfindliche Befund von 'a'?
Gnudiff
@ Gnudiff \cüberall in einer Regex-Suche ermöglicht Groß -und Kleinschreibung
Herman L
Müssen Sie ein bestimmtes Flag setzen, damit g~$es funktioniert? Weil es bei mir nur die Groß- / Kleinschreibung bis zum Ende der Zeile invertiert, nicht die gesamte Datei, so dass dies bei mehrzeiligen Dateien für mich nicht wirklich funktioniert.
Cubic
1
@ Cubic Wie ich in der Antwort schrieb, "geht es davon aus, dass die Eingabe in einer einzigen Zeile ist"
Herman L
@Cubic Wenn Sie möchten, dass das Ende der Datei erreicht wird und Eingaben in mehreren Zeilen unterstützt werden, können Sie g~vGoder ausführen vG~.
DJMcMayhem
15

C 72 Bytes

Vielen Dank an @Ton Hospel für die Unterstützung beim Sparen von 16 Bytes!

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

Probieren Sie es online!

Steadybox
quelle
2
Sie können den Fall von Buchstaben mit einem xor mit 32
Ton Hospel
Sie können sich wahrscheinlich noch mehr sparen , indem er tseine 0/32anstelle von gerade / ungerade (xor t mit 32 für jeden a) und dann xor Buchstaben direkt mitt
Ton Hospel
2
Schöne Möglichkeit, a's zu erkennen
Ton Hospel
1
@TonHospel- Funktionen müssen wiederverwendbar sein , und ich glaube nicht, dass sie wiederverwendbar sind, wenn Sie externen Code benötigen, um ihn nach jedem Aufruf wieder verwendbar zu machen.
Steadybox
1
6305%cist 0, wenn cist 13.
Rosie F
11

Schale , 11 Bytes

Γ·§?m\:€"Aa

Probieren Sie es online!

Erläuterung

Ich benutze die etwas obskure Überladung von Γcalled listNF, die rekursive Funktionen aufbaut, die mit Listen arbeiten. Es entspricht dem folgenden Haskell-Muster:

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

Die Idee ist, dass listNFeine Hilfsfunktion verwendet wird fund eine neue Funktion zurückgegeben wird g, die eine Liste verwendet. Die Funktion fnimmt eine Funktion, die es immer geben wird g, sowie den Kopf xund den Schwanz xsder Liste und macht etwas mit ihnen. In unserer Anwendung fruft grekursiv auf xs. Das Programm wird folgendermaßen interpretiert:

Γ (· (§ (?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
quelle
3
Wow, gut , dass ich aufgefrischt , bevor ich meine 12 - Byte - Lösung geschrieben: Ḟ·+m\ṁx'Ax'a. Könnten wir eine Erklärung bekommen? Ich kann keine Informationen darüber finden, was Γgenau funktioniert, und dies scheint eine gute Chance zu sein, etwas zu lernen.
Sophia Lechner
1
@SophiaLechner Fertig Diese Version von Γist ein bisschen schwer zu erklären, ich hoffe, Sie können einen Sinn daraus machen.
Zgarb
Wow das ist langsam. Ist es nur TIO?
FrownyFrog
1
@FrownyFrog Es ist Hülsen. Die Typinferenz von Programmen mit Γscheint im Allgemeinen langsam zu sein. Wenn Sie mit Husk nicht vertraut sind, wird ein Programm interpretiert, indem Sie alle möglichen Strukturen des Programms (im Wesentlichen die möglichen Klammerpositionen) und alle Überladungen jedes eingebauten Programms durchlaufen und die erste auswählen, bei der das Ergebnis gut ist. getippt. Der Interpreter ist klug genug, um einige Möglichkeiten frühzeitig abzulehnen, aber es scheint, dass die rekursive Version von Γmit diesem Schritt in Konflikt geraten und ihn dazu zwingen kann, eine Reihe von Entscheidungen zu durchlaufen.
Zgarb
@SophiaLechner Ich habe einen Tipp geschrieben, der Γetwas ausführlicher erklärt .
Zgarb
11

Retina , 33 21 17 Bytes

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

Probieren Sie es online aus

Erläuterung:

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 dank Martin
-4 Bytes dank Leo

mbomb007
quelle
Erstaunlicherweise ist dies fast so kurz wie die aktuellen Pyth-Lösungen
Ton Hospel
1
Ich denke, iT`aAlL`__Ll`a[^a]*a?funktioniert auch für 21 Bytes.
Neil
4 Bytes kürzer mit überlappenden Übereinstimmungen
Leo
Ich bin daran interessiert, wie das funktioniert, wenn Sie Zeit haben, die Erklärung hinzuzufügen. Vielen Dank!
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()));

** Update (danke an @John & @aloisdg) **

C # , 69 Bytes

x=>string.Concat(x.Split('a','A').Select((a,i)=>i%2>0?a.ToUpper():a))
Aalawlx
quelle
2
Willkommen bei PPCG! Schöne erste Antwort!
RedClover
2
Sie können 7 Bytes speichern, indem Sie new[] { 'a', 'A' }zu'a', 'A'
John
5
Sie können es in 69 Bytes mit der gleichen Logik tun! Probieren Sie es online! (Verwenden Sie input / ouput anstelle von console, entfernen Sie ToList, kehren Sie den ternären Wert um und verwenden Sie @John comment) Dies ist eine schöne erste Antwort. Mach weiter!
Aloisdg
3
Diese beiden Versionen tauschen die Groß- und Kleinschreibung nicht aus (sie werden nur in Großbuchstaben umgewandelt), wenn CapsLock aktiviert ist. Dies ist eine Voraussetzung. (Siehe den letzten Testfall)
Broadwell
@Broadwell Woher wissen Sie, ob CapsLock aktiviert ist? Sind Sie sicher, dass der letzte Testfall korrekt ist? Soweit ich sehen kann, besteht es alle anderen Testfälle. Vielen Dank!
Aalawlx
7

JavaScript (ES6), 93 88 84 82 Byte

(5 Bytes dank @Shaggy, 4 Bytes dank @ user81655 und 2 Bytes dank @ l4m2 eingespart.)

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

Testfälle:

Rick Hitchcock
quelle
1
['to${c<'a'?'Low':'Upp'}erCase']Sie sollten ein paar Bytes sparen, indem Sie einfache Anführungszeichen durch Backticks ersetzen.
Shaggy
Sicher, @Shaggy. Vielen Dank!
Rick Hitchcock
Mit ^1have ube können Sie die Parität kürzer initialisieren:s=>s.replace(u=/./g,c=>/a/i.test(c)?(u^=1,''):+u?c[`to${c<'a'?'Low':'Upp'}erCase`]():c)
user81655
Auch hier ist eine andere schwierige Möglichkeit, nach dem akürzeren Buchstaben zu a=>a.replace(A=/./g,c=>c in{a,A}?(A^=1,''):+A?c[`to${c<'a'?'Low':'Upp'}erCase`]():c)
suchen
Genial, @ user81655, besonders wenn man den inOperator so benutzt. Immer mehr zu lernen!
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="")

Vielen Dank an @ Giuseppe für die Korrektur der Antwort.

Erläuterung

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

Probieren Sie es online!

Vlo
quelle
Vielleicht habe ich es nicht klargestellt, aber diese Antwort kehrt die Großschreibung nicht um, wenn CapsLock aktiviert ist (es funktioniert nur toupper), was eine Voraussetzung ist.
Broadwell
2
ooohhhhhh, das ist sehr klug mit dem c(F,T), obwohl @Broadwell recht hat; sieht aus wie es chartr("a-zA-Z","A-Za-z",v)[w]eher als sein wirdtoupper
Giuseppe
@ Giuseppe Dank
Vlo
6

PowerShell Core , 105 Byte

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

Probieren Sie es online!

Was, wenn es keinen echten ternären Operator und keinen Standardalias für das Drucken auf dem Bildschirm gibt, ist es nicht so kurz.

  • % t*yerweitert sich zu | ForEach-Object -Method ToCharArrayäquiv. von"$args".ToCharArray()
  • Write-Host -n ist für den Parameter -NoNewLine
  • "$_"Schaltet den [char]Typ zurück auf [string](Zeichen haben keine Groß- / Kleinschreibung in .Net)
  • |% *perführt die gleiche Methode wie zuvor aus, aber für .ToUpper(), dasselbe mit.ToLower()
  • ($a,$b)[boolean test] als fake-ternary operator missbraucht
  • !!$cKraft wirft , um [bool]es beginnt hier nicht definiert , $nullso dass es es in der Existenz gezwungen wird als „Caps Lock: $ false“.
TessellatingHeckler
quelle
1
Das |% t*yist ein guter Trick, an den ich mich erinnern muss. Kürzer als [char[]], was ich viel benutze. Ich würde fast sagen, dass das auf den Tips-Thread gehen sollte.
AdmBorkBork
94 Bytes -join($args|% t*y|%{if($_-eq'a'){$c=!$c}else{(("$_"|%("*per","*wer")[$_-in65..90]),$_)[!$c]}}). danke für einen |% *ethodoperator!
mazzy
6

Perl 5 -p , 31 30 29 Bytes

-1 Byte danke an @nwellnhof

-1 Byte danke an @ikegami

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

Probieren Sie es online!

Tonne Hospel
quelle
Warum nicht einfach s/a(.*?)(a|$)/uc$1/egi(22 Bytes)?
Nwellnhof
@nwellnhof Da die Feststelltaste bei Aktivierung die Groß- / Kleinschreibung umschaltet, werden nicht nur Großbuchstaben verwendet
Ton Hospel
1
Ah ich sehe. Dann s/a(.*?)(a|$)/$1^uc$1^lc$1/egiist ein Byte kürzer.
Nwellnhof
@nwellnhof Danke, das ist sehr ordentlich
Ton Hospel
a([^a]*)a?ist kürzer alsa(.*?)(a|$)
ikegami
5

Python, 63 Bytes

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

Eine andere Python-Lösung funktioniert in Python 2 und 3. Es dauert sehr lange, bis auf kleine Eingaben.

ManfP
quelle
5

6502 Maschinencode- Routine (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

Erwartet einen Zeiger auf eine 0-terminierte Eingabezeichenfolge $fc/$fd, die auf dem Bildschirm ausgegeben wird .

Kommentierte Demontage

 .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

Beispiel für ein Assembler-Programm mit der Routine:

Online-Demo

Bildschirmfoto

Code in ca65- Syntax:

.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
quelle
Ich muss nur sagen, ich bewundere, dass Sie sich die Mühe gemacht haben, in der Versammlung zu schreiben. Ich denke, das hat nicht viel mit der Tatsache zu tun, dass ich asm wirklich genossen habe, aber vielleicht macht mir die Erfahrung bewusster, was es bedeutet. Erfahrung oder Leichtigkeit ist neben dem Punkt zu mir. Es hellt meinen Tag ein bisschen auf, auch solche Begeisterung zu sehen.
Pryftan
@Pryftan danke :) Es ist nur ein guter Weg, um in der Praxis zu bleiben, ich arbeite an einem Spiel und vor kurzem auch Demo-Code für diese schöne alte Maschine :)
Felix Palmen
Schön zu sehen! Mach weiter; Ich erinnere mich daran, wie ich asm genossen habe, aber ich glaube nicht, dass ich es heutzutage so sehr genießen würde (es sei denn, ich hatte vielleicht eine alte Maschine wie Sie, aber vielleicht auch nicht damals) verwenden. Wie auch immer, ich werde nicht zulassen, dass sich daraus ein Chat entwickelt. Ich wollte nur sagen, dass ich die Antwort sehr geschätzt habe!
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 dank @ OlivierGrégoire .
-10 Bytes dank @Nevay .

Erläuterung:

Probieren Sie es online aus.

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
quelle
1
Verdammte Imperative ... sie haben mir verboten, meine Antwort vor Ihrer zu posten ... Wie auch immer, hier ist meine Antwort, 11 Bytes kürzer: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 Schöne Antwort! Und was meinst du damit, dass ich das Posten verboten habe? Ist Ihr Arbeitsnetzwerk so streng?
Kevin Cruijssen
Meine Antwort war für eine Weile fertig: Ich habe gerade die Testfälle geputzt, bevor sie veröffentlicht wurden, aber dann passierten plötzlich endlose Besprechungen.
Olivier Grégoire
1
Nein, es ist in Ordnung, ich muss mir nur die Schuld geben, dass ich vor den Meetings nicht schnell genug war ;-) Aber danke, dass du das vorgeschlagen hast!
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

Vielen Dank für @Martin Ender für die Codeüberprüfung: Ich habe die Stream-Verarbeitung auf String-Verarbeitung umgestellt, um die Wiederverwendbarkeit zu verbessern. Vielen Dank auch an @RiaD und @ceilingcat für ihre Vorschläge.

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

Probieren Sie es online!

Wie funktioniert es?

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

Anmerkungen

  • s[][]Hier geschieht die Magie: [][0]Ist die Vergleichsfunktion und [][1]ist die zugehörige Transformationsfunktion für jeden Zustand.
  • ! wird auf die Vergleichsfunktion angewendet, um sie in den Bereich [0,1] zu zwingen.
ErikF
quelle
Willkommen bei PPCG! Leider können Sie sich nicht auf die Initialisierung ddieser Art verlassen, da dies bedeutet, dass Ihre Funktion nicht wiederverwendbar ist . Ein einfacher d=0;sollte es beheben.
Martin Ender
Ich war mir nicht sicher, ob in diesem Fall die Wiederverwendbarkeit oder die Aufrechterhaltung des Zustands wichtiger war. Wenn die Wiederverwendbarkeit wichtiger ist, würde ich die Variablendeklarationen innerhalb der Funktion verschieben, damit der Anfang lesen würde void f(){int c,d=0;[...]. In jedem Fall stirbt der Stream, eine Bearbeitung ist also in Ordnung!
ErikF
Benötigen Sie s in Ihrer while-Schleife? Es kann nicht NULL werden, wenn Sie nicht mit f (NULL)
angerufen haben
d =! d zum
Umdrehen
!! wird sein ! Wenn Sie die Reihenfolge von t umdrehen und d mit 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

Probieren Sie es online!

Erläuterung

Zuerst erklären wir, dass ges sich um die Funktion handelt, die Kleinbuchstaben auf Großbuchstaben und Großbuchstaben auf Kleinbuchstaben abbildet. Dies ist eigentlich der größte Teil unseres bytecount. Dann definieren wir die Funktion f. Wenn die Eingabe zu fder Form ist, die a:bwir tun

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

aund Apassen Sie das erste Muster an, und daher wenden wir fes bei umgekehrter Schreibweise auf den Eingang an. Ansonsten ziehen wir nach avorne und bewerben uns fbei b.

Sriotchilism O'Zaic
quelle
4

Wolfram Language (Mathematica) , 70 Byte

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

Probieren Sie es online!

Nimmt die Eingabe und Ausgabe als Liste von Zeichen. Der Einfachheit halber habe ich Code in die Fußzeile eingefügt, um dies von und zurück in eine Zeichenfolge zu konvertieren.

Wie es funktioniert

Der #//.{x___,"a"|"A",y___}:>Join[{x},... {y}]&Teil ist Standard: Wir finden den ersten A(Groß- oder Kleinschreibung), den umgekehrten Fall nach dem Aund wiederholen ihn, bis keine weiteren mehr Azu finden sind.

Der interessante Teil ist, wie wir die Groß- und Kleinschreibung umkehren: die Funktion ToUpperCase@# + ToLowerCase@# - #&. Wir addieren die Großbuchstabenversion der Eingabe und die Kleinbuchstabenversion der Eingabe und subtrahieren dann die tatsächliche Eingabe. Wenn Sie beispielsweise die Liste angeben, die {"I","n","P","u","T"}dies berechnet

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

welche Threads über Listen wie

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

und obwohl Mathematica keine bestimmte Möglichkeit zum Hinzufügen von zwei Zeichenfolgen hat, ist es klug genug a+b-a, dies bfür alle Werte von aund b, einschließlich Zeichenfolgenwerten, zu vereinfachen, sodass dies vereinfacht wird {"i","N","p","U","t"}.

Mischa Lawrow
quelle
4

Ruby , 42 41 Bytes

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

Probieren Sie es online!

Ein Lambda, das eine Zeichenfolge akzeptiert, die Zeichenfolge an der richtigen Stelle mutiert und sie zurückgibt. Der Trick dabei ist, dass subdie Zeichenfolge (ein wahrer Wert) zurückgegeben wird, wenn eine Ersetzung vorgenommen wurde, und nilansonsten zurückgegeben wird. Die Existenz von swapcaseist auch ziemlich praktisch.

-1 Byte: Ersetzen Sie die boolesche Logik durch einen ternären Operator, dank 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
quelle
1 Byte speichern . Der Link war zu lang, wenn ich alle Testfälle eingeschlossen habe.
Asone Tuhid
@AsoneTuhid Danke ... Eines Tages werde ich daran denken, den ternären Operator sofort zu verwenden, damit Sie mich nicht daran erinnern müssen.
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];

Laufen Sie wie folgt:

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

Dies durchläuft die Zeichenkette nur mit einer for-Schleife und überprüft bei jeder Iteration, ob der aktuelle Buchstabe vorhanden ist a. Wenn dies der Fall ist, wird die gesamte Zeichenkette umgedreht (Methode von hier ). Wenn nicht, wird der aktuelle Buchstabe gedruckt.

Davіd
quelle
1
Die Konvention für Code Golf ist, dass jeder Code enthalten sein muss. Das heißt , Sie Eingabe als Funktionsparameter zu nehmen und tatsächlich eine Funktion (über die Funktion Schlüsselwort in php) oder hat ein komplettes Skript (zB mit erklären $argn, $argv, $_GET). Im Moment ist dies also keine korrekte Einreichung. Return muss editiert echooder returneditiert sein (nur für Funktionen von c erlaubt).
Christoph
1
Danke für das @Christoph, ich bin ein bisschen neu im Golfen :). Ich habe meine Antwort jetzt aktualisiert, lass es mich wissen, wenn noch etwas falsch ist.
Davіd
@Christoph Wow! 75! Sehr schön! Du hast meine +1 :)
Davіd
4

Jelly , 14 Bytes

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

Probieren Sie es online!

Volles Programm.

Erläuterung:

Œ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 der Outgolfer
quelle
Erklärung des Codes?
SK19
1
@ SK19 Eine Erklärung hinzugefügt.
Erik der Outgolfer
4

MATL , 23 20 Bytes

'a A'Yb&Ybt2L)Yo2L(g

Probieren Sie es online!

Erläuterung:

'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

Ältere Antwort (23 Bytes):

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

Andere Methoden, die ich ausprobiert habe:

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

Schale , 15 Bytes

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

Probieren Sie es online!

Erläuterung

ω(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."
ბიმო
quelle
3

05AB1E , 12 Bytes

õ?„AaS¡Dvć?š

Probieren Sie es online!

Erläuterung

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

Japt v2.0a0, 16 Bytes

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

Versuch es


Erläuterung

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
Zottelig
quelle
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

Probieren Sie es online!

Nimmt eine einzelne Eingabezeile an.

Satte 49 Bytes, die von @ninjalj gespeichert wurden !

Line Serledigt die ganze Arbeit, die unten erklärt wird:

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
quelle
Dies gibt die falsche Antwort (wie Sie in Ihrem Kommentar angegeben haben, wird die Groß- / Kleinschreibung getauscht, wenn CapsLock aktiviert ist)
mbomb007
Ich habe den Beitrag so bearbeitet, dass bei aktiviertem CapsLock ein Austausch der Groß- und Kleinschreibung erforderlich ist, da ich nie bemerkt habe, dass mein Computer dies tut.
Broadwell
@ mbomb007 ah, ich hatte nicht bemerkt, dass OP es geändert hatte; Ich bearbeite jetzt für eine Erklärung, also werde ich das in die Erklärung aufnehmen.
Giuseppe
I =INPUT;S I ANY("Aa") REM . R =REPLACE(R,&LCASE &UCASE,&UCASE &LCASE) :S(S); OUTPUT =I;END
Ninjalj
@ninjalj bist du auch ein SNOBOL-Golfer oder bin ich einfach schrecklich darin, Golf zu spielen ??
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

Probieren Sie es online!

Da Fortran keine "fortgeschrittenen" Werkzeuge für den Umgang mit Strings hat, habe ich mir dieses kleine Monster ausgedacht.

Eingerückt und kommentiert:

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
quelle
3

Stax , 12 Bytes

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

Führen Sie es online aus und debuggen Sie es

Es teilt sich auf einem regulären Ausdruck und wechselt dann abwechselnd zwischen Groß- und Kleinschreibung. Hier ist das gleiche Programm, entpackt, ungolfed und kommentiert.

"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

Führen Sie dieses aus

rekursiv
quelle
Ich kann Ihre Erklärung irgendwie nicht mit Ihrem Code in Verbindung bringen.
SK19
Versuchen Sie, den kommentierten Schritt durchzugehen und den internen Status des Interpreters zu beobachten. Hilft das?
rekursiven
1
@ SK19: Oh, ich glaube ich sehe das Problem. Ich habe nicht erwähnt, dass Stax-Programme zwei Darstellungen haben. Ascii und verpackt. Es gibt eine verlustfreie Konvertierung zwischen den beiden. Ascii ist einfach zu tippen, aber für das Golfen verschwenderisch, da es nur 95 Symbole gibt. Das Golfprogramm ist voll, sieht also anders aus, ist aber das gleiche.
rekursive
3

Javascript (ES6), 80 bis 79 Byte

(Teilweise basierend auf dieser Antwort von Rick Hitchcock. Posten als separate Antwort, da ich nicht den Ruf habe, einen Kommentar abzugeben.)

(1 Byte dank @ l4m2s Beitrag hier gespeichert .)

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

Schmutzig , 55 Bytes

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

Probieren Sie es online!

Kann wohl um ein Drittel kürzer sein.
Ich schreibe eine Erklärung auf und spiele noch ein bisschen Golf, wenn ich auf einem Desktop bin.

Οurous
quelle
2

Python 3, 78 72 Bytes

import re
lambda x:re.sub("[Aa](.*?)(a|A|$)",lambda m:m[1].swapcase(),x)
Pfeffer
quelle
Sie können m[1]anstelle von m.group(1)auf Python 3.6+ verwenden.
Bubbler
Warum wurde dies als minderwertig gekennzeichnet?
Nissa
Ich habe keine Ahnung ...
pppery
1
Neue Beiträge werden automatisch markiert, wenn sie kurz sind und keinen Text enthalten. Das Hinzufügen einer Beschreibung verhindert dies normalerweise.
mbomb007
Und jetzt frage ich mich, wie viele "A" in "ppperry" sein sollen.
Mr Lister