Instrucciones

Dado un nombre de clase / paquete Java totalmente calificado, debe acortarlo como tal:

Cada parte del paquete separado por puntos se acortará a su primera letra, aparte de la última sección y la clase (si existe).

los nombres de los paquetes estarán en minúsculas, y la clase (si existe) comenzará con una letra mayúscula y será UpperCamelCase. los paquetes vienen en forma de:

foo.bar.foo

y

foo.bar.foo.Class

Ejemplos

(No Class)
Input com.stackoverflow.main
Output c.s.main

(Class)
Input com.google.parser.Gson
Output c.g.parser.Gson

(Class)
Input com.google.longer.package.TestClass
Output c.g.l.package.TestClass

Reglas

• El código más corto en bytes gana
• Se aplican lagunas estándar

Retina , 17 bytes

\B\w+(\.[a-z])
$1

Pruébalo en línea!

Explicación

\B         # Start from a position that isn't a word boundary. This ensures that
           # the first letter of the package name is skipped.
\w+        # Match one or more word characters. This is the remainder of the
           # package name which we want to remove.
(          # Capture the next part in group 1, because we want to keep it...
  \.[a-z]  #   Match a period and a lower-case letter. This ensures that we
           #   don't match the package that precedes the class, or the package or
           #   class at the end of the input.
)

Esto se reemplaza con $1, que es el punto y la letra minúscula que no se debe eliminar.

JavaScript (ES6), 68 53 bytes

s=>s.split`.`.map((x,y,z)=>z[y+1]>"["?x[0]:x).join`.`

• 15 bytes guardados gracias a Arnauld .

Vea mi otra solución aquí .

Intentalo

f=
s=>s.split`.`.map((x,y,z)=>z[y+1]>"["?x[0]:x).join`.`
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("com.stackoverflow.main"))
console.log(f("c.g.parser.Gson"))
console.log(f("com.google.longer.package.TestClass"))

<input id=i><pre id=o>

Mathematica, 75 bytes

#[[;;-3]]~StringTake~1~Join~#[[-2;;]]~StringRiffle~"."&[#~StringSplit~"."]&

Función anónima. Toma una cadena como entrada y devuelve una cadena como salida.

Japt , 30 27 25 bytes

¡Y>Zl -('[>ZgJ)-2?X:Xg}'.

Pruébalo en línea!

Python 2 , 76 73 bytes

q=input().split('.')
i=~(q[-1]<'_')
q[:i]=zip(*q[:i])[0]
print'.'.join(q)

Pruébalo en línea! o Pruebe todos los casos de prueba

Python 2 , 88 81 bytes

f=lambda s,d=".":s.count(d)>(s.split(d)[-1]<"[")and s[0]+d+f(s[s.find(d)+1:])or s

Pruébalo en línea!

Java 7, 66 bytes

String c(String s){return s.replaceAll("\\B\\w+(\\.[a-z])","$1");}

Puerto de la sorprendente respuesta de Retina de @MartinEnder .

Pruébalo aquí.

JavaScript (ES6), 36 bytes

Otro puerto de la Retina de Martin responde . Vea mi otra solución aquí .

s=>s.replace(/\B\w+(\.[a-z])/g,"$1")

f=
s=>s.replace(/\B\w+(\.[a-z])/g,"$1")
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("com.stackoverflow.main"))
console.log(f("c.g.parser.Gson"))
console.log(f("com.google.longer.package.TestClass"))

<input id=i><pre id=o>

V , 9 bytes

Í쓃…®õÀ!

Pruébalo en línea!

Hexdump:

00000000: cdec 9383 85ae f5c0 21                   ........!

Este es un maravilloso ejemplo de la firma del V compresión de expresiones regulares .

Explicación:

Í          " Remove every match on every line:
 ì         " A lower case letter
  “ …      "   *ONLY MATCH THIS PART:*
   ƒ       "   As few characters as possible
      ®    " Followed by a dot
       õÀ! " Not followed by an uppercase letter

Python 2 , 108 97 89 bytes

i=input().split(".")
for x in range(len(i)+~(i[-1][0]<"[")):i[x]=i[x][0]
print".".join(i)

Pruébalo en línea!

-8 con muchas gracias a @ovs por el dato

sed , 57 22 bytes

Esperaba que la solución sed fuera un poco más corta que esto ...

Editar:

La solución más corta utiliza expresiones regulares de la respuesta de Martin Ender .

Código fuente de 21 bytes + 1 byte para -rbandera (o -Ebandera para BSD sed).

s|\B\w+(\.[a-z])|\1|g

Haskell , 58 bytes

f s|[(a:t,p:x:r)]<-lex s=a:concat[t|x<'a']++p:f(x:r)|1<3=s

Pruébalo en línea! Uso: f "some.string".

lexanaliza una cadena como tokens Haskell, por lo que lex "some.string"regresa [("some",".string")]. fvuelve a aparecer sobre los tokens en la cadena y siempre agrega el primer carácter adel token actual, pero el resto tdel token solo si la cadena restante después de los dos puntos pcomienza con un carácter en mayúscula, es decir x<'a'. Si la coincidencia de patrón falló, hemos alcanzado el último token y simplemente regresamos s.