Biorąc pod uwagę adres e-mail, wynik transformacji zastosowanej do tego adresu e-mail oraz drugi adres e-mail zwracają wynik tej samej transformacji zastosowanej do drugiego adresu e-mail.

Wszystkie adresy e-mail będą miały następującą strukturę:

Ciąg o długości dodatniej zawierający znaki alfanumeryczne i co najwyżej jeden .(część lokalna), po którym następuje @symbol, po czym ciąg o długości dodatniej zawierający alfanumeryczne znaki sumboliczne (dziedzina), po którym następuje .symbol i ostatni ciąg o długości dodatniej zawierający znaki alfanumeryczne (TLD).

Możliwe są cztery transformacje:

• Tożsamość (bez zmian). ( a.b@c.d -> a.b@c.d)
• Zwracanie tylko części lokalnej (wszystko przed @) niezmodyfikowanej ( a.b@c.d -> a.b).
• Zwracanie części lokalnej podzielonej na „ .jeśli jest obecny”, z pierwszym symbolem każdej połowy pisanym wielkimi literami. ( a.b@c.d -> A B).
• Zwracanie tylko domeny (wszystko między @ostatecznym .) niezmodyfikowanym. ( a.b@c.d -> c).

Gdy możliwa jest więcej niż jedna transformacja, możesz dać wynik dowolnej z możliwości. Białe spacje na początku i na końcu wyjścia nie mają znaczenia, ale na środku ma to znaczenie (tzn. Jeśli podzielisz się a.bna A B, powinna być tylko jedna spacja na środku [i dowolna liczba na początku i na końcu wyjścia], ale jeśli podzielisz a., wówczas Adowolna liczba spacji po obu stronach jest akceptowalna).

Przykłady ( 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

Obowiązują zwykłe zasady i luki.

Java 8, 254 240 236 bajtów

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

-4 bajty dzięki @LukeStevens .

Wyjaśnienie:

Wypróbuj tutaj.

(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

Haskell , 208 bajtów

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]

Wypróbuj online!

To smutne, że musiałem wydać 59 bajtów na ponowne wynalezienie split( s).

Rozwiązanie tworzy listę przekształceń i zwraca pierwszą, która prowadzi do oczekiwanego wyniku.

Galaretka , 40 bajtów

^{Uprzedzające dzięki Erikowi Outgolferowi za zauważenie niepowodzenia w użyciu Œt(przypadek tytułowy), a co Œu1¦€Kza tym idzieŒtK}

-1 bajt dzięki Erik the Outgolfer (przegrupowanie ⁵⁸ç⁹¤Ŀna çµ⁵⁸Ŀ)

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

Pełną podejmowanie programu exampleEmail, exampleOutput, realEmaili drukowanie wyników.

Wypróbuj online!

W jaki sposób?

Wykonuje wszystkie cztery transformacje (plus prekursor), znajduje pierwszą, która daje przykład z pierwszego e-maila, a następnie stosuje go do drugiego e-maila:

            - 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

Uwagi:

1. Zakłada, że ​​przykład wejściowy Wyjście jest dokładnie taki sam, jak wynik wyjściowy.

2. „Prekursor” (wynik linku 3) jest testowany pod kątem dopasowania exampleOutput, ale nie będzie pasował, dopóki exampleOutputsam nie będzie listą znaków. Jako takie dane wejściowe powinny być prawdopodobnie cytowane (tutaj można zastosować formatowanie w języku Python), aby uniknąć możliwości ich interpretacji jako takiej.

Python 2 , 135 bajtów

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

Wypróbuj online!

JavaScript (ES6), 145 bajtów

Wywołaj ze składnią curry, np 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 bajtów

(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]]]])&

Wypróbuj online!

Ruby , 117 106 102 bajtów

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

Wypróbuj online!

CJam, 42

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

Wypróbuj online

Wyjaśnienie:

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 bajtów

<?$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])))));

Wypróbuj online!

PHP <7.1, 180 bajtów

Wersje poniżej 7.1 musiałyby zmienić [,$p,$q,$r]=$argvTO list(,$p,$q,$r)=$argv, dodając 4 bajty.

GNU sed , 105 + 1 (flaga r) = 106 bajtów

Pierwsze trzy spolecenia sprawdzają odpowiednio tożsamość , część lokalną i transformacje domeny . Jeśli jedna transformacja jest zgodna, jest ona stosowana do drugiego adresu e-mail, a następujące spolecenia zakończą się niepowodzeniem z powodu braku formatu wejściowego.

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

Wypróbuj online!

Lokalny część podzielonego transformacja (ostatnia skomenda) jest najdroższym, by sprawdzić, w kategoriach bajtów, dlatego umieściłem go na końcu i zakłada się, że pasuje (ponieważ inni nie udało w tym czasie), przechodząc bezpośrednio do jego stosowania.

Galaretka , 43 bajty

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

Wypróbuj online!