Algunos de sus empleados tienen llaves de mayúsculas rotas y usted es demasiado barato para reemplazarlas. ¡Ayúdelos creando el programa más corto posible para corregir su trabajo! Simplemente convierta cada carácter en una cadena dada de mayúsculas a minúsculas y viceversa ... ¡pero hay un giro!

¡También estás muy emocionado por la Navidad! Por lo tanto, va a dejar un pequeño "error" que no corrige las letras que están dentro de las secuencias de Christmas(sin distinción entre mayúsculas y minúsculas).

Entrada

Para la entrada, usará una sola cadena (o matriz de bytes) que puede contener nuevas líneas y ascii entre 0x20 y 0x7e ( - ~). No necesita preocuparse por retornos de carro o cualquier otro carácter que esté en la cadena.

Salida

El resultado debe contener solo la cadena proporcionada con los caracteres mayúsculas y minúsculas intercambiados (¡y el error de Navidad, por supuesto!). Puede contener hasta un espacio en blanco final adicional.

Insecto de navidad

Vamos a explicar esto con un ejemplo:

Input: i CAN HARDLY WORK LIKE THIS please GET ME A NEW KEYBOARD FOR cHRISTMAS
Output: I Can HaRdly work lIke thiS PLEASE geT Me A new keyboard for ChriStmas

cancontiene "c", que es la primera carta de Navidad, por lo que no se cambia. La siguiente letra en Christmases "h", que está en hardly(que también contiene la "r"), por lo que no se cambia, etc. en Christmassí solo tiene una letra sin cambios porque para cuando el código llega allí, en realidad está buscando "s", no "c".

Una vez que se encuentra la secuencia, debe comenzar de nuevo en "c" y comenzar a iterar Christmasuna vez más. Así ChristmasChristmasquedaría sin cambios.

Casos de prueba

Input: Hello World!
Output: hELLO wORLD!

Input: I like pie :)
Output: i LIKE PIE :)

Input: hELP my KeYboarD
       iS BROKEN
Output: Help MY kEyBOARd
        Is broken

Input: cHRISTMAS IS COMING REALLY SOON!
Output: cHRISTMAS is Coming really soon!

Input: C is the first letter in cHRISTMAS
Output: C IS ThE FIrST LETTER iN ChriSTMAS

Ganador

Este es el código de golf, por lo que gana la respuesta más corta.

05AB1E , 16 bytes

¡Gracias a Emigna por guardar un byte y corregir un error!

vyÐl'ŒÎ¾èQi¼ëš}?

Explicación:

vy                # For each character in the string...
  Ð               #   Triplicate that character
   l              #   Convert to lowercase
    'ŒÎ           #   Compressed version of "christmas"
       ¾          #   Push the counting variable (let's call this N)
        è         #   Get the nth character of "christmas", with modular indexing
         Qi   }   #   If equal...
           ¼      #      N += 1
            ë     #   Else...
             š    #      Swapcase
               ?  #   Print that character

Utiliza la codificación CP-1252 . Pruébalo en línea!

V , 38 , 36 bytes

ÄVumaOchristmasòÉf2x`a@"maj~HòHdjV~

Pruébalo en línea! (contiene entrada y salida esperada para comparación)

Cuando vi esto por primera vez, pensé que sería extremadamente fácil. De hecho, si no fuera por el insecto "navidad", esto sería sólo 2 bytes: V~. El error de Navidad lo hace significativamente más difícil, por una respuesta muy hacky.

Como de costumbre, aquí hay un hexdump:

00000000: c456 756d 614f 6368 7269 7374 6d61 731b  .VumaOchristmas.
00000010: f2c9 6632 7860 6140 226d 616a 7e48 f248  ..f2x`a@"maj~H.H
00000020: 646a 567e                                djV~

PHP, 113 110 102 bytes

while($o=ord($c=$argv[1][$i++]))echo chr(32|$o==ord(christmas[$k%9])?$o|0&$k++:ctype_alpha($c)*32^$o);

toma la entrada del primer argumento de la línea de comando. Corre con -r.

Descompostura

while($o=ord($c=$argv[1][$i++]))// loop through string characters
    echo chr(
        32|$o==ord(christmas[$k%9]) // if $c equals next character in "christmas"
            ?$o|0&$k++              // no change, increase "christmas" index
            :ctype_alpha($c)        // else if $c is a letter
                    *32^$o          // toggle bit 5 of the ascii code
        );

MATL , 36 30 bytes

"@tk'schristma'H)=?HQXHx}Yo]&h

Las cadenas con líneas nuevas deben definirse concatenando con el código ASCII 10(consulte el ejemplo en el enlace con los casos de prueba).

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

Explicación

"              % Implicit input of a string. For each character in that string
  @            %   Push current character
  tk           %   Duplicate and convert to lowercase
  'schristma'  %   Push string. This is 'Christmas' in lowercase and circularly
               %   shifted such that the 'c' is in the second position
  H            %   Push contents of clipboard H, which is initiallized to 2.
               %   This value will be gradually increased when a new character
               %   from the the sequence is found
  )            %   Get character from 'schristma' at that (modular) position
  =            %   Are they equal?
  ?            %   If so
    HQ         %     Push contents of clipboard H and add 1
    XHx        %     Copy into clipboard K and delete
  }            %   Else
    Yo         %     Change case
  ]            %   End
  &h           %   Concatenate stack contents horizontally. This gives a string 
               %   with all characters processed up to now
               % Implicit end. Implicit display

Pyke, 31 25 bytes

FD.dґ~o@Dl3+{DIoK)R!Il3

Pruébalo aquí!

Perl 6 , 84 bytes

{my $i=0;[~] (.lc~~"christmas".comb[$i%9]??(++$i&&$_)!!.ord>90??.uc!!.lc for .comb)}

C # 197 bytes

No voy a ganar con esto, pero espero que la implementación de C # más pequeña que funcione ...

string C(string s){int i=0,j=0;var r="";for(;i<s.Length;){char c=s[i++],o=(char)32;if(c=="christmas"[j]|c=="CHRISTMAS"[j])j=j>7?0:j+1;else if(c>64&c<91)c+=o;else if(c>96&c<123)c-=o;r+=c;}return r;}

Explicación:

string C(string s)
{
    // define our two index ints
    // i for indexing across the input string
    // j for indexing across christmas
    int i = 0, j = 0;

    // r is our return string
    var r = "";

    // declare our loop
    // skip the initialisation and afterthought
    for (; i < s.Length;)
    {
        // get our current character c, and increment index i
        // initial our offset char o (difference between upper and lower case)
        char c = s[i++], o = (char)32;

        // check if c is the current character in our christmas bug
        if (c == "christmas"[j] | c == "CHRISTMAS"[j])
            // increment j (or reset to 0)
            j = j > 7 ? 0 : j + 1;

        // else if c is an upper case char
        else if (c > 64 & c < 91)
            // add our offset to make it lower case
            c += o;

        // else if c is lower case
        else if (c > 96 & c < 123)
            // subtract our offset to make it upper case
            c -= o;

        // append c to our return string r
        r += c;
    }

    return r;
}

JavaScript, 122 118 114 107 104 93 bytes

f=
s=>s.replace(/./g,c=>(k=c.toLowerCase())=='christmas'[i%9]?++i&&c:k!=c?k:c.toUpperCase(),i=0)


F=s=>console.log(f(s))
F(`Hello World!`)
F(`I like pie :)`)
F(`hELP my KeYboarD
       iS BROKEN`)
F(`cHRISTMAS IS COMING REALLY SOON!`)
F(`C is the first letter in cHRISTMAS`)

• 11 bytes de descuento gracias @Neil.

Perl 6 , 80 bytes

{my$i=0;S:g{.?<!{'christmas'.comb[$i%9]eq$/.lc&&++$i}>}=$/eq$/.lc??$/.uc!!$/.lc}

Intentalo

{   # bare block lambda with implicit parameter ｢$_｣

  my $i = 0;             # counter

  S                      # substitute and return ( implicitly against ｢$_｣ )
  :global
  {
    .                    # any char
    ?                    # work around a bug where ｢$/｣ doesn't get set

    <!{                  # fail this match if this block returns True
      'christmas'.comb\  # a list of the characters of ｢christmas｣
      [ $i % 9 ]         # grab a char from the list
      eq                 # is it equal to
      $/.lc              # the lowercase version of the char
      &&                 # if so
      ++$i               # increment ｢$i｣ ( result is True )
    }>

  }

  =                      # for each matched char

  $/ eq $/.lc            # is it lowercase?
  ?? $/.uc               # the uppercase it
  !! $/.lc               # otherwise lowercase it
}

Java 7, 200 bytes

String c(char[]a){String r="";int i=0,s;Character l='a';for(char c:a)if((s="christma".indexOf(l=l.toLowerCase(c)))==i|i>7&s==4){r+=c;i=i>7?0:i+1;}else r+=l.isUpperCase(c)?l:l.toUpperCase(c);return r;}

Feo, pero funciona ... Definitivamente, sin duda, se puede jugar más al golf ... Estoy oxidado ...

Sin golf:

String c(char[] a){
  String r = "";
  int i = 0,
      s;
  Character l = 'a';
  for(char c : a){
    if((s = "christma".indexOf(l = l.toLowerCase(c))) == i) | i > 7 & s == 4){
      r += c;
      i = i > 7
           ? 0
           : i+1;
    } else{
      r += l.isUpperCase(c)
       ? l
       : l.toUpperCase(c);
    }
  }
  return r;
}

Código de prueba:

Pruébalo aquí.

class M{
  static String c(char[]a){String r="";int i=0,s;Character l='a';for(char c:a)if((s="christma".indexOf(l=l.toLowerCase(c)))==i|i>7&s==4){r+=c;i=i>7?0:i+1;}else r+=l.isUpperCase(c)?l:l.toUpperCase(c);return r;}

  public static void main(String[] a){
    System.out.println(c("i CAN HARDLY WORK LIKE THIS please GET ME A NEW KEYBOARD FOR cHRISTMAS".toCharArray()));
    System.out.println(c("Hello World!".toCharArray()));
    System.out.println(c("I like pie :)".toCharArray()));
    System.out.println(c("hELP my KeYboarD\niS BROKEN".toCharArray()));
    System.out.println(c("cHRISTMAS IS COMING REALLY SOON!".toCharArray()));
    System.out.println(c("C is the first letter in cHRISTMAS".toCharArray()));
  }
}

Salida:

I Can HaRdly work lIke thiS PLEASE geT Me A new keyboard for ChriStmas
hELLO wORLD!
i LIKE PIE :)
Help MY kEyBOARd
Is broken
cHRISTMAS is Coming really soon!
C IS ThE FIrST LETTER iN ChriSTMAS

Python 100 bytes

def a(s,i=0,g=''):
 for c in s:a=c.lower()=='christmas'[i%9];i+=a;g+=[c.swapcase(),c][a]
 return g

Ruby, 63 + 1 = 64 bytes

Usa la -pbandera.

i=0;gsub(/./){|c|c=~/#{"christmas"[i%9]}/i?(i+=1;c):c.swapcase}

C # 239 caracteres

var s=Console.ReadLine().ToCharArray();int j=0,i=0;var c="christmas";for(;j<s.Length;j++)if(s[j]==c[i%9]|s[j]==(c[i%9]-32))i++;else if(s[j]>64&s[j]<91)s[j]=(char)(s[j]+32);else if(s[j]>96&s[j]<123)s[j]=(char)(s[j]-32);Console.WriteLine(s);

versión más explícita:

var s = Console.ReadLine().ToCharArray();
int j = 0,i = 0;
var c = "christmas";
for (var j = 0; j < s.Length; j++)
   if (s[j] == c[i%9]|s[j] == (c[i%9] - 32))// non case sensitive compare with c 
      i++;//next char in christmas
   else
      if (s[j] > 64 & s[j] < 91)//if between A and Z
         s[j] = (char)(s[j] + 32);//convert to a-z
      else
         if (s[j] > 96 & s[j] < 123)//if between a and z
            s[j] = (char)(s[j] - 32);//convert to A-Z
Console.WriteLine(s);

Esta es una solución bastante ingenua, y probablemente pueda mejorarse (¿tal vez podamos permitir la conversión implícita a char?).

se supone que está dentro de una función, lee desde la consola (stdin) y escribe en ella (stdout).

editar: Char.IsUpper (s [j]) es 2 bytes más largo que s [j]> 64 && s [j] <91, Char.ToUpper es más largo que mi versión también.

Haskell, 222207 bytes

import Data.Char
s=(+(-65)).ord
f=(`divMod`32).s
l=[['a'..'z'],['A'..'Z']]
c=cycle$map s"CHRISTMAS"
k _[]=[]
k(a:b)(x:y)|isAlpha x=let(d,m)=f x in if(m==a)then(x:k b y)else(l!!d!!m:k(a:b)y)|1>0=x:k(a:b)y
main=interact$k c

actualizado:

import Data.Char
s=(+(-65)).ord
k _[]=[]
k(a:b)(x:y)|isAlpha x=let(d,m)=s x`divMod`32 in if(m==a)then(x:k b y)else([['a'..'z'],['A'..'Z']]!!d!!m:k(a:b)y)|1>0=x:k(a:b)y
main=interact$k$cycle$map s"CHRISTMAS"

Cómo funciona:

s=(+(-65)).ord

sx = valor ASCII de x - valor ASCII de 'A'

f=(`divMod`32).s

f (sx) = (0, sx) para mayúsculas, (1, (s x-32)) para minúsculas

l=[['a'..'z'],['A'..'Z']]

lista paralela de letras, indexable por f (minúsculas-> 1-> mayúsculas, mayúsculas-> 0-> minúsculas)

c = cycle $ map s "CHRISTMAS"

lista infinita de los valores ASCII de Navidad mayúscula repetida

k _ []=[]

caso base

k (a:b) (x:y) | isAlpha x = let (d,m) =f x
                             in if m == a
                                then x : k b y
                                else (l!!d)!!m : k (a:b) y
              | 1 > 0 = x : k (a:b) y

devuelve caracteres no alfanuméricos y guarda la letra si su valor s es el mismo que la carta de navidad actual (pasando a la siguiente letra), de lo contrario conviértala al otro caso y continúe

main=interact$k c

IO