Bei einer gegebenen E-Mail-Adresse geben das Ergebnis einer auf diese E-Mail-Adresse angewendeten Umwandlung und eine zweite E-Mail-Adresse die Ausgabe derselben auf die zweite E-Mail-Adresse angewendeten Umwandlung zurück.

Die E-Mail-Adressen haben alle die folgende Struktur:

Eine Zeichenfolge positiver Länge mit alphanumerischen Zeichen und höchstens einem .(lokaler Teil), gefolgt von einem @Symbol, gefolgt von einer Zeichenfolge positiver Länge mit alphanumerischen Sumbolen (Domäne), gefolgt von einem .Symbol und einer letzten Zeichenfolge positiver Länge mit alphanumerischen Zeichen (die TLD).

Es gibt vier zulässige Transformationen:

• Identität (keine Änderung). ( a.b@c.d -> a.b@c.d)
• Rückgabe nur des lokalen Teils (alles vor dem @) unverändert ( a.b@c.d -> a.b).
• Rückgabe des lokalen Teils aufgeteilt auf den, .falls vorhanden, wobei das erste Symbol jeder Hälfte groß geschrieben wird. ( a.b@c.d -> A B).
• Rückgabe nur der Domain (alles zwischen dem @und dem endgültigen .) unverändert. ( a.b@c.d -> c).

Wenn mehr als eine Transformation möglich ist, können Sie die Ausgabe einer der Möglichkeiten angeben. Leerzeichen am Anfang und Ende der Ausgabe spielen keine Rolle, aber in der Mitte (dh wenn Sie aufteilen a.b, A Bsollte es nur ein Leerzeichen in der Mitte geben [und eine beliebige Zahl am Anfang und Ende der Ausgabe], aber wenn Sie aufteilen a., dann Amit einer beliebigen Anzahl von Leerzeichen auf jeder Seite sind alle akzeptabel).

Beispiele ( 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

Es gelten die üblichen Regeln und Lücken.

Java 8, 254 240 236 Bytes

(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 Bytes dank @LukeStevens .

Erläuterung:

Probieren Sie es hier aus.

(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 Bytes

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]

Probieren Sie es online!

Es ist traurig, dass ich 59 Bytes für die Neuerfindung ausgeben musste split( s).

Die Lösung erstellt eine Liste von Transformationen und gibt die erste zurück, die zum erwarteten Ergebnis führt.

Gelee , 40 Bytes

^{Präventiv danke an Erik den Outgolfer für das Bemerken des MissbrauchsŒt (Titel-Fall) und damit Œu1¦€KvorbeiŒtK}

-1 Byte dank Erik the Outgolfer (Neuordnung von ⁵⁸ç⁹¤Ŀto çµ⁵⁸Ŀ)

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

Ein volles Programm Mitnahmen exampleEmail, exampleOutput, realEmailund das Drucken des Sende .

Probieren Sie es online!

Wie?

Führt alle vier Transformationen aus (plus eine Vorgänger-Transformation), findet die erste, die das Beispiel aus der ersten E-Mail ergibt, und wendet sie dann auf die zweite E-Mail an:

            - 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

Anmerkungen:

1. Angenommen, die Eingabe exampleOutput entspricht genau der Ausgabe.

2. Der "Vorläufer" (das Ergebnis von Link 3) wird auf Übereinstimmung mit dem getestet exampleOutput, aber er wird nicht übereinstimmen, es sei denn, derselbe exampleOutputist eine Liste von Listen von Zeichen. Daher sollten die Eingaben wahrscheinlich in Anführungszeichen gesetzt werden (möglicherweise wird hier die Python-Formatierung verwendet), um die Möglichkeit zu vermeiden, sie als solche zu interpretieren.

Python 2 , 135 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 145 Byte

Mit der aktuellen Syntax aufrufen, z 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 Bytes

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

Probieren Sie es online!

Ruby , 117 106 102 Bytes

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

Probieren Sie es online!

CJam, 42

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

Probieren Sie es online aus

Erläuterung:

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 Bytes

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

Probieren Sie es online!

PHP <7.1, 180 Bytes

Versionen unter 7.1 müßten die Änderungen [,$p,$q,$r]=$argvzu list(,$p,$q,$r)=$argv, Zugabe von 4 Bytes.

GNU sed , 105 + 1 (r Flag) = 106 Bytes

Die ersten drei sBefehle prüfen für die Identität , lokalen Teil und Domain - Transformationen sind. Wenn eine Umwandlung zutrifft, wird sie auf die zweite E-Mail-Adresse angewendet, und die folgenden sBefehle schlagen fehl, weil das Eingabeformat fehlt.

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

Probieren Sie es online!

Die lokale Teiltrennungstransformation (letzter sBefehl) ist in Bezug auf die Bytes am teuersten zu überprüfen. Daher habe ich sie am Ende platziert und angenommen, dass sie übereinstimmt (da die anderen zu diesem Zeitpunkt fehlgeschlagen sind), und bin direkt zu ihrer Anwendung übergegangen.

Jelly , 43 Bytes

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

Probieren Sie es online!