Für die heutige Herausforderung müssen Sie ein Programm oder eine Funktion schreiben, die den Fall einer Zeichenfolge abwechselt. Sie müssen jedoch nicht alphabetische Zeichen ignorieren. Dies bedeutet, dass jedes alphabetische Zeichen einen anderen Groß- und Kleinschreibung als das vorangehende und nachfolgende alphabetische Zeichen haben muss. Dies ist etwas komplexer als zum Beispiel das Großschreiben jedes anderen Buchstabens. Wenn Sie eine Zeichenfolge wie

hello world

Wenn Sie jedes andere Zeichen in Großbuchstaben umwandeln, erhalten Sie:

hElLo wOrLd

Wie Sie sehen, ofolgt auf den Kleinbuchstaben ein Kleinbuchstabe w. Dies ist ungültig. Stattdessen müssen Sie das Leerzeichen ignorieren und uns das folgende Ergebnis geben:

hElLo WoRlD

Alle nicht alphabetischen Zeichen müssen gleich bleiben. Die Ausgabe kann mit Groß- oder Kleinbuchstaben beginnen, sofern sie sich ständig abwechselt. Dies bedeutet, dass auch Folgendes eine akzeptable Ausgabe wäre:

HeLlO wOrLd

Ihr Programm sollte unabhängig von der Eingabe funktionieren.

Die Eingabezeichenfolge enthält immer nur druckbares ASCII , sodass Sie sich nicht um nicht druckbare Zeichen, Zeilenumbrüche oder Unicode kümmern müssen. Ihre Einreichung kann entweder ein vollständiges Programm oder eine Funktion sein, und Sie können die Ein- und Ausgabe in jedem vernünftigen Format vornehmen. Zum Beispiel Funktionsargumente / Rückgabewert, STDIN / STDOUT, Lesen / Schreiben einer Datei usw.

Beispiele:

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

Da es sich um Code-Golf handelt , gelten Standardlücken und die kürzeste Antwort in Bytes gewinnt!

JavaScript (ES6), 66 63 Bytes

Beginnt mit Großbuchstaben.

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

Testfälle

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 Bytes

Code:

lvyJ¤aiš

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung:

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 Bytes gespart dank @TobySpeight

Punktzahl beinhaltet +1 für -rFlagge zu sed.

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

Probieren Sie es online aus .

Jelly , 13 Bytes

nŒsTm2
ŒlŒuǦ

Probieren Sie es online!

Wie es funktioniert

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

r"%l"_m"uv"gT°

Probieren Sie es online!

Erläuterung

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 Bytes

^{-2 Bytes dank DJMcMayhem
-3 Bytes dank Cyoce}

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

Probieren Sie es online! oder Probieren Sie alle Testfälle aus

Alice , 18 Bytes

/olZlYuN
@iy.u..//

Probieren Sie es online!

Erläuterung

Dieses Programm folgt einer weniger bekannten Vorlage für Programme ungerader Länge, die vollständig im Ordnungsmodus ausgeführt werden. Die linearisierte Version dieses Codes lautet:

il.l.uN.YuZyo@

Erklärung des Codes:

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

Ohne Verwendung ldes Duplikats Nwäre der Stapel danach ["helloworld", "helloworld"]. Ich vermute sehr, dass dies ein Fehler ist.

C (TCC) , 60 57 56 Byte

Dank DigitalTrauma für das Erkennen von Bit 5 ist der einzige Unterschied für ASCII-Groß- / Kleinschreibung.

Besonderer Dank geht an zch für das Abschlagen von drei weiteren Bytes.

Speichern Sie ein weiteres Byte von RJHunters Idee

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

Probieren Sie es online!

Java 8, 99 Bytes

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

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

Die Byteanzahl umfasst zwei Bytes für Befehlszeilenoptionen.
Führen Sie es zum Beispiel so aus:$ ruby -p0 alternate_case.rb <<< "some input"

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

Mit der p0Option wird die gesamte Eingabe auf einmal verbraucht und das magische Global $.wird auf 1 erhöht. Dies wird später zwischen 0 und 1 umgeschaltet und zum Beibehalten des Status verwendet.

Funktioniert mit mehrzeiliger Eingabe; Probieren Sie es online!

Vielen Dank an Ventero für die großartigen Beiträge. Weitere Informationen finden Sie in den Kommentaren.

Brachylog , 25 Bytes

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

Probieren Sie es online!

Das ist lang und langsam.

Erläuterung

{   }ᵐ.                       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 Bytes

Xktkyy-f2L))5M(

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Sie die Eingabe "Hallo Welt"

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  Bytes

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

Versuch es

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

Versuch es

Erweitert:

{  # 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 Bytes

Lösung:

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

Beispiel:

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

Anmerkungen:

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

VUÍშáü$©/ì&

Probieren Sie es online!

Oder Überprüfen Sie alle Testfälle!

HeXdUmP:

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

Erläuterung:

Dies verwendet einen komprimierten regulären Ausdruck (regex ™ before). Bevor wir ihn erklären, sollten wir den regulären Ausdruck wie folgt erweitern:

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

Das VUkonvertiert alles in Großbuchstaben. Dann führen wir Folgendes aus:

:%                      " 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

Alte / interessantere Antwort:

:se nows
Vuò~h2/á

PHP, 71 Bytes

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

Probieren Sie es online!

CJam , 26 24 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

srR~xZ}dGrZ

Probieren Sie es hier aus

Erläuterung

              # 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 Byte

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

Die Eingabe ist ein [char[]]Array.

Kommentare im Code zur Erklärung

# 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 Byte Trennzeichen = 108 86 88 Byte

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

Funktion ist (1#), startet Kleinbuchstaben. Probieren Sie es online!

Das Traurige ist, dass dies länger ist als die Java- und C # -Antworten. Vielen Dank an Ørjan Johansen, der durch das Zusammenführen von drei Zeilen zu einer Zeile 22 Byte gespart hat!

Google Sheets, 264 Bytes

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

Es ist ein großes Durcheinander, aber es ist ein bisschen einfacher, wenn Sie es erweitern:

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

Die Pseudologik würde folgendermaßen ablaufen:

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 für -p.

Vielen Dank an @Dada für -2 Bytes.

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

Probieren Sie es online!

Netzhaut , 46 Bytes

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

Probieren Sie es online! Beinhaltet Testfälle.

C 64 Bytes

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

Nutzt die ASCII-Codierung, bei der Groß- und Kleinbuchstaben um 0x20 versetzt sind.

Netzhaut , 32 Bytes

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

Probieren Sie es online!

Konvertiert zuerst die Eingabe in Großbuchstaben und gruppiert sie dann in Übereinstimmungen mit bis zu zwei Großbuchstaben. Es enthält nur einen Buchstaben, wenn der letzte Buchstabe kein Paar enthält. Dann wird der erste Buchstabe jeder dieser Übereinstimmungen unterstrichen.

Das 01in der zweiten Stufe bedeutet ungefähr: Ändern Sie das Verhalten dieser Stufe nicht anhand der Übereinstimmungsnummer, sondern wenden Sie die Änderungen nur auf das erste Zeichen jeder Übereinstimmung an.

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])

Probieren Sie es online!

Konvex , 16 Bytes

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

Probieren Sie es online!

Konvexer Port der Antwort von @Business Cat .