ALTERNEZ LA CAUSE

42

Pour le défi d'aujourd'hui, vous devez écrire un programme ou une fonction qui alterne la casse d'une chaîne. Cependant, vous devez ignorer les caractères non alphabétiques. Cela signifie que chaque caractère alphabétique doit avoir une casse différente des caractères alphabétiques précédent et suivant. Ceci est légèrement plus complexe que de mettre en majuscule une lettre sur deux, par exemple. Si vous prenez une chaîne telle que

hello world

et convertissez tous les autres caractères en majuscules, vous obtiendrez:

hElLo wOrLd

Comme vous pouvez le constater, la minuscule oest suivie d'une minuscule w. Ceci est invalide. Au lieu de cela, vous devez ignorer l'espace en nous donnant le résultat suivant:

hElLo WoRlD

Tous les caractères non alphabétiques doivent rester les mêmes. La sortie peut commencer par des majuscules ou des minuscules, dans la mesure où elle alterne régulièrement. Cela signifie que les résultats suivants seraient également une sortie acceptable:

HeLlO wOrLd

Votre programme devrait fonctionner quel que soit le cas de l'entrée.

La chaîne d'entrée ne contiendra jamais que l' ASCII imprimable , vous n'avez donc pas à vous soucier des caractères non imprimables, des nouvelles lignes ou de l'unicode. Votre soumission peut être un programme complet ou une fonction, et vous pouvez utiliser les entrées et les sorties dans un format raisonnable. Par exemple, arguments de fonction / valeur de retour, STDIN / STDOUT, lecture / écriture d'un fichier, etc.

Exemples:

ASCII                                   ->  AsCiI
42                                      ->  42
#include <iostream>                     ->  #InClUdE <iOsTrEaM>
LEAVE_my_symbols#!#&^%_ALONE!!!         ->  lEaVe_My_SyMbOlS#!#&^%_aLoNe!!!
PPCG Rocks!!! For realz.                ->  PpCg RoCkS!!! fOr ReAlZ.
This example will start with lowercase  ->  tHiS eXaMpLe WiLl StArT wItH lOwErCaSe
This example will start with uppercase  ->  ThIs ExAmPlE wIlL sTaRt WiTh UpPeRcAsE
A1B2                                    ->  A1b2

Puisqu'il s'agit de code-golf , des échappatoires standard s'appliquent et la réponse la plus courte en octets est gagnante!

code-golf string DJMcMayhem
la source
33
Ugh, je viens juste de réaliser que c'était ce meme xD
Beta Decay
@BetaDecay Hahaha, ce n'était pas mon intention. Plus juste le timing malheureux. J'y ai pensé comme un mini-défi de chat , et j'aime bien l'idée derrière tout ça, car c'est légèrement plus difficile qu'il n'y paraît.
DJMcMayhem
4
Le prochain défi consiste à imprimer un spongebob ascii à lacowsay
Frambot
1
Mince! Je viens d' écrire un script CJam pour cela (comme hier) et de le supprimer.
Esolanging Fruit
2
Il manque un peu de potentiel pour le titre ou du moins pour les exemples utilisant un pingouin de malheur ou des sporks.
Ian

Réponses:

19

JavaScript (ES6), 66 63 octets

Commence avec majuscule.

s=>s.replace(/[a-z]/gi,c=>c[`to${(s=!s)?'Low':'Upp'}erCase`]())

Cas de test

Afficher l'extrait de code

