Étant donné une adresse e-mail, le résultat d'une transformation appliquée à cette adresse e-mail et une deuxième adresse e-mail, retournez la sortie de la même transformation appliquée à la deuxième adresse e-mail.

Les adresses e-mail auront toutes la structure suivante:

Une chaîne de longueur positive contenant des caractères alphanumériques et au plus un .(la partie locale), suivie d'un @symbole, suivie d'une chaîne de longueur positive contenant des symboles alphanumériques (le domaine), suivie d'un .symbole et d'une chaîne finale de longueur positive contenant des caractères alphanumériques (le TLD).

Il existe quatre transformations autorisées:

• Identité (pas de changement). ( [email protected] -> [email protected])
• Renvoyer uniquement la partie locale (tout ce qui précède @) non modifié ( [email protected] -> a.b).
• Retour de la partie locale divisée sur le .cas échéant, avec le premier symbole de chaque moitié en majuscule. ([email protected] -> A B ).
• Retour juste le domaine (tout entre le @et le final .) non modifié. ( [email protected] -> c).

Lorsque plusieurs transformations sont possibles, vous pouvez fournir la sortie de l'une des possibilités. Au début Whitespace et à la fin de la production de peu d' importance, mais au milieu ne ( par exemple , si vous divisez a.bà A Bil devrait y avoir un seul espace au milieu [et un nombre au début et à la fin de la production], mais si vous divisez a., alors Aavec n'importe quel nombre d'espaces de chaque côté sont tous acceptables).

Exemples ( input | output):

[email protected], John Doe, [email protected]         | Phillip Maini
[email protected], John Doe, [email protected]         | Phillip Maini
[email protected], foo.bar, [email protected]           | gee.whizz
[email protected], foo.bar, [email protected]           | gEe.Whizz
[email protected], comedy, [email protected] | office
[email protected], Jones, [email protected]                                     | A
[email protected], [email protected], [email protected]                                | [email protected]
[email protected], .jones, [email protected]                                    | a.
[email protected], x, [email protected]                                         | 3
[email protected], [email protected], [email protected]                                           | [email protected]
[email protected], John Jones, [email protected]           | 1in Thehand
[email protected], Chicken Soup, [email protected]                    | Fab
[email protected], lange, [email protected]                          | fat.so
[email protected], Lange, [email protected]                          | {fat.so, Fat So} # either acceptable
[email protected], chicken, [email protected]              | {horse, pig} # either acceptable

Les règles et les failles habituelles s'appliquent.

Java 8, 254 240 236 octets

(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 octets grâce à @LukeStevens .

Explication:

Essayez-le ici.

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

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]

Essayez-le en ligne!

C'est triste d'avoir dû dépenser 59 octets pour réinventer split( s).

La solution crée une liste de transformations et renvoie la première qui mène au résultat attendu.

Gelée , 40 octets

^{Préemption grâce à Erik l'Outgolfer pour avoir remarqué l'échec de l'utilisation Œt(case-titre) et donc Œu1¦€KplusŒtK}

-1 octet grâce à Erik l'Outgolfer (réarrangement de ⁵⁸ç⁹¤Ŀto çµ⁵⁸Ŀ)

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

Un programme complet prenant exampleEmail, exampleOutput, realEmailet d' imprimer le résultat.

Essayez-le en ligne!

Comment?

Effectue les quatre transformations (plus une précurseur), trouve la première qui donne l'exemple du premier e-mail, puis l'applique au deuxième e-mail:

            - 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

Remarques:

1. Suppose que l'exemple d'entrée est strictement identique à la sortie.

2. Le "précurseur" (le résultat du lien 3) est testé pour faire correspondre le exampleOutput, mais il ne correspondra que si le exampleOutputlui-même est une liste de listes de caractères. En tant que tel, les entrées doivent probablement être citées (le formatage Python peut être utilisé ici) pour éviter la possibilité de l'interpréter comme tel.

Python 2 , 135 octets

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

Essayez-le en ligne!

JavaScript (ES6), 145 octets

Invoquer avec la syntaxe de curry, par exemple f('[email protected]')('Chicken Soup')('[email protected]')

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 [
['[email protected]', 'John Doe', '[email protected]'], // Phillip Maini
['[email protected]', 'John Doe', '[email protected]'], // Phillip Maini
['[email protected]', 'foo.bar', '[email protected]'], // gee.whizz
['[email protected]', 'foo.bar', '[email protected]'], // gEe.Whizz
['[email protected]', 'comedy', '[email protected]'], // office
['[email protected]', 'Jones', '[email protected]'], // A
['[email protected]', '[email protected]', '[email protected]'], // [email protected]
['[email protected]', '.jones', '[email protected]'], // a.
['[email protected]', 'x', '[email protected]'], // 3
['[email protected]', '[email protected]', '[email protected]'], // [email protected]
['[email protected]', 'John Jones', '[email protected]'], // 1in Thehand
['[email protected]', 'Chicken Soup', '[email protected]'], // Fab
['[email protected]', 'lange', '[email protected]'], // fat.so
['[email protected]', 'Lange', '[email protected]'], // {fat.so, Fat So} # either acceptable
['[email protected]', 'chicken', '[email protected]'], // {horse, pig} # either acceptable
]) console.log( f(x)(y)(z) )

Mathematica, 217 octets

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

Essayez-le en ligne!

Ruby , 117 106 102 octets

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

Essayez-le en ligne!

CJam, 42

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

Essayez-le en ligne

Explication:

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 octets

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

Essayez-le en ligne!

PHP <7,1, 180 octets

Les versions sous 7.1 devraient changer le [,$p,$q,$r]=$argven list(,$p,$q,$r)=$argv, en ajoutant 4 octets.

GNU sed , 105 + 1 (drapeau r) = 106 octets

Les trois premières scommandes vérifient respectivement les transformations d' identité , de partie locale et de domaine . Si une transformation correspond, elle est appliquée à la deuxième adresse e-mail et les scommandes suivantes échoueront en raison d'un manque de format d'entrée.

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

Essayez-le en ligne!

La transformation de fractionnement de partie locale (dernière scommande) est la plus coûteuse à vérifier, en termes d'octets, donc je l'ai placée à la fin et j'ai supposé qu'elle correspond (puisque les autres ont échoué à ce moment-là), en allant directement à son application.

Gelée , 43 octets

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

Essayez-le en ligne!