첫 번째 당신과 함께 할 수 있습니다

19

모든 문자 위치의 원래 대소 문자를 유지하면서 "force"의 모든 발생을 "first"로 바꾸고 "first"의 모든 발생을 "force"로 바꾸는 프로그램을 작성하십시오.

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

나머지 문자열은 변경되지 않아야하므로 프로그램을 두 번 실행하면 원래 문자열이 반환됩니다.

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

프로그램은 모든 초기 문자열에서 작동해야합니다. 힌트로, 마법 문자를 중간 표현으로 사용하지 않는 것이 좋습니다. 3 패스 대체 ( "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
아타 소년. 사람들에게 태그에 승리 기준이 있음을 상기 시키십시오.
— Christopher
1
@ Challenger5 아니오 나는 그렇게 생각하지 않습니다. 왜냐하면 선도 [Ff]가 없다면 단어를 대체해서는 안됩니다.
— Outgolfer Erik
2
먼저 당신과 함께 할 수 있습니다. (5 월 1 일 주석)
— Esolanging Fruit
19
" 네 번째 가 당신과 함께 할 수 있습니까?"
— wizzwizz4
3
@ mbomb007 "fourth"및 "force"는 같은 문자 수를 갖지 않으므로 동일한 문자 대소 문자를 유지하는 데 호환되지 않습니다.
— Cœur

답변:

6

레티 나 , 33 바이트

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

온라인으로 사용해보십시오!

편집 : @MartinEnder 덕분에 5 바이트가 절약되었습니다 Ro.

— 닐
소스
그러나 OP가 내 의견에 답하면 게시물을 게시하려고했습니다. 첫 번째 세트를 재정렬하여 두 번째 바이트가되도록 몇 바이트를 절약 할 수 있습니다 Ro.
— 마틴 엔더
@MartinEnder 설명서 R가 범위에 미치는 영향에 너무 많은주의를 기울임으로써 저를 혼란스럽게했습니다 . 예를 들어 그 실현되지 못했을 RE에 해당 86420당신이 그것을 지적하지 않았다면.
— Neil
알려 줘서 고마워. 문서에서 더 명확하게하려고 노력할 것입니다.
— 마틴 엔더
9

자바 스크립트 (ES6), 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

APL (Dyalog) , 61 바이트

⎕IO←0많은 시스템에서 기본값이 필요합니다 . 대신 유니 코드 기호 를 사용하여 4 자 보다 짧을 수 있습니다 .⍠⎕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 2016 년
4

펄 5 , 52 바이트

51 바이트의 코드 + -p플래그

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

온라인으로 사용해보십시오!

너무 미친 일이 없습니다. 의 발생 찾기 force및 first비 대소 문자 구분을 ( s%force|first%%gi)하고 다른 하나를 변환하는 문자로 변환합니다.

— 다다이즘
소스
3

CJam, 66 바이트

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

"first"와 "force"의 모든 경우 변형을 거쳐 분할하려고합니다. 가능한 경우 반대 단어와 다시 결합합니다.

의사 코드 :

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변경하지 않는 것이 확실합니다 . thirstthorcedivorcedivirst
— Neil
@Neil True, 편집했습니다.
— Esolanging Fruit
— Esolanging 과일
3

자바 7, 318310 바이트

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

좋아, 이것은 Java에서 꽤 어려웠다.

설명:

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("...")).
— Cœur
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)
— 조나단 앨런
소스
Pyth와 Jelly는 동일합니다 : o
— Leaky Nun
골퍼가 있어야합니다 : D
— Jonathan Allan
예, 방금 찾았습니다. D
— Leaky Nun
2

Flex (렉서), 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
— 리치
소스
first.l:3: EOF encountered inside an action(아, 신경 쓰지 마라 : 끝에 줄 바꿈이 필요하다)
— Cœur
ld: library not found for -lfl(오, 신경 쓰지 gcc lex.yy.c -ll마라 , 명령은 macOS에있다)
— Cœur
테스트 및 승인.
— Cœur
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을 사용하여 변환 된 버전으로 바꾸고 다시 문자열로 결합하십시오.

온라인으로 사용해보십시오!

— 퀴 토피아
소스
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]

온라인으로 사용해보십시오

단계별로 세분화 :

  1. S.lower().split("force"): 문자열을 가져 와서 소문자로 통합하고 다음으로 구분 된 하위 문자열로 나눕니다. "force"
  2. s.replace("first","force")for s in <STEP 1>모든 교체 "first"와 함께 '들"force"
  3. _`.join("first".join(<STEP 2>)`[2::5]`_모든 교체 "force"'들과 "first"재결합에 의해 "force"로 묘사 문자열을"first" 단일 문자열로 다시 참가를 (밑줄 표시가 수정 틱 얻기 위해 추가)
  4. zip(<STEP 3>,[(2,1)[l.isupper()]for l in S]): 교체 된 문구의 각 문자를 원래 문자열의 대소 문자 인코딩으로 압축합니다 (소문자 2, 대문자 1)
  5. _`[(t[0],t[0].upper())[t[1]==1]for t in <STEP 4>]`[2::5]`_: 원래 대소 문자를 복원하고 목록을 문자열로 변환합니다 (밑줄이 추가되어 눈금이 올바르게 표시됨)
— wnnmaw
소스
upper는 True로, False는 낮은 값으로 인코딩하여 8 바이트를 절약 할 수 있습니다. 온라인으로 사용해보십시오!
— quintopia
1

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

온라인으로 사용해보십시오!

Kevin Cruijssen의 Java 응답의 직접 포트는 주어진 색인에서 문자열로 문자를 가져올 때 밝혀집니다 .C #은 java보다 훨씬 골퍼입니다 ( s[i++]대신 s.charAt(i++))

— 스키드 데프
소스
1

C #, 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;}
— 레오나르도 라자 노
소스
0

Java, 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")).-> ,zafter String s=""and z=w.toLowerCase();if(z.equals("force")|z.equals("first")). 또한, 'O'할 수있다 79, 'C'할 수 있습니다 67및 'E'수 있습니다 69. 그리고 if else둘 다하므로 하나의 큰 삼항 if-else로 바꿀 수 있습니다 s+=.
— Kevin Cruijssen
예를 들어 "forceforce"에서 실패하므로이 솔루션이 적합하지 않다는 것을 확인했습니다.
— Cœur
@ Cœur non competent제목에 추가 한
— Khaled.K
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"로 나눕니다.

  • 결과를 집계하고 분할 할 때마다 집계되는 문자열의 길이를 사용하여 원래 문자열을 분할하는 데 사용 된 5 문자 하위 문자열을 찾으십시오. "강제"인 경우 "첫 번째"로 설정하고 그 반대의 경우도 마찬가지입니다.

  • 새로 만든 모든 대문자 문자열의 모든 문자를 선택하고 원래 문자열이 동일한 색인에서 소문자인지 확인하십시오. 그렇다면 새 문자열의 해당 색인에서 소문자를 반환하고, 그렇지 않으면 대문자를 반환
— 남자 이름
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.