Che il primo sia con te

19

Scrivi un programma per sostituire tutte le occorrenze di "force" con "first" e tutte le occorrenze di "first" con "force", mantenendo il caso originale per tutte le posizioni dei personaggi:

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

Il resto della stringa deve rimanere invariato, quindi eseguire due volte il programma restituirà la stringa originale:

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

Il tuo programma dovrebbe funzionare su qualsiasi stringa iniziale. Quindi, come suggerimento, è meglio evitare di usare caratteri magici come rappresentazione intermedia, perché se provi una sostituzione a tre passaggi ( "force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first"), fallirà sulle stringhe contenenti "zzzzz".

Dovresti supportare l'intera gamma di caratteri consentiti in una definizione di String dal tuo linguaggio di programmazione (nella maggior parte dei casi, è Unicode). Esempio, utilizzo della rappresentazione in stile JSON per caratteri non stampabili (\ u + 4 cifre):

"\u0000\u0001\u0002\u0003the Force of the firsT"
                     |
                     V
"\u0000\u0001\u0002\u0003the First of the forcE"
code-golf  string 
— Cœur
fonte
1
Ragazzo Atta. Ricorda alle persone che il tag ha il criterio vincente '
— Christopher,
1
@ Challenger5 No, non credo, dato che se il comando [Ff]non è presente non devi sostituire la parola.
— Erik the Outgolfer,
2
Maggio Potrebbe essere prima con te. (Commentato il 1 maggio)
— Esolanging Fruit
19
Non dovrebbe essere "Il quarto può essere con te"?
— wizzwizz4,
3
@ mbomb007 "4th" e "force" non hanno lo stesso numero di lettere, il che lo rende incompatibile per mantenere lo stesso caso di carattere.
— Cœur

Risposte:

6

Retina , 33 byte

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

Provalo online!

Modifica: salvato 5 byte grazie a @MartinEnder per aver sottolineato cosa Rofa.

— Neil
fonte
Sì, stava per pubblicare una volta che l'OP ha risposto al mio commento. È possibile salvare alcuni byte riordinando il primo set in modo che il secondo possa essere Ro.
— Martin Ender,
@MartinEnder La documentazione mi ha confuso prestando troppa attenzione Rall'effetto sugli intervalli; per esempio non mi sarei mai reso conto che REequivale a 86420se non l'avessi sottolineato.
— Neil,
grazie per avermi fatto sapere. Proverò a renderlo più chiaro nei documenti.
— Martin Ender,
9

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>
Espandi frammento

Modifica: 5 byte salvati ottimizzando la maiuscola invariata.

— Neil
fonte
5

APL (Dyalog) , 61 byte

Richiede il ⎕IO←0valore predefinito su molti sistemi. Può essere più corto di quattro caratteri usando il simbolo Unicode ⍠invece di ⎕OPT .

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

Provalo online!

— Adamo
fonte
4

PHP, 88 byte

Versioni online

<?=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);
— Jörg Hülsermann
fonte
3
È possibile salvare alcuni byte con $t[0]^first^forceinvece di strtr().
— user63956,
@ user63956 Grazie per lo sforzo di apprendimento
— Jörg Hülsermann,
4

Perl 5 , 52 byte

51 byte di codice + -pflag.

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

Provalo online!

Non sta succedendo niente di pazzo. Trova le occorrenze di forcee firstsenza distinzione tra maiuscole e minuscole ( s%force|first%%gi), quindi traslittera i caratteri per convertirli l'uno nell'altro.

— Dada
fonte
3

CJam, 66 byte

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

Passa attraverso ogni variazione del caso di "primo" e "forza" e cerca di dividerlo. Se è possibile, lo unisce nuovamente con le parole inverse.

pseudocodice:

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: \*
— Esolanging Fruit
fonte
Sicuramente fè importante evitare di cambiare thirstin thorceo divorcein divirst?
— Neil,
@Neil True, modificato.
— Esolanging Fruit
— Esolanging Fruit
3

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, questo è stato piuttosto difficile in Java ..

Spiegazione:

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

Codice di prova:

Provalo qui.

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

Produzione:

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
— Kevin Cruijssen
fonte
1
Apprezzo che tu abbia fornito un esempio simmetrico c(c("..."))!
— Cœur
3

Gelatina , 37 36 byte

Esiste invece un modo per utilizzare una riduzione su sezioni di lunghezza 5?

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

Provalo online!

Come?

®‘©ị“Ɓ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)
— Jonathan Allan
fonte
Pyth e Jelly sono uguali: o
— Leaky Nun
Ci deve essere un modo per giocare a golf: D
— Jonathan Allan,
Sì, e l'ho appena trovato: D
— Leaky Nun
2

MATL , 47 byte

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

Provalo online!

