Các URL đang trở nên quá dài. Vì vậy, bạn phải thực hiện một thuật toán để rút ngắn URL.

Tôi. Cấu trúc của một URL

Một URL có 2 phần chính: tên miền và đường dẫn . Tên miền là một phần của URL trước dấu gạch chéo đầu tiên. Bạn có thể cho rằng URL không bao gồm giao thức. Con đường là mọi thứ khác.

ii. Lĩnh vực

Tên miền của một URL sẽ giống như : xkcd.com meta.codegolf.stackexcchhannnge.cooom. Mỗi phần được phân tách theo giai đoạn, ví dụ: trong blag.xkcd.com, các phần là "blag", "xkcd" và "com". Đây là những gì bạn sẽ làm với nó:

• Nếu nó chứa nhiều hơn hai phần, đặt hai phần cuối sang một bên và ghép chữ cái đầu tiên của phần còn lại.

• Sau đó, nối nó với chữ cái đầu tiên đến phần thứ hai đến phần cuối cùng.

• Thêm một khoảng thời gian và chữ cái thứ hai và thứ ba của phần thứ hai đến cuối cùng.

• Hủy phần cuối cùng.

iii. Con đường

Đường dẫn sẽ như : /questions/2140/ /1407/. Như trước đây, "các bộ phận" được ngăn cách bằng dấu gạch chéo. Đối với mỗi phần trong đường dẫn, hãy làm:

• Thêm một dấu gạch chéo

• Nếu nó được làm hoàn toàn bằng mười chữ số cơ sở, hãy hiểu nó là một số và chuyển đổi thành số nguyên cơ sở 36.

• Nếu không, thêm chữ cái đầu tiên của phần.

Cuối cùng, thêm một dấu gạch chéo.

iv. Linh tinh

• Đây là mã golf , vì vậy mã ngắn nhất sẽ thắng.
• Đường dẫn có thể trống, nhưng URL sẽ luôn kết thúc bằng dấu gạch chéo.
• Sẽ không có một giao thức (ví dụ http://, file:///)
• Sẽ không bao giờ có ít hơn hai phần trong miền.
• Tiêu chuẩn áp dụng.

Ví dụ

Trong: xkcd.com/72/
Ra:x.kc/20/

Trong: math.stackexchange.com/a/2231/
Ra:ms.ta/a/1pz/

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

Pyth, 93 85 byte

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

Biên dịch bằng tay cho mã giả 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)))

Cuối cùng, sự kết thúc ...

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

Giải trình

Tôi đã thực hiện điều này độc lập với giải pháp của @ Neil nhưng cuối cùng nó trông rất giống nhau.

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

Kiểm tra

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

Chỉnh sửa: Đã lưu 4 byte nhờ Doᴡɴɢᴏᴀᴛ.

Python 2, 378 365 byte

Cập nhật

Đánh nó xuống một chút. ~ 150 Byte cho chức năng base36 gây phiền nhiễu, nhưng tôi không thể loại bỏ nó cho đến khi python có sẵn nội dung cho ...

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

Phiên bản cũ

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

Vì Python không có cách dựng sẵn để chuyển đổi int thành chuỗi cơ sở 36, nên tôi đã thực hiện từ numpy và đánh gôn xuống. Nghỉ ngơi là khá đơn giản, tôi sẽ đánh golf nó nhiều hơn sau khi làm việc. Đề nghị luôn luôn đánh giá cao trong khi chờ đợi!

Pyhton 2, 336 329 byte

cập nhật

cố định và ngắn hơn nhờ vào webwar chiến binh

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

nguyên

Phiên bản của DenkerAffe với một số mod: xử lý chính xác lược đồ "foo / bar? Baz", cộng với, không cần trường hợp tiêu cực trong chức năng chuyển đổi cơ sở36.

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