42

Для сегодняшнего вызова вы должны написать программу или функцию, которая чередует регистр строки. Тем не менее, вы должны игнорировать не алфавитные символы. Это означает, что каждый буквенный символ должен иметь другой регистр, чем предыдущий и следующий буквенный символ. Это немного сложнее, чем заглавные буквы, например. Если вы берете строку, такую как

hello world

и преобразовать все остальные символы в верхний регистр, вы получите:

hElLo wOrLd

Как видите, за строчными буквами oследует строчная w. Это неверно Вместо этого вы должны игнорировать пространство, давая нам такой результат:

hElLo WoRlD

Все не алфавитные символы должны быть одинаковыми. Выходные данные могут начинаться с прописных или строчных букв, если они постоянно чередуются. Это означает, что следующее также будет приемлемым результатом:

HeLlO wOrLd

Ваша программа должна работать независимо от случая ввода.

Входная строка будет содержать только печатный ASCII , так что вам не нужно беспокоиться о непечатаемых символах, новых строках или юникоде. Ваша заявка может быть либо полной программой, либо функцией, и вы можете выполнять ввод и вывод в любом приемлемом формате. Например, аргументы функции / возвращаемое значение, 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

Поскольку это код-гольф , применяются стандартные лазейки и выигрывает самый короткий ответ в байтах!

code-golf string

— DJMcMayhem
источник

33

Тьфу, я только понял , что это было , что мем XD

— бета -

@BetaDecay Хахаха, это не было моим намерением. Больше всего неудачных сроков. Я думаю, что это мини-вызов для чата , и мне нравится идея этого, потому что он немного сложнее, чем кажется.

— DJMcMayhem

4

Следующая задача - напечатать ascii spongebob à lacowsay

— Frambot

1

Слей это! Я просто написал сценарий CJam для этого (как и вчера) и удалил его.

— Esolanging Fruit

2

Существует некоторая пропущенная возможность для названия или, по крайней мере, примеров, использующих либо пингвина гибели, либо спорсов.

— Ян

19

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

Expand snippet

— Arnauld
источник

Как именно я собирался это сделать. Я думаю, я вижу, где вы можете сохранить пару байтов, но я на моем телефоне, поэтому не могу проверить должным образом.

— Лохматый

Да, использование троичного - вот что я собирался предложить.

— Лохматый

1

Как работает s=!sтрюк?

— Критиси Литос

7

@KritixiLithos Поскольку sэто входная строка, !sсначала оценивается как false(если только входная строка не пуста, в этом случае она будет оцениваться true- но пустая строка не будет генерировать никакого совпадения в любом случае). После этого он просто становится стандартной логической операцией, чередуя между falseи true. Кроме того, мы не против потерять контент sна этом этапе, потому что он уже использовался для подачи .replace().

— Arnauld

3

@MayorMonty К сожалению, это будет соответствовать нескольким символам. Вход, такой как "A[I", потерпит неудачу.

— Арно

12

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

— Аднан
источник

Мне нравится, как я пытаюсь идти вслепую, зная, что мне нужно побить 11 байтов; затем медленно переходите от 17 до 11 байтов и понимаете lvy¾Fš}Da½J, что именно то, что у вас уже было.

— Волшебная урна осьминога

1

@carusocomputing Существует гораздо более простое 8-байтовое решение: p

— Аднан

4

о, да, супер легко, ха-ха.

— Волшебная урна осьминога

2

@ Осьминог Есть некоторые обсуждения по этому поводу, но я использую оба «osable» и «osabie».

— Аднан

1

@ octopus Я буквально говорю Oh-Five-Ay-Bee-One-Eee, я не творческий человек.

— Волшебная Урна Осьминога

11

GNU Sed, 33

5 байтов сохранено благодаря @TobySpeight

Оценка включает +1 для -rфлага к седу.

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

Попробуйте онлайн .

— Цифровая травма
источник

8

Желе , 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.

— Деннис
источник

7

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

— powelles
источник

Очень хорошо! Вы можете удалить ,. Если это не число (то есть [12]), Джапт знает, что это разные предметы. Я считаю, что вы можете удалить &1также.

— Оливер

Спасибо @obarakon. Документация по Japt немного скудна.

— Пауэлл

Спасибо за использование Japt. Не стесняйтесь задавать вопросы, предложения и т. Д. В чате Japt . Есть также Подсказки для темы Japt . :)

— Оливер

_m"uv"gT°Ницца. Я как раз собирался это предложить.

— Оливер

@obarakon Да, я видел, как ETH ответил на твой вопрос в чате, и это заставило меня попробовать.

— Пауэлл

6

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

Попробуйте онлайн! или попробуйте все тестовые случаи

