URL बहुत लंबे हो रहे हैं। तो, आपको एक यूआरएल को छोटा करने के लिए एक एल्गोरिथ्म को लागू करना होगा।

मैं। एक URL की संरचना

एक URL में 2 मुख्य भाग होते हैं: एक डोमेन और एक पथ । पहली स्लैश से पहले एक डोमेन URL का हिस्सा है। आप मान सकते हैं कि URL में प्रोटोकॉल शामिल नहीं है। रास्ता ही सब कुछ है।

ii। डोमेन

एक URL के डोमेन की तरह कुछ हो जाएगा: xkcd.com meta.codegolf.stackexcchhannnge.cooom। प्रत्येक भाग को अवधि-अलग किया जाता है, उदाहरण के लिए blag.xkcd.com, भाग "ब्लाॅग", "xkcd" और "कॉम" हैं। यह आप इसके साथ क्या करेंगे:

यदि इसमें दो से अधिक भाग हैं, तो अंतिम दो को अलग रखें और बाकी हिस्सों के पहले अक्षर को समाप्‍त करें।
फिर, पहले अक्षर को दूसरे-से-अंतिम भाग तक संक्षिप्त करें।
एक अवधि और दूसरे-से-अंतिम भाग के दूसरे और तीसरे अक्षर को जोड़ें।
अंतिम भाग को त्यागें।

iii। राह

पथ तरह होगा: /questions/2140/ /1407/। पहले की तरह, "भागों" को स्लैश द्वारा अलग किया जाता है। पथ के प्रत्येक भाग के लिए, करें:

एक स्लैश जोड़ें
यदि यह पूरी तरह से बेस-दस अंकों से बना है, तो इसे संख्या के रूप में व्याख्या करें और बेस -36 पूर्णांक में परिवर्तित करें।
अन्यथा, भाग का पहला अक्षर जोड़ें।

अंत में, एक स्लैश जोड़ें।

iv। विविध।

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।
पथ रिक्त हो सकता है, लेकिन URL हमेशा स्लैश के साथ समाप्त होगा।
एक प्रोटोकॉल नहीं होगा (उदाहरण http://के लिए file:///)
डोमेन में कभी भी दो भागों से कम नहीं होगा।
मानक खामियां लागू होती हैं।

उदाहरण

में: xkcd.com/72/
बाहर:x.kc/20/

में: math.stackexchange.com/a/2231/
बाहर:ms.ta/a/1pz/

में: hello.org/somecoolcodeintrepreteriijjkk?code=3g3fzsdg32,g2/
बाहर:h.el/s/

code-golf string compression

— ev3commander
स्रोत

आपके अंतिम उदाहरण में, क्या पथ समाप्त नहीं होता है kkऔर सब कुछ जो ?एक स्ट्रिंग स्ट्रिंग है, जो एक स्लैश के साथ समाप्त नहीं होनी चाहिए? इसके अलावा सभी URL स्लैश के साथ समाप्त नहीं होंगे /, जैसे www.something.com/path। या इस चुनौती के उद्देश्य के लिए यह अप्रासंगिक है?

— 8

वह अप्रासंगिक है।

— 20

0

पायथ, 93 85 बाइट्स

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

पाइथोनिक स्यूडोकोड के लिए हाथ से संकलित:

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

अंत में, बहिष्कार समाप्त होता है ...

— busukxuan
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 149 बाइट्स

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

व्याख्या

मैंने @ नील के समाधान से इसे स्वतंत्र कर दिया लेकिन यह बहुत समान दिख रहा है ।

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

परीक्षा

कोड स्निपेट दिखाएं

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>

स्निपेट का विस्तार करें

— user81655
स्रोत

1

जावास्क्रिप्ट ईएस 6, 157 बाइट्स

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

संपादित करें: सहेजे गए 4 बाइट Doᴡɴɢᴏᴀᴛ के लिए धन्यवाद।

— नील
स्रोत

आपको स्ट्रिंग टेम्प्लेट बनाने .split('/')और बनाने में सक्षम होना चाहिए.split('.')

— डाउनगोएट

@ दो @ बाह, मुझे भी याद है join!

— नील

1

पायथन 2, 378 365 बाइट्स

अपडेट करें

इसे थोड़ा नीचे करके घुमाएं। बेस36-फंक्शन के लिए ~ 150 बाइट्स कष्टप्रद हैं, लेकिन मैं तब तक इससे छुटकारा नहीं पा सकता, जब तक कि अजगर के पास एक बिल्डिन नहीं है ...

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

पुराना संस्करण

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

चूंकि पायथन के पास एक बेस 3636-स्ट्रिंग में चींटियों को परिवर्तित करने का एक अंतर्निहित तरीका नहीं है, इसलिए मैंने कार्यान्वयन को संख्यात्मक रूप से लिया और इसे नीचे गिरा दिया। आराम बहुत सीधा है, मैं काम के बाद इसे और नीचे कर दूंगा। इस बीच सुझावों की हमेशा सराहना की!

— Denker
स्रोत

0

पायथन 2, ~~336~~ 329 बाइट्स

अपडेट करें

वेबवार के लिए निश्चित और छोटा धन्यवाद

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

मूल

कुछ मोड्स के साथ DenkerAffe का संस्करण: "foo / bar? Baz" योजना को सही ढंग से संभालता है, साथ ही, बेस 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+'/'

— Setop
स्रोत

आपके लुकअप स्ट्रिंग में त्रुटि है, और यह भी कि पूरी लाइन छोटी हो सकती है:r+=chr((range(48,58)+range(65,91))[a%36])

— वेबवार

URL शॉर्टनर लागू करें