42

Para el desafío de hoy, debe escribir un programa o función que alterne el caso de una cadena. Sin embargo, debe ignorar los caracteres no alfabéticos. Esto significa que cada carácter alfabético debe tener un caso diferente al del carácter alfabético anterior y siguiente. Esto es un poco más complejo que poner en mayúscula cualquier otra letra, por ejemplo. Si toma una cadena como

hello world

y convierte todos los demás caracteres a mayúsculas, obtendrás:

hElLo wOrLd

Como puede ver, la minúscula oes seguida por una minúscula w. Esto no es valido. En cambio, debe ignorar el espacio, dándonos este resultado:

hElLo WoRlD

Todos los caracteres no alfabéticos se deben dejar igual. La salida puede comenzar con mayúsculas o minúsculas, siempre y cuando se alterne constantemente. Esto significa que lo siguiente también sería un resultado aceptable:

HeLlO wOrLd

Su programa debería funcionar independientemente del caso de la entrada.

La cadena de entrada solo contendrá ASCII imprimible , por lo que no tiene que preocuparse por caracteres no imprimibles, líneas nuevas o unicode. Su envío puede ser un programa completo o una función, y puede tomar la entrada y salida en cualquier formato razonable. Por ejemplo, argumentos de función / valor de retorno, STDIN / STDOUT, leer / escribir un archivo, etc.

Ejemplos:

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

Como se trata de código de golf , se aplican las lagunas estándar y gana la respuesta más corta en bytes.

code-golf string

— DJMcMayhem
fuente

33

Ugh, me acabo de dar cuenta de que era ese meme xD

— Beta Decay

@BetaDecay Jajaja, esa no era mi intención. Más tiempo desafortunado. Pensé en ello como un mini desafío de chat , y me gusta la idea detrás de esto porque es sutilmente más difícil de lo que parece.

— DJMcMayhem

44

El próximo desafío es imprimir un Bob cowsay

— esponja

1

¡Maldita sea! Yo simplemente escribí un guión Cjam para esto (como en el día de ayer) y lo borre.

— Esolanging Fruit

2

Hay un potencial perdido para el título o al menos los ejemplos que usan pingüino de la fatalidad o sporks.

— Ian

19

JavaScript (ES6), 66 63 bytes

Comienza con mayúsculas.

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

Casos de prueba

Mostrar fragmento de código

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

Expandir fragmento

— Arnauld
fuente

Exactamente cómo lo iba a hacer. Yo creo que puedo ver dónde se puede ahorrar un par de bytes, pero estoy en mi teléfono así que no puedo probar correctamente.

— Shaggy

Sí, usar un ternario es lo que iba a sugerir.

— Shaggy

1

¿Cómo funciona el s=!struco?

— Kritixi Lithos

77

@KritixiLithos Debido a que ses la cadena de entrada, !sevalúa primero a false(a menos que la cadena de entrada está vacía, en cuyo caso se podría evaluar a true- pero una cadena vacía no generará ningún partido de todos modos). Después de eso, se convierte en una operación booleana estándar, alternando entre falsey true. Además, no nos importa perder el contenido sen este momento porque ya se usaba para alimentar .replace().

— Arnauld

3

@MayorMonty Desafortunadamente, eso coincidiría con algunos símbolos. Una entrada como "A[I"fallaría.

— Arnauld

12

05AB1E , 11 8 bytes

Código:

lvyJ¤aiš

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación:

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
fuente

Me encanta cómo intento ir a ciegas, sabiendo que tengo que superar los 11 bytes; luego pase lentamente de 17 a 11 bytes y comprenda que lvy¾Fš}Da½Jes exactamente lo que ya tenía ._.

— Magic Octopus Urn

1

@carusocomputing Hay una solución de 8 bytes mucho más fácil: p

— Adnan

44

oh, sí, super fácil jaja.

— Magic Octopus Urn

2

@Octopus Hay algo de discusión sobre esto, pero utilizo 'osable' y 'osabie'.

— Adnan

1

@octopus Literalmente digo Oh-Five-Ay-Bee-One-Eee, no soy un hombre creativo.

— Magic Octopus Urn

11

GNU Sed, 33

5 bytes guardados gracias a @TobySpeight

La puntuación incluye +1 para la -rbandera a sed.

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

Pruébalo en línea .

— Trauma digital
fuente

8

Jalea , 13 bytes

nŒsTm2
ŒlŒuÇ¦

Pruébalo en línea!

Cómo funciona

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

7

Japt , 16 14 bytes

r"%l"_m"uv"gT°

Pruébalo en línea!

Explicación

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
fuente

¡Muy agradable! Puedes eliminar el ,. A menos que sea un número (es decir [12]), Japt sabe que son elementos diferentes. Creo que también puedes eliminar el &1.

— Oliver

Gracias @obarakon. La documentación de Japt es un poco escasa.

— Powelles

Gracias por usar Japt. No dude en hacer preguntas, sugerencias, etc. en la sala de chat de Japt . También hay un consejo para el hilo Japt . :)

— Oliver

_m"uv"gT°Agradable. Estaba a punto de sugerir eso.

— Oliver

@obarakon Sí, vi dónde ETH respondió a su pregunta en el chat y me hizo probar cosas.

— Powelles

6

Python 3 , 86 76 68 66 63 bytes

^{-2 bytes gracias a DJMcMayhem}
^{-3 bytes gracias a Cyoce}

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

Pruébalo en línea! o Pruebe todos los casos de prueba

— Barra
fuente

Dos bytes más cortos en python 3: ¡ Pruébelo en línea!

— DJMcMayhem

1

alguna razón que no puedes hacer print(end=(2*i).title()[x])?

— Cyoce

5

Alice , 18 bytes

/olZlYuN
@iy.u..//

Pruébalo en línea!

Explicación

Este programa sigue una plantilla menos conocida para programas de longitud impar que se ejecutan completamente en modo ordinal. La versión linealizada de este código es:

il.l.uN.YuZyo@

Explicación del código:

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

Sin usar len el duplicado, la pila después Nsería ["helloworld", "helloworld"]. Sospecho fuertemente que esto es un error.

— Nitrodon
fuente

5

C (tcc) , 60 57 56 bytes

Gracias a DigitalTrauma por notar que el bit 5 es la única diferencia para las mayúsculas / minúsculas ASCII.

Un agradecimiento especial a zch por jugar tres bytes más.

Ahorre un byte más de la idea de RJHunter

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

Pruébalo en línea!

— cleblanc
fuente

Lo jugué un poco más y lo modifiqué para que funcione en todos los gcc, tcc, clang. FWIW, gcc pone literales de cadena en la memoria de solo lectura, por lo que solía strdup()obtener punteros para leer y escribir memoria en el código del controlador de prueba.

— Trauma digital

1

@ DigitalTrauma gracias por eso. Debería haber reconocido que el bit 5 era la diferencia entre superior e inferior. Agradable !

— cleblanc

Yo probé a hacer esta versión recursiva también, pero no podía conseguir más corto.

— Trauma digital

Puede reemplazar condicional interno con *s&~32|++l%2<<5para guardar 3 bytes.

— zch

Dado que la entrada promete ser ASCII imprimible, puede reemplazar &~33con &95para guardar un byte adicional.

— RJHunter

4

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

Explicación:

Pruébalo aquí

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
fuente

No pude acortarlo, pero es posible que pueda usar (c+"").matches("[A-Za-z]")o Character.isLetter(c)guardar bytes.

— TheLethalCoder

@TheLethalCoder Ambos son más largos que c>64&c<91|c>96&c<123sin embargo. Y dado que uso de inttodos modos para las partes Character.toUpperCase(...)y Character.toLowerCase(...)golf (estas: (char)(c&~32)y (char)(c|32)), dudo que pueda acortarlo con cualquiera de ellas.

— Kevin Cruijssen

1

Pensé que no podrías hacerlo, pero vale la pena publicarlo para ver si podrías hacer uso de ellos de todos modos

— TheLethalCoder

@TheLethalCoder Ah, ok. :) En algunos casos, el primero podría ayudar con un enfoque ligeramente diferente para otros desafíos, pero para este desafío es más corto como es. Gracias de cualquier manera.

— 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

Ruby, 57 55 47 41 bytes

El recuento de bytes incluye dos bytes para las opciones de línea de comando.
Ejecútelo por ejemplo así:$ ruby -p0 alternate_case.rb <<< "some input"

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

Con la p0opción, toda la entrada se consume de una vez, y el global mágico $.se incrementa a 1. Esto luego se alterna entre 0 y 1 y se usa para mantener el estado.

Funciona con entrada multilínea; Pruébalo en línea!

Gracias a Ventero por su increíble aporte: revise los comentarios para más detalles.

— daniero
fuente

1

Hombre, si no fuera por el hecho de que $.los incrementos automáticos con cada getsllamada, un programa completo con la -pbandera habría sido más corto ...

— Value Ink

1

1&$.+=1le permite soltar los paréntesis. Y por el amor integridad, hay otro número entero mundial - es por desgracia acaba de sólo lectura: $$.

— Ventero

1

Otra cosa sobre el indicador de línea de comando: -p0hace que el intérprete lea todas las entradas disponibles de una sola vez, por lo que su código solo se invoca una vez, lo que le permite usarlo libremente $.. La combinación de eso con el hecho de que gsubimplícitamente funciona como $_.gsub!cuando se especifica -phace que un programa completo sea significativamente más corto: 48 caracteres para gsub(/[a-z]/i){[$&.upcase,$&.downcase][1&$.+=1]}y 2 para la p0bandera.

— Ventero

1

Comentario final, lo prometo :) Una vez que esté usando -p0, en realidad puede guardar algunos caracteres más en la forma en que cambia de $.un lado a otro: ya que ahora está garantizado 1cuando se invoca su código, simplemente puede usarlo $.^=1.

— Ventero

2

Resulta que mentí, tengo otro comentario: D Como se garantiza que la entrada solo contendrá ASCII imprimible, podemos usar el soporte de Ruby para las categorías Unicode en expresiones regulares: /\p{L}/( Letra de categoría Unicode ) es un carácter más corto que /[a-z|/i.

— Ventero

3

Brachylog , 25 bytes

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

Pruébalo en línea!

Esto es largo y lento.

Explicación

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

— Fatalizar
fuente

3

MATL , 16 15 bytes

Xktkyy-f2L))5M(

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Considere la entrada 'hola mundo'

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
fuente

3

Perl 6 , 32 30 bytes

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

Intentalo

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

Intentalo

Expandido:

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

3

q / kdb +, 51 42 38 bytes

Solución:

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

Ejemplo:

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

Notas:

.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

— callejero
fuente

2

V , 17 , 13 bytes

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

Pruébalo en línea!

¡O verifique todos los casos de prueba!

HeXdUmP:

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

Explicación:

Utiliza un regex ™ ️ comprimido , así que antes de explicarlo, expandamos el regex:

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

El VUconvierte todo a mayúsculas. Luego ejecutamos esto:

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

Antigua / más interesante respuesta:

:se nows
Vuò~h2/á

— DJMcMayhem
fuente

2

PHP, 71 bytes

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

Pruébalo en línea!

— Jörg Hülsermann
fuente

2

CJam , 26 24 bytes

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

Pruébalo en línea!

Explicación

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)

— Gato de negocios
fuente

2

Pyth, 11 bytes

srR~xZ}dGrZ

Pruébalo aquí

Explicación

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

2

PowerShell, 86 bytes

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

La entrada es una [char[]]matriz.

Comentarios en el código para explicación

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

— Mate
fuente

2

Haskell, 105 83 + 2 4 + 1 byte de separador = 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

La función es (1#), comienza en minúsculas. Pruébalo en línea!

~~Lo triste es que esto es más largo que las respuestas de Java y C # ¡~~ Gracias a Ørjan Johansen por guardar 22 bytes fusionando tres líneas en una!

— Nombre de visualización genérico
fuente

2

Vi que necesitaba esas largas funciones importadas, así que ni siquiera lo intenté ... pero eso es demasiado, puedes combinar algunas líneas:f#(x:y)|isLetter x=([toUpper,toLower]!!f)x:(1-f)#y|1>0=x:f#y

— Ørjan Johansen

Perdón por la trampa, pero creo 1#que no cuenta como una función anónima. Según tengo entendido, uno debería poder vincular una función anónima a un identificador, pero, por ejemplo f=1#, no funcionará. En su lugar, necesita la sección (1#)para +2 bytes. Esto también se afirma implícitamente en las pautas de nuestra comunidad para jugar al golf en Haskell , aunque quizás deberían adaptarse para mencionar explícitamente este caso.

— Laikoni

@Laikoni ok, respuesta actualizada

— Nombre de visualización genérico

2

Hojas de cálculo de Google, 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 un gran desastre, pero es un poco más fácil si lo expande:

=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 lógica correría así:

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

— Tostadas de ingeniero
fuente

2

Perl 5 , 24 bytes

23 bytes + 1 byte para -p.

Gracias a @Dada por -2 bytes.

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

Pruébalo en línea!

— Dom Hastings
fuente

Ordenado. \plen lugar de [a-z]2 bytes aunque :)

— Dada

@Dada, ¡realmente no lo sabía! ¡¿Cómo no supe eso? ¡Gracias!

— Dom Hastings

Creo que lo aprendí de Ton Hospel, y lo uso de vez en cuando (¡en realidad tiendo a olvidarlo con demasiada frecuencia y en su [a-z]lugar lo uso !). Si te preguntas, proviene de perlrecharclass ;)

— Dada

1

Retina , 46 bytes

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

Pruébalo en línea! Incluye casos de prueba.

— Neil
fuente

1

C 64 bytes

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

Aprovecha la codificación ascii donde las letras mayúsculas y minúsculas se compensan con 0x20.

— usuario230118
fuente

No necesita el '' espacio entre chary*s

— cleblanc

Esto se parece mucho a la respuesta de @ cleblanc .

— Trauma digital

Lo publiqué cuando la publicación de @ cleblanc usaba toUpper () y toLower ().

— user230118

1

Mi comentario que sugiere este enfoque fue a las 18: 29: 34Z. La edición de cleblanc para incorporar esto fue a las 18: 37: 36Z. Su respuesta fue publicada a las 18: 38: 21Z. Así que supongo que la respuesta de cleblanc fue menos de un minuto antes de tu publicación. Su respuesta es notablemente similar a mi sugerencia, pero supongo que esa es la naturaleza del código de golf: a menudo las soluciones en el mismo idioma convergerán en lo mismo, así que lo dejaré pasar :)

— Digital Trauma

1

Retina , 32 bytes

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

Pruébalo en línea!

Primero convierte la entrada a mayúsculas, y luego agrupa la entrada en coincidencias que contienen hasta dos letras mayúsculas. La única vez que contendrá solo una letra es si la última letra no tiene un par. Luego, pone en minúscula la primera letra de cada una de estas coincidencias.

En 01la segunda etapa se traduce aproximadamente a: no cambie el comportamiento de esta etapa en función del número de coincidencia, sino que solo aplique los cambios al primer carácter de cada coincidencia.

— FryAmTheEggman
fuente

1

PHP 5, 54 bytes

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

— usuario63956
fuente

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
fuente

1

Groovy, 79 bytes

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

— Urna de pulpo mágico
fuente

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

Pruébalo en línea!

— caird coinheringaahing
fuente

0

Convexo , 16 bytes

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

Pruébalo en línea!

Puerto convexo de la respuesta de @Business Cat .

— GamrCorps
fuente

ALTEnAR EL CASO

Ejemplos:

JavaScript (ES6), 66 63 bytes

Casos de prueba

05AB1E , 11 8 bytes

Código:

Explicación:

GNU Sed, 33

Jalea , 13 bytes

Cómo funciona

Japt , 16 14 bytes

Explicación

Python 3 , 86 76 68 66 63 bytes

Alice , 18 bytes

Explicación

C (tcc) , 60 57 56 bytes

Java 8, 99 bytes

Ruby, 57 55 47 41 bytes

Brachylog , 25 bytes

Explicación

MATL , 16 15 bytes

Explicación

Perl 6 , 32 30 bytes

Expandido:

q / kdb +, 51 42 38 bytes

V , 17 , 13 bytes

PHP, 71 bytes

CJam , 26 24 bytes

Explicación

Pyth, 11 bytes

Explicación

PowerShell, 86 bytes

Comentarios en el código para explicación

Haskell, 105 83 + 2 4 + 1 byte de separador = 108 86 88 Bytes

Hojas de cálculo de Google, 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

Convexo , 16 bytes