Viết chương trình thay thế tất cả các lần xuất hiện của "lực lượng" bằng "lần đầu tiên" và tất cả các lần xuất hiện của "lần đầu tiên" bằng "lực lượng", giữ trường hợp ban đầu cho tất cả các vị trí ký tự:

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

Phần còn lại của chuỗi phải không thay đổi và vì vậy, chạy chương trình của bạn hai lần sẽ trả về chuỗi gốc:

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

Chương trình của bạn sẽ hoạt động trên bất kỳ chuỗi ban đầu. Vì vậy, như một gợi ý, tốt hơn hết bạn nên tránh sử dụng các ký tự ma thuật làm biểu diễn trung gian, bởi vì nếu bạn thử thay thế ba lượt ( "force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first"), nó sẽ thất bại trên các chuỗi chứa "zzzzz".

Bạn nên hỗ trợ đầy đủ các ký tự được cho phép trong định nghĩa Chuỗi bằng ngôn ngữ lập trình của bạn (trong hầu hết các trường hợp, đó là Unicode). Ví dụ: sử dụng biểu diễn kiểu JSON cho các ký tự không in được (\ u + 4 chữ số):

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

Võng mạc , 33 byte

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

Hãy thử trực tuyến!

Chỉnh sửa: Đã lưu 5 byte nhờ @MartinEnder để chỉ ra những gì Ro.

JavaScript (ES6), 93 88 byte

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>

Chỉnh sửa: Đã lưu 5 byte bằng cách tối ưu hóa trường hợp chữ không thay đổi.

APL (Dyalog) , 61 byte

Yêu cầu ⎕IO←0mặc định trên nhiều hệ thống. Có thể là bốn nhân vật ngắn hơn bằng cách sử dụng ký hiệu Unicode ⍠thay vì ⎕OPT .

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

Hãy thử trực tuyến!

PHP, 88 byte

Phiên bản trực tuyến

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

PHP, 110 byte

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

Perl 5 , 52 byte

51 byte mã + -pcờ.

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

Hãy thử trực tuyến!

Không có gì quá điên rồ đang diễn ra. Tìm các lần xuất hiện forcevà firstkhông phân biệt chữ hoa chữ thường ( s%force|first%%gi), sau đó chuyển ngữ các ký tự để chuyển đổi ký tự này sang ký tự khác.

CJam, 66 byte

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

Đi qua mọi biến thể của trường hợp "đầu tiên" và "lực lượng" và cố gắng phân tách trên đó. Nếu có thể, nó sẽ nối lại với các từ ngược lại.

Mã giả:

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 byte

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, điều này khá khó khăn trong Java ..

Giải trình:

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

Mã kiểm tra:

Hãy thử nó ở đây.

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

Đầu ra:

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

Thạch , 37 36 byte

Thay vào đó, có cách nào để sử dụng giảm trên các lát có độ dài 5 không?

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

Hãy thử trực tuyến!

Làm sao?

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

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

Hãy thử trực tuyến!

Điều này sử dụng các giá trị âm làm bước trung gian và sau khi cả hai vượt qua, nó sẽ nhận giá trị tuyệt đối.

Bình thường , 36 35 byte

K"first"srVjJ"force"mjKcdJcr0QKqVr1

Hãy thử trực tuyến!

Pyth không đặc biệt giỏi trong các thao tác chuỗi.

Flex (lexer), 72 byte

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

Để biên dịch và chạy:

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

Python 2, 171 byte

Tôi muốn thử làm điều này bằng cách sử dụng tích hợp sẵn, nhưng nó không thể đánh bại phương thức lộn xộn với tất cả sự phân tách và né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)

Tôi nghĩ rằng nó khá rõ ràng những gì tôi đang làm ở đây. Tách chuỗi trên các phiên bản đầu tiên và bắt buộc (không phân biệt chữ hoa chữ thường), thay thế các phiên bản đó bằng các phiên bản được dịch bằng str.translate và nối lại chuỗi đó thành một chuỗi.

Hãy thử trực tuyến!

Python 2.7, 173 165 byte

8 byte được lưu bởi quintopia

Điều này có tổng:

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]

Dùng thử trực tuyến

Phá vỡ nó từng bước:

1. S.lower().split("force"): lấy chuỗi, thống nhất thành chữ thường, tách thành các chuỗi con cách nhau bởi "force"
2. s.replace("first","force")for s in <STEP 1>: Thay thế tất cả "first" bằng"force"
3. _`.join("first".join(<STEP 2>)`[2::5]`_: thay thế tất cả "force"bằng "first"cách kết hợp lại"force" chuỗi con được phân định bằng"first" và nối lại thành một chuỗi (gạch dưới được thêm vào để có dấu tick chính xác)
4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): zip từng ký tự của cụm từ được thay thế bằng mã hóa trường hợp của chuỗi gốc (2 cho chữ thường, 1 cho chữ hoa)
5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: Khôi phục vỏ ban đầu, chuyển đổi danh sách thành chuỗi (dấu gạch dưới được thêm vào để có dấu tick chính xác)

C (tiếng kêu) , 201 183 226 214 byte

Có một số lỗi ... Vẫn cần phải chơi golf khá nhiều

(lưu 12 nhờ trần nhà)

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

Hãy thử trực tuyến!

C # 273 byte

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

Hãy thử trực tuyến!

Cổng trực tiếp của câu trả lời Java của Kevin Cruijssen , hóa ra khi nói đến việc lấy char trong một chuỗi tại một chỉ mục nhất định, C # mạnh hơn nhiều so với java ( s[i++]thay vì s.charAt(i++))

Japt , 41 byte

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

Hãy thử trực tuyến!

Điều này sẽ ngắn hơn đáng kể nếu Japt có chức năng chuyển ngữ lành mạnh ...

Phiên bản thay thế:

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

Hãy thử trực tuyến!

C #, 235 ký tự

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 byte

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

Hãy thử trực tuyến!

Java, 382 byte không thành phần

Thử trực tuyến

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

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òn một giải pháp c # khác, chỉ nhỏ nhất thứ hai vì tôi đã khai báo hai biến và vì vậy không thể sử dụng cú pháp lambda. oh tốt, tôi đã có niềm vui :)

giải trình:

• upshift chuỗi ban đầu, sau đó phân tách trên "FORCE" và "FIRST".

• tổng hợp các kết quả và trên mỗi lần phân tách, tìm chuỗi con gồm năm ký tự được sử dụng để phân tách chuỗi gốc bằng cách sử dụng độ dài cho đến nay của chuỗi được tổng hợp. nếu đó là "lực lượng" hãy làm cho nó "đầu tiên" và ngược lại

• chọn tất cả các ký tự của chuỗi mũ được tạo mới và kiểm tra xem chuỗi gốc có phải là chữ thường ở cùng một chỉ mục không. nếu có, trả về ký tự chữ thường ở chỉ mục đó trong chuỗi mới, nếu không thì trả về ký tự viết hoa