Arnauld
la source
Exactement comment j'allais le faire. Je pense que je peux voir où vous pouvez enregistrer quelques octets mais je suis sur mon téléphone, donc je ne peux pas tester correctement.
Shaggy
Ouais, en utilisant un ternaire, c'est ce que j'allais suggérer.
Shaggy
1
Comment ça s=!smarche?
Kritixi Lithos
7
@KritixiLithos Puisqu'il ss'agit de la chaîne d'entrée, !sévalue d'abord à false(sauf si la chaîne d'entrée est vide, auquel cas elle serait évaluée à true- mais une chaîne vide ne générera aucune correspondance de toute façon). Après cela, cela devient une opération booléenne standard, alternant entre falseet true. En outre, cela ne nous dérange pas de perdre le contenu de sà ce stade car il était déjà utilisé pour l'alimentation .replace().
Arnauld
3
@MayorMonty Malheureusement, cela correspondrait à quelques symboles. Une entrée telle que "A[I"échouera.
Arnauld
12

05AB1E , 11 8 octets

Code:

lvyJ¤aiš

Utilise le codage 05AB1E . Essayez-le en ligne!

Explication:

l           # Lowercase the input
 vy         # For each element..
   J        #   Join the entire stack into a single string
    ¤a      #   Check if the last character is alphabetic
      iš    #   If true, swapcase the entire string
Adnan
la source
J'aime la façon dont j'essaie d'aller à l'aveugle, sachant que je dois battre 11 octets; puis lentement, passez de 17 à 11 octets et réalisez que lvy¾Fš}Da½Jc’est exactement ce que vous aviez déjà ._.
Urne Octopus Magique
1
@carusocomputing Il existe une solution beaucoup plus simple à 8 octets: p
Adnan
4
ah oui super facile haha.
Urne Magique Octopus
2
@ Octopus Il y a quelques discussions à ce sujet, mais j'utilise à la fois 'osable' et 'osabie'.
Adnan
1
@ octopus Je dis littéralement que Oh-Five-Ay-Bee-One-Eeeje ne suis pas un homme créatif.
Urne Magique Octopus
11

GNU Sed, 33

  • 5 octets enregistrés grâce à @TobySpeight

Le score inclut +1 pour le -rdrapeau à séduire.

s/([a-z])([^a-z]*.?)/\U\1\L\2/gi

Essayez-le en ligne .

Trauma numérique
la source
8

Gelée , 13 octets

nŒsTm2
ŒlŒuǦ

Essayez-le en ligne!

Comment ça marche

ŒlŒsǦ  Main link. Argument: s (string)

Œl      Cast to lowercase.
    Ǧ  At indices returned by the helper link...
  Œu        apply uppercase.


nŒsTm2      Helper link. Argument: s (string)

 Œs         Apply swapcase to s.
n           Perform vectorizing not-equal comparison.
   T        Compute the truthy indices.
    m2      Select every other one, starting with the first.
Dennis
la source
7

Japt , 16 14 octets

r"%l"_m"uv"gT°

Essayez-le en ligne!

Explication

r              // RegEx replace input
 "%l"          // [A-Za-z] as first arg to replace
     _         // created function Z=>Z as second arg to replace
       "uv"gT° // alternates "u" & "v"
      m        // map Z to either "u" upper or "v" lower
Powelles
la source
Très agréable! Vous pouvez enlever le ,. À moins que ce ne soit un nombre (par exemple [12]), Japt sait que ce sont des éléments différents. Je crois que vous pouvez supprimer le &1aussi.
Oliver
Merci @obarakon. La documentation Japt est un peu clairsemée.
Powelles
Merci d'avoir utilisé Japt. N'hésitez pas à poser des questions, des suggestions, etc. dans la salle de discussion Japt . Il existe également un fil Astuces pour Japt . :)
Oliver
_m"uv"gT°Agréable. J'étais sur le point de le suggérer.
Oliver
@obarakon Ouais, j'ai vu où ETH avait répondu à votre question sur le chat et ça m'a permis d'essayer.
Powelles
5

Alice , 18 octets

/olZlYuN
@iy.u..//

Essayez-le en ligne!

Explication

Ce programme suit un modèle moins connu pour les programmes de longueur impaire entièrement exécutés en mode ordinal. La version linéarisée de ce code est:

il.l.uN.YuZyo@

Explication du code:

i - push input onto stack            ["Hello world!"]
l - convert to lowercase             ["hello world!"]
. - duplicate                        ["hello world!", "hello world!"]
l - convert to lowercase (should be no-op, but avoids what seems to be a bug in the TIO implementation)
. - duplicate again                  ["hello world!", "hello world!", "hello world!"]
u - convert to uppercase             ["hello world!", "hello world!", "HELLO WORLD!"]
N - difference between sets          ["hello world!", "helloworld"]
. - duplicate reduced string         ["hello world!", "helloworld", "helloworld"]
Y - unzip (extract even positions)   ["hello world!", "helloworld", "hlool", "elwrd"]
u - convert to uppercase             ["hello world!", "helloworld", "hlool", "ELWRD"]
Z - zip evens back into string       ["hello world!", "helloworld", "hElLoWoRlD"]
y - perform substitution             ["hElLo WoRlD!"]
o - output                           []
@ - terminate

Sans utiliser lsur le duplicata, la pile après Nserait ["helloworld", "helloworld"]. Je soupçonne fortement que c'est un bug.

Nitrodon
la source
5

C (tcc) , 60 57 56 octets

