Certains de vos employés ont cassé des clés de verrouillage et vous êtes trop bon marché pour les remplacer. Aidez-les en créant le programme le plus court possible pour corriger leur travail! Convertissez simplement chaque caractère d'une chaîne donnée de majuscules en minuscules et vice-versa ... mais il y a une torsion!

Vous êtes également très excité pour Noël! Vous allez donc laisser un minuscule "bug" qui ne corrige pas les lettres qui se trouvent dans des séquences de Christmas(insensible à la casse).

Contribution

Pour l'entrée, vous utiliserez une seule chaîne (ou tableau d'octets) qui peut contenir des sauts de ligne et des ascii entre 0x20 et 0x7e ( - ~). Vous n'avez pas à vous soucier des retours chariot ou de tout autre caractère dans la chaîne.

Sortie

La sortie ne doit contenir que la chaîne fournie avec les caractères majuscules et minuscules échangés (et le bug de Noël bien sûr!). Il peut contenir jusqu'à un espace de fin supplémentaire.

Bug de Noël

Expliquons cela avec un exemple:

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

cancontient "c" qui est la première lettre de Noël, donc cela ne change pas. La lettre suivante Christmasest « h », qui est en hardly(qui contient aussi le « r »), de sorte que n'est pas changé, etc. Christmaselle - même n'a qu'une seule lettre inchangée car au moment où le cours de code là - bas, il est actuellement à la recherche de "s", pas "c".

Une fois la séquence trouvée, elle devrait recommencer à nouveau à "c" et recommencer l'itération Christmas. Ainsi ChristmasChristmasserait laissé inchangé.

Cas de test

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

Gagnant

Il s'agit de code-golf, donc la réponse la plus courte l'emporte!

05AB1E , 16 octets

Merci à Emigna d' avoir sauvé un octet et corrigé un bug!

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

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!

V , 38 , 36 octets

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

Essayez-le en ligne! (contient entrée et sortie attendue pour comparaison)

Quand j'ai vu cela pour la première fois, j'ai pensé que ce serait extrêmement facile. En fait, s'il n'y avait pas le bug « Noël », ce serait tout simplement 2 octets: V~. Le bug de Noël le rend beaucoup plus difficile, pour une réponse très hacky.

Comme d'habitude, voici 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 octets

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

prend l'entrée du premier argument de ligne de commande. Courez avec -r.

panne

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 octets

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

Les chaînes avec des sauts de ligne doivent être définies en concaténant avec le code ASCII 10(voir l'exemple dans le lien avec les cas de test).

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

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

Essayez-le ici!

Perl 6 , 84 octets

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

C # 197 octets

Je ne vais pas gagner avec ça, mais j'espère que la plus petite implémentation C # qui fonctionne ...

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

Explication:

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 octets de réduction merci @Neil.

Perl 6 , 80 octets

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

Essayez-le

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

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

Moche, mais ça marche .. Peut certainement être joué sans aucun doute plus .. Je suis rouillé ..

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

Code de test:

Essayez-le ici.

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

Sortie:

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 octets

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 octets

Utilise le -pdrapeau.

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

Caractères C # 239

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

version plus explicite:

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

c'est une solution assez naïve, et peut probablement être améliorée (peut-être pouvons-nous autoriser une conversion implicite en char?).

il suppose être à l'intérieur d'une fonction, lit à partir de la console (stdin) et y écrit (stdout).

edit: Char.IsUpper (s [j]) est 2 octets plus long que s [j]> 64 && s [j] <91, Char.ToUpper est plus long que ma version aussi.

Haskell, 222 207 octets

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

mis à jour:

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"

Comment ça marche:

s=(+(-65)).ord

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

f=(`divMod`32).s

f (sx) = (0, sx) pour les majuscules, (1, (s x-32)) pour les minuscules

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

liste parallèle de lettres, indexable par f (minuscule-> 1-> majuscule, majuscule-> 0-> minuscule)

c = cycle $ map s "CHRISTMAS"

liste infinie des valeurs ascii de Noël majuscule répétées

k _ []=[]

cas de 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

retourner des caractères non alphanumériques, et soit conserver la lettre si sa valeur s est la même que la lettre de noël actuelle (passer à la lettre suivante), sinon la convertir dans l'autre cas et continuer

main=interact$k c

IO