Que le premier soit avec toi

19

Écrivez un programme pour remplacer toutes les occurrences de "force" par "premier" et toutes les occurrences de "premier" par "force", en conservant la casse d'origine pour toutes les positions de caractères:

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

Le reste de la chaîne doit rester inchangé, et donc exécuter votre programme deux fois retournera la chaîne d'origine:

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

Votre programme devrait fonctionner sur n'importe quelle chaîne initiale. Donc, à titre indicatif, vous feriez mieux d'éviter d'utiliser des caractères magiques comme représentation intermédiaire, car si vous essayez un remplacement en trois passes ( "force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first"), il échouera sur les chaînes contenant "zzzzz".

Vous devez prendre en charge la plage complète de caractères autorisée dans une définition d'une chaîne par votre langage de programmation (dans la plupart des cas, c'est Unicode). Exemple, utilisation d'une représentation de style JSON pour les caractères non imprimables (\ u + 4 chiffres):

"\u0000\u0001\u0002\u0003the Force of the firsT"
                     |
                     V
"\u0000\u0001\u0002\u0003the First of the forcE"
code-golf  string 
— Cœur
source
1
Atta boy. Rappelez aux gens que le tag a le critère gagnant '
— Christopher
1
@ Challenger5 Non, je ne pense pas, car si le premier [Ff]n'est pas là, vous ne devez pas remplacer le mot.
— Erik the Outgolfer
2
Peut être d'abord avec vous. (Commenté le 1er mai)
— Esolanging Fruit
19
Cela ne devrait-il pas être "que le quatrième soit avec vous"?
— wizzwizz4
3
@ mbomb007 "quatrième" et "force" n'ont pas le même nombre de lettres, ce qui le rend incompatible pour conserver la même casse de caractères.
— Cœur

Réponses:

6

Rétine , 33 octets

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

Essayez-le en ligne!

Edit: 5 octets enregistrés grâce à @MartinEnder pour avoir souligné ce qui se Ropasse.

— Neil
source
Oui, j'allais poster une fois que le PO répondra à mon commentaire. Vous pouvez enregistrer quelques octets en réorganisant le premier ensemble afin que le second puisse être Ro.
— Martin Ender
@MartinEnder La documentation m'a dérouté en accordant trop d'attention à Rl'effet sur les plages; par exemple, je n'aurais jamais réalisé que cela REéquivaut à 86420si vous ne l'aviez pas souligné.
— Neil
Merci de me le faire savoir. Je vais essayer de clarifier cela dans les documents.
— Martin Ender
9

JavaScript (ES6), 93 88 octets

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>
Développer l'extrait

Edit: économisé 5 octets en optimisant la casse des lettres inchangée.

— Neil
source
5

APL (Dyalog) , 61 octets

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes. Peut être quatre caractères plus court en utilisant le symbole Unicode ⍠au lieu de ⎕OPT .

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

Essayez-le en ligne!

— Adam
source
4

PHP, 88 octets

Versions en ligne

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

PHP, 110 octets

<?=preg_replace_callback("#first|force#i",function($t){return strtr($t[0],iIsStToOcCeE,oOcCeEiIsStT);},$argn);
— Jörg Hülsermann
source
3
Vous pouvez enregistrer quelques octets avec $t[0]^first^forceau lieu de strtr().
— user63956
@ user63956 Merci pour l'effort d'apprentissage
— Jörg Hülsermann
4

Perl 5 , 52 octets

51 octets de code + -pindicateur.

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

Essayez-le en ligne!

Rien de trop fou. Recherchez les occurrences de forceet firstnon sensibles à la casse ( s%force|first%%gi), puis translittérez les caractères pour les convertir l'un en l'autre.

— Dada
source
3

CJam, 66 octets

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

Parcourt chaque variation de cas de "premier" et "force" et essaie de se diviser dessus. S'il le peut, il le rejoint ensuite avec les mots inverses.

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: \*
— Esolanging Fruit
source
Assurément, fest-il pertinent d'éviter de changer thirsten thorceou divorceen divirst?
— Neil
@Neil True, édité.
— Esolanging Fruit
— Esolanging Fruit
3

Java 7, 318 310 octets

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, c'était assez dur en Java ..

Explication:

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

Code de test:

Essayez-le ici.

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

Production:

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
source
1
J'apprécie que vous ayez fourni un exemple symétrique c(c("..."))!
— Cœur
3

Gelée , 37 36 octets

Existe-t-il un moyen d'utiliser une réduction sur des tranches de longueur 5 à la place?

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

Essayez-le en ligne!

Comment?

®‘©ị“Ɓ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
source
Pyth et Jelly sont égaux: o
— Leaky Nun
Il doit y avoir une voie golfeur: D
— Jonathan Allan
Oui, et je viens de le trouver: D
— Leaky Nun
2

MATL , 47 octets

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

Essayez-le en ligne!

Cela utilise des valeurs négatives comme étape intermédiaire et après les deux passes, il prend la valeur absolue.

— Luis Mendo
source
2

Pyth , 36 35 octets

K"first"srVjJ"force"mjKcdJcr0QKqVr1

Essayez-le en ligne!

Pyth n'est pas particulièrement bon pour les manipulations de chaînes.

— Leaky Nun
source
pourtant, vous détenez actuellement la deuxième place
— Cœur
2

Flex (lexer), 72 octets

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

Pour compiler et exécuter:

flex first.l
gcc lex.yy.c -lfl # -ll on Macs, apparently
./a.out
— rici
source
first.l:3: EOF encountered inside an action(oh, peu importe: il faut une nouvelle ligne à la fin)
— Cœur
ld: library not found for -lfl(oh tant pis, la commande est gcc lex.yy.c -llsur macOS)
— Cœur
Testé et approuvé.
— Cœur
2

Python 2, 171 octets

Je voulais essayer de le faire en utilisant des intégrés, mais cela ne peut pas battre la méthode désordonnée avec tous les fractionnements et zips.

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)

Je pense que c'est assez clair ce que je fais ici. Fractionnez la chaîne sur les instances de first et force (insensible à la casse), remplacez ces instances par des versions traduites à l'aide de str.translate et joignez-la à nouveau dans une chaîne.

Essayez-le en ligne!

— quintopie
source
2

Python 2.7, 173 165 octets

8 octets enregistrés par quintopia

Celui-ci est devenu grossier:

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]

Essayez-le en ligne

Décomposer étape par étape:

  1. S.lower().split("force"): prendre la chaîne, unifier en minuscules, diviser en sous-chaînes séparées par "force"
  2. s.replace("first","force")for s in <STEP 1>: Remplacez tous "first"par"force"
  3. _`.join("first".join(<STEP 2>)`[2::5]`_: remplacez tous "force"les éléments "first"par en recombinant les "force"sous-chaînes délimitées avec "first"et rejoignez-les en une seule chaîne (les traits de soulignement sont ajoutés pour obtenir des graduations correctes)
  4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): compresser chaque caractère de la phrase remplacée avec l'encodage en casse de la chaîne d'origine (2 pour les minuscules, 1 pour les majuscules)
  5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: Restaurer le boîtier d'origine, convertit la liste en chaîne (soulignements ajoutés pour obtenir des graduations correctes)
— wnnmaw
source
Vous pouvez économiser 8 octets en encodant supérieur en Vrai et inférieur en Faux: Essayez-le en ligne!
— quintopie
2

C (bruit) , 201 183 226 214 octets

Eu quelques bugs ... Il faut encore beaucoup de golf

(sauvé 12 grâce au plafond)

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

Essayez-le en ligne!

— cleblanc
source
— plafondcat
1

C # 273 octets

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

Essayez-le en ligne!

Le port direct de la réponse Java de Kevin Cruijssen , s'avère quand il s'agit d'obtenir le caractère dans une chaîne à un index donné, C # est beaucoup plus golfique que java ( s[i++]au lieu de s.charAt(i++))

— Skidsdev
source
1

C #, 235 caractères

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
source
0

Java, 382 octets non-comptent

Essayez en ligne

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
source
3
Hmm, cela ne fonctionne que si tous les mots sont divisés par des espaces, mais qu'en est-il des virgules ou des chaînes étranges "The first, force,|first'forced!"? De plus, vous pouvez jouer un peu à votre code actuel: if(w.equalsIgnoreCase("force")|w.equalsIgnoreCase("first"))-> ,zaprès String s=""et z=w.toLowerCase();if(z.equals("force")|z.equals("first")). Aussi, 'O'peut être 79, 'C'peut être 67et 'E'peut être 69. Et le if elsepeut être remplacé par un grand if-else ternaire, car les deux le font s+=.
— Kevin Cruijssen
Je confirme que cette solution n'est pas admissible, car elle échoue sur "forceforce" par exemple.
— Cœur
@ Cœur que j'ai ajouté non competentdans le titre
— Khaled.K
0

C # (269 octets)

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

encore une autre solution c #, seulement la deuxième plus petite parce que j'ai déclaré deux variables et que je ne peux donc pas utiliser la syntaxe lambda. eh bien, je me suis amusé. :)

explication:

  • augmenter la chaîne d'origine, puis diviser sur "FORCE" et "FIRST".

  • agréger les résultats et à chaque fractionnement, recherchez la sous-chaîne de cinq caractères qui a été utilisée pour fractionner la chaîne d'origine en utilisant la longueur jusqu'à présent de la chaîne agrégée. si c'était "force", faites-le "en premier" et vice versa

  • sélectionnez tous les caractères de la chaîne de majuscules nouvellement créée et vérifiez si la chaîne d'origine était en minuscules au même index. si oui, retournez le caractère en minuscule à cet index dans la nouvelle chaîne, sinon retournez le caractère en majuscule
— Lee
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.