— прут
источник

В Python 3 на два байта короче: попробуйте онлайн!

— DJMcMayhem

1

по какой-то причине вы не можете сделать print(end=(2*i).title()[x])?

— Cyoce

5

Алиса , 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"]. Я сильно подозреваю, что это ошибка.

— Nitrodon
источник

5

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

Попробуйте онлайн!

— cleblanc
источник

Я немного поиграл в нее и модифицировал ее, чтобы она работала на всех gcc, tcc, clang. Кстати, gcc помещает строковые литералы в постоянную память, поэтому я использовал strdup()указатели для чтения-записи памяти в коде тест-драйвера.

— Цифровая травма

1

@DigitalTrauma спасибо за это. Я должен был признать, что бит 5 был разницей между верхним и нижним. Ницца !

— cleblanc

Я тоже пытался сделать эту версию рекурсивной, но не смог сделать ее короче.

— Цифровая травма

Вы можете заменить внутреннее условное *s&~32|++l%2<<5выражение на 3 байта.

— ПНУ

Так как входные обещает быть для печати ASCII, вы можете заменить &~33с , &95чтобы сохранить дополнительные байты.

— RJHunter

4

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

— Кевин Круйссен
источник

Я не мог получить его короче, но вы могли бы использовать (c+"").matches("[A-Za-z]")или Character.isLetter(c)сохранить байты.

— TheLethalCoder

@TheLethalCoder Оба длиннее, чем c>64&c<91|c>96&c<123все же. И так как я в intлюбом случае использую для Character.toUpperCase(...)и Character.toLowerCase(...)гольф частей (эти: (char)(c&~32)и (char)(c|32)), я сомневаюсь, что я мог бы сделать его короче с любым из них.

— Кевин Круйссен

1

Я думал, что вы не сможете, но стоит опубликовать, чтобы посмотреть, сможете ли вы их использовать в любом случае

— TheLethalCoder

@TheLethalCoder А, хорошо. :) В некоторых случаях первый может помочь с немного другим подходом для других задач, но для этой задачи он короче, как есть. Спасибо, в любом случае.

— Кевин Круйссен

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

— Роман Греф

4

Рубин, 57 55 47 41 байт

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

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

С помощью этой p0опции весь ввод потребляется за один раз, и магический глобал $.увеличивается до 1. Позже он переключается между 0 и 1 и используется для сохранения состояния.

Работает с многострочным вводом; Попробуйте онлайн!

Спасибо Ventero за потрясающий вклад - проверьте комментарии для деталей.

— daniero
источник

1

Чувак, если бы не тот факт, что $.автоинкремент увеличивается при каждом getsвызове, полная программа с -pфлагом была бы короче ...

— Value Ink

1

1&$.+=1позволяет отбросить скобки. И для полноты, есть еще одна глобальная целое - это , к сожалению , только для чтения только: $$.

— Вентеро

1

Еще одна вещь, связанная с флагом командной строки: -p0заставляет интерпретатор читать все доступные входные данные за один раз - поэтому ваш код вызывается только один раз, что позволяет вам свободно использовать $.. Объединение этого с фактом, что gsubнеявно действует как $_.gsub!при определении, -pделает полную программу значительно короче: 48 символов для gsub(/[a-z]/i){[$&.upcase,$&.downcase][1&$.+=1]}и 2 для p0флага.

— Вентеро

1

Заключительное замечание, обещаю :) После того, как вы используете -p0, вы можете фактически сохранить еще несколько символов в том, как вы переворачиваете $.назад и вперед: так как теперь гарантированно будет, 1когда ваш код вызывается, вы можете просто использовать $.^=1.

— Вентеро

2

Оказывается, я солгал, у меня есть еще один комментарий: D Поскольку входные данные гарантированно будут содержать только печатные ASCII, мы можем использовать поддержку Ruby для категорий Unicode в регулярных выражениях: /\p{L}/( Буква Unicode категории ) на один символ короче /[a-z|/i.

— Вентеро

3

Брахилог , 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

— Фатализировать
источник

3

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

'

— Луис Мендо
источник

3

Perl 6 , 32 30 байт

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

Попытайся

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

Попытайся

Expanded:

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

— Брэд Гилберт b2gills
источник

3

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

— streetster
источник

2

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

— DJMcMayhem
источник

2

PHP, 71 байт

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

Попробуйте онлайн!

— Йорг Хюльсерманн
источник

2

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)

— Бизнес Кот
источник

2

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

— FryAmTheEggman
источник

2

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

— Мэтт
источник

2

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 #~~ Спасибо Эрджану Йохансену за сохранение 22 байта путем объединения трех строк в одну!