Merci à DigitalTrauma d'avoir remarqué que le bit 5 est la seule différence entre les majuscules et les minuscules ASCII.

Un merci spécial à zch pour avoir joué trois octets supplémentaires.

Enregistrer un octet supplémentaire de l'idée de RJHunter 

l;f(char*s){for(;*s=isalpha(*s)?*s&95|++l%2<<5:*s;s++);}

Essayez-le en ligne!

cleblanc
la source
Je l'ai joué au golf un peu plus , et modifié pour qu'il fonctionne sur tous les gcc, tcc, clang. FWIW, gcc place les littéraux de chaîne dans la mémoire en lecture seule. J'avais donc l'habitude strdup()de faire en sorte que les pointeurs de la mémoire en lecture / écriture soient stockés dans le code du pilote de test.
Digital Trauma
1
@ DigitalTrauma merci pour cela. J'aurais dû reconnaître que le bit 5 était la différence entre le haut et le bas. Agréable !
Cleblanc
J'ai aussi essayé de rendre cette version récursive, mais je ne pouvais pas la raccourcir.
Digital Trauma
Vous pouvez remplacer le conditionnel interne par *s&~32|++l%2<<5pour économiser 3 octets.
zch
Comme l'entrée promet d'être imprimable en ASCII, vous pouvez remplacer &~33par &95pour sauvegarder un octet supplémentaire.
RJHunter
4

Java 8, 99 octets

a->{String r="";int i=0;for(int c:a)r+=(char)(c>64&c<91|c>96&c<123?i++%2<1?c|32:c&~32:c);return r;}

Explication:

Essayez ici.

a->{                          // Lambda with char-array parameter and String return-type
  String r="";                //  Result-String
  int i=0;                    //  Flag for alteration
  for(int c:a)                //  Loop over the characters of the input
    r+=(char)                 //   And append the result-String with the following (converted to char):
      (c>64&c<91|c>96&c<123?  //    If it's a letter:
       i++%2<1?               //     And the flag states it should be lowercase:
        (c|32)                //      Convert it to lowercase
       :                      //     Else (should be uppercase):
        (c&~32)               //      Convert it to uppercase
      :                       //    Else:
       c);                    //     Simply append the non-letter character as is
                              //  End of loop (implicit / single-line body)
  return r;                   //  Return result-String
}                             // End of method
Kevin Cruijssen
la source
Je ne pouvais pas le raccourcir, mais vous pourriez peut-être utiliser (c+"").matches("[A-Za-z]")ou Character.isLetter(c)économiser des octets.
TheLethalCoder
@TheLethalCoder Les deux sont plus longs que c>64&c<91|c>96&c<123bien. Et comme je l’utilise intquand même pour les parties Character.toUpperCase(...)et les Character.toLowerCase(...)parties jouées au golf (celles-ci: (char)(c&~32)et (char)(c|32)), je doute d’être en mesure de les raccourcir.
Kevin Cruijssen
1
Je pensais que vous ne pourriez pas, mais ça valait le coup de poster pour voir si vous pouviez les utiliser de toute façon
TheLethalCoder
@TheLethalCoder Ah ok. :) Dans certains cas, le premier peut aider avec une approche légèrement différente de celle des autres défis, mais pour ce défi, il est plus court tel quel. Merci quand même.
Kevin Cruijssen
a->{String r="";int i=0,f=32;for(int c:a)r+=(char)(c>64&c<91|c>96&c<123?(f=~f):c);return r;} ??
Roman Gräf
4

Ruby, 57 55 47 41 octets

Le nombre d'octets inclut deux octets pour les options de ligne de commande.
Exécutez-le par exemple comme ceci:$ ruby -p0 alternate_case.rb <<< "some input" 

gsub(/\p{L}/){($&.ord&95|32*$.^=1).chr}

Avec l' p0option, la totalité de l'entrée est consommée en une fois et le global magique $.est incrémenté à 1. Il est ensuite basculé entre 0 et 1 et est utilisé pour conserver l'état.

Fonctionne avec une entrée multiligne; Essayez-le en ligne!

Merci à Ventero pour ses contributions remarquables - vérifiez les commentaires pour plus de détails

Daniero
la source
1
Bon sang, sans le fait que $.l'incrémentation automatique s'incrémentait à chaque getsappel, un programme complet avec le -pdrapeau aurait été plus court ...
Value Ink
1
1&$.+=1vous permet de supprimer les parenthèses. Et pour être complet, il est un autre entier global - il est malheureusement juste en lecture seule: $$.
Ventero
1
Une autre chose à propos de l'indicateur de ligne de commande: -p0permet à l'interprète de lire toutes les entrées disponibles en une fois. Votre code n'est donc appelé qu'une fois, vous permettant ainsi de l'utiliser librement $.. En combinant cela avec le fait que cela gsubfonctionne implicitement $_.gsub!lorsque vous spécifiez, -pun programme complet est nettement plus court: 48 caractères gsub(/[a-z]/i){[$&.upcase,$&.downcase][1&$.+=1]}pour le p0drapeau et 2 pour le drapeau.
Ventero
1
Remarque finale, je vous le promets :) Une fois que vous l'utilisez -p0, vous pouvez en réalité enregistrer quelques caractères supplémentaires dans la façon dont vous effectuez un basculement $.: Dans la mesure où il est maintenant garanti 1que votre code est appelé, vous pouvez simplement l'utiliser $.^=1.
Ventero
2
Il s'avère que j'ai menti, j'ai un autre commentaire: D Comme il est garanti que l'entrée ne contient jamais que de l'ASCII imprimable, nous pouvons utiliser le support de Ruby pour les catégories Unicode dans les expressions régulières: /\p{L}/(La catégorie de la lettre Unicode ) a un caractère plus court que /[a-z|/i.
Ventero
3

Brachylog , 25 octets

{ḷ|ụ}ᵐ.{ḷ∈Ạ&}ˢ¬{s₂{∈Ạ}ᵐ}∧

Essayez-le en ligne!

C'est à la fois long et lent.

Explication

{   }ᵐ.                       The Output is the result of mapping on each char of the Input:
 ḷ                              Lowecase the char
  |                             Or
   ụ                            Uppercase the char
       {    }ˢ                In the Ouput, select the chars that:
        ḷ∈Ạ&                    when lowercased are in "abc...xyz" (ie are letters)
              ¬{       }∧     In that new string, it is impossible to find:
                s₂              a substring of 2 consecutive chars
                  {∈Ạ}ᵐ         where both of them are in the lowercase alphabet
Fataliser
la source
3

MATL , 16 15 octets

Xktkyy-f2L))5M(

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Considérez l'entrée 'hello world'

Xk    % To upper case
      % STACK: 'HELLO WORLD'
t     % Duplicate top element
      % STACK: 'HELLO WORLD', 'HELLO WORLD'
k     % To lower case
      % STACK: 'HELLO WORLD', 'hello word'
yy    % Duplicate top two elements
      % STACK: 'HELLO WORLD', 'hello word', 'HELLO WORLD', 'hello word'
-     % Difference (of code points; element-wise)
      % STACK: 'HELLO WORLD', 'hello word', [-32 -32 -32 -32 -32 0 -32 -32 -32 -32 -32]
f     % Indices of nonzeros
      % STACK: 'HELLO WORLD', 'hello word', [1 2 3 4 5 7 8 9 10 11]
2L)   % Keep only even-indexed values (*)
      % STACK: 'HELLO WORLD', 'hello word', [2 4 7 9 11]
)     % Reference indexing (get values at indices)
      % STACK: 'HELLO WORLD', 'elwrd'
5M    % Push (*) again
      % STACK: 'HELLO WORLD', 'elwrd', [2 4 7 9 11]
(     % Assignment indexing (write values at indices). Implicit display
      % STACK: 'HeLlO wOrLd

'

Luis Mendo
la source
3

Perl 6 ,  32  30 octets

{S:g/<:L><-:L>*<:L>?/$/.tclc()/}

L'essayer

{S:g{<:L><-:L>*<:L>?}=$/.tclc}

L'essayer

Étendu:

{  # bare block lambda with implicit parameter ｢$_｣

  S            # string replace (not in-place) implicitly against ｢$_｣

  :global

  {

    <+ :L >    # a letter
    <- :L >*   # any number of non-letters
    <+ :L >?   # an optional letter

  }

  =

  $/.tclc()    # uppercase the first letter, lowercase everything else
}
Brad Gilbert b2gills
la source
3

q / kdb +, 51 42 38 octets

Solution:

{@[x;;upper]1#'2 cut(&)x in .Q.a}lower

Exemple:

q){@[x;;upper]1#'2 cut(&)x in .Q.a}lower"hello world"
"HeLlO wOrLd"

Remarques:

.Q.a        // abcde...xyz lowercase alphabet
(&) x in    // where, returns indices for where x (hello world) is an alpha
2 cut       // splits list into 2-item lists
1#'         // takes first item of each 2-item list; ie the indices to uppercase
@[x;;upper] // apply (@) upper to x at these indices
streetster
la source
2

V , 17 , 13 octets

VUÍშáü$©/ì&

Essayez-le en ligne!

Ou vérifiez tous les cas de test!

HeXdUmP:

00000000: 5655 cde1 83a8 e1fc 24a9 2fec 26         VU......$./.&

Explication:

Ceci utilise un regex ™ compressé so, donc avant de l'expliquer, développons le regex:

:%s/\v\a.{-}(\a|$)/\l&

Le VUconvertit tout en majuscule. Puis on lance ceci:

:%                      " On every line:
  s/\v                  "   Substitute:
      \a                "     A letter
        .{-}            "     Followed by as few characters as possible
            (\a|$)      "     Followed by either another letter or an EOL
                  /     "   With:
                   \l   "     The next character is lowercased
                     &  "     The whole text we matched

Réponse ancienne / plus intéressante:

:se nows
Vuò~h2/á
DJMcMayhem
la source
2

PHP, 71 octets

for(;a&$c=$argn[$i++];)echo ctype_alpha($c)?(ul[$k++&1].cfirst)($c):$c;

Essayez-le en ligne!

Jörg Hülsermann
la source
2

CJam , 26 à 24 octets

qeu{_'[,65>&,T^:T{el}&}%

Essayez-le en ligne!

Explication

q         e# Read all input.
eu        e# Uppercase it.
{         e# For each character:
 _        e#  Duplicate it.
 '[,65>&  e#  Set intersection with the uppercase alphabet.
 ,        e#  Length (either 0 or 1 in this case).
 T^:T     e#  XOR with T (T is initially 0), then store the result back in T.
 {el}&    e#  If The result of the XOR is true, lowercase the character.
}%        e# (end for)
Chat d'affaires
la source
2

Pyth, 11 octets

srR~xZ}dGrZ

Essayez-le ici

Explication

              # Z = 0; Q = eval(input())
srR~xZ}dGrZQ  # Auto-fill variables
         rZQ  # lowercase the input
 rR           # Apply the r function to each letter of the input with
   ~xZ}dG     # ... this as the other argument
   ~          # use the old value of the variable Z, then update it with the value of ...
    xZ        # Z xor ...
      }dG     # the variable d is a lowercase letter
              # because of how mapping works in pyth, d will contain the current letter
              # This causes Z to flip between 0 and 1, alternately upper and lower casing
              # the current character if it is a letter
FryAmTheEggman
la source
2

PowerShell, 86 octets

-join($args[0]|%{if($_-match"[a-z]"-and($i=!$i)){"$_".toupper()}else{"$_".tolower()}})

L'entrée est un [char[]]tableau.

Commentaires dans le code pour l'explication

# Join the array of string and char back together.
-join
    # Take the first argument and pass each element ([char]) down the pipe. 
    ($args[0]|%{
        # Check if this is a letter. Second condition is a boolean that changes at every pass 
        # but only if the current element is a letter. If not the condition never fires
        if($_-match"[a-z]"-and($i=!$i)){
            # Change the character to uppercase
            "$_".toupper()
        }else{
            # Output the character to lowercase. 
            # Special characters are not affected by this method
            "$_".tolower()
        }
    })
Mat
la source
2

Haskell, 105 83 + 2 4 + 1 octet de séparateur = 108 86 88 octets

import Data.Char
f#(x:y)|isLetter x=([toUpper,toLower]!!f)x:(1-f)#y|1>0=x:f#y
_#l=l

La fonction est (1#), commence en minuscule. Essayez-le en ligne!

Ce qui est triste, c’est que c’est plus long que les réponses Java et C # Merci à Ørjan Johansen d’avoir économisé 22 octets en fusionnant trois lignes en une!

Nom d'affichage générique
la source
2
J'ai vu qu'il avait besoin de ces fonctions importées depuis longtemps, alors je n'ai même pas essayé ... mais c'est un peu trop, vous pouvez fusionner certaines lignes:f#(x:y)|isLetter x=([toUpper,toLower]!!f)x:(1-f)#y|1>0=x:f#y
Ørjan Johansen
Désolé pour nitpicking, mais je pense 1#ne compte pas comme une fonction anonyme. Selon ma compréhension, on devrait pouvoir lier une fonction anonyme à un identifiant, mais f=1#cela ne fonctionnera pas par exemple . Au lieu de cela, vous avez besoin de la section (1#)pour +2 octets. Ceci est également indiqué implicitement dans les directives de notre communauté pour le golf à Haskell , bien que celles-ci devraient peut-être être adaptées pour mentionner explicitement ce cas.
Laikoni
@Laikoni ok, réponse mise à jour
Nom d'affichage générique
2

Google Sheets, 264 octets

=ArrayFormula(JOIN("",IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Za-z]"),CHAR(CODE(UPPER(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)))+MOD(LEN(REGEXREPLACE(LEFT(A1,ROW(OFFSET(A1,0,0,LEN(A1)))),"[^A-Za-z]","")),2)*32),MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1))))

C'est un gros bazar mais c'est un peu plus facile si vous le développez:

=ArrayFormula(
  JOIN(
    "",
    IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Za-z]"),
      CHAR(
        CODE(UPPER(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)))
        +
        MOD(LEN(REGEXREPLACE(LEFT(A1,ROW(OFFSET(A1,0,0,LEN(A1)))),"[^A-Za-z]","")),2)*32
      ),
      MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1)
    )
  )
)

La pseudo-logique fonctionnerait comme ceci:

For each character {                                    // ArrayFormula()
  If (character is a letter) {                          // REGEXMATCH(MID())
    Return CHAR(                                        // CHAR()
      CODE(UPPER(letter))                               // CODE(UPPER(MID()))
      +
      If (nth letter found and n is odd) {32} else {0}  // MOD(LEN(REGEXREPLACE(LEFT())))
    )
  } else {
    Return character                                    // MID()
  }
}
Engineer Toast
la source
2

Perl 5, 24 bytes

23 bytes + 1 byte for -p.

Thanks to @Dada for -2 bytes.

s/\pl/--$|?uc$&:lc$&/eg

Try it online!

Dom Hastings
la source
Neat. \pl instead of [a-z] to 2 bytes tho :)
Dada
@Dada, I genuinely didn't know that! How didn't I know that!! Thank you!
Dom Hastings
I think I learned it from Ton Hospel, and I use it now and then (actually I tend to forget about it too often and use [a-z] instead!). If you wonder, it comes from perlrecharclass ;)
Dada
1

C 64 bytes

B;R(char *s){for(;*s=isalpha(*s)?(B=!B)?*s|=32:*s&=~32:*s;s++);}

Takes advantage of ascii encoding where upper and lower case letters are offset by 0x20.

user230118
la source
You don't need the ' ' space between char and *s
cleblanc
This looks very similar to @cleblanc's answer.
Digital Trauma
I posted it when @cleblanc's post used toUpper() and toLower().
user230118
1
My comment suggesting this approach was at 18:29:34Z. cleblanc's edit to incorporate this was at 18:37:36Z. Your answer was posted at 18:38:21Z. So I guess cleblanc's answer was less than a minute before your post. Your answer is remarkably similar to my suggestion, but I guess that's the nature of code-golf - often solutions in the same language will converge to the same thing - so I'll let it slide :)
Digital Trauma
1

Retina, 32 bytes

T`l`L
01T`L`l`[A-Z][^A-Z]*[A-Z]?

Try it online!

First converts the input to uppercase, and then groups the input into matches containing up to two capital letters. The only time it will contain only one letter is if the last letter doesn't have a pair. Then it lowercases the first letter of each of these matches.

The 01 in the second stage translates roughly to: do not change the behaviour of this stage based on the match number, but only apply the changes to the first character of each match.

FryAmTheEggman
la source
1

PHP 5, 54 bytes

<?=preg_filter('/\pL/e','($0|" ")^a^aA[$i^=1]',$argn);
user63956
la source
1

C#, 100 bytes

s=>{var r="";int m=0;foreach(var c in s)r+=char.IsLetter(c)?(char)(++m%2>0?c|32:c&~32):c;return r;};
TheLethalCoder
la source
1

Groovy, 79 bytes

{x=0;it.toUpperCase().collect{(it==~/\w/)?x++%2?it:it.toLowerCase():it}.join()}
Magic Octopus Urn
la source
1

Python 3, 192 bytes

x=list(input())
s=[]
for i in x[1::2]:
 s.append(i)
 x.remove(i)
s.reverse()
while len(x)<len(s):
 x.append("")
while len(x)>len(s):
 s.append("")
for i in range(len(x)):
 print(end=x[i]+s[i])

Try it online!

caird coinheringaahing
la source