Escreva um programa para substituir todas as ocorrências de "força" por "primeiro" e todas as ocorrências de "primeiro" por "força", mantendo o caso original para todas as posições de caracteres:

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

O restante da string deve permanecer inalterado e, portanto, a execução do programa duas vezes retornará a string original:

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

Seu programa deve funcionar em qualquer sequência inicial. Portanto, como dica, é melhor evitar o uso de caracteres mágicos como representação intermediária, porque se você tentar uma substituição de três passagens ( "force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first"), ela falhará nas strings que contêm "zzzzz".

Você deve suportar todo o intervalo de caracteres permitido na definição de uma String pela sua linguagem de programação (na maioria dos casos, é Unicode). Exemplo, usando representação no estilo JSON para caracteres não imprimíveis (\ 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

Experimente online!

Editar: salvou 5 bytes graças a @MartinEnder por apontar o que Rofaz.

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: salvou 5 bytes otimizando a caixa de letra inalterada.

APL (Dyalog) , 61 bytes

Requer ⎕IO←0qual é o padrão em muitos sistemas. Pode ter quatro caracteres mais curtos usando o símbolo Unicode em ⍠vez de ⎕OPT .

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

Experimente online!

PHP, 88 bytes

Versões Online

<?=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 + -psinalizador.

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

Experimente online!

Nada muito louco acontecendo. Encontre as ocorrências de forcee que firstnão diferenciam maiúsculas de minúsculas ( s%force|first%%gi) e depois translitera os caracteres para converter um no outro.

CJam, 66 bytes

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

Passa por todas as variações de casos "primeiro" e "força" e tenta se dividir. Se puder, ele volta a juntar as palavras inversas.

Pseudo-có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, isso foi muito difícil em Java ..

Explicação:

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 do teste:

Experimente aqui.

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

Resultado:

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éia , 37 36 bytes

Existe uma maneira de usar uma redução entre fatias de comprimento 5?

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

Experimente online!

Quão?

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

Experimente online!

Isso usa valores negativos como etapa intermediária e, após as duas passagens, assume o valor absoluto.

Pitão , 36 35 bytes

K"first"srVjJ"force"mjKcdJcr0QKqVr1

Experimente online!

Pyth não é especialmente bom em manipulações de cordas.

Flex (lexer), 72 bytes

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

Para compilar e executar:

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

Python 2, 171 bytes

Eu queria tentar fazer isso usando built-ins, mas ele não pode vencer o método confuso com toda a divisão e o zíper.

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)

Eu acho que está bem claro o que estou fazendo aqui. Divida a sequência nas instâncias first e force (sem distinção entre maiúsculas e minúsculas), substitua essas instâncias por versões traduzidas usando str.translate e junte-a novamente a uma sequência.

Experimente online!

Python 2.7, 173 165 bytes

8 bytes salvos por quintopia

Este ficou nojento:

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]

Experimente online

Dividindo passo a passo:

1. S.lower().split("force"): pegue a string, unifique em minúsculas, divida em substrings separados por "force"
2. s.replace("first","force")for s in <STEP 1>: Substitua todos "first"por"force"
3. _`.join("first".join(<STEP 2>)`[2::5]`_: Substituir todos os "force"'s com "first"recombinando as "force"substrings delineadas com "first"e voltar em seqüência única (sublinhados adicionado para obter carrapato marcas corrigir)
4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): zip cada caractere da frase substituída com a codificação de maiúsculas e minúsculas da sequência original (2 para letras minúsculas e 1 para letras maiúsculas)
5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: Restaura a caixa original e converte a lista em sequência de caracteres (sublinhados adicionados para obter as marcas de escala corretas)

C (clang) , 201 183 226 214 bytes

Tinha alguns bugs ... Ainda precisa ser jogado bastante

(economizou 12 graças 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]);}

Experimente online!

Bytes em C # 273

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

Experimente online!

Porta direta da resposta Java de Kevin Cruijssen , acontece quando se trata de obter o char em uma string em um determinado índice, o C # é muito mais golfista que o java (em s[i++]vez de s.charAt(i++))

Japonês , 41 bytes

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

Experimente online!

Isso seria consideravelmente mais curto se Japt tivesse uma função transliterada sã ...

Versão alternativa:

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

Experimente online!

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

Experimente online!

Java, 382 bytes não comptent

Experimente on-line

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

ainda outra solução c #, apenas a segunda menor porque eu declarei duas variáveis ​​e, portanto, não posso usar a sintaxe lambda. oh bem, eu me diverti. :)

explicação:

• mude a string original e divida em "FORCE" e "PRIMEIRO".

• agregue os resultados e, em cada divisão, localize a subcadeia de cinco caracteres usada para dividir a cadeia original usando o comprimento até agora da cadeia agregada. se fosse "força", faça "primeiro" e vice-versa

• selecione todos os caracteres da string all caps recém-criada e verifique se a string original estava em minúscula no mesmo índice. se sim, retorne o caractere em minúsculas nesse índice na nova string; caso contrário, retorne o caractere em maiúsculas