— Общее отображаемое имя
источник

2

Я видел, что для этого нужны эти длинные импортированные функции, поэтому я даже не пытался ... но это немного, вы можете объединить несколько строк:f#(x:y)|isLetter x=([toUpper,toLower]!!f)x:(1-f)#y|1>0=x:f#y

— Орджан Йохансен

Извините за придирки, но я думаю 1#, не считается анонимной функцией. В моем понимании можно связать анонимную функцию с идентификатором, но, например f=1#, не будет работать. Вместо этого вам нужен раздел (1#)для +2 байта. Это также косвенно указано в наших руководящих принципах сообщества по игре в гольф на Хаскеле , хотя, возможно, они должны быть адаптированы для явного упоминания этого случая.

— Лайкони

@Laikoni хорошо, ответ обновлен

— общее отображаемое имя

2

Google Sheets, 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()
  }
}

— Инженер Тост
источник

2

Perl 5 , 24 байта

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

Спасибо @Dada за -2 байта.

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

Попробуйте онлайн!

— Дом Гастингс
источник

Ухоженная. \plвместо [a-z]2 байтов tho :)

— Dada

@ Дада, я искренне не знал этого! Как я этого не знал !! Спасибо!

— Дом Гастингс

Я думаю, что я узнал об этом от Тон Хоспель, и я использую это время от времени (на самом деле, я склонен слишком часто забывать об этом и использовать [a-z]вместо этого!). Если вам интересно, это происходит от perlrecharclass ;)

— Dada

1

Сетчатка , 46 байт

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

Попробуйте онлайн! Включает тестовые случаи.

— Нил
источник

1

C 64 байта

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

Использует преимущества кодировки ascii, где буквы верхнего и нижнего регистра смещены на 0x20.

— user230118
источник

Вам не нужно пространство между ' charи*s

— cleblanc

Это выглядит очень похоже на ответ @ cleblanc .

— Цифровая травма

Я отправил это, когда сообщение @ cleblanc использовало toUpper () и toLower ().

— user230118

1

Мой комментарий, предлагающий такой подход, был в 18: 29: 34Z. Правка cleblanc, чтобы включить это было в 18: 37: 36Z. Ваш ответ был опубликован в 18: 38: 21Z. Поэтому я думаю, что ответ Клеблана был менее чем за минуту до вашего поста. Ваш ответ удивительно похож на мое предложение, но я полагаю, что это природа код-гольфа - часто решения на одном языке сходятся к одному и тому же - поэтому я позволю этому скользить :)

— Digital Trauma

1

Сетчатка , 32 байта

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

Попробуйте онлайн!

Сначала преобразует ввод в верхний регистр, а затем группирует ввод в совпадения, содержащие до двух заглавных букв. Единственный раз, когда он будет содержать только одну букву, это если последняя буква не имеет пары. Затем в нижнем регистре указывается первая буква каждого из этих совпадений.

На 01втором этапе примерно означает: не изменяйте поведение этого этапа в зависимости от номера совпадения, а применяйте только изменения к первому символу каждого совпадения.

— FryAmTheEggman
источник

1

PHP 5, 54 байта

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

— user63956
источник

1

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

— TheLethalCoder
источник

1

Groovy, 79 байт

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

— Урна волшебного осьминога
источник

1

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

Попробуйте онлайн!

— Caird Coneheringaahing
источник

0

Выпуклый , 16 байт

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

Попробуйте онлайн!

Выпуклый порт ответа @Business Cat .

— GamrCorps
источник

АЛЬТЕРНАТА КАЗ

Примеры:

JavaScript (ES6), 66 63 байта

Контрольные примеры

05AB1E , 11 8 байт

Код:

Объяснение:

GNU Sed, 33

Желе , 13 байт

Как это работает

Japt , 16 14 байтов

объяснение

Python 3 , 86 76 68 66 63 байта

Алиса , 18 байт

объяснение

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

Java 8, 99 байт

Рубин, 57 55 47 41 байт

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

объяснение

MATL , 16 15 байт

объяснение

Perl 6 , 32 30 байт

Expanded:

q / kdb +, 51 42 38 байт

V , 17 , 13 байтов

PHP, 71 байт

CJam , 26 24 байта

объяснение

Pyth, 11 байт

объяснение

PowerShell, 86 байт

Комментарии в коде для объяснения

Haskell, 105 83 + 2 4 + 1 байт разделителя = 108 86 88 байт

Google Sheets, 264 байта

Perl 5 , 24 байта

Сетчатка , 46 байт

Сетчатка , 32 байта

PHP 5, 54 байта

C #, 100 байт

Groovy, 79 байт

Python 3 , 192 байта

Выпуклый , 16 байт