编写一个程序，用“ first”替换所有出现的“ force”，并用“ force”替换所有出现的“ first”：保留所有字符位置的原始大小写：

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

字符串的其余部分必须保持不变，因此运行程序两次将返回原始字符串：

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

您的程序应该可以在任何初始字符串上运行。因此，建议您最好避免使用魔术字符作为中间表示，因为如果尝试三遍替换（"force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first"），它将在包含的字符串上失败"zzzzz"。

您应该支持您的编程语言在字符串定义中允许的所有字符（在大多数情况下，它是Unicode）。例如，对不可打印的字符（\ u + 4位数字）使用JSON样式表示形式：

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

视网膜，33字节

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

在线尝试！

编辑：感谢@MartinEnder指出了什么Ro，节省了5个字节。

JavaScript（ES6），93 88字节

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>

编辑：通过优化未更改的字母大小写节省了5个字节。

APL（Dyalog），61字节

要求⎕IO←0在许多系统上是默认设置。可以使用Unicode符号（而不是）缩短四个字符。⍠⎕OPT

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

在线尝试！

PHP，88字节

在线版本

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

PHP，110字节

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

Perl 5，52个字节

51个字节的代码+ -p标志。

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

在线尝试！

没什么太疯狂了。找到force和first不区分大小写（s%force|first%%gi）的出现，然后音译字符以将一个转换为另一个。

CJam，66个字节

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

遍历“ first”和“ force”的每种情况的变体，然后尝试在其上进行拆分。如果可以，则将其与反向单词重新连接在一起。

伪代码：

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字节

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

好的，这在Java中很难。

说明：

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

测试代码：

在这里尝试。

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

输出：

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

果冻，37 36 字节

有没有一种方法可以在长度为5的切片之间使用reduce呢？

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

在线尝试！

怎么样？

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

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

在线尝试！

这将负值用作中间步骤，并且在两次通过之后取其绝对值。

Pyth，36 35字节

K"first"srVjJ"force"mjKcdJcr0QKqVr1

在线尝试！

Pyth在字符串操作方面不是特别擅长。

Flex（词法分析器），72字节

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

要编译并运行：

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

Python 2，171字节

我想尝试使用内置函数来做到这一点，但是它在所有分割和压缩方面都无法克服凌乱的方法。

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)

我认为我在这里做什么很清楚。在first和force实例上拆分字符串（不区分大小写），将这些实例替换为使用str.translate翻译的版本，然后再次将其重新连接为字符串。

在线尝试！

Python 2.7版，173个 165字节

quintopia保存了8个字节

这一个很累：

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]

在线尝试

逐步分解：

1. S.lower().split("force")：采用字符串，统一为小写形式，分割为由 "force"
2. s.replace("first","force")for s in <STEP 1>：全部替换"first"为"force"
3. _`.join("first".join(<STEP 2>)`[2::5]`_：替换所有"force"带的"first"通过重新组合"force"与子划定"first"并重新加入到单一的字符串（下划线相加得到刻度修正）
4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S])：使用原始字符串的大小写编码压缩替换短语的每个字符（小写为2，大写为1）
5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_：恢复原始大小写，将列表转换为字符串（添加下划线以使刻度线正确）

C（铛），201 183 226 214字节

有一些错误...仍然需要打很多球

（由于吊顶猫节省了12）

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

在线尝试！

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

在线尝试！

凯文·克鲁伊森（Kevin Cruijssen）的Java答案的直接端口，事实证明，要在给定索引的字符串中获取char，C＃比Java（s[i++]而不是s.charAt(i++)）更具优势。

Japt，41个字节

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

在线尝试！

如果Japt具有健全的音译功能，这将大大缩短...

备用版本：

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

在线尝试！

C＃，235个字符

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个字节

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

在线尝试！

Java，382字节非内容

在线尝试

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字节）

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

另一个c＃解决方案，仅次于第二个，因为我声明了两个变量，因此不能使用lambda语法。哦，我很开心。:)

说明：

• 上移原始字符串，然后在“ FORCE”和“ FIRST”上分割。

• 聚合结果，并在每次拆分时，使用要聚合的字符串的到目前为止长度，找到用于拆分原始字符串的五个字符的子字符串。如果是“强制”，则将其设置为“第一”，反之亦然

• 选择新创建的全大写字符串的所有字符，并检查原始字符串在同一索引处是否为小写。如果是，则在新字符串的该索引处返回小写字符，否则返回大写字符