Для сьогоднішнього виклику необхідно написати програму або функцію, яка чергує регістр рядків. Однак ви повинні ігнорувати неабетичні символи. Це означає, що кожен алфавітний символ повинен мати інший випадок, ніж попередній та наступний алфавітний символ. Це дещо складніше, ніж, наприклад, велике написання будь-якого іншого листа. Якщо ви берете такий рядок, як

hello world

та перетворивши будь-який інший символ у великі регістри, ви отримаєте:

hElLo wOrLd

Як бачите, за малим регістром oйде нижній регістр w. Це недійсне. Натомість ви повинні ігнорувати простір, даючи нам такий результат:

hElLo WoRlD

Усі не алфавітні символи повинні залишатися однаковими. Вихід може починатися з верхнього або нижнього регістру, доки він послідовно чергується. Це означає, що наступним також буде прийнятний вихід:

HeLlO wOrLd

Ваша програма повинна працювати незалежно від випадку введення.

Рядок введення завжди буде містити ASCII для друку , тому вам не доведеться турбуватися про недруковані символи, нові рядки або unicode. Подання може бути як повноцінною програмою, так і функцією, і ви можете приймати введення та вихід у будь-якому розумному форматі. Наприклад, аргументи функції / значення повернення, STDIN / STDOUT, читання / запис файлу тощо.

Приклади:

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

Оскільки це код-гольф , застосовуються стандартні лазівки, і найкоротша відповідь у байтах виграє!

JavaScript (ES6), 66 63 байт

Починається з великої літери.

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

Тестові справи

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 байт

Код:

lvyJ¤aiš

Використовує кодування 05AB1E . Спробуйте в Інтернеті!

Пояснення:

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 байт збережено завдяки @TobySpeight

Оцінка включає +1 за -rпрапор до с.

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

Спробуйте в Інтернеті .

Желе , 13 байт

nŒsTm2
ŒlŒuǦ

Спробуйте в Інтернеті!

Як це працює

Œ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 байт

r"%l"_m"uv"gT°

Спробуйте в Інтернеті!

Пояснення

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 байт

^{-2 байти завдяки DJMcMayhem
-3 байти завдяки Cyoce}

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

Спробуйте в Інтернеті! або Спробуйте всі тестові приклади

Аліса , 18 байт

/olZlYuN
@iy.u..//

Спробуйте в Інтернеті!

Пояснення

Ця програма дотримується менш відомого шаблону для програм непарної довжини, які повністю працюють в порядку. Лінеаризована версія цього коду:

il.l.uN.YuZyo@

Пояснення коду:

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

Без використання lдубліката, стек після Nбуде ["helloworld", "helloworld"]. Я сильно підозрюю, що це помилка.

C (tcc) , 60 57 56 байт

Завдяки DigitalTrauma за те, що помітив біт 5, є єдиною відмінністю для верхнього / нижнього регістру ASCII.

Особлива подяка zch за те, що ви пограли ще три байти.

Збережіть ще один байт від ідеї RJHunter

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

Спробуйте в Інтернеті!

Java 8, 99 байт

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

Пояснення:

Спробуйте тут.

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

Рубі, 57 55 47 41 байт

Кількість байтів включає два байти для параметрів командного рядка.
Запустити його, наприклад, так:$ ruby -p0 alternate_case.rb <<< "some input"

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

За допомогою p0опції весь вхід витрачається за один раз, а магічний глобальний $.збільшується до 1. Це пізніше змінюється між 0 і 1 і використовується для збереження стану.

Працює з багаторядковим входом; Спробуйте в Інтернеті!

Завдяки Вентеро за чудовий вклад - перегляньте коментарі для деталей.

Брахілог , 25 байт

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

Спробуйте в Інтернеті!

Це і довге, і повільне.

Пояснення

{   }ᵐ.                       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 байт

Xktkyy-f2L))5M(

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

Розглянемо вхід "привіт світ"

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 байт

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

Спробуй це

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

Спробуй це

Розширено:

{  # 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 байт

Рішення:

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

Приклад:

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

Примітки:

.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 байт

VUÍშáü$©/ì&

Спробуйте в Інтернеті!

Або Перевірте всі тестові випадки!

HeXdUmP:

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

Пояснення:

Для цього використовується стислий регекс ™ ️, тому перед тим, як пояснити це, давайте розширимо регулярний вираз:

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

VUНовонавернені все в верхній регістр. Потім ми запускаємо це:

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

Стара / більш цікава відповідь:

:se nows
Vuò~h2/á

PHP, 71 байт

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

Спробуйте в Інтернеті!

CJam , 26 24 байти

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

Спробуйте в Інтернеті!

Пояснення

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 байт

srR~xZ}dGrZ

Спробуйте тут

Пояснення

              # 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 байт

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

Вхід - це [char[]]масив.

Коментарі в коді для пояснення

# 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 байт роздільника = 108 86 88 байт

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

Функція (1#), починається з малих літер Спробуйте в Інтернеті!

Сумно в тому, що це довше, ніж відповіді Java та C # Завдяки Ørjan Johansen за збереження 22 байтів, об'єднавши три рядки в одну!

Google Таблиці, 264 байти

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

Це великий безлад, але трохи легше, якщо розширити його:

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

Псевдо-логіка працюватиме так:

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 байти

23 байти + 1 байт для -p.

Завдяки @Dada за -2 байти.

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

Спробуйте в Інтернеті!

Сітківка , 46 байт

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

Спробуйте в Інтернеті! Включає тестові приклади.

C 64 байт

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

Скористається кодуванням ascii, де великі та малі літери зміщені на 0x20.

Сітківка , 32 байти

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

Спробуйте в Інтернеті!

Спочатку перетворює вхід у великі регістри, а потім групує введення у відповідність, що містить до двох великих літер. Єдиний раз, коли він буде містити лише одну букву, якщо останній лист не має пари. Тоді він пише малі літери першої літери кожного з цих матчів.

На 01другому етапі грубо перекладається: не змінювати поведінку цього етапу на основі номера матчу, а лише застосовувати зміни до першого символу кожного матчу.

PHP 5, 54 байти

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

C #, 100 байт

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 байт

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

Пітон 3 , 192 байти

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

Спробуйте в Інтернеті!

Опукла , 16 байт

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

Спробуйте в Інтернеті!

Опуклий порт відповіді @Business Cat .