Schreiben Sie ein Programm, um alle Vorkommen von "force" durch "first" und alle Vorkommen von "first" durch "force" zu ersetzen, wobei der ursprüngliche Fall für alle Zeichenpositionen beibehalten wird:

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

Der Rest der Zeichenfolge muss unverändert bleiben. Wenn Sie Ihr Programm also zweimal ausführen, wird die ursprüngliche Zeichenfolge zurückgegeben:

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

Ihr Programm sollte mit jeder Anfangszeichenfolge funktionieren. Als Hinweis sollten Sie keine magischen Zeichen als Zwischendarstellung verwenden, denn wenn Sie einen Ersatz mit drei Durchgängen ( "force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first") versuchen , schlägt dies bei Zeichenfolgen mit fehl "zzzzz".

Sie sollten in Ihrer Programmiersprache alle Zeichen unterstützen, die in einer Definition eines Strings zulässig sind (in den meisten Fällen Unicode). Beispiel mit JSON-Darstellung für nicht druckbare Zeichen (\ u + 4 Ziffern):

"\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

Probieren Sie es online!

Bearbeiten: 5 Bytes dank @MartinEnder für den Hinweis darauf, was Rofunktioniert , gespeichert .

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>

Bearbeiten: 5 Bytes durch Optimierung der unveränderten Groß- und Kleinschreibung gespeichert.

APL (Dyalog) , 61 Bytes

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist. Kann mit dem Unicode-Symbol statt vier Zeichen kürzer sein .⍠⎕OPT

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

Probieren Sie es online!

PHP, 88 Bytes

Online-Versionen

<?=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 Byte Code + -pFlag.

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

Probieren Sie es online!

Nichts zu verrückt los. Suchen Sie nach Vorkommen von forceund firstohne Berücksichtigung der Groß- / Kleinschreibung ( s%force|first%%gi) und transkribieren Sie dann die Zeichen, die konvertiert werden sollen.

CJam, 66 Bytes

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

Durchläuft in jedem Fall die Variation von "first" und "force" und versucht, sich darauf aufzuspalten. Wenn dies möglich ist, wird es mit den umgekehrten Worten wieder verbunden.

Pseudocode:

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, das war ziemlich schwer in Java.

Erläuterung:

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

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

Jelly , 37 36 Bytes

Gibt es eine Möglichkeit, stattdessen eine Reduzierung über Slices der Länge 5 zu verwenden?

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

Probieren Sie es online!

Wie?

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

Probieren Sie es online!

Dies verwendet negative Werte als Zwischenschritt und nimmt nach den beiden Durchgängen den absoluten Wert an.

Pyth , 36 35 Bytes

K"first"srVjJ"force"mjKcdJcr0QKqVr1

Probieren Sie es online!

Pyth ist nicht besonders gut bei Saitenmanipulationen.

Flex (Lexer), 72 Bytes

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

Kompilieren und ausführen:

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

Python 2, 171 Bytes

Ich wollte versuchen, dies mit eingebauten Funktionen zu tun, aber es kann die chaotische Methode mit all dem Aufteilen und Zippen nicht übertreffen.

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)

Ich denke, es ist ziemlich klar, was ich hier mache. Teilen Sie die Zeichenfolge bei Instanzen von first und force auf (ohne Berücksichtigung der Groß- und Kleinschreibung), ersetzen Sie diese Instanzen durch Versionen, die mit str.translate übersetzt wurden, und fügen Sie sie wieder zu einer Zeichenfolge zusammen.

Probieren Sie es online!

Python 2.7, 173 165 Bytes

8 Bytes von Quintopia gespeichert

Dieser wurde eklig:

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]

Probieren Sie es online aus

Schritt für Schritt zerlegen:

1. S.lower().split("force"): nimm den String, füge ihn in Kleinbuchstaben ein und teile ihn in durch getrennte Teilstrings auf "force"
2. s.replace("first","force")for s in <STEP 1>: Ersetze alle "first"durch"force"
3. _`.join("first".join(<STEP 2>)`[2::5]`_: Ersetze all "force"'s mit, "first"indem du die "force"abgegrenzten Teilstrings mit neu kombinierst "first"und wieder zu einer einzelnen Zeichenkette zusammenfügst
4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): zip jedes Zeichen der ersetzten Phrase mit Groß- / Kleinschreibung der Originalzeichenfolge (2 für Kleinbuchstaben, 1 für Großbuchstaben)
5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: Originalgehäuse wiederherstellen, Liste in Zeichenfolge konvertieren (Unterstriche hinzugefügt, um die richtigen Häkchen zu setzen)

C (clang) , 201 183 226 214 Bytes

Hatte ein paar Bugs ... Muss noch ziemlich viel runtergolfen werden

(12 dank ceilingcat gespeichert)

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

Probieren Sie es online!

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

Probieren Sie es online!

Direkte Portierung der Java-Antwort von Kevin Cruijssen , die sich herausstellt, wenn es darum geht, das Zeichen in einer Zeichenfolge bei einem bestimmten Index abzurufen. C # ist viel golfiger als Java ( s[i++]statt s.charAt(i++)).

Japt , 41 Bytes

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

Probieren Sie es online!

Dies wäre erheblich kürzer, wenn Japt eine vernünftige Transliterationsfunktion hätte ...

Alternative Version:

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

Probieren Sie es online!

C #, 235 Zeichen

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

Probieren Sie es online!

Java, 382 Bytes nicht kompetent

Versuchen Sie es 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 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));}

Noch eine C # -Lösung, nur die zweitkleinste, weil ich zwei Variablen deklariert habe und daher keine Lambda-Syntax verwenden kann. na ja, ich hatte spaß :)

Erläuterung:

• schalte die ursprüngliche Saite hoch und teile sie dann auf "FORCE" und "FIRST".

• Fassen Sie die Ergebnisse zusammen und suchen Sie bei jeder Aufteilung die aus fünf Zeichen bestehende Teilzeichenfolge, die zum Aufteilen der ursprünglichen Zeichenfolge verwendet wurde, wobei Sie die bisherige Länge der zu aggregierenden Zeichenfolge verwenden. wenn es "Kraft" war, mach es "zuerst" und umgekehrt

• Wählen Sie alle Zeichen der neu erstellten Zeichenfolge aus, und überprüfen Sie, ob die ursprüngliche Zeichenfolge am selben Index in Kleinbuchstaben geschrieben war. Wenn ja, geben Sie an diesem Index in der neuen Zeichenfolge Kleinbuchstaben zurück. Anderenfalls wird das Großbuchstaben zurückgegeben