Briefing

Dado um nome de classe / pacote Java totalmente qualificado, você deve abreviá-lo da seguinte forma:

Cada parte do pacote separado por pontos será reduzida para a primeira letra, além da última seção e da classe (se existir).

os nomes dos pacotes serão todos minúsculos e a classe (se existir) começará com uma letra maiúscula e será UpperCamelCase. pacotes vêm na forma de:

foo.bar.foo

e

foo.bar.foo.Class

Exemplos

(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

Regras

• Menor código em bytes ganha
• Aplicam-se brechas padrão

Retina , 17 bytes

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

Experimente online!

Explicação

\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.
)

Isso é substituído por $1, que é o período e a letra minúscula que não deve ser removida.

JavaScript (ES6), 68 53 bytes

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

• 15 bytes economizados graças ao Arnauld .

Veja minha outra solução aqui .

Tente

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~"."]&

Função anônima. Pega uma string como entrada e retorna uma string como saída.

Japonês , 30 27 25 bytes

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

Experimente online!

Python 2 , 76 73 bytes

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

Experimente online! ou Experimente todos os casos de teste

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

Experimente online!

Java 7, 66 bytes

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

Porto da incrível resposta Retina de @MartinEnder .

Experimente aqui.

JavaScript (ES6), 36 bytes

Outro porto da resposta da Martin Retina . Veja minha outra solução aqui .

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

Í쓃…®õÀ!

Experimente online!

Hexdump:

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

Este é um exemplo maravilhoso da assinatura do V compressão regex .

Explicação:

Í          " 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)

Experimente online!

-8 com muito obrigado a @ovs pela dica

sed , 57 22 bytes

Eu esperava que a solução sed fosse um pouco mais curta que isso ...

Editar:

A solução mais curta usa regex da resposta de Martin Ender .

Código de origem de 21 bytes + 1 byte para -rsinalizador (ou -Esinalizador 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

Experimente online!Uso: f "some.string".

lexanalisa uma string como tokens Haskell, então lex "some.string"retorna [("some",".string")]. frecorre sobre os tokens na string e sempre acrescenta o primeiro caractere ado token atual, mas o restante tdo token somente se a string restante após os dois pontos pcomeçar com um caractere maiúsculo x<'a'. Se a correspondência do padrão falhar, alcançamos o último token e simplesmente retornamos s.