전자 메일 주소, 해당 전자 메일 주소에 적용된 변환 결과 및 두 번째 전자 메일 주소는 두 번째 전자 메일 주소에 적용된 동일한 변환의 출력을 반환합니다.

이메일 주소는 모두 다음과 같은 구조를 갖습니다.

영숫자 문자를 포함하는 양의 길이의 문자열, 최대 하나 .(로컬 부분), 그 뒤에 @기호, 영숫자 sumbol (도메인)을 포함하는 양의 길이 문자열, .기호, 기호 및 양의 길이의 마지막 문자열 영숫자 (TLD)를 포함합니다.

허용되는 네 가지 변환이 있습니다.

• 정체성 (변화 없음). ( a.b@c.d -> a.b@c.d)
• 로컬 부분 만 @( a.b@c.d -> a.b) 앞에있는 모든 부분을 수정하지 않고 반환합니다 ( ).
• .if 의 로컬 부분 분할을 반환하고 각 절반의 첫 번째 기호는 대문자로 표시합니다. ( a.b@c.d -> A B).
• 단지 (사이의 모든 도메인 반환 @및 최종 .수정되지 않은 참조). ( a.b@c.d -> c).

둘 이상의 변환이 가능한 경우 모든 가능성의 결과를 제공 할 수 있습니다. 시작과 출력의 끝에 공백은 상관 없어,하지만 당신은 분할하면 중간에 (즉 않습니다 a.b에 A B당신이 분할하는 경우가 중간 [와 시작과 출력의 끝에 임의의 숫자]에서 하나 개의 공간해야하지만, a.그런 다음 A양쪽에 공백이 있으면 허용됩니다.

예 ( input | output) :

john.doe@gmail.com, John Doe, phillip.maini@gmail.com         | Phillip Maini
John.Doe@gmail.com, John Doe, Phillip.Maini@gmail.com         | Phillip Maini
foo.bar@hotmail.com, foo.bar, gee.whizz@outlook.com           | gee.whizz
foo.bar@hotmail.com, foo.bar, gEe.Whizz@outlook.com           | gEe.Whizz
rodney.dangerfield@comedy.net, comedy, michael.scott@office.0 | office
.jones@x.1, Jones, a.@3.z                                     | A
.jones@x.1, .jones@x.1, a.@3.z                                | a.@3.z
.jones@x.1, .jones, a.@3.z                                    | a.
.jones@x.1, x, a.@3.z                                         | 3
.@b.c, .@b.c, 1@2.3                                           | 1@2.3
john.jones@f.f, John Jones, 1in.thehand@2inthe.bush           | 1in Thehand
chicken.soup@q.z, Chicken Soup, fab@ulou.s                    | Fab
lange@haare.0, lange, fat.so@fat.net                          | fat.so
Lange@haare.0, Lange, fat.so@fat.net                          | {fat.so, Fat So} # either acceptable
chicken@chicken.chicken, chicken, horse@pig.farm              | {horse, pig} # either acceptable

일반적인 규칙과 허점이 적용됩니다.

자바 8, 254 240 236 바이트

(a,b,c)->{String A[]=a.split("@"),C[]=c.split("@"),x="";for(String p:C[0].split("\\."))x+=(p.charAt(0)+"").toUpperCase()+p.substring(1)+" ";return a.equals(b)?c:A[0].equals(b)?C[0]:A[1].split("\\.")[0].equals(b)?C[1].split("\\.")[0]:x;}

@LukeStevens 덕분에 -4 바이트 .

설명:

여기에서 시도하십시오.

(a,b,c)->{                  // Method with three String parameters and String return-type
  String A[]=a.split("@"),  //  Split `a` by "@" into two parts
         C[]=c.split("@"),  //  Split `c` by "@" into two parts
         x="";              //  Temp-String
  for(String p:C[0].split("\\.")) 
                            //  Loop over the first part of `c`, split by dots
    x+=                     //   Append String `x` with:
       (p.charAt(0)+"").toUpperCase()
                            //    The first character as uppercase
       +p.substring(1)      //    + the rest of the String
       +" ";                //    + a space
                            //  End of loop (implicit / single-line body)
  return a.equals(b)?       //  If input `a` and `b` are exactly the same:
    c                       //   Return `c`
   :A[0].equals(b)?         //  Else-if the first part of `a` equals `b`:
    C[0]                    //   Return the first part of `c`
   :A[1].split("\\.)[0].equals(b)?
                            //  Else-if the domain of `a` equals `b`
    C[1].split("\\.)[0]     //   Return the domain of `c`
   :                        //  Else:
    x;                      //   Return String `x`
}                           // End of method

하스켈 , 208 바이트

import Data.Char
s c""=[]
s c a=w:f t where
 (w,t)=span(/=c)a
 f(_:y)=s c y
 f _=[]
h=head
u""=""
u(x:y)=toUpper x:y
l=h.s '@'
f x y=h[t|t<-[id,l,unwords.filter(/="").map u.s '.'.l,h.s '.'.last.s '@'],t x==y]

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

재발 명에 59 바이트를 소비해야했던 것이 슬프다 split( s).

솔루션은 변환 목록을 작성하고 첫 번째 변환 결과를 리턴합니다.

젤리 , 40 바이트

^{선제 덕분에 에릭 Outgolfer 사용의 실패 몰래에 대한 Œt(타이틀의 경우) 따라서 Œu1¦€K이상ŒtK}

-1 바이트 덕분 에릭 Outgolfer (재배치 ⁵⁸ç⁹¤Ŀ에 çµ⁵⁸Ŀ)

ÑṪṣ”.Ḣ
ṣ”@
ÇḢ
Çṣ”.Œu1¦€K
⁹ĿðЀ5i
çµ⁵⁸Ŀ

전체 프로그램의 촬영은 exampleEmail, exampleOutput, realEmail그 결과를 인쇄.

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

어떻게?

네 가지 변환 (전조 변환)을 모두 수행하고 첫 번째 이메일에서 예제를 생성하는 첫 번째 변환을 찾은 다음 두 번째 이메일에 적용합니다.

            - Link 1, do nothing: email
            - do nothing but return the input

ÑṪṣ”.Ḣ      - Link 2, the domain: email
Ñ           - call the next link (3) as a monad (split at "@")
 Ṫ          - tail
  ṣ”.       - split at "."
     Ḣ      - head

ṣ”@         - Link 3, split at @: email
ṣ”@         - split at "@"

ÇḢ          - Link 4, local part: email
Ç           - call the last link (3) as a monad (split at "@")
 Ḣ          - head

Çṣ”.Œu1¦€K  - Link 5, name-ified: email
Ç           - call the last link (4) as a monad (get the local part)
 ṣ”.        - split at "."
       ¦€   - for €ach sparsley apply:
      1     - ...to index: 1
    Œu      - ...action: uppercase
         K  - join with space(s)

⁹ĿðЀ5i     - Link 6, index of first correct link: exampleEmail; exampleOutput
   Ѐ5      - map across (implicit range of) 5 (i.e. for each n in [1,2,3,4,5]):
  ð         -   dyadicly (i.e. with n on the right and exampleEmail on the left):
 Ŀ          -     call referenced link as a monad:
⁹           -     ...reference: chain's right argument, n
      i     - first index of exampleOutput in the resulting list

çµ⁵⁸Ŀ       - Main link: exampleEmail; exampleOutput
ç           -   call the last link (6) as a dyad (get the first "correct" link index)
 µ          - monadic chain separation (call that L)
   ⁸        - chain's left argument, L
    Ŀ       - call the link at that reference as a monad with input:
  ⁵         -   program's third input, realEmail

노트:

1. 입력 예제 출력이 출력과 완전히 동일하다고 가정합니다.

2. "precursor"(링크 3의 결과)는와 일치하는지 테스트 exampleOutput되었지만 exampleOutput자체가 문자 목록 이 아닌 경우 일치하지 않습니다 . 따라서 입력을 인용 할 수 있으므로 (Python 형식을 여기에서 사용할 수 있음) 해석 할 가능성을 피하십시오.

파이썬 2 , 135 바이트

s,r,x=input()
def f(x):S,D=x.split('@');return x,S,' '.join(map(str.capitalize,S.split('.'))),D.split('.')[0]
print f(x)[f(s).index(r)]

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

자바 스크립트 (ES6), 145 바이트

카레 구문으로 호출하십시오. 예 : f('chicken.soup@q.z')('Chicken Soup')('fab@ulou.s')

x=>y=>[x=>x,s=x=>x.split`@`[0],x=>s(x).split`.`.map(w=>w&&w[0].toUpperCase()+w.slice(1)).join` `.trim(),x=>/@(.+)\./.exec(x)[1]].find(f=>f(x)==y)

f=x=>y=>[x=>x,s=x=>x.split`@`[0],x=>s(x).split`.`.map(w=>w&&w[0].toUpperCase()+w.slice(1)).join` `.trim(),x=>/@(.+)\./.exec(x)[1]].find(f=>f(x)==y)

for(const [x, y, z] of [
['john.doe@gmail.com', 'John Doe', 'phillip.maini@gmail.com'], // Phillip Maini
['John.Doe@gmail.com', 'John Doe', 'Phillip.Maini@gmail.com'], // Phillip Maini
['foo.bar@hotmail.com', 'foo.bar', 'gee.whizz@outlook.com'], // gee.whizz
['foo.bar@hotmail.com', 'foo.bar', 'gEe.Whizz@outlook.com'], // gEe.Whizz
['rodney.dangerfield@comedy.net', 'comedy', 'michael.scott@office.0'], // office
['.jones@x.1', 'Jones', 'a.@3.z'], // A
['.jones@x.1', '.jones@x.1', 'a.@3.z'], // a.@3.z
['.jones@x.1', '.jones', 'a.@3.z'], // a.
['.jones@x.1', 'x', 'a.@3.z'], // 3
['.@b.c', '.@b.c', '1@2.3'], // 1@2.3
['john.jones@f.f', 'John Jones', '1in.thehand@2inthe.bush'], // 1in Thehand
['chicken.soup@q.z', 'Chicken Soup', 'fab@ulou.s'], // Fab
['lange@haare.0', 'lange', 'fat.so@fat.net'], // fat.so
['Lange@haare.0', 'Lange', 'fat.so@fat.net'], // {fat.so, Fat So} # either acceptable
['chicken@chicken.chicken', 'chicken', 'horse@pig.farm'], // {horse, pig} # either acceptable
]) console.log( f(x)(y)(z) )

Mathematica, 217 바이트

(L=Capitalize;T@x_:=(M=StringSplit)[x,"@"];P@x_:=#&@@T[x];W@x_:=If[StringContainsQ[P@x,"."],StringRiffle@L@M[P@x,"."],L@P@x];Z@x_:=#&@@M[T[x][[2]],"."];If[#==#2,#3,If[#2==P@#,P@#3,If[#2==W@#,W@#3,If[#2==Z@#,Z@#3]]]])&

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

루비 , 117 (106) 102 바이트

->a,b,c{r=[/.*/,/(?<=@)\w*/,/[^@]*/].find{|x|r=c[x];a[x]==b}?r:r.sub(?.," ").gsub(/\b(.)/){$1.upcase}}

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

CJam, 42

q~@{[_\'@/~'./0=\_'.%{(eu\+}%S*]}:T~@a#\T=

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

설명:

q~        read and evaluate the input (given as 3 quoted strings)
@         bring the first string to the top of the stack
{…}:T     define a function T that calculates the 4 transformations of a string:
  [       begin array
  _\      duplicate the string, and swap with the other copy to bring it in the array
           (1st transformation)
  '@/~    split by '@' and put the 2 pieces on the stack
  './0=   split the 2nd piece by '.' and keep the first part
           (4th transformation)
  \_      swap with the piece before '@' and duplicate it
           (2nd transformation)
  '.%     split by '.', removing the empty pieces
  {…}%    transform the array of pieces
    (eu   take out the first character and capitalize it
    \+    prepend it back to the rest
  S*      join the pieces by space
           (3rd transformation)
  ]       end array
~         execute the function on the first string
@a        bring the 2nd string to the top of the stack, and wrap it in an array
#         find the position of this string in the array of transformations
\T        bring the 3rd string to the top and call function T
=         get the transformation from the array, at the position we found before

PHP 7.1, 176 바이트

<?$e=explode;[,$p,$q,$r]=$argv;echo$p==$q?$r:($e('@',$p)[0]==$q?$e('@',$r)[0]:($e('.',$e('@',$p)[1])[0]==$q?$e('.',$e('@',$r)[1])[0]:ucwords(join(' ',$e('.',$e('@',$r)[0])))));

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

PHP <7.1, 180 바이트

7.1 아래 버전은 변경해야 [,$p,$q,$r]=$argv에를 list(,$p,$q,$r)=$argv4 명 바이트를 추가.

GNU sed , 105 + 1 (r 플래그) = 106 바이트

처음 세 s명령은 각각 신원 , 로컬 부분 및 도메인 변환을 확인합니다. 하나의 변환이 일치하면 두 번째 이메일 주소에 적용되며 s입력 형식이 없기 때문에 다음 명령이 실패합니다.

s:^(.*),\1,::
s:(.*)@.*,\1,(.*)@.*:\2:
s:.*@(.*)\..*,\1,.*@(.*)\..*:\2:
s:.*,([^.]*)\.?(.*)@.*:\u\1 \u\2:

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

로컬 부분 분할 변환 (마지막 s명령) 그러므로 나는 그것의 응용 프로그램으로 직접 이동, 마지막에 배치하고 (다른 사람이 그 시간에 의해 실패 이후)이 일치하는 것으로, 바이트의 관점에서, 확인하기가 가장 비싸다.

젤리 , 43 바이트

ḢŒlṣ”.Œu1¦€K
ṣ”@Wẋ4j”@$ḷ/ÇṪṣ”.Ḣ$$4ƭ€
Çiị⁵Ǥ

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