¡Transformación mágica de correo electrónico! O bien: ayude a la NSA a extraer sus metadatos de su dirección de correo electrónico

17

Dada una dirección de correo electrónico, el resultado de una transformación aplicada a esa dirección de correo electrónico, y una segunda dirección de correo electrónico, devuelve el resultado de la misma transformación aplicada a la segunda dirección de correo electrónico.

Todas las direcciones de correo electrónico tendrán la siguiente estructura:

Una cadena de longitud positiva que contiene caracteres alfanuméricos y como máximo uno .(la parte local), seguido de un @símbolo, seguido de una cadena de longitud positiva que contiene símbolos alfanuméricos (el dominio), seguido de un .símbolo y una cadena final de longitud positiva que contiene caracteres alfanuméricos (el TLD).

Hay cuatro transformaciones permitidas:

Cuando es posible más de una transformación, puede dar el resultado de cualquiera de las posibilidades. Los espacios en blanco al inicio y al final de la salida no importan, pero en el medio sí (es decir, si se divide a.ben A Bdebería haber solo un espacio en el medio [y cualquier número al inicio y al final de la salida], pero si se divide a., entonces, Acon cualquier número de espacios a cada lado, todos son aceptables).

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

Se aplican las reglas habituales y las lagunas.

code-golf string LangeHaare
fuente
¿No debería el último caso de prueba devolver "caballo"? No veo por qué puede devolver "cerdo" en su lugar.
Erik the Outgolfer
3
@EriktheOutgolfer porque la cuarta transformación es devolver solo el dominio (la parte entre @y final .). Dado que la parte local y el dominio son ambos chicken, es ambiguo si se trata de la segunda o cuarta transformación
LangeHaare es el
Oh, lo malinterpreté.
Erik the Outgolfer
¿Podemos exigir que la entrada relevante esté formateada con el espacio en todos los casos (por ejemplo, en la prueba donde la salida es A[con un espacio final] que la segunda entrada sea Jones[con un espacio inicial])?
Jonathan Allan
No entiendo por qué [email protected], Jones, [email protected]es así A: si jonescoincide, significa que la parte coincidente es la parte entre el primer período y el símbolo @. Pero eso daría como resultado una cadena vacía porque aes anterior al primer período y no después.
Jerry Jeremiah

Respuestas:

4

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 gracias a @LukeStevens .

Explicación:

Pruébalo aquí

(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
Kevin Cruijssen
fuente
1
Puede eliminar 4 bytes utilizando en (p.charAt(0)+"").toUpperCase()lugar de Character.toUpperCase(p.charAt(0)).
Luke Stevens el
@LukeStevens Gracias! Al (char)(p.charAt(0)&~32)principio tenía , pero esto no funcionó debido al 1in Thehandcaso de prueba. Pero ponerlo en mayúsculas como String es realmente más corto que Character.toUpperCase, ¡así que gracias!
Kevin Cruijssen
3

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]

Pruébalo en línea!

Es triste que tuve que gastar 59 bytes en reinventar split( s).

La solución crea una lista de transformaciones y devuelve la primera que conduce al resultado esperado.

user75684
fuente
Bienvenido al sitio! No conozco a Haskell, pero ¿es posible eliminar alguno de los caracteres de espacios en blanco, como líneas nuevas y espacios?
caird coinheringaahing
Buena primera respuesta! Quizás te interese nuestra colección de consejos para jugar al golf en Haskell , especialmente esto y esto debería ahorrar algunos bytes.
Laikoni
También siéntase libre de unirse a nosotros en Of Monads and Men , una sala de chat para golf y discusión general de Haskell.
Laikoni
3

Jalea , 40 bytes

Gracias preventivas a Erik the Outgolfer por notar la falla en el uso Œt(title-case) y por Œu1¦€Klo tantoŒtK

-1 byte gracias a Erik the Outgolfer (reordenamiento de ⁵⁸ç⁹¤Ŀa çµ⁵⁸Ŀ)


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

Una toma de programa completo exampleEmail, exampleOutput, realEmaile imprimir el resultado.

Pruébalo en línea!

¿Cómo?

Realiza las cuatro transformaciones (más una precursora), encuentra la primera que proporciona el ejemplo del primer correo electrónico y luego la aplica al segundo correo electrónico:

            - 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

Notas:

  1. Asume que la entrada exampleOutput es estrictamente la misma que la salida sería.

  2. Se prueba que el "precursor" (el resultado del enlace 3) coincide exampleOutput, pero no coincidirá a menos que exampleOutputsea ​​una lista de listas de caracteres. Como tal, las entradas probablemente deberían citarse (el formato de Python se puede usar aquí) para evitar la posibilidad de interpretarlo como tal.

Jonathan Allan
fuente
39 bytes
Erik the Outgolfer
2

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

Pruébalo en línea!

Erik el Outgolfer
fuente
-3 bytes moviendo la tira
ovs
@ovs gracias, de todos modos las reglas cambiaron para eliminar la necesidad de ello
Erik the Outgolfer
2

JavaScript (ES6), 145 bytes

Invocar con sintaxis curry, p. Ej. 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)

Mostrar fragmento de código

Darrylyeo
fuente
1

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


Pruébalo en línea!

J42161217
fuente
1

Rubí , 117 106 102 bytes

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

Pruébalo en línea!

Restablecer a Monica - notmaynard
fuente
1

CJam, 42

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

Pruébalo en línea

Explicación:

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
aditsu
fuente
1

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

Pruébalo en línea!

PHP <7.1, 180 bytes

Las versiones anteriores a 7.1 tendrían que cambiar el [,$p,$q,$r]=$argva list(,$p,$q,$r)=$argv, agregando 4 bytes.

Jo
fuente
1

GNU sed , 105 + 1 (r flag) = 106 bytes

Los primeros tres scomandos verifican la identidad , la parte local y las transformaciones de dominio respectivamente. Si una transformación coincide, se aplica a la segunda dirección de correo electrónico y los siguientes scomandos fallarán debido a la falta del formato de entrada.

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

Pruébalo en línea!

La transformación de división de parte local (último scomando) es la más costosa de verificar, en términos de bytes, por lo tanto, la coloqué al final y asumí que coincide (ya que las otras fallaron en ese momento), yendo directamente a su aplicación.

seshoumara
fuente
1

Jalea , 43 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente
¿ ŒtKFuncionaría en lugar de Œu1¦€Kguardar 3?
Jonathan Allan
... y para qué se necesita Œl?
Jonathan Allan
^ ah veo que eso 1in.thehandno funcionaría ŒtK.
Jonathan Allan
@JonathanAllan Sí, esa es la razón por la que no usé eso, y también la razón por la cual la respuesta de ovs (ahora eliminada) no era válida ( str.title).
Erik the Outgolfer