Non A, juste MAJUSCULES


197

Que se passe-t-il lorsque la CapsLocktouche de votre clavier ne comporte pas d'entaille?

"Ce hPPENS."

Le but de ce programme est d’émuler de manière cohérente les occurrences du clavier où chaque Apression est remplacée par CapsLock. Les A majuscules de la source devraient produire le même effet. Lorsque CapsLockest activé, la capitalisation est inversée.

Cas de test

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

Le critère gagnant est, comme d'habitude, la taille du code source du programme soumis.


110
Bienvenue sur le site! C’est un beau premier défi, et malheureusement très difficile à comprendre pour moi et mes doigts.
DJMcMayhem

5
cas de test suggéré:teSTateSTateSTateST
Rod

88
Si seulement la touche entrée avait aussi une encoche, cela ne serait pas
12Me21

75
t arrive .......
12Me21

22
Littéralement rejoint ce site pour upvote "Sans l'entaille, personne ne peut vous entendre crier"
lucasvw

Réponses:


115

AutoHotKey , 7 octets

a::vk14

// Est-ce valide? Cela fait vraiment ce que l'OP veut - remplacer apar CapsLock (vk14).

Exécutez ce programme et tapez l'entrée à partir du clavier.


4
"Est-ce que c'est valide?" OP n'a pas spécifié de contraintes d'entrée ou de sortie, donc je considère cela comme valide.
Nefrin

5
Ne voyez pas trop de réponses ahk!
HaveSpacesuit

57
C'EST GRET, mais comment puis-je le désactiver?
RobbG

69
@RobbG tapez simplement "killLL utohotkey" ... oh wIT
Nefrin

5
@th je pense que vous avez manqué la blague ici ...
RobbG

32

V , 9 octets

ò/ãa
xg~$

Essayez-le en ligne!

Hexdump:

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

Explication:

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

qq/\ca
xg~$@qq@q

Suppose que l'entrée est sur une seule ligne

Explication

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 

Cette conclusion insensible à la casse de "a"?
Gnudiff

@Gnudiff \cn'importe où dans une recherche regex permet l'insensibilité à la casse
Herman L

Avez-vous besoin de définir un drapeau spécifique pour g~$pouvoir fonctionner? Parce que pour moi, cela n'inverse que les cas jusqu'à la fin de la ligne, pas le fichier entier, donc cela ne fonctionne pas vraiment pour les fichiers multilignes pour moi.
Cubic

1
@Cubic Comme je l'ai écrit dans la réponse, cela "suppose que l'entrée est sur une seule ligne"
Herman L

@Cubic Si vous voulez aller jusqu'à la fin du fichier et prendre en charge les entrées sur plusieurs lignes, vous pouvez le faire g~vGou vG~.
DJMcMayhem

15

C, 72 octets

Merci à @Ton Hospel d’avoir aidé à économiser 16 octets!

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

Essayez-le en ligne!


2
Vous pouvez échanger la casse des lettres en utilisant un xor avec 32
Ton Hospel

Vous pouvez probablement économiser encore plus en ayant tété à la 0/32place de pair / impair (xor t avec 32 pour chaque a) puis de xor lettres directement avect
Ton Hospel

2
Une bonne façon de détecter a« s
Ton Hospel

1
@TonHospel Les fonctions doivent être réutilisables , et je ne pense pas que ce soit considéré comme réutilisable si vous avez besoin d'un code externe pour le rendre réutilisable après chaque appel.
Steadybox

1
6305%cest 0 si cest 13.
Rosie F

11

Décortiquer , 11 octets

Γ·§?m\:€"Aa

Essayez-le en ligne!

Explication

J'utilise la surcharge un peu obscure de Γcalled listNF, qui construit des fonctions récursives qui agissent sur des listes. Il correspond au modèle Haskell suivant:

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

L'idée est que listNFprend une fonction d'assistance fet retourne une nouvelle fonction g, qui prend une liste. La fonction fprend une fonction, qui sera toujours g, ainsi que la tête xet la queue xsde la liste, et fait quelque chose avec elles. Dans notre application, fappelle de gmanière récursive xs. Le programme est interprété comme ceci:

