Escriba un programa para reemplazar todas las ocurrencias de "fuerza" con "primero" y todas las ocurrencias de "primero" con "fuerza", manteniendo el caso original para todas las posiciones de los personajes:

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

El resto de la cadena debe permanecer sin cambios, por lo que ejecutar su programa dos veces devolverá la cadena original:

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

Su programa debería funcionar en cualquier cadena inicial. Entonces, como pista, es mejor que evites usar caracteres mágicos como representación intermedia, porque si intentas un reemplazo de tres pasos ( "force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first"), fallará en las cadenas que contengan "zzzzz".

Debe admitir la gama completa de caracteres permitidos en una definición de una Cadena por su lenguaje de programación (en la mayoría de los casos, es Unicode). Ejemplo, usando la representación de estilo JSON para caracteres no imprimibles (\ u + 4 dígitos):

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

Retina , 33 bytes

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

Pruébalo en línea!

Editar: Guardado 5 bytes gracias a @MartinEnder por señalar qué Ro hace.

JavaScript (ES6), 93 88 bytes

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>

Editar: se guardaron 5 bytes al optimizar la letra mayúscula sin cambios.

APL (Dyalog) , 61 bytes

Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas. Pueden ser cuatro caracteres más cortos usando el símbolo Unicode en ⍠lugar de ⎕OPT .

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

Pruébalo en línea!

PHP, 88 bytes

Versiones en linea

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

PHP, 110 bytes

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

Perl 5 , 52 bytes

51 bytes de código + -pbandera.

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

Pruébalo en línea!

No pasa nada loco. Encuentre las ocurrencias de forcey firstno distingue entre mayúsculas y minúsculas ( s%force|first%%gi), y luego translitera los caracteres para convertir uno a otro.

CJam, 66 bytes

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

Pasa por cada variación de caso de "primero" y "fuerza" e intenta dividirse en él. Si puede, lo une de nuevo con las palabras inversas.

Pseudocódigo:

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 bytes

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, esto fue bastante difícil en Java ...

Explicación:

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

Código de prueba:

Pruébalo aquí

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

Salida:

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

Jalea , 37 36 bytes

¿Hay alguna forma de usar una reducción en los cortes de longitud 5 en su lugar?

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

Pruébalo en línea!

¿Cómo?

®‘©ị“Ɓ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 bytes

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

Pruébalo en línea!

Esto usa valores negativos como el paso intermedio, y después de las dos pasadas toma el valor absoluto.

Pyth , 36 35 bytes

K"first"srVjJ"force"mjKcdJcr0QKqVr1

Pruébalo en línea!

Pyth no es especialmente bueno en manipulaciones de cuerdas.

Flex (lexer), 72 bytes

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

Para compilar y ejecutar:

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

Python 2, 171 bytes

Quería intentar hacer esto usando los elementos integrados, pero no puede superar el método desordenado con toda la división y la compresión.

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)

Creo que está bastante claro lo que estoy haciendo aquí. Divida la cadena en instancias de first y force (no distingue entre mayúsculas y minúsculas), reemplace esas instancias con versiones traducidas usando str.translate y vuelva a unirlas en una cadena.

Pruébalo en línea!

Python 2.7, 173 165 bytes

8 bytes guardados por quintopia

Este se puso asqueroso:

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]

Pruébalo en línea

Desglosándolo paso a paso:

1. S.lower().split("force"): toma la cadena, unifica a minúsculas, divide en subcadenas separadas por "force"
2. s.replace("first","force")for s in <STEP 1>: Reemplaza todo "first" con"force"
3. _`.join("first".join(<STEP 2>)`[2::5]`_: reemplace todos "force"con "first"recombinando el"force" subcadenas delineadas con"first" y vuelva a unirse en una sola cadena (subrayados añadidos para obtener las marcas correctas)
4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): comprime cada carácter de la frase reemplazada con codificación de mayúsculas y minúsculas de la cadena original (2 para minúsculas, 1 para mayúsculas)
5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: Restaura la carcasa original, convierte la lista en cadena (se agregan guiones bajos para obtener las marcas correctas)

C (sonido metálico) , 201 183 226 214 bytes

Tenía algunos errores ... Todavía necesita mucho golf

(ahorrado 12 gracias a ceilingcat)

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

Pruébalo en línea!

C # 273 bytes

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

Pruébalo en línea!

El puerto directo de la respuesta Java de Kevin Cruijssen , resulta cuando se trata de obtener el carácter en una cadena en un índice dado, C # es mucho más golfista que Java (en s[i++]lugar de s.charAt(i++))

Japt , 41 bytes

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

Pruébalo en línea!

Esto sería considerablemente más corto si Japt tuviera una función de transliteración sensata ...

Versión alternativa:

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

Pruébalo en línea!

C #, 235 caracteres

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 bytes

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

Pruébalo en línea!

Java, 382 bytes sin contenido

Probar en línea

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

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

otra solución de c #, solo la segunda más pequeña porque declaró dos variables y, por lo tanto, no puedo usar la sintaxis lambda. oh bueno, me divertí mucho. :)

explicación:

• cambie la cadena original hacia arriba, luego divídala en "FORCE" y "FIRST".

• agregue los resultados y en cada división, encuentre la subcadena de cinco caracteres que se usó para dividir la cadena original usando la longitud hasta ahora de la cadena que se agrega. si fue "forzar" hacerlo "primero" y viceversa

• seleccione todos los caracteres de la cadena de mayúsculas recién creada y verifique si la cadena original estaba en minúscula en el mismo índice. en caso afirmativo, devuelva el carácter en minúscula en ese índice en la nueva cadena; de lo contrario, devuelva el carácter en mayúscula