19

"बल" की सभी घटनाओं को "पहले" के साथ बदलने और "बल" के साथ "पहले" की सभी घटनाओं को बदलने के लिए एक कार्यक्रम लिखें, सभी चरित्र पदों के लिए मूल मामला रखते हुए:

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

स्ट्रिंग के बाकी हिस्सों को अपरिवर्तित रहना चाहिए, और इसलिए आपके प्रोग्राम को दो बार चलाने से मूल स्ट्रिंग वापस आ जाएगी:

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

आपका प्रोग्राम किसी भी प्रारंभिक स्ट्रिंग पर काम करना चाहिए। एक संकेत के रूप में, आप बेहतर रूप से जादू पात्रों को मध्यवर्ती प्रतिनिधित्व के रूप में उपयोग करने से बचते हैं, क्योंकि यदि आप तीन पास प्रतिस्थापन ( "force" -> "zzzzz", "first" -> "force", "zzzzz" -> "first") की कोशिश करते हैं, तो यह युक्त तारों पर विफल हो जाएगा "zzzzz"।

आपको अपनी प्रोग्रामिंग भाषा द्वारा स्ट्रिंग की परिभाषा में अनुमत वर्णों की पूरी श्रृंखला का समर्थन करना चाहिए (ज्यादातर मामलों में, यह यूनिकोड है)। गैर-मुद्रण योग्य वर्ण (\ u + 4 अंक) के लिए JSON- शैली प्रतिनिधित्व का उपयोग करते हुए उदाहरण:

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

code-golf string

— कोयूर
स्रोत

1

अट्टा लड़का। लोगों को याद दिलाएं कि टैग जीतने की कसौटी है '

— क्रिस्टोफर

1

@ चैलेंजर 5 नहीं मुझे ऐसा नहीं लगता है क्योंकि यदि अग्रणी [Ff]नहीं है तो आपको शब्द को प्रतिस्थापित नहीं करना चाहिए।

— बजे द एग्रीग्राफर

2

मई पहले आपके साथ हो सकता है। (1 मई को टिप्पणी की गई)

— बजे फल खाना

19

यह " आपके साथ चौथा हो सकता है" नहीं होना चाहिए ?

— wizzwizz4

3

@ mbomb007 "चौथा" और "बल" में समान वर्णों को रखने के लिए असंगत नहीं होने से अक्षरों की समान संख्या नहीं है।

— कोयूर

6

रेटिना , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

संपादित करें: सहेजे गए 5 बाइट्स @MartinEnder को इंगित करने के लिए कि क्या Roकरता है।

— नील
स्रोत

हां, एक बार ओपी मेरी टिप्पणी का जवाब देने जा रहा था। आप पहले सेट को फिर से व्यवस्थित करके कुछ बाइट्स बचा सकते हैं ताकि दूसरा हो Ro।

— मार्टिन एंडर

@MartinEnder Rरेंज पर प्रभाव पर बहुत अधिक ध्यान देकर प्रलेखन ने मुझे भ्रमित किया ; उदाहरण के लिए मुझे कभी भी यह एहसास नहीं होता कि REयह बराबर है 86420यदि आपने इसे इंगित नहीं किया है।

— नील

मुझे बताने के लिए धन्यवाद। मैं डॉक्स में स्पष्ट करने की कोशिश करूंगा।

— मार्टिन एंडर

9

जावास्क्रिप्ट (ईएस 6), 93 88 बाइट्स

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>

स्निपेट का विस्तार करें

संपादित करें: अपरिवर्तित पत्र मामले को अनुकूलित करके 5 बाइट्स सहेजे गए।

— नील
स्रोत

5

एपीएल (डायलॉग) , 61 बाइट्स

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है। इसके बजाय यूनिकोड प्रतीक का उपयोग करके चार वर्णों को छोटा किया जा सकता ⍠है ⎕OPT ।

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

इसे ऑनलाइन आज़माएं!

— एडम
स्रोत

4

PHP, 88 बाइट्स

ऑनलाइन संस्करण

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

PHP, 110 बाइट्स

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

— जार्ग हुल्सरमैन
स्रोत

3

आप के $t[0]^first^forceबजाय के साथ कुछ बाइट्स बचा सकता है strtr()।

— user63956

@ user63956 सीखने के प्रयास के लिए धन्यवाद

— Jörg Hülsermann

4

पर्ल 5 , 52 बाइट्स

कोड + -pध्वज के 51 बाइट्स ।

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

इसे ऑनलाइन आज़माएं!

कुछ भी पागल नहीं चल रहा है। forceऔर firstगैर-केस-संवेदी ( s%force|first%%gi) की घटनाओं का पता लगाएं , और फिर एक को दूसरे में बदलने के लिए वर्णों को बदल देता है।

— बापू
स्रोत

3

सीजेएम, 66 बाइट्स

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

"पहले" और "बल" के हर मामले की भिन्नता से गुजरता है और उस पर विभाजित होने की कोशिश करता है। यदि यह हो सकता है, तो यह उल्टे शब्दों के साथ वापस जुड़ता है।

स्यूडोकोड:

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: \*

— फल तोड़ना
स्रोत

निश्चित रूप से fबदल रहा से बचने के लिए प्रासंगिक है thirstमें thorceया divorceमें divirst?

— नील

@ नील सच, संपादित

— फल तोड़कर

@ C @ur इसे ऑनलाइन आज़माएं!

— फल तोड़ना

3

जावा 7, 318 310 बाइट्स

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

ठीक है, यह जावा में बहुत कठिन था ..

स्पष्टीकरण:

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

टेस्ट कोड:

इसे यहाँ आज़माएँ।

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

आउटपुट:

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

— केविन क्रूज़सेन
स्रोत

1

मैं सराहना करता हूं कि आपने एक सममित उदाहरण प्रदान किया है c(c("..."))!

— कोयूर

3

जेली , 37 36 बाइट्स

क्या इसके बजाय लंबाई 5 के स्लाइस में कमी का उपयोग करने का एक तरीका है?

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

इसे ऑनलाइन आज़माएं!

कैसे?

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

— जोनाथन एलन
स्रोत

पायथ और जेली समान हैं: ओ

— लीकी नून

एक गोल्फ रास्ता होना चाहिए: D

— जोनाथन एलन

हां, और मुझे यह पता चला: डी

— लीक नून

2

MATL , 47 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह मध्यवर्ती चरण के रूप में नकारात्मक मूल्यों का उपयोग करता है, और दो पास होने के बाद यह पूर्ण मूल्य लेता है।

— लुइस मेंडो
स्रोत

2

पायथ , 36 35 बाइट्स

K"first"srVjJ"force"mjKcdJcr0QKqVr1

इसे ऑनलाइन आज़माएं!

पायल स्ट्रिंग जोड़तोड़ में विशेष रूप से अच्छा नहीं है।

— लीक नन
स्रोत

फिर भी, आप वर्तमान में दूसरे स्थान पर हैं

— Cœur

2

फ्लेक्स (लेक्सर), 72 बाइट्स

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

संकलन और चलाने के लिए:

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

— rici
स्रोत

first.l:3: EOF encountered inside an action(ओह, कभी नहीं: यह अंत में एक नई पंक्ति की आवश्यकता है)

— C

ld: library not found for -lfl(ओह, कोई बात नहीं, कमांड gcc lex.yy.c -llmacOS पर है)

— C

परीक्षण किया और अनुमोदित किया गया।

— कूर

2

पायथन 2, 171 बाइट्स

मैं बिल्ट-इन का उपयोग करके ऐसा करने की कोशिश करना चाहता था, लेकिन यह सभी विभाजन और ज़िपिंग के साथ गन्दा तरीका नहीं हरा सकता है।

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)

मुझे लगता है कि यह बहुत स्पष्ट है कि मैं यहाँ क्या कर रहा हूँ। पहले और बल के उदाहरणों पर स्ट्रिंग को विभाजित करें (केस-असंवेदनशील), उन उदाहरणों को str.translate का उपयोग करके अनुवादित संस्करणों से बदलें, और इसे फिर से एक स्ट्रिंग में शामिल करें।

इसे ऑनलाइन आज़माएं!

— quintopia
स्रोत

2

पायथन 2.7, 173 165 बाइट्स

क्विंटोपिया द्वारा बचाए गए 8 बाइट्स

यह एक सकल है:

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]

इसे ऑनलाइन आज़माएं

इसे चरण दर चरण तोड़ना:

S.lower().split("force"): स्ट्रिंग लें, निचले हिस्से को एकजुट करें, द्वारा अलग किए गए सब्सट्रिंग्स में विभाजित करें "force"
s.replace("first","force")for s in <STEP 1>: सभी "first"के साथ बदलें"force"
_`.join("first".join(<STEP 2>)`[2::5]`_: सभी को प्रतिस्थापित के "force"साथ पुनर्वितरित पदार्थों को "first"पुनर्संयोजित करके प्रतिस्थापित "force"करें"first" एकल स्ट्रिंग में और rejoin को (अंडरस्कोर टिक पाने के लिए के निशान को सही जोड़ा)
zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): मूल स्ट्रिंग के केस एन्कोडिंग (लोअरकेस के लिए 2, अपरकेस के लिए 1) के साथ ज़िपित वर्ण के प्रत्येक वर्ण को ज़िप करें
_`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: मूल आवरण को पुनर्स्थापित करें, सूची को स्ट्रिंग में परिवर्तित करें (टिक के निशान को सही करने के लिए अंडरस्कोर जोड़ा गया)

— wnnmaw
स्रोत

आप ऊपरी बाइट के रूप में 8 बाइट्स को ट्रू के रूप में एन्कोडिंग द्वारा सहेज सकते हैं और गलत के रूप में कम कर सकते हैं

— क्विंटोपिया

2

सी (क्लैंग) , 201 183 226 214 बाइट्स

कुछ कीड़े थे ... अभी भी काफी नीचे गोल्फ की जरूरत है

(सेविंग के लिए 12 धन्यवाद)

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

इसे ऑनलाइन आज़माएं!

— cleblanc
स्रोत

199 बाइट्स

— छत

1

सी # 273 बाइट्स

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

इसे ऑनलाइन आज़माएं!

केविन क्रूज़सेन के जावा उत्तर का सीधा पोर्ट , यह बताता है कि जब किसी दिए गए इंडेक्स में स्ट्रिंग में चार को प्राप्त करने की बात आती है, तो C # java ( s[i++]बजाय s.charAt(i++))

— Skidsdev
स्रोत

1

Japt , 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काफी छोटा होगा अगर जाप में एक साने ट्रांसलेटेड फंक्शन हो ...

वैकल्पिक संस्करण:

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

इसे ऑनलाइन आज़माएं!

— ETHproductions
स्रोत

1

सी #, 235 वर्ण

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

— लियोनार्डो लेज़ानो
स्रोत

1

रूबी , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— मूल्य स्याही
स्रोत

0

जावा, 382 बाइट नॉन-कॉम्पिटेंट

ऑनलाइन प्रयास करें

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
स्रोत

3

हम्म, यह केवल तभी काम करता है जब सभी शब्दों को रिक्त स्थान से विभाजित किया जाता है, लेकिन कॉमा, या अजीब तार के बारे में क्या "The first, force,|first'forced!"? इसके अलावा, आप अपने वर्तमान कोड को थोड़ा सा गोल्फ कर सकते हैं: if(w.equalsIgnoreCase("force")|w.equalsIgnoreCase("first"))-> के ,zबाद String s=""और z=w.toLowerCase();if(z.equals("force")|z.equals("first"))। इसके अलावा, 'O'हो सकता है 79, 'C'हो सकता है 67और 'E'हो सकता है 69। और if elseअगर दोनों करते हैं, तो एक और बड़े टर्नरी के साथ प्रतिस्थापित किया जा सकता है s+=।

— केविन क्रूज़सेन

मैं पुष्टि करता हूं कि यह समाधान योग्य नहीं है, क्योंकि यह उदाहरण के लिए "फोर्सफोर्स" पर विफल है।

— कोयूर

@ non competent

— C @ur

0

C # (269 बाइट्स)

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 # समाधान, केवल दूसरा सबसे छोटा क्योंकि मैंने दो चर घोषित किए और इसलिए लंबोदर सिंटैक्स का उपयोग नहीं कर सकता। ओह ठीक है, मुझे मज़ा आया था। :)

स्पष्टीकरण:

मूल स्ट्रिंग को ऊपर उठाएं, फिर "FORCE" और "FIRST" पर विभाजित करें।
परिणामों को एकत्र करें और प्रत्येक विभाजन पर, पांच-वर्ण प्रतिस्थापन को ढूंढें जो मूल स्ट्रिंग को विभाजित करने के लिए उपयोग किया गया था जो कि स्ट्रिंग के एकत्र होने तक अब तक की लंबाई का उपयोग कर रहा है। अगर यह "बल" था, तो इसे "पहले" और इसके विपरीत बनाओ
नए बनाए गए सभी कैप्स स्ट्रिंग के सभी पात्रों का चयन करें और जांचें कि क्या मूल स्ट्रिंग एक ही इंडेक्स में कम थी। यदि हाँ, तो नए स्ट्रिंग में उस इंडेक्स पर निचला चरित्र लौटाएँ, अन्यथा अपरकेस वर्ण वापस लौटाएँ

— ली
स्रोत

पहले तुम्हारे साथ हो सकता है

रेटिना , 33 बाइट्स

जावास्क्रिप्ट (ईएस 6), 93 88 बाइट्स

एपीएल (डायलॉग) , 61 बाइट्स

PHP, 88 बाइट्स

PHP, 110 बाइट्स

पर्ल 5 , 52 बाइट्स

सीजेएम, 66 बाइट्स

जावा 7, 318 310 बाइट्स

जेली , 37 36 बाइट्स

कैसे?

MATL , 47 बाइट्स

पायथ , 36 35 बाइट्स

फ्लेक्स (लेक्सर), 72 बाइट्स

पायथन 2, 171 बाइट्स

पायथन 2.7, 173 165 बाइट्स

सी (क्लैंग) , 201 183 226 214 बाइट्स

सी # 273 बाइट्स

Japt , 41 बाइट्स

सी #, 235 वर्ण

रूबी , 55 बाइट्स

जावा, 382 बाइट नॉन-कॉम्पिटेंट