Γ (· (§ (?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, bonne chose que je rafraîchis avant posté ma solution à 12 octets: Ḟ·+m\ṁx'Ax'a. Pouvons-nous avoir une explication? Je ne trouve aucune information sur ce qui Γfonctionne exactement et cela semble être une bonne chance d'apprendre.
Sophia Lechner

1
@SophiaLechner Fait. Cette version de Γest un peu difficile à expliquer, j'espère que vous pourrez la comprendre.
Zgarb

Wow c'est lent. Est-ce juste TIO?
FrownyFrog

1
@FrownyFrog c'est Husk. L'inférence de type des programmes contenant Γsemble être lente en général. Si vous n'êtes pas familier avec Husk, un programme est interprété en parcourant toutes les structures possibles du programme (essentiellement les emplacements possibles des parenthèses) et toutes les surcharges de chaque fonction intégrée, et en choisissant la première où le résultat est correct. tapé. L’interprète est assez intelligent pour rejeter certaines possibilités très tôt, mais il semble que la version récursive de Γgâchis puisse gâcher cette étape et l’obliger à parcourir de nombreux choix.
Zgarb

@SophiaLechner J'ai écrit un conseil qui explique Γen détail .
Zgarb

11

Retina , 33 21 17 octets

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

Essayez-le en ligne

Explication:

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 octets grâce à Martin
-4 octets grâce à Leo


Etonnamment, c'est presque aussi court que les solutions Pyth actuelles
Ton Hospel

1
Je pense iT`aAlL`__Ll`a[^a]*a?aussi fonctionne pour 21 octets.
Neil

4 octets plus courts en utilisant des correspondances qui se chevauchent
Leo

Je suis intéressé par la façon dont cela fonctionne si vous avez le temps d'ajouter l'explication. Merci!
Seshoumara

9

C # , 121 octets

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

** Mise à jour (merci à @John & @aloisdg) **

C # , 69 octets

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

2
Bienvenue chez PPCG! Belle première réponse!
RedClover

2
vous pouvez économiser 7 octets en changeant new[] { 'a', 'A' }pour'a', 'A'
John

5
Vous pouvez le faire en 69 octets avec la même logique! Essayez-le en ligne! (utilisez input / ouput au lieu de console, supprimez ToList, inversez le ternaire et utilisez @John commenter) C'est une bonne première réponse. Continue!
aloisdg

3
Les deux versions n'échangent pas de casse (elles se transforment uniquement en majuscule) lorsque CapsLock est activé. C'est une exigence. (Voir le dernier cas de test)
Broadwell

@Broadwell Comment sauriez-vous si CapsLock est activé? Êtes-vous sûr que le dernier cas de test est correct? Il passe tous les autres cas de test, autant que je peux voir. Merci!
Aalawlx

7

JavaScript (ES6), 93 88 84 82 octets

(enregistré 5 octets grâce à @Shaggy, 4 octets grâce à @ user81655 et 2 octets grâce à @ l4m2.)

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

Cas de test:


1
['to${c<'a'?'Low':'Upp'}erCase']devrait vous faire économiser quelques octets, en remplaçant les guillemets simples par des backticks.
Shaggy

Bien sûr, @Shaggy. Merci!
Rick Hitchcock

L' utilisation ^1d'avoir ula parité peut vous permettre de initialisez plus court:s=>s.replace(u=/./g,c=>/a/i.test(c)?(u^=1,''):+u?c[`to${c<'a'?'Low':'Upp'}erCase`]():c)
user81655

Voici également un autre moyen délicat de tester la lettre, aqui est plus courte:a=>a.replace(A=/./g,c=>c in{a,A}?(A^=1,''):+A?c[`to${c<'a'?'Low':'Upp'}erCase`]():c)
user81655

Brillant, @ user81655, en particulier en utilisant l' inopérateur comme ça. Toujours plus à apprendre!
Rick Hitchcock

6

R , 92 octets

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

Merci @ Giuseppe pour avoir corrigé la réponse.

Explication

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

Essayez-le en ligne!


Je n’ai peut-être pas été clair, mais cette réponse n’inverse pas la capitalisation lorsque CapsLock est activé (il ne fonctionne que toupper), ce qui est une exigence.
Broadwell

2
ooohhhhhhh c'est très intelligent avec le c(F,T), bien que @Broadwell ait raison; on dirait que ça va être chartr("a-zA-Z","A-Za-z",v)[w]plutôt quetoupper
Giuseppe

@ Giuseppe Merci
Vlo

6

PowerShell Core , 105 octets

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

Essayez-le en ligne!

Quoi sans opérateur ternaire réel et sans alias par défaut pour l'impression à l'écran, ce n'est pas si court.

  • % t*yse développe à | ForEach-Object -Method ToCharArrayéquiv. de"$args".ToCharArray()
  • Write-Host -n est pour le paramètre -NoNewLine
  • "$_"retourne le [char]type à [string](les caractères n'ont pas de majuscules / minuscules en .Net)
  • |% *perfait le même raccourci d'appel de méthode que précédemment, mais pour .ToUpper(), pareil avec.ToLower()
  • ($a,$b)[boolean test] abusé en tant que faux opérateur ternaire
  • !!$cforce-castts jusqu'à [bool]ici, il commence indéfini $nullpour le forcer à exister sous la forme "maj maj: $ false".

1
C'est |% t*yune astuce que je dois retenir. Plus court que [char[]], que j'utilise beaucoup. Je dirais presque que cela devrait aller sur le fil Astuces.
AdmBorkBork

94 Octets -join($args|% t*y|%{if($_-eq'a'){$c=!$c}else{(("$_"|%("*per","*wer")[$_-in65..90]),$_)[!$c]}}). merci pour un |% *ethodopérateur!
mazzy

6

Perl 5 -p , 31 30 29 octets

-1 octet grâce à @nwellnhof

-1 octet grâce à @ikegami

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

Essayez-le en ligne!


Pourquoi pas simplement s/a(.*?)(a|$)/uc$1/egi(22 octets)?
nwellnhof

@nwellnhof Parce que la touche majuscule active le cas, elle ne se limite pas à la majuscule
Ton Hospel

1
Ah, je vois. Ensuite, s/a(.*?)(a|$)/$1^uc$1^lc$1/egiun octet est plus court.
nwellnhof

@nwellnhof Merci, c'est très soigné
Ton Hospel

a([^a]*)a?est plus court quea(.*?)(a|$)
ikegami

5

Python, 63 octets

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

Une autre solution Python fonctionne en Python 2 et 3. Cela prend beaucoup de temps pour toutes les entrées, sauf les petites.


5

6502 routine de code machine (C64), 51 octets

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

Attend un pointeur sur une chaîne d'entrée terminée par 0 dans $fc/$fd , les sorties à l'écran.

Démontage commenté

 .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

Exemple de programme assembleur utilisant la routine:

Démo en ligne

capture d'écran

Code en syntaxe 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        

Je dois juste dire que j'admire que vous ayez fait l'effort d'écrire en assemblée. Je pense que cela n’a pas grand-chose à voir avec le fait que j’aimais vraiment beaucoup en asm, mais peut-être que cette expérience me rend plus conscient de ce que cela implique. L'expérience ou la facilité est en outre le point pour moi. Ça m'éclaire juste un peu de voir un tel enthousiasme aussi.
Pryftan

@Pryftan merci :) C'est juste un bon moyen de rester en pratique, je travaille sur un jeu et récemment aussi sur du code de démonstration pour cette belle vieille machine :)
Felix Palmen

Eh bien, c'est super à voir! Continuez; Je me souviens d’avoir apprécié asm, mais je ne pense pas que j’apprécierais tellement autant aujourd’hui (à moins peut-être que j’avais une vieille machine comme vous, c’est, mais ce n’est peut-être pas encore le cas) - C est ma préférée de tous les temps et c’est ce que je fais surtout utilisation. Quoi qu'il en soit, ne laissez pas cela évoluer dans le chat - je voulais juste dire que j'ai apprécié la réponse!
Pryftan

5

Java 8, 119 108 98 octets

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 octets grâce à @ OlivierGrégoire .
-10 octets grâce à @Nevay .

Explication:

Essayez-le en ligne.

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

1
Putain d'impératifs ... ils m'ont interdit de poster ma réponse devant la vôtre ... Quoi qu'il en soit, voici ma réponse, 11 octets de moins: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 Belle réponse! Et qu'entendez-vous par m'interdire de poster? Votre réseau de travail est-il aussi strict?
Kevin Cruijssen

Ma réponse était prête depuis un moment: je perfectionnais juste les cas de test avant de poster, mais soudain des réunions interminables se sont produites.
Olivier Grégoire

1
Non, c'est bon, je dois seulement me reprocher de ne pas avoir été assez rapide avant les réunions ;-) Mais merci d'avoir suggéré cela!
Olivier Grégoire

2
98 octets: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 octets

Merci à @Martin Ender pour la révision du code: j'ai changé le traitement du flux pour le traitement des chaînes afin de faciliter la réutilisation. Merci également à @RiaD et @ceilingcat pour leurs suggestions.

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

Essayez-le en ligne!

Comment ça marche?

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

Remarques

  • s[][]C'est là que se passe la magie: [][0]c'est la fonction de comparaison et [][1]c'est la fonction de transformation associée pour chaque état.
  • ! est appliqué à la fonction de comparaison pour la forcer dans la plage [0,1].

Bienvenue chez PPCG! Malheureusement, vous ne pouvez pas compter sur l'initialisation de dce type car cela signifie que votre fonction n'est pas réutilisable . Un simple d=0;devrait le réparer.
Martin Ender

Je ne savais pas si la possibilité de réutilisation ou le maintien de l'état était plus important dans ce cas. Si la réutilisabilité est plus importante, je déplacerais les déclarations de variable à l'intérieur de la fonction pour que le début soit lu void f(){int c,d=0;[...]. Dans tous les cas, le flux meurt, une édition est donc en ordre!
ErikF

avez-vous besoin de s dans votre boucle while? Il ne peut devenir NULL que si vous
appelez

d =! d pour retourner
RiaD

!! sera ! si vous retournez l’ordre de t et commencez par d
RiaD

4

Haskell , 92 octets

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

Essayez-le en ligne!

Explication

Premièrement, nous déclarons gêtre la fonction qui mappe les minuscules en majuscules et les majuscules en minuscules. C’est en fait la majorité de notre décompte. Ensuite, nous définissons la fonction f. Si l'entrée à fest de la forme que a:bnous faisons

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

aet Acorrespondons au premier motif et nous appliquons donc fà l'entrée avec sa casse inversée. Sinon, nous allons de l' aavant et nous nous adressons fà b.


4

Wolfram Language (Mathematica) , 70 octets

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

Essayez-le en ligne!

Prend l'entrée et la sortie sous forme de liste de caractères. Pour plus de commodité, j'ai ajouté du code dans le pied de page pour convertir ceci à partir de et retour en chaîne.

Comment ça fonctionne

La partie #//.{x___,"a"|"A",y___}:>Join[{x},... {y}]&est standard: on trouve la première A(majuscule ou minuscule), le cas inverse de celui-ci vient après A, et on répète jusqu'à ce qu'il n'y en ait plusA .

La partie intéressante est la façon dont nous inversons le cas: la fonction ToUpperCase@# + ToLowerCase@# - #&. Nous additionnons la version en majuscule de l'entrée et la version en minuscule de l'entrée, puis soustrayons l'entrée réelle. Par exemple, étant donné la liste, {"I","n","P","u","T"}ceci calcule

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

quels threads sur les listes comme

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

et bien que Mathematica ne dispose d' aucun moyen particulier d'ajouter deux chaînes, il est assez intelligent pour simplifier a+b-aà bpour toutes les valeurs de aet b, y compris les valeurs de chaîne, donc ce à simplifier {"i","N","p","U","t"}.


4

Ruby , 42 41 octets

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

Essayez-le en ligne!

Un lambda accepte une chaîne, la mute en place et la renvoie. L'astuce ici est que subrenvoie la chaîne (une valeur de vérité) si une substitution a été effectuée, et retourne nilsinon. L'existence de swapcaseest assez pratique aussi.

-1 octet: Remplacer la logique booléenne par un opérateur ternaire, grâce à 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
}

économiser 1 octet . Le lien était trop long si j'incluais tous les cas de test.
Asone Tuhid

@ AsoneTuhid Merci ... Un de ces jours, je me souviendrai tout de suite d'utiliser l'opérateur ternaire pour que vous n'ayez pas à me le rappeler.
benj2240

4

PHP 101 99 octets

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

Courez comme ça:

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

Cela parcourt simplement la chaîne avec une boucle for, et à chaque itération, il vérifie si la lettre actuelle est a, le cas échéant, puis retourne la casse de la chaîne entière (méthode à partir de ici ), et sinon, affiche la lettre actuelle.


1
La convention pour le code golf est que tout le code doit être inclus. Cela signifie que vous devez prendre l' entrée en tant que paramètre de fonction et de déclarer en fait une fonction (via le mot - clé de fonction en php) ou un script complet (par exemple , en utilisant $argn, $argv, $_GET). Donc, pour le moment, ce n'est pas une soumission correcte. Le retour doit être echoed ou returned (autorisé uniquement pour les fonctions ofc).
Christoph

1
Merci pour cela @Christoph, je suis un peu novice en golf :). J'ai mis à jour ma réponse maintenant, laissez-moi savoir s'il y a autre chose qui ne va pas.
David

@Christoph Wow! 75! Très agréable! Vous avez mon +1 :)
David

4

Gelée , 14 octets

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

Essayez-le en ligne!

Programme complet.

Explication:

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

Explication du code?
SK19

1
@ SK19 Ajout d'une explication.
Erik the Outgolfer

4

MATL , 23 à 20 octets

'a A'Yb&Ybt2L)Yo2L(g

Essayez-le en ligne!

Explication:

'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

Réponse plus ancienne (23 octets):

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

Autres méthodes que j'ai essayées:

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

3

Coque , 15 octets

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

Essayez-le en ligne!

Explication

ω(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 octets

õ?„AaS¡Dvć?š

Essayez-le en ligne!

Explication

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

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

L'essayer


Explication

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 octets

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

Essayez-le en ligne!

Suppose une seule ligne d’entrée.

49 octets sauvés par @ninjalj !

Line Sfait tout le travail, expliqué ci-dessous:

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 


Cela donne la mauvaise réponse (comme vous l'avez dit dans votre commentaire, le cas est échangé lorsque CapsLock est
activé

J'ai modifié le message pour exiger la permutation de cas (plutôt que de simples majuscules) lorsque CapsLock est activé, car je ne me suis jamais rendu compte que ma machine le faisait.
Broadwell

@ mbomb007 ah, je n'avais pas réalisé que l'OP l'avait changé; Je corrige pour une explication maintenant, donc je vais l'inclure dans l'explication.
Giuseppe

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

@ninjalj, es-tu aussi un golfeur de SNOBOL ou suis-je si terrible au golf?
Giuseppe

3

Fortran (GFortran) , 307 octets

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

Essayez-le en ligne!

Comme Fortran n’a pas "avancé" d’outils pour gérer les chaînes, j’ai imaginé ce petit monstre.

Indenté et commenté:

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 octets

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

Exécuter et déboguer en ligne

Il se scinde sur une expression rationnelle, puis bascule alternativement en majuscule et en majuscule. Voici le même programme, non emballé, non-golfé et commenté.

"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

Exécuter celui-ci


Je ne peux pas en quelque sorte relier votre explication à votre code.
SK19

Essayez de parcourir celle commentée et de surveiller l’état interne de l’interprète. Est ce que ça aide?
récursive

1
@ SK19: Oh, je pense que je vois le problème. Je n'ai pas mentionné que les programmes Stax ont deux représentations. Ascii et emballé. Il y a une conversion sans perte entre les deux. Ascii est facile à saisir, mais inutile pour le golf car il n’ya que 95 symboles. Le programme de golf est plein à craquer, donc il a l'air différent, mais c'est le même programme.
récursive

3

Javascript (ES6), 80 79 octets

(En partie sur la base de cette réponse de Rick Hitchcock. Publication séparée car je n'ai pas assez de réputation pour commenter.)

(1 octet enregistré grâce au message de @ l4m2 ici .)

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

Bienvenue chez PPCG!
Laikoni

2

Sale , 55 octets

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

Essayez-le en ligne!

Peut probablement être environ un tiers plus court.
J'écrirai une explication et jouerai un peu plus quand je serai sur un bureau.


2

Python 3, 78 72 octets

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

Vous pouvez utiliser m[1]à la place de m.group(1)sur Python 3.6+.
Bubbler

Pourquoi cela at-il été signalé comme étant de mauvaise qualité…
Nissa

Je n'ai aucune idée ...
pppery

1
Les nouveaux articles sont automatiquement signalés s’ils sont courts et ne contiennent aucun texte. Ajouter une description empêche généralement cela.
mbomb007

Et maintenant je me demande combien de "A" il est supposé être dans "ppperry".
M. Lister
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.