URLs werden zu lang. Sie müssen also einen Algorithmus implementieren, um eine URL zu verkürzen.

ich. Die Struktur einer URL

Eine URL besteht aus zwei Hauptteilen: einer Domain und einem Pfad . Eine Domain ist der Teil der URL vor dem ersten Schrägstrich. Sie können davon ausgehen, dass die URL kein Protokoll enthält. Der Weg ist alles andere.

ii. Die Domain

Die Domäne einer URL wird wie etwas sein: xkcd.com meta.codegolf.stackexcchhannnge.cooom. Jeder Teil ist nach Perioden getrennt, z. B. blag.xkcd.comlauten die Teile "blag", "xkcd" und "com". Das wirst du damit machen:

• Wenn es mehr als zwei Teile enthält, legen Sie die letzten beiden beiseite und verketten Sie den ersten Buchstaben der restlichen Teile.

• Verketten Sie das dann zu dem ersten Buchstaben zu dem vorletzten Teil.

• Fügen Sie einen Punkt und den zweiten und dritten Buchstaben des vorletzten Teils hinzu.

• Verwerfen Sie den letzten Teil.

iii. Der Weg

Der Weg wird sein , wie: /questions/2140/ /1407/. Nach wie vor werden "Teile" durch Schrägstriche getrennt. Führen Sie für jeden Teil des Pfads Folgendes aus:

• Fügen Sie einen Schrägstrich hinzu

• Wenn es vollständig aus Ziffern zur Basis zehn besteht, interpretieren Sie es als Zahl und konvertieren Sie es in eine Ganzzahl zur Basis 36.

• Andernfalls fügen Sie den ersten Buchstaben des Teils hinzu.

Fügen Sie am Ende einen Schrägstrich hinzu.

iv. Sonstiges

• Das ist Code-Golf , also gewinnt der kürzeste Code.
• Der Pfad kann leer sein, die URL endet jedoch immer mit einem Schrägstrich.
• Es wird kein Protokoll (zB sein http://, file:///)
• Es wird niemals weniger als zwei Teile in der Domäne geben.
• Es gelten Standardlücken.

Beispiele

In: xkcd.com/72/
Out:x.kc/20/

In: math.stackexchange.com/a/2231/
Out:ms.ta/a/1pz/

In: hello.org/somecoolcodeintrepreteriijjkk?code=3g3fzsdg32,g2/
Out:h.el/s/

Pyth, 93 85 Bytes

Lsm@+jkUTGdjb36J<zxz\/KP>zhxz\/=cJ\.pss[mhd<J_2hePJ\.<tePJ2\/;=cK\/sm+?-djkUThdysd\/K

Handkompilierter pythonischer Pseudocode:

                z = input()                     # raw, unevaluated
                G = "abcdefghijklmnopqrstuvwxyz"
                k = ""
                T = 10
L               def y(b):                       # define y as base10to36
 sm                 join(map(lambda d:
  @+jkUTGd            (join(range(T),interleave=k)+G)[d],
                                                # the join(..)+G makes "0...9a...z"
  jb36                 convert(b,36)            # returns a list of digit values in base10
J<zxz\/         J = z[:z.index("\/")]           # domain portion
KP>zhxz\/       K = z[1+z.index("\/"):][:-1]    # path portion
=cJ\.           J = J.split(".")                # splits domain into parts
pss[            no_newline_print(join(join[     # 1 join yields a list, the other a string
 mhd<J_2            map(lambda d:d[0],J[:-2]),
 hePJ               J[:-1][-1][1],
 \.                 ".",
 <tePJ2             J[:-1][-1][1:][:2],
 \/                 "\/"
;               ])
=cK\/           K = K.split("\/")
sm              print(join(map(lambda d:
 +?-djkUThdysd\/    "\/"+(d[0] if filterOut(d,join(range(T),interleave=k)) else y(int(d))),
                    # the filter will turn pure number into empty string, which is False
 K                  K)))

Endlich endet die Grausamkeit ...

JavaScript (ES6), 149 Byte

u=>u.split`/`.map((p,i)=>i?/^\d+$/.test(p)?(+p).toString(36):p[0]:(d=p.split`.`).slice(0,-1).map((s,j)=>s[l=j,0]).join``+"."+d[l].slice(1,3)).join`/`

Erläuterung

Ich habe dies unabhängig von der Lösung von @ Neil gemacht, aber es sah sehr ähnlich aus.

u=>
  u.split`/`.map((p,i)=>       // for each part p at index i
    i?                         // if this is not the first part
      /^\d+$/.test(p)?         // if p is only digits
        (+p).toString(36)      // return p as a base-36 number
      :p[0]                    // else return the first letter
    :
      (d=p.split`.`)           // d = domain parts
      .slice(0,-1).map((s,j)=> // for each domain part before the last
        s[l=j,0]               // return the first letter, l = index of last domain part
      ).join``
      +"."+d[l].slice(1,3)     // add the 2 letters as the final domain
  )
  .join`/`                     // output each new part separated by a slash

Prüfung

var solution = u=>u.split`/`.map((p,i)=>i?/^\d+$/.test(p)?(+p).toString(36):p[0]:(d=p.split`.`).slice(0,-1).map((s,j)=>s[l=j,0]).join``+"."+d[l].slice(1,3)).join`/`

<input type="text" id="input" value="math.stackexchange.com/a/2231/" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

JavaScript ES6, 157 Byte

u=>u.split`/`.map((p,i)=>i?/^\d+$/.test(p)?(+p).toString(36):p[0]:p.split`.`.reverse().map((h,i)=>i--?i?h[0]:h[0]+'.'+h[1]+h[2]:'').reverse().join``).join`/`

Bearbeiten: 4 Bytes dank Doᴡɴɢᴏᴀᴛ gespeichert.

Python 2, 378 365 Bytes

Aktualisieren

Golf es ein bisschen runter. Die ~ 150 Bytes für die base36-Funktion sind ärgerlich, aber ich kann es nicht loswerden, bis Python ein eingebautes dafür hat ...

def b(n):
 a=abs(n);r=[];
 while a :
    r.append('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'[a%36]);a//=36
 if n<0:r.append('-')
 return''.join(reversed(r or'0'))
u=raw_input();P=u.split("/")[0].split(".")
print"".join([p[0] for p in P[0:-2]]+[P[-2][0]]+["."]+list(P[-2])[1:3]+["/"]+[b(int(p))+"/"if p.isdigit()else p[0]+"/" for p in u.split(".")[-1].split("/")[1:-1]])

Alte Version

def b(n):
 a=abs(n)
 r=[]
 while a:
    r.append('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'[a%36])
    a//=36
 if n<0:r.append('-')
 return''.join(reversed(r or'0'))
u=raw_input()
P=u.split("/")[0].split(".")
s=""
if len(P)>2:
 for p in P[:-2]:s+=p[0]
s+=P[-2][0]+"."+P[0][1:3]
P=u.split(".")[-1].split("/")[1:-1]
for p in P:
 s+="/"+(b(int(p)) if p.isdigit() else p[0])
print s+"/"

Da es in Python keine integrierte Möglichkeit gibt, Ints in einen base36-String umzuwandeln, habe ich die Implementierung von Numpy übernommen und sie heruntergespielt. Die Erholung ist ziemlich unkompliziert, ich werde nach der Arbeit noch mehr Golf spielen. Vorschläge immer in der Zwischenzeit geschätzt!

Pyhton 2, 336 329 Bytes

aktualisieren

fest und kürzer dank webwarrior

def b(a):
 r=''
 while a:
  r+=chr((range(48,58)+range(65,91))[a%36])
  a//=36
 return ''.join(reversed(r or '0'))
u=raw_input()
P=u.split('/')[0].split('.')
s=''
if len(P)>2:
 for p in P[:-2]: s+=p[0]
s+=P[-2][0]+'.'+P[0][1:3]
P=u.split('.')[-1].split('/')[1:]
for p in P: s+='/'+(b(int(p)) if p.isdigit() else p[0])
print s+'/'

Original

DenkerAffes Version mit einigen Mods: korrektes Handling des "foo / bar? Baz" Schemas, plus, keine Notwendigkeit für negative Groß- und Kleinschreibung in der base36-Konvertierungsfunktion.

 def b(a):
 r=''
 while a:
  r+=('0123456789ABCDEFGHUKLMNOPQRSTUVWXYZ'[a%36])
  a//=36
 return ''.join(reversed(r or '0'))
u=raw_input()
P=u.split('/')[0].split('.')
s=''
if len(P)>2:
 for p in P[:-2]: s+=p[0]
s+=P[-2][0]+'.'+P[0][1:3]
P=u.split('.')[-1].split('/')[1:]
for p in P: s+='/'+(b(int(p)) if p.isdigit() else p[0])
print s+'/'