42

Per la sfida di oggi, è necessario scrivere un programma o una funzione che alterna il caso di una stringa. Tuttavia, è necessario ignorare i caratteri non alfabetici. Ciò significa che ogni carattere alfabetico deve avere un caso diverso rispetto al carattere alfabetico precedente e successivo. Questo è leggermente più complesso rispetto al maiuscolo ad ogni altra lettera per esempio. Se prendi una stringa come

hello world

e converti tutti gli altri caratteri in maiuscolo, otterrai:

hElLo wOrLd

Come puoi vedere, il minuscolo oè seguito da un minuscolo w. Questo non è valido Invece, devi ignorare lo spazio, dandoci questo risultato:

hElLo WoRlD

Tutti i caratteri non alfabetici devono essere lasciati uguali. L'output può iniziare con lettere maiuscole o minuscole, purché si alterni costantemente. Ciò significa che anche un risultato accettabile sarebbe il seguente:

HeLlO wOrLd

Il tuo programma dovrebbe funzionare indipendentemente dal caso dell'input.

La stringa di input conterrà sempre e solo ASCII stampabile , quindi non devi preoccuparti di caratteri non stampabili, nuove righe o unicode. Il tuo invio può essere un programma completo o una funzione e puoi prendere l'input e l'output in qualsiasi formato ragionevole. Ad esempio, argomenti di funzione / valore restituito, STDIN / STDOUT, lettura / scrittura di un file, ecc.

Esempi:

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

Poiché si tratta di code-golf , si applicano scappatoie standard e vince la risposta più breve in byte!

code-golf string

— DJMcMayhem
fonte

33

Ugh, ho appena capito che questo era quel meme xD

— Decadimento beta del

@BetaDecay Hahaha, non era mia intenzione. Altro solo tempismo sfortunato. L'ho pensato come una mini-sfida di chat e mi piace l'idea alla base perché è leggermente più difficile di quanto sembri.

— DJMcMayhem

4

La prossima sfida è stampare uno cowsay

— spugnabo

1

Dannazione! Ho appena scritto una sceneggiatura di CJam per questo (come ieri) e l'ho cancellata.

— Esolanging Fruit,

2

C'è un potenziale mancante per il titolo o almeno gli esempi usando il pinguino della rovina o le spork.

— Ian

19

JavaScript (ES6), 66 63 byte

Inizia con le maiuscole.

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

Casi test

Mostra snippet di codice

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
fonte

Esattamente come stavo per farlo. Io penso che io posso vedere dove si può risparmiare un paio di byte, ma io sono sul mio telefono in modo da non posso testare correttamente.

— Shaggy,

Sì, usare un ternario è ciò che stavo per suggerire.

— Shaggy,

1

Come funziona il s=!strucco?

— Kritixi Lithos,

7

@KritixiLithos Poiché sè la stringa di input, !sprimi restituisce false(a meno che la stringa di input è vuota, nel qual caso sarebbe valutare a true- ma una stringa vuota non genererà una partita comunque). Dopodiché, diventa solo un'operazione booleana standard, alternando tra falsee true. Inoltre, sa questo punto non ci dispiace perdere il contenuto perché era già utilizzato per alimentare .replace().

— Arnauld,

3

@MayorMonty Sfortunatamente, corrisponderebbe ad alcuni simboli. Un input come "A[I"fallirebbe.

— Arnauld,

12

05AB1E , 11 8 byte

Codice:

lvyJ¤aiš

Utilizza la codifica 05AB1E .Provalo online!

Spiegazione:

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
fonte

Adoro come provo ad andare alla cieca, sapendo che devo battere 11 byte; poi passa lentamente da 17 a 11 byte e realizzi che lvy¾Fš}Da½Jè esattamente quello che avevi già ._.

— Magic Octopus Urn

1

@carusocomputing Esiste una soluzione a 8 byte molto più semplice: p

— Adnan,

4

oh sì, ahah super facile.

— Magic Octopus Urn

2

@Octopus C'è qualche discussione a riguardo, ma io uso sia 'osable' che 'osabie'.

— Adnan,

1

@octopus Dico letteralmente che Oh-Five-Ay-Bee-One-Eeenon sono un uomo creativo.

— Magic Octopus Urn,

11

GNU Sed, 33

5 byte salvati grazie a @TobySpeight

Il punteggio include +1 per -rflag to sed.

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

Provalo online .

— Trauma digitale
fonte

8

Gelatina , 13 byte

nŒsTm2
ŒlŒuÇ¦

Provalo online!

Come funziona

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

7

Japt , 16 14 byte

r"%l"_m"uv"gT°

Provalo online!

Spiegazione

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
fonte

Molto bella! È possibile rimuovere il ,. A meno che non sia un numero (cioè [12]), Japt sa che sono oggetti diversi. Credo che anche tu puoi rimuovere &1.

— Oliver,

Grazie @obarakon. La documentazione di Japt è un po 'scarsa.

— Powelles,

Grazie per aver usato Japt. Sentiti libero di porre domande, suggerimenti, ecc. Nella chat room di Japt . C'è anche un thread Suggerimenti per Japt . :)

— Oliver,

_m"uv"gT°Bello. Stavo per suggerirlo.

— Oliver,

@obarakon Sì, ho visto dove ETH ha risposto alla tua domanda nella chat e mi ha fatto provare cose.

— Powelles,

6

Python 3 , 86 76 68 66 63 byte

^{-2 byte grazie a DJMcMayhem}
^{-3 byte grazie a Cyoce}

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

Provalo online! oppure Prova tutti i casi di test

— asta
fonte

Due byte più brevi in Python 3: provalo online!

— DJMcMayhem

1

qualche motivo che non puoi fare print(end=(2*i).title()[x])?

— Cyoce,

5

Alice , 18 byte

/olZlYuN
@iy.u..//

Provalo online!

Spiegazione

Questo programma segue un modello meno noto per i programmi di lunghezza dispari eseguiti interamente in modalità ordinale. La versione linearizzata di questo codice è:

il.l.uN.YuZyo@

Spiegazione del codice:

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

Senza usare lil duplicato, lo stack dopo Nsarebbe ["helloworld", "helloworld"]. Sospetto fortemente che si tratti di un bug.

— Nitrodon
fonte

5

C (tcc) , 60 57 56 byte

Grazie a DigitalTrauma per aver notato il bit 5 è l'unica differenza per le maiuscole / minuscole ASCII.

Un ringraziamento speciale a zch per il golf di altri tre byte.

Salvare un altro byte dall'idea di RJHunter

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

Provalo online!

— cleblanc
fonte

L'ho giocato un po 'di più , e modificato in modo che funzioni su tutti i file gcc, tcc, clang. FWIW, gcc mette i letterali di stringa nella memoria di sola lettura, quindi ho usato i strdup()puntatori per leggere la memoria di scrittura nel codice del driver di test.

— Trauma digitale

1

@DigitalTrauma grazie per quello. Avrei dovuto riconoscere che il bit 5 era la differenza tra superiore e inferiore. Bello !

— Cleblanc,

Ho provato a rendere anche questa versione ricorsiva, ma non ho potuto accorciarla.

— Digital Trauma,

È possibile sostituire il condizionale interno con *s&~32|++l%2<<5per salvare 3 byte.

— ZCH

Poiché l'ingresso promette di essere ASCII stampabile, è possibile sostituirlo &~33con &95per salvare un ulteriore byte.

— RJHunter,

4

Java 8, 99 byte

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

Spiegazione:

Provalo qui.

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
fonte

Non potrei accorciarlo ma potresti essere in grado di utilizzare (c+"").matches("[A-Za-z]")o Character.isLetter(c)salvare byte.

— TheLethalCoder

@TheLethalCoder Entrambi sono più lunghi del c>64&c<91|c>96&c<123però. E dal momento che io uso intcomunque per le parti Character.toUpperCase(...)e il Character.toLowerCase(...)golf (queste: (char)(c&~32)e (char)(c|32)), dubito che potrei accorciarle con una di queste.

— Kevin Cruijssen,

1

Pensavo che non saresti stato in grado, ma vale la pena postare per vedere se potessi comunque usarli

— TheLethalCoder,

@TheLethalCoder Ah ok. :) In alcuni casi il primo potrebbe aiutare con un approccio leggermente diverso per altre sfide, ma per questa sfida è più breve così com'è. Grazie comunque.

— 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

Rubino, 57 55 47 41 byte

Il conteggio dei byte include due byte per le opzioni della riga di comando.
Eseguilo ad esempio in questo modo:$ ruby -p0 alternate_case.rb <<< "some input"

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

Con l' p0opzione, l'intero input viene consumato in una volta sola e il magico mondo$. viene incrementato a 1. Questo viene successivamente commutato tra 0 e 1 e utilizzato per mantenere lo stato.

Funziona con input multilinea; Provalo online!

Grazie a Ventero per input straordinari - controlla i commenti per i dettagli.

— daniero
fonte

1

Amico, se non fosse per il fatto che $.gli incrementi automatici ad ogni getschiamata, un programma completo con il -pflag sarebbe stato più breve ...

— Value Ink

1

1&$.+=1ti permette di rilasciare le parentesi. E per l'amor di completezza, c'è un altro intero globale - è purtroppo solo in sola lettura: $$.

— Ventero,

1

Another thing about the command line flag: -p0 makes the interpreter read all available input in one go - so your code is only invoked once, allowing you to freely use $.. Combining that with the fact that gsub implicitly operates as $_.gsub! when specifying -p makes a full program significantly shorter: 48 characters for gsub(/[a-z]/i){[$&.upcase,$&.downcase][1&$.+=1]} and 2 for the p0 flag.

— Ventero

1

Final remark, I promise :) Once you're using -p0, you can actually save a few more characters in how you flip $. back and forth: Since it's now guaranteed to be 1 when your code is invoked, you can simply use $.^=1.

— Ventero

2

Risulta che ho mentito, ho un altro commento: D Poiché l'input è garantito per contenere sempre e solo ASCII stampabile, possiamo usare il supporto di Ruby per le categorie Unicode in espressioni regolari: /\p{L}/( Lettera categoria Unicode ) è un carattere più corto di /[a-z|/i.

— Ventero,

3

Brachylog , 25 byte

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

Provalo online!

Questo è lungo e lento.

Spiegazione

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

— Fatalize
fonte

3

MATL , 16 15 byte

Xktkyy-f2L))5M(

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

Considera input "ciao mondo"

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
fonte

3

Perl 6, 32 30 bytes

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

Try it

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

Try it

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
}

— Brad Gilbert b2gills
fonte

3

q/kdb+, 51 42 38 bytes

Solution:

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

Example:

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

Notes:

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

2

V, 17, 13 bytes

VUÍáƒ¨áü$©/ì&

Try it online!

Or Verify all test cases!

HeXdUmP:

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

Explanation:

This uses a compressed regex™️, so before explaining it, let's expand the regex out:

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

The VU converts everything to uppercase. Then we run this:

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

Old/more interesting answer:

:se nows
Vuò~h2/á

— DJMcMayhem
fonte

2

PHP, 71 Bytes

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

Try it online!

— Jörg Hülsermann
fonte

2

CJam, 26 24 bytes

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

Try it online!

Explanation

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)

— Business Cat
fonte

2

Pyth, 11 bytes

srR~xZ}dGrZ

Try it here

Explanation

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

2

PowerShell, 86 bytes

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

Input is a [char[]] array.

Comments in code for explanation

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

— Matt
fonte

2

Haskell, 105 83 + 2 4 + 1 byte of separator = 108 86 88 Bytes

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

Function is (1#), starts lowercase. Try it online!

~~The sad thing is that this is longer than the Java and C# answers~~ Thanks to Ørjan Johansen for saving 22 bytes by merging three lines into one!

— Generic Display Name
fonte

2

I saw it needed those long imported functions so I didn't even try... but that's a bit much, you can merge some lines: f#(x:y)|isLetter x=([toUpper,toLower]!!f)x:(1-f)#y|1>0=x:f#y

— Ørjan Johansen

Sorry for nitpicking, but I think 1# does not count as an anonymous function. In my understanding, one should be able to bind an anonymous function to an identifier, but e.g. f=1# won't work. Instead you need the section (1#) for +2 bytes. This is also implicitly stated in our community guidelines for golfing in Haskell, though maybe those should be adapted to explicitly mention this case.

— Laikoni

@Laikoni ok, answer updated

— Generic Display Name

2

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

It's a big mess but it's a little easier if you expand it out:

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

The pseudo-logic would run like this:

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
fonte

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
fonte

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

Retina, 46 bytes

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

Try it online! Includes test cases.

— Neil
fonte

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
fonte

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
fonte

1

PHP 5, 54 bytes

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

— user63956
fonte

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
fonte

1

Groovy, 79 bytes

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

— Magic Octopus Urn
fonte

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
fonte

0

Convex, 16 bytes

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

Try it online!

Convex port of @Business Cat's answer.

— GamrCorps
fonte

ALTEZZA DELLA CAUSA

Esempi:

JavaScript (ES6), 66 63 byte

Casi test

05AB1E , 11 8 byte

Codice:

Spiegazione:

GNU Sed, 33

Gelatina , 13 byte

Come funziona

Japt , 16 14 byte

Spiegazione

Python 3 , 86 76 68 66 63 byte

Alice , 18 byte

Spiegazione

C (tcc) , 60 57 56 byte

Java 8, 99 byte

Rubino, 57 55 47 41 byte

Brachylog , 25 byte

Spiegazione

MATL , 16 15 byte

Spiegazione

Perl 6, 32 30 bytes

Expanded:

q/kdb+, 51 42 38 bytes

V, 17, 13 bytes

PHP, 71 Bytes

CJam, 26 24 bytes

Explanation

Pyth, 11 bytes

Explanation

PowerShell, 86 bytes

Comments in code for explanation

Haskell, 105 83 + 2 4 + 1 byte of separator = 108 86 88 Bytes

Google Sheets, 264 bytes

Perl 5, 24 bytes

Retina, 46 bytes

Retina, 32 bytes

PHP 5, 54 bytes

C#, 100 bytes

Groovy, 79 bytes

Python 3, 192 bytes

Convex, 16 bytes