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!

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

let f =

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

console.log(f("ASCII"))
console.log(f("42"))
console.log(f("#include <iostream>"))
console.log(f("LEAVE_my_symbols#!#&^%_ALONE!!!"))
console.log(f("PPCG Rocks!!! For realz."))
console.log(f("This example will start with lowercase"))
console.log(f("This example will start with uppercase"))
console.log(f("A1B2"))

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

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 .

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.

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

Python 3 , 86 76 68 66 63 octets

^{-2 octets grâce à DJMcMayhem
-3 octets grâce à Cyoce}

x=0
for i in input():print(end=(2*i).title()[x]);x^=i.isalpha()

Essayez-le en ligne! ou Essayez tous les cas de test

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.

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!

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

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

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

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

'

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
}

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

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/á

PHP, 71 octets

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

Essayez-le en ligne!

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)

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

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

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!

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

Perl 5, 24 bytes

23 bytes + 1 byte for -p.

Thanks to @Dada for -2 bytes.

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

Try it online!

Retina, 46 bytes

T`L`l
T`l`L`.(?=([^a-z]*|[a-z][^a-z]*[a-z])*$)

Try it online! Includes test cases.

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.

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.

PHP 5, 54 bytes

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

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

Groovy, 79 bytes

{x=0;it.toUpperCase().collect{(it==~/\w/)?x++%2?it:it.toLowerCase():it}.join()}

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!

Convex, 16 bytes

¯{_U&,R^:R{¬}&}%

Try it online!

Convex port of @Business Cat's answer.