Einweisung

Wenn Sie einen vollständig qualifizierten Java-Klassen- / Paketnamen angeben, müssen Sie ihn als solchen kürzen:

Jeder Teil des durch Punkte getrennten Pakets wird auf den ersten Buchstaben gekürzt, abgesehen vom letzten Abschnitt und der Klasse (falls vorhanden).

Paketnamen werden alle in Kleinbuchstaben geschrieben, und die Klasse (falls vorhanden) beginnt mit einem Großbuchstaben und lautet UpperCamelCase. Pakete kommen in Form von:

foo.bar.foo

und

foo.bar.foo.Class

Beispiele

(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

Regeln

• Der kürzeste Code in Bytes gewinnt
• Es gelten Standardlücken

Netzhaut , 17 Bytes

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

Probieren Sie es online aus!

Erläuterung

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

Dies wird durch $1den Punkt und den Kleinbuchstaben ersetzt , die nicht entfernt werden sollten.

JavaScript (ES6), 68 53 Byte

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

• 15 Bytes dank Arnauld gespart .

Sehen Sie meine andere Lösung hier .

Versuch es

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

Anonyme Funktion. Nimmt eine Zeichenfolge als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück.

Japt , 30 27 25 Bytes

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

Probieren Sie es online aus!

Python 2 , 76 73 Bytes

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

Probieren Sie es online aus! oder Probieren Sie alle Testfälle aus

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

Probieren Sie es online aus!

Java 7, 66 Bytes

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

Port von @MartinEnders erstaunlicher Retina-Antwort .

Probieren Sie es hier aus.

JavaScript (ES6), 36 Byte

Ein weiterer Hafen von Martins Retina-Antwort . Sehen Sie meine andere Lösung hier .

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

Í쓃…®õÀ!

Probieren Sie es online aus!

Hexdump:

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

Dies ist ein wunderbares Beispiel für V Unterschrift regex Kompression .

Erläuterung:

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

Probieren Sie es online aus!

-8 mit vielen Dank an @ovs für den Tipp

sed , 57 22 Bytes

Ich habe erwartet, dass die sed-Lösung etwas kürzer ist ...

Bearbeiten:

Die kürzere Lösung verwendet Regex aus Martin Enders Antwort .

21 Bytes Quellcode + 1 Byte für -rFlag (oder -EFlag für 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

Probieren Sie es online aus! Verwendung : f "some.string".

lexanalysiert eine Zeichenfolge als Haskell-Token und lex "some.string"kehrt daher zurück [("some",".string")]. frekursiv über die Token in der Zeichenfolge und hängt immer das erste aZeichen des aktuellen Tokens an, den Rest tdes Tokens jedoch nur, wenn die verbleibende Zeichenfolge nach dem Doppelpunkt pmit einem Großbuchstaben beginnt x<'a'. Wenn die Musterübereinstimmung fehlgeschlagen ist, haben wir das letzte Token erreicht und kehren einfach zurück s.