Questo utilizza valori negativi come passaggio intermedio e dopo i due passaggi assume il valore assoluto.

— Luis Mendo
fonte
2

Flex (lexer), 72 byte

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

Per compilare ed eseguire:

flex first.l
gcc lex.yy.c -lfl # -ll on Macs, apparently
./a.out
— RICI
fonte
first.l:3: EOF encountered inside an action(oh, non importa: richiede una nuova riga alla fine)
— Cœur
ld: library not found for -lfl(oh non importa, il comando è gcc lex.yy.c -llsu macOS)
— Cœur
Testato e approvato.
— Cœur
2

Python 2, 171 byte

Volevo provare a farlo usando i built-in, ma non può battere il metodo disordinato con tutte le suddivisioni e zippare.

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)

Penso che sia abbastanza chiaro cosa sto facendo qui. Dividi la stringa nelle istanze di first e force (senza distinzione tra maiuscole e minuscole), sostituisci quelle istanze con le versioni tradotte usando str.translate e ricollegala nuovamente in una stringa.

Provalo online!

— quintopia
fonte
2

Python 2.7, 173 165 byte

8 byte salvati dalla chintopia

Questo è diventato disgustoso:

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]

Provalo online

Abbattendolo passo dopo passo:

  1. S.lower().split("force"): prende la stringa, unifica in minuscolo, divisa in sottostringhe separate da "force"
  2. s.replace("first","force")for s in <STEP 1>: Sostituisci tutto "first" con"force"
  3. _`.join("first".join(<STEP 2>)`[2::5]`_: sostituisci tutto "force"con "first"ricombinando le "force"sottostringhe delineate con"first" e ricongiungersi in un'unica stringa (sottolineatura aggiunti per ottenere segni di graduazione correggere)
  4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): comprime ogni carattere della frase sostituita con la codifica maiuscola della stringa originale (2 per le lettere minuscole, 1 per le maiuscole)
  5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: Ripristina involucro originale, converte l'elenco in stringa (caratteri di sottolineatura aggiunti per ottenere i segni di spunta corretti)
— wnnmaw
fonte
Puoi salvare 8 byte codificando upper come True e lower come False: provalo online!
— Quintopia,
2

C (clang) , 201 183 226 214 byte

Aveva alcuni bug ... Devo ancora giocare a golf parecchio

(salvato 12 grazie 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]);}

Provalo online!

— cleblanc
fonte
— ceilingcat il
1

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

Provalo online!

Il port diretto della risposta Java di Kevin Cruijssen , risulta quando si tratta di ottenere il carattere in una stringa in un determinato indice, C # è molto più golfoso di java ( s[i++]invece di s.charAt(i++))

— Skidsdev
fonte
1

Japt , 41 byte

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

Provalo online!

Ciò sarebbe considerevolmente più breve se Japt avesse una sana funzione di traslitterazione ...

Versione alternativa:

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

Provalo online!

— ETHproductions
fonte
1

C #, 235 caratteri

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;}
— Leonardo Lazcano
fonte
0

Java, 382 byte non comptent

Prova 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());}
— Khaled.K
fonte
3
Hmm, questo funziona solo se tutte le parole sono divise da spazi, ma per quanto riguarda le virgole o strane stringhe come "The first, force,|first'forced!"? Inoltre, puoi giocare un po 'il tuo codice attuale: if(w.equalsIgnoreCase("force")|w.equalsIgnoreCase("first"))-> ,zdopo String s=""e z=w.toLowerCase();if(z.equals("force")|z.equals("first")). Inoltre, 'O'può essere 79, 'C'può essere 67e 'E'può essere 69. E il if elsepuò essere sostituito con un grande ternario se-else, poiché entrambi lo fanno s+=.
— Kevin Cruijssen,
Confermo che questa soluzione non è idonea, ad esempio in caso di errore su "forceforce".
— Cœur
@Cœur Ho aggiunto non competentnel titolo
— Khaled.K
0

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

ancora un'altra soluzione c #, solo la seconda più piccola perché ho dichiarato due variabili e quindi non posso usare la sintassi lambda. vabbè, mi sono divertito. :)

spiegazione:

  • spostare la stringa originale, quindi dividere "FORCE" e "FIRST".

  • aggregare i risultati e su ogni divisione, trovare la sottostringa di cinque caratteri utilizzata per dividere la stringa originale utilizzando la lunghezza finora della stringa da aggregare. se era "forza", fallo "prima" e viceversa

  • seleziona tutti i caratteri della stringa di maiuscole appena creata e controlla se la stringa originale era in minuscolo nello stesso indice. in caso affermativo, restituisce il carattere minuscolo in quell'indice nella nuova stringa, altrimenti restituisce il carattere maiuscolo
— sottovento
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.