Napisz program, który zastąpi wszystkie wystąpienia słowa „force” słowem „first”, a wszystkie wystąpienia słowa „first” słowem „force”, zachowując oryginalny przypadek dla wszystkich pozycji znaków:

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

Reszta ciągu musi pozostać niezmieniona, więc dwukrotne uruchomienie programu zwróci oryginalny ciąg:

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

Twój program powinien działać na dowolnym ciągu początkowym. Tak więc, jako wskazówkę, lepiej unikać używania znaków magicznych jako reprezentacji pośredniej, ponieważ jeśli spróbujesz zastąpienia trzyprzebiegowego ( "force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first"), to zawiedzie na łańcuchach zawierających "zzzzz".

Powinieneś obsługiwać pełny zakres znaków dozwolony w definicji ciągu znaków przez swój język programowania (w większości przypadków jest to Unicode). Przykład z użyciem reprezentacji w stylu JSON dla znaków niedrukowalnych (\ u + 4 cyfry):

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

Siatkówka , 33 bajty

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

Wypróbuj online!

Edycja: Zaoszczędź 5 bajtów dzięki @MartinEnder za wskazanie, co Rorobi.

JavaScript (ES6), 93 88 bajtów

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>

Edycja: Zapisano 5 bajtów, optymalizując niezmienioną wielkość liter.

APL (Dyalog) , 61 bajtów

Wymaga ⎕IO←0ustawienia domyślnego w wielu systemach. Może być o cztery znaki krótszy przy użyciu symbolu Unicode ⍠zamiast ⎕OPT .

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

Wypróbuj online!

PHP, 88 bajtów

Wersje online

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

PHP, 110 bajtów

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

Perl 5 , 52 bajty

51 bajtów kodu + -pflaga.

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

Wypróbuj online!

Nie dzieje się nic szalonego. Znajdź wystąpienia forcei firstbez rozróżniania wielkości liter ( s%force|first%%gi), a następnie transliteruje znaki, aby przekonwertować jeden na drugi.

CJam, 66 bajtów

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

Przegląda każdą odmianę „pierwszego” i „wymuszenia” i próbuje się na nią rozdzielić. Jeśli to możliwe, łączy je z powrotem odwrotnymi słowami.

Pseudo kod:

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 bajtów

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, to było dość trudne w Javie ..

Wyjaśnienie:

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

Kod testowy:

Wypróbuj tutaj.

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

Wynik:

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

Galaretka , 37 36 bajtów

Czy istnieje sposób na użycie zamiast tego skrótu w plasterkach o długości 5?

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

Wypróbuj online!

W jaki sposób?

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

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

Wypróbuj online!

Wykorzystuje wartości ujemne jako krok pośredni, a po dwóch przejściach przyjmuje wartość bezwzględną.

Pyt , 36 35 bajtów

K"first"srVjJ"force"mjKcdJcr0QKqVr1

Wypróbuj online!

Pyth nie jest szczególnie dobry w manipulacjach ciągami.

Flex (Lexer), 72 bajty

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

Aby skompilować i uruchomić:

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

Python 2, 171 bajtów

Chciałem to zrobić za pomocą wbudowanych funkcji, ale nie jest w stanie pokonać nieuporządkowanej metody z całym dzieleniem i kompresowaniem.

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)

Myślę, że to całkiem jasne, co tu robię. Podziel ciąg na instancje first i force (bez rozróżniania wielkości liter), zamień te instancje na wersje przetłumaczone przy użyciu str.translate i ponownie dołącz do łańcucha.

Wypróbuj online!

Python 2.7, 173 165 bajtów

8 bajtów zapisanych przez kwintopię

Ten dostał brutto:

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]

Wypróbuj online

Podział na krok po kroku:

1. S.lower().split("force"): weź ciąg, ujednolicaj małe litery, podziel na podciągi oddzielone "force"
2. s.replace("first","force")for s in <STEP 1>Wymienić wszystkie "first"„s ze"force"
3. _`.join("first".join(<STEP 2>)`[2::5]`_Zamienić wszystkie "force"„s z "first"o ponowne łączenie "force"wyodrębnione z podciągi"first" i dołączyć do pojedynczego łańcucha (podkreślenia dodane dostać znaczniki skorygować)
4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): zip każdy znak zastępowanej frazy z kodowaniem wielkich i małych liter (2 dla małych liter, 1 dla wielkich liter)
5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: Przywróć oryginalną obudowę, konwertuje listę na ciąg znaków (dodane podkreślenia, aby poprawnie zaznaczyć znaczniki)

C (brzęk) , 201 183 226 214 bajtów

Miałem kilka błędów ... Nadal trzeba dużo grać w golfa

(uratowano 12 dzięki pułapowi cat)

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

Wypróbuj online!

C # 273 bajtów

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

Wypróbuj online!

Bezpośredni port odpowiedzi Java Kevina Cruijssena , okazuje się, że jeśli chodzi o uzyskanie znaku w ciągu o danym indeksie, C # jest znacznie bardziej golfowy niż Java ( s[i++]zamiast s.charAt(i++))

Japt , 41 bajtów

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

Wypróbuj online!

Byłoby to znacznie krótsze, gdyby Japt miał rozsądną funkcję transliteracji ...

Alternatywna wersja:

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

Wypróbuj online!

C #, 235 znaków

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

Rubinowy , 55 bajtów

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

Wypróbuj online!

Java, 382 bajty niezgodne

Wypróbuj online

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 bajtów)

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

jeszcze inne rozwiązanie c #, tylko drugie najmniejsze, ponieważ zadeklarowałem dwie zmienne, więc nie mogę używać składni lambda. no cóż, dobrze się bawiłem. :)

wyjaśnienie:

• w górę oryginalny ciąg znaków, a następnie podziel na „FORCE” i „FIRST”.

• agreguj wyniki i przy każdym podziale znajdź pięcioznakowy podciąg, który został użyty do podzielenia oryginalnego łańcucha przy użyciu długości do tej pory agregowanego łańcucha. jeśli była to „siła”, uczyń to „pierwszym” i odwrotnie

• zaznacz wszystkie znaki nowo utworzonego ciągu wszystkich wielkich liter i sprawdź, czy oryginalny ciąg był pisany małymi literami przy tym samym indeksie. jeśli tak, zwracaj małe litery w tym indeksie w nowym ciągu, w przeciwnym razie zwracaj wielkie litery