Compte rendu

Étant donné un nom de classe / package Java entièrement qualifié, vous devez le raccourcir en tant que tel:

Chaque partie du paquet séparé par points sera raccourcie à sa première lettre, à l'exception de la dernière section et de la classe (si elle existe).

les noms de packages seront tous en minuscules et la classe (si elle existe) commencera par une majuscule et sera UpperCamelCase. les packages se présentent sous la forme de:

foo.bar.foo

et

foo.bar.foo.Class

Exemples

(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

Règles

• Le code le plus court en octets gagne
• Des échappatoires standard s'appliquent

Rétine , 17 octets

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

Essayez-le en ligne!

Explication

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

Il est remplacé par $1, qui est la période et la lettre minuscule qui ne doivent pas être supprimées.

JavaScript (ES6), 68 53 octets

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

• 15 octets économisés grâce à Arnauld .

Voir mon autre solution ici .

Essayez-le

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 octets

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

Fonction anonyme. Prend une chaîne en entrée et renvoie une chaîne en sortie.

Japt , 30 27 25 octets

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

Essayez-le en ligne!

Python 2 , 76 73 octets

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

Essayez-le en ligne! ou Essayez tous les cas de test

Python 2 , 88 81 octets

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

Essayez-le en ligne!

Java 7, 66 octets

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

Port de l'incroyable réponse Retina de @MartinEnder .

Essayez-le ici.

JavaScript (ES6), 36 octets

Un autre port de la rétine de Martin répond . Voir mon autre solution ici .

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 octets

Í쓃…®õÀ!

Essayez-le en ligne!

Hexdump:

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

Ceci est un exemple merveilleux de la signature de V de compression regex .

Explication:

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

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

Essayez-le en ligne!

-8 avec un grand merci à @ovs pour l'astuce

sed , 57 22 octets

Je m'attendais à ce que la solution sed soit un peu plus courte que cela ...

Éditer:

La solution la plus courte utilise l'expression régulière de la réponse de Martin Ender .

21 octets code source + 1 octet pour -rindicateur (ou -Eindicateur pour BSD sed).

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

Haskell , 58 octets

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

Essayez-le en ligne! Utilisation: f "some.string".

lexanalyse une chaîne en tant que jetons Haskell, donc lex "some.string"retourne [("some",".string")]. frevient sur les jetons de la chaîne et ajoute toujours le premier caractère adu jeton actuel, mais le reste tdu jeton uniquement si la chaîne restante après les deux-points pcommence par un caractère majuscule, c'est-à-dire x<'a'. Si la correspondance de modèle a échoué, nous avons atteint le dernier jeton et revenons simplement s.