Écrivez un programme pour remplacer toutes les occurrences de "force" par "premier" et toutes les occurrences de "premier" par "force", en conservant la casse d'origine pour toutes les positions de caractères:

"ForcefoRcefOrcE" -> "FirstfiRstfIrsT"
"FirstfiRstfIrsT" -> "ForcefoRcefOrcE"

Le reste de la chaîne doit rester inchangé, et donc exécuter votre programme deux fois retournera la chaîne d'origine:

"thirst of forces" -> "thirst of firsts" -> "thirst of forces"

Votre programme devrait fonctionner sur n'importe quelle chaîne initiale. Donc, à titre indicatif, vous feriez mieux d'éviter d'utiliser des caractères magiques comme représentation intermédiaire, car si vous essayez un remplacement en trois passes ( "force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first"), il échouera sur les chaînes contenant "zzzzz".

Vous devez prendre en charge la plage complète de caractères autorisée dans une définition d'une chaîne par votre langage de programmation (dans la plupart des cas, c'est Unicode). Exemple, utilisation d'une représentation de style JSON pour les caractères non imprimables (\ u + 4 chiffres):

"\u0000\u0001\u0002\u0003the Force of the firsT"
                     |
                     V
"\u0000\u0001\u0002\u0003the First of the forcE"

Rétine , 33 octets

iT`\OC\E\ocetsiTSI`Ro`first|force

Essayez-le en ligne!

Edit: 5 octets enregistrés grâce à @MartinEnder pour avoir souligné ce qui se Ropasse.

JavaScript (ES6), 93 88 octets

f=
s=>s.replace(/force|first/gi,s=>s.replace(/./g,c=>s[s.search(c)^1]||c,s="oicsetOICSET"))

<textarea oninput=o.textContent=f(this.value)></textarea><pre id=o>

Edit: économisé 5 octets en optimisant la casse des lettres inchangée.

APL (Dyalog) , 61 octets

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes. Peut être quatre caractères plus court en utilisant le symbole Unicode ⍠au lieu de ⎕OPT .

(t←'force' 'first')⎕R{(m∊⎕A)c¨t⊃⍨~t⍳(c←819⌶)⊂m←⍵.Match}⎕OPT 1

Essayez-le en ligne!

PHP, 88 octets

Versions en ligne

<?=preg_replace_callback("#first|force#i",function($t){return$t[0]^first^force;},$argn);

PHP, 110 octets

<?=preg_replace_callback("#first|force#i",function($t){return strtr($t[0],iIsStToOcCeE,oOcCeEiIsStT);},$argn);

Perl 5 , 52 octets

51 octets de code + -pindicateur.

s%first|force%$&=~y/oceOCEistIST/istISToceOCE/r%eig

Essayez-le en ligne!

Rien de trop fou. Recherchez les occurrences de forceet firstnon sensibles à la casse ( s%force|first%%gi), puis translittérez les caractères pour les convertir l'un en l'autre.

CJam, 66 octets

qY5m*_"force"{f{_eu}3/:z{~?}f%}:K~\"first"K.{[\]:P~@\/\f/P~@\f*\*}

Parcourt chaque variation de cas de "premier" et "force" et essaie de se diviser dessus. S'il le peut, il le rejoint ensuite avec les mots inverses.

Pseudocode:

input_chars = list(read_all_input()) # CJam: q
power = cartesian_power(2, 5) # CJam: Y4m*_
def case_variations(s): # CJam: {...}:K
    temp0 = [[i, j, upper(j)] for i, j in zip(power, s)] # CJam: f{_eu}3/
    temp1 = map(transpose, temp0) # CJam: :z
    ret = []
    for i in ret:
        for j in i: # CJam: {...}f%
            ret.append(j[1] if j[0] else j[2]) # CJam: ~?
    return ret
force_var = K("force") # CJam: "force"{...}:K~
first_var = K("first") # CJam: \"first"K
for force, first in zip(force_var, first_var): # CJam: .{...}
    current = [force, first] # CJam: [\]:P~
    input_chars = list_split(input_chars, force) # CJam: @\/
    input_chars = [list_split(i, first) for i in input_chars] # CJam: \f/
    input_chars = [list_join(i, force) for i in input_chars] # CJam: P~@\f*
    input_chars = list_split(input_chars, first) # CJam: \*

Java 7, 318 310 octets

String c(String s){String x=s.toLowerCase();int i=x.indexOf("force")+1,j=x.indexOf("first")+1,t=i>0&j>i?0:j>0?1:0;return i>0|j>0?s.substring(0,t>0?(i=j):i)+(char)(s.charAt(i++)-(t>0?-6:6))+s.charAt(i++)+(char)(s.charAt(i++)+(t>0?-16:16))+(char)(s.charAt(i++)+(t>0?-15:15))+c(s.length()>i?s.substring(i):""):s;}

Ok, c'était assez dur en Java ..

Explication:

String c(String s){                       // Method with String parameter and String return-type
  String x=s.toLowerCase();               //  Temp String as lowercase of the input
  int i=x.indexOf("force")+1,             //  Index of "force" + 1 (becomes 0 if NOT present; >=1 if it is present)
      j=x.indexOf("first")+1,             //  Index of "first" + 1 (becomes 0 if NOT present; >=1 if it is present)
      t=i>0&j>i?0:j>0?1:0;                //  Temp integer: 0 if "force" is found first; 1 if "first" is found first
  return i>0|j>0?                         //  If either "force" or "first" is found:
    s.substring(0,t>0?(i=j):i)            //   Return the substring before that (if any) + ('f' or 'F')
     +(char)(s.charAt(i++)-(t>0?-6:6))    //   + 'i' <-> 'o', or 'I' <-> 'O'
     +s.charAt(i++)                       //   + 'r' or 'R'
     +(char)(s.charAt(i++)+(t>0?-16:16))  //   + 's' <-> 'c', or 'S' <-> 'C'
     +(char)(s.charAt(i++)+(t>0?-15:15))  //   + 't' <-> 'e', or 'T' <-> 'E'
     +c(s.length()>i?s.substring(i):"")   //   + a recursive call for the rest of the input-String (if any)
   :                                      //  Else:
    s;                                    //   Return the input-String
}                                         // End of method

Code de test:

Essayez-le ici.

class M{
  static String c(String s){String x=s.toLowerCase();int i=x.indexOf("force")+1,j=x.indexOf("first")+1,t=i>0&j>i?0:j>0?1:0;return i>0|j>0?s.substring(0,t>0?(i=j):i)+(char)(s.charAt(i++)-(t>0?-6:6))+s.charAt(i++)+(char)(s.charAt(i++)+(t>0?-16:16))+(char)(s.charAt(i++)+(t>0?-15:15))+c(s.length()>i?s.substring(i):""):s;}

  public static void main(String[] a){
    System.out.println(c("Force"));
    System.out.println(c("First"));
    System.out.println(c("foRce"));
    System.out.println(c("fiRst"));
    System.out.println(c("fOrcE"));
    System.out.println(c("fIrsT"));
    System.out.println(c("\u0000\u0001\u0002\u0003the Force of the firsT"));
    System.out.println(c("May the first be with you"));
    System.out.println(c(c("May the first be with you"))); // 2x
    System.out.println(c("The fIrSt of the First of the fORCE of the FIRST of the FoRCe"));
  }
}

Production:

First
Force
fiRst
foRce
fIrsT
fOrcE
 ���the First of the forcE
May the force be with you
May the first be with you
The fOrCe of the Force of the fIRST of the FORCE of the FiRSt

Gelée , 37 36 octets

Existe-t-il un moyen d'utiliser une réduction sur des tranches de longueur 5 à la place?

®‘©ị“Ɓu“¡Ḣƭ»
Œlœṣ¢œṣ€¢j€¢j¢Œu⁸=ŒuT¤¦

Essayez-le en ligne!

Comment?

®‘©ị“Ɓu“¡Ḣƭ» - Link 1 helper that fetches the next word to use: no arguments
®            - recall value from register (initially zero)
 ‘           - increment
  ©          - place the result into the register
    “Ɓu“¡Ḣƭ» - literal dictionary compressed string list ["first","force"]
   ị         - index into (1-indexed and modular)
             - so this link first yields "first", then "force", then "first" and so on.

Œlœṣ¢œṣ€¢j€¢j¢Œu⁸=ŒuT¤¦ - Main link: list of characters, S
Œl                      - convert S to lower case
  œṣ                    - split on sublists equal to:
    ¢                   -   call the last link (1) as a nilad ("first")
     œṣ€                - split €ach on sublists equal to:
        ¢               -   call the last link (1) as a nilad ("force")
         j€             - join €ach with:
           ¢            -   call the last link (1) as a nilad ("first")
            j           - join with:
             ¢          -   call the last link (1) as a nilad ("force")
                      ¦ - apply a link to sparse indices:
              Œu        -   convert to upper case
                     ¤  -   nilad followed by link(s) as a nilad:
                ⁸       -     chain's left argument, S
                  Œu    -     convert to upper case
                 =      -     equal to S? (vectorises)
                    T   -     truthy indexes (indexes at which input is upper case)

MATL , 47 octets

5W:qB!"o['first';'force']@!32*-cZ}_Zt5M_6MoZt|c

Essayez-le en ligne!

Cela utilise des valeurs négatives comme étape intermédiaire et après les deux passes, il prend la valeur absolue.

Pyth , 36 35 octets

K"first"srVjJ"force"mjKcdJcr0QKqVr1

Essayez-le en ligne!

Pyth n'est pas particulièrement bon pour les manipulations de chaînes.

Flex (lexer), 72 octets

%%
 #define x(a) yytext[a]^=
(?i:first|force) x(1)6;x(3)16;x(4)17;ECHO;

Pour compiler et exécuter:

flex first.l
gcc lex.yy.c -lfl # -ll on Macs, apparently
./a.out

Python 2, 171 octets

Je voulais essayer de le faire en utilisant des intégrés, mais cela ne peut pas battre la méthode désordonnée avec tous les fractionnements et zips.

import re,string as g
def f(s):f="istISTECOeco";l=re.split("(first|force)",s,0,re.IGNORECASE);l[1::2]=[t.translate(g.maketrans(f,f[::-1]))for t in l[1::2]];print"".join(l)

Je pense que c'est assez clair ce que je fais ici. Fractionnez la chaîne sur les instances de first et force (insensible à la casse), remplacez ces instances par des versions traduites à l'aide de str.translate et joignez-la à nouveau dans une chaîne.

Essayez-le en ligne!

Python 2.7, 173 165 octets

8 octets enregistrés par quintopia

Celui-ci est devenu grossier:

lambda S:`[(t[0],t[0].upper())[t[1]]for t in zip("".join("first".join(s.replace("first","force")for s in S.lower().split("force"))),[l.isupper() for l in S])]`[2::5]

Essayez-le en ligne

Décomposer étape par étape:

1. S.lower().split("force"): prendre la chaîne, unifier en minuscules, diviser en sous-chaînes séparées par "force"
2. s.replace("first","force")for s in <STEP 1>: Remplacez tous "first"par"force"
3. _`.join("first".join(<STEP 2>)`[2::5]`_: remplacez tous "force"les éléments "first"par en recombinant les "force"sous-chaînes délimitées avec "first"et rejoignez-les en une seule chaîne (les traits de soulignement sont ajoutés pour obtenir des graduations correctes)
4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): compresser chaque caractère de la phrase remplacée avec l'encodage en casse de la chaîne d'origine (2 pour les minuscules, 1 pour les majuscules)
5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: Restaurer le boîtier d'origine, convertit la liste en chaîne (soulignements ajoutés pour obtenir des graduations correctes)

C (bruit) , 201 183 226 214 octets

Eu quelques bugs ... Il faut encore beaucoup de golf

(sauvé 12 grâce au plafond)

char*s,*p,*q;main(i,v)char**v;{puts(s=v[1]);do{p=strcasestr(s,"first");q=strcasestr(s,"force");if(p&&(!q|p<q))p[1]+=6,p[3]-=16,p[4]-=15;else if(q)q[1]-=6,q[3]+=16,q[4]+=15;s=p&&(!q|p<q)?p:q;}while(s++);puts(v[1]);}

Essayez-le en ligne!

C # 273 octets

string c(string s){var x=s.ToLower();int i=x.IndexOf("force")+1,j=x.IndexOf("first")+1,t=i>0&j>i?0:j>0?1:0;return i>0|j>0?s.Substring(0,t>0?(i=j):i)+(char)(s[i++]-(t>0?-6:6))+s[i++]+(char)(s[i++]+(t>0?-16:16))+(char)(s[i++]+(t>0?-15:15))+c(s.Length>i?s.Substring(i):""):s;}

Essayez-le en ligne!

Le port direct de la réponse Java de Kevin Cruijssen , s'avère quand il s'agit d'obtenir le caractère dans une chaîne à un index donné, C # est beaucoup plus golfique que java ( s[i++]au lieu de s.charAt(i++))

Japt , 41 octets

r"first|force"_d"i1o s1c t1e"¸m²®+ZuÃq}'i

Essayez-le en ligne!

Cela serait considérablement plus court si Japt avait une fonction de translittération saine ...

Version alternative:

r"first|force"_d"io sc te"¸®¬¸²Ã®+ZuÃq}'i

Essayez-le en ligne!

C #, 235 caractères

string a(string s){var l=s.ToLower();int f=l.IndexOf("first"),F=l.IndexOf("force"),m=f<F&f>-1?f:F>-1?F:f;return ++m>0?s.Substring(0,m)+(char)(s[m]^6)+s[m+1]+(char)(s[m+2]^16)+(char)(s[m+3]^17)+(s.Length-m>5?c(s.Substring(m+4)):""):s;}

Ruby , 55 octets

gsub(/first|force/i){$&.tr(s="iIsStTEeCcOo",s.reverse)}

Essayez-le en ligne!

Java, 382 octets non-comptent

Essayez en ligne

String f(String t){String s="";for(String w:t.split(" "))if(w.equalsIgnoreCase("force")|w.equalsIgnoreCase("first"))s+=" "+w.charAt(0)+(char)(w.charAt(1)+(w.charAt(1)=='o'|w.charAt(1)=='O'?-6:6))+w.charAt(2)+(char)(w.charAt(3)+(w.charAt(3)=='c'|w.charAt(3)=='C'?16:-16))+(char)(w.charAt(4)+(w.charAt(4)=='e'|w.charAt(4)=='E'?15:-15));else s+=" "+w;return s.substring(1,s.length());}

C # (269 octets)

string s(string z){var u=z.ToUpper();var a=new[]{"FIRST","FORCE"};return String.Join("",u.Split(a,StringSplitOptions.None).Aggregate((c,n)=>c+(u.Substring(c.Length,5)==a[0]?a[1]:a[0])+n).Select((c,i)=>Char.IsLower(z[i])?Char.ToLower(c):c));}

encore une autre solution c #, seulement la deuxième plus petite parce que j'ai déclaré deux variables et que je ne peux donc pas utiliser la syntaxe lambda. eh bien, je me suis amusé. :)

explication:

• augmenter la chaîne d'origine, puis diviser sur "FORCE" et "FIRST".

• agréger les résultats et à chaque fractionnement, recherchez la sous-chaîne de cinq caractères qui a été utilisée pour fractionner la chaîne d'origine en utilisant la longueur jusqu'à présent de la chaîne agrégée. si c'était "force", faites-le "en premier" et vice versa

• sélectionnez tous les caractères de la chaîne de majuscules nouvellement créée et vérifiez si la chaîne d'origine était en minuscules au même index. si oui, retournez le caractère en minuscule à cet index dans la nouvelle chaîne, sinon retournez le caractère en majuscule