URL terlalu panjang. Jadi, Anda harus menerapkan algoritma untuk mempersingkat URL.

saya. Struktur URL

URL memiliki 2 bagian utama: domain dan jalur . Domain adalah bagian dari URL sebelum garis miring pertama. Anda dapat berasumsi bahwa URL tidak termasuk protokol. Jalan adalah segalanya.

ii. Domain

Domain dari URL akan menjadi sesuatu seperti: xkcd.com meta.codegolf.stackexcchhannnge.cooom. Setiap bagian dipisahkan periode, misalnya dalam blag.xkcd.com, bagian-bagiannya adalah "blag", "xkcd", dan "com". Inilah yang akan Anda lakukan dengannya:

• Jika berisi lebih dari dua bagian, sisihkan dua yang terakhir dan gabungkan huruf pertama dari sisa bagian tersebut.

• Kemudian, gabungkan itu ke huruf pertama ke bagian kedua hingga terakhir.

• Tambahkan titik dan huruf kedua dan ketiga dari bagian kedua hingga terakhir.

• Buang bagian terakhir.

aku aku aku. Jalan

Jalan itu akan menjadi seperti: /questions/2140/ /1407/. Seperti sebelumnya, "bagian-bagian" dipisahkan oleh garis miring. Untuk setiap bagian di jalan, lakukan:

• Tambahkan garis miring

• Jika benar-benar terbuat dari basis-sepuluh digit, tafsirkan sebagai angka dan konversikan ke basis-36 integer.

• Kalau tidak, tambahkan huruf pertama bagian itu.

Pada akhirnya, tambahkan garis miring.

iv. Lain-lain

• Ini kode-golf , jadi kode terpendek menang.
• Path bisa kosong, tetapi URL akan selalu diakhiri dengan garis miring.
• Tidak akan ada protokol (misalnya http://, file:///)
• Tidak akan pernah ada kurang dari dua bagian dalam domain.
• Celah standar berlaku.

Contohnya

Masuk: xkcd.com/72/
Keluar:x.kc/20/

Masuk: math.stackexchange.com/a/2231/
Keluar:ms.ta/a/1pz/

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

Pyth, 93 85 byte

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

Dikompilasi dengan tangan ke pseudocode pythonic:

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

Akhirnya, penyiksaan berakhir ...

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`/`

Penjelasan

Saya membuat ini independen dari solusi @ Neil tetapi akhirnya tampak sangat mirip.

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

Uji

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`/`

Sunting: Disimpan 4 byte berkat Doᴡɴɢᴏᴀᴛ.

Python 2, 378 365 Bytes

Memperbarui

Golf turun sedikit. ~ 150 Bytes untuk fungsi dasar36 mengganggu, tapi saya tidak bisa menghilangkannya sampai python memiliki builtin untuk itu ...

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]])

Versi lama

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+"/"

Karena Python tidak memiliki cara builtin untuk mengkonversi ints menjadi base36-String, saya mengambil implementasinya dari numpy dan menurunkannya. Istirahat cukup mudah, saya akan menurunkannya setelah bekerja. Sementara itu, saran selalu dihargai!

Pyhton 2, 336 329 byte

memperbarui

diperbaiki dan terima kasih lebih pendek untuk 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+'/'

asli

Versi DenkerAffe dengan beberapa mods: menangani skema "foo / bar? Baz" dengan benar, plus, tidak perlu untuk case negatif dalam fungsi konversi base36.

 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+'/'