URL'ler çok uzun sürüyor. Dolayısıyla, bir URL'yi kısaltmak için bir algoritma uygulamalısınız.

ben. Bir URL'nin Yapısı

Bir URL'nin 2 ana bölümü vardır: bir alan ve bir yol . Alan adı, URL'nin ilk eğik çizgiden önceki bölümüdür. URL'nin bir protokol içermediğini varsayabilirsiniz. Yol her şeydir.

ii. Alan adı

Bir URL'nin alanı gibi bir şey olacaktır: xkcd.com meta.codegolf.stackexcchhannnge.cooom. Her bölüm, periyotla ayrılmıştır, örneğin blag.xkcd.com, parçalar "blag", "xkcd" ve "com" dur. Bununla ne yapacaksınız:

• İkiden fazla parça içeriyorsa, son ikisini bir kenara koyun ve parçaların geri kalanının ilk harfini birleştirin.

• Ardından, ikinci ile son arasındaki ilk harfe birleştirin.

• Bir nokta ve ikinci-son parçanın ikinci ve üçüncü harfini ekleyin.

• Son kısmı atın.

iii. Yol

Yol gibi olacak: /questions/2140/ /1407/. Daha önce olduğu gibi, "parçalar" eğik çizgilerle ayrılır. Yoldaki her bölüm için şunları yapın:

• Eğik çizgi ekle

• Tamamen temel on basamaktan oluşuyorsa, sayı olarak yorumlayın ve base-36 tamsayısına dönüştürün.

• Aksi takdirde, parçanın ilk harfini ekleyin.

Sonunda bir eğik çizgi ekleyin.

iv. Çeşitli.

• Bu kod golf , bu yüzden en kısa kod kazanır.
• Yol boş olabilir, ancak URL her zaman eğik çizgi ile biter.
• Protokol olmayacak (ör http://. file:///)
• Alan adında hiçbir zaman iki bölümden az olmayacak.
• Standart boşluklar geçerlidir.

Örnekler

Giriş: xkcd.com/72/
Çıkış:x.kc/20/

Giriş: math.stackexchange.com/a/2231/
Çıkış:ms.ta/a/1pz/

Giriş: hello.org/somecoolcodeintrepreteriijjkk?code=3g3fzsdg32,g2/
Çıkış:h.el/s/

Pyth, 93 85 bayt

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

Pythonic sözde koduna elle derlendi:

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

Sonunda, çürütme sona erer ...

JavaScript (ES6), 149 bayt

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

açıklama

Bunu @ Neil'in çözümünden bağımsız yaptım ama çok benzer görünüyordu.

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

Ölçek

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 bayt

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

Düzenleme: Doᴡɴɢᴏᴀᴛ sayesinde 4 bayt kaydedildi.

Python 2, 378365 Bayt

Güncelleme

Biraz aşağı golf. Base36 işlevi için ~ 150 Byte sinir bozucu, ama python bunun için bir yerleşik olana kadar ondan kurtulamıyorum ...

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

Eski versiyon

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

Python'un, bir base36-String'e dönüştürmek için yerleşik bir yolu olmadığından, uygulamayı numpy'den aldım ve golf oynadım. Dinlenme oldukça basit, işten sonra daha fazla golf yapacağım. Öneriler bu arada her zaman takdir!

Pyhton 2, 336 329 bayt

Güncelleme

webwarrior sayesinde sabit ve daha kısa

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

orijinal

DenkerAffe'nin bazı modlarla sürümü: "foo / bar? Baz" şemasını doğru bir şekilde ele alın, ayrıca base36 dönüştürme işlevinde negatif duruma gerek yok.

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