19

इस चुनौती के लिए, आपको एक पूर्ण पथ दिया जाएगा, और एक "नया" पथ (जो पूर्ण या सापेक्ष हो सकता है), और आपको अंतिम पथ वापस करने की आवश्यकता है।

उदाहरण के लिए, यदि आपकी वर्तमान निर्देशिका थी /var/tmp/test:

my_dirया my_dir/ लौटना चाहिए/var/tmp/test/my_dir

../../my_dir लौट जाना चाहिए /var/my_dir

/my_dir/./ लौट जाना चाहिए /my_dir

../../../../../ लौट जाना चाहिए /

अधिक पांडित्य होना:

एक निर्देशिका एक गैर खाली अक्षरांकीय अक्षर से मिलकर स्ट्रिंग है और प्रतीकों -, _या.
एक पथ 0 या अधिक निर्देशिकाओं की एक सूची है, जिसका उपयोग करके अलग किया जाता है /। एक निरपेक्ष पथ एक के साथ शुरू होता है /, एक सापेक्ष पथ नहीं होता है। पथ में एक समाप्ति शामिल हो सकती है /।

आपको पहले पथ को देखते हुए, दूसरे पथ को "हल" करने की आवश्यकता है।

हल करने की प्रक्रिया है:

यदि दूसरा मार्ग सापेक्ष है तो परीक्षण करें। यदि ऐसा है, तो दूसरे पथ की शुरुआत के लिए निरपेक्ष पथ की निर्देशिकाएं डालें।
यदि कोई निर्देशिका है .., तो उसे और पूर्ववर्ती निर्देशिका को हटा दें। यदि यह पहली निर्देशिका है, तो बस इसे हटा दें।
यदि कोई निर्देशिका है ., तो उसे हटा दें।
अंतिम निरपेक्ष पथ का उत्पादन। आपको एंडिंग आउटपुट नहीं करना चाहिए /।

आपको गलत इनपुट को संभालने की आवश्यकता नहीं है। आदेशों को काम करना चाहिए, पारित निर्देशिका वास्तव में आपकी मशीन पर मौजूद हैं या नहीं। आप मान सकते हैं कि सब कुछ एक निर्देशिका है, भले ही इसका विस्तार हो।

परीक्षण के मामलों

Absolute      New          Output
"/a/b/c"      "d"       -> "/a/b/c/d" 
"/a/b/c/"     "d"       -> "/a/b/c/d"
"/a/b/c/"     "d/"      -> "/a/b/c/d"
"/a/b/c"      "/d"      -> "/d"
"/a/b/c"      "/d/"     -> "/d"
"/../a/b/c/"  "d"       -> "/a/b/c/d"
"/a/../b/c/"  "d"       -> "/b/c/d"
"/a/b/../c"   "d"       -> "/a/c/d"
"/a/b/c/.."   "d"       -> "/a/b/d"
"/a/b/c/"     ".."      -> "/a/b"
"/a/b/c"      "../d"    -> "/a/b/d"
"/a/b/c"      "/../d"   -> "/d"
"/a/b/c"      ""        -> "/a/b/c"
"/a/b/c"      "."       -> "/a/b/c"
"/a/b/c"      "./d"     -> "/a/b/c/d"
"/a/b/c"      "/./d"    -> "/d"
"/a/b/c"      "d.txt"   -> "/a/b/c/d.txt"
"/a/b/c"      "d."      -> "/a/b/c/d."
"/a/b/c"      ".txt"    -> "/a/b/c/.txt"
"/a/b/c"      ".txt/d"  -> "/a/b/c/.txt/d"
"/a/b/."      "./././." -> "/a/b"
"/direc"      "tory"    -> "/direc/tory"
"/a-_.b/"     "__._-."  -> "/a-_.b/__._-."
"/a/b"        "../.."   -> "/"
"/a/b"        "../../.."-> "/"
"/a"          "../../.."-> "/"
"/"           ""        -> "/"
"/"           "a"       -> "/a"
"/.."         "a"       -> "/a"
"/."          ""        -> "/"

यह एक कोड-गोल्फ है , इसलिए अपनी पसंदीदा भाषा में अपने सबमिशन को जितना हो सके कम करें!

code-golf string file-system

— नाथन मेरिल
स्रोत

कुछ उत्तर यह मानते हैं कि मशीन (डायरेक्टरी ट्री के किसी भी हिस्से के समान नाम) वाली फाइलें (या सिमिलिंक) मशीन पर मौजूद नहीं हैं। क्या इसकी अनुमति है?

— डेनिस

क्या हम अपनी इच्छानुसार दो इनपुट ले सकते हैं?

— डाउनगेट

मूर्खतापूर्ण प्रश्न ... क्या मुझे दुष्प्रभाव हो सकता है? विशेष रूप से, साइड इफेक्ट्स जैसे, उम, mkdir $patha; cd $patha; mkdir $pathb; cd $pathb; echo `abspath`(या कुछ)?

— बिल्ली

@dennis। कार्यक्रमों का आउटपुट फाइल सिस्टम से स्वतंत्र होना चाहिए

— नाथन मेरिल

@ उल्टागोत ठीक है

— नाथन मेरिल

7

रेटिना , 44 बाइट्स

+`.+ /| |/\.?/
/
+1`/?[^/]*/\.\.|/\.?$

^$
/

इनपुट एक ही स्थान से अलग होने वाले दो मार्ग होने की उम्मीद है।

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

— मार्टिन एंडर
स्रोत

3

पायथन, 53 बाइट्स

from os.path import*;p=lambda a,n:normpath(join(a,n))

— orlp
स्रोत

3

बैच, 282 281 279 276 बाइट्स

@echo off
set a=\
set r=%~2
if "%r%"=="" set r=%~1
if not %r:~,1%==/ set r=%~1/%~2
for %%a in (%r:/= %)do call:x %%a
if not %a%==\ set a=%a:~,-1%
echo %a:\=/%
exit/b
:x
if %1==. exit/b
if not %1==.. set a=%a%%1\&exit/b
if not %a%==\ for %%a in (%a:~,-1%)do set a=%%~pa

आमतौर पर बैच के भाव आमतौर पर खाली चर की तरह नहीं होते हैं। संपादित करें: @ C SavO'B 2 और 2 बाइट्स के लिए @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ (और अन्य उत्तरों पर बाइट्स का एक गुच्छा, हालांकि अफसोस बिना श्रेय दिए) के लिए 1 बाइट धन्यवाद के साथ सहेजा गया।

— नील
स्रोत

मुझे लगता है कि आप बीच का स्थान हटा सकते हैं call: x`, नहीं?

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ हुआ, तो आप कर सकते हैं। मुझे उन उत्तरों का एक गुच्छा मिला है, जिन्हें उस मामले में अद्यतन करने की आवश्यकता है ...

— नील

2

पायथन 2, 265 260 254 बाइट्स

y=lambda:[x for x in raw_input().split("/")if x!=""and x!="."]
a=y();n=y();m=len(a)-1
while m>0:
 if a[m]==".."and m>0:del a[m];del a[m-1];m-=1
 elif a[m]=="..":del a[m]
 m-=1
for i in n:
 if i==".."and len(a)>0:del a[-1]
 else:a+=i,
print"/"+"/".join(a)

— acrolith
स्रोत

1

पायथन, 142 137 बाइट्स

def p(a,n,r=[],S="/"):
 for s in[s for s in((n[:1]!=S)*a+S+n).split(S)if"."!=s and s]:e=s!="..";r=[s]*e+r[1-e:]
 return S+S.join(r[::-1])

— orlp
स्रोत

1

बैश, 41 बाइट्स

यदि वे मौजूद नहीं हैं तो यह बैश स्क्रिप्ट निर्देशिका बनाने का दुष्प्रभाव है, लेकिन यह आवश्यकताओं को पूरा करना चाहिए। आपके सुधार के लिए धन्यवाद कार्ल और नील ।

mkdir -p $1;cd $1;mkdir -p $2;cd "$2";pwd

उपयोग: bash getpath.sh "निरपेक्ष" "नया"

यदि आप दूसरे तर्क के खाली होने के बाद स्टैडर को पसंद नहीं करते हैं, तो आप इसके लिए निम्न प्रकार से परीक्षण कर सकते हैं (48 बाइट्स):

mkdir -p $1;cd $1;[ $2 ]&&mkdir -p $2&&cd $2;pwd

पिछला 30 बाइट का प्रयास (निर्देशिकाओं को मौजूद रहने की आवश्यकता है): ~~सीडी $ 1; [$ 2] && सीडी $ $ प्रतिध्वनिpwd~~

— Bryn
स्रोत

सवाल कहता है कि आदेशों को काम करना चाहिए, क्या पारित निर्देशिका वास्तव में आपकी मशीन पर मौजूद है या नहीं।

— डेनिस

ओह समझा। बहुत बुरा।

— ब्रायन

नमस्कार, और PPCG में आपका स्वागत है! आम तौर पर, यदि आपका जवाब काम नहीं करता है, तो आप इसे हटा देते हैं। आप इस टिप्पणी के ऊपर हटाए गए लिंक पर क्लिक कर सकते हैं।

— NoOneIsHere

आप mkdir -pयह सुनिश्चित कर सकते हैं कि वे मौजूद हैं।

— कार्ल नेफ

धन्यवाद, मैं mkdir के साथ एक संस्करण की कोशिश कर रहा हूँ। यदि मैं इसका पता लगाता हूं तो मैं इस उत्तर को हटा दूंगा और एक नया जोड़ दूंगा।

— ब्रायन

1

सी #, 43 बाइट्स

(x,y)=>Path.GetFullPath(Path.Combine(x,y));

@Aloisdg को 1 बाइट धन्यवाद दिया

Path.Combineकहते हैं तर्क एक साथ, और Path.GetFullPathनिराकरण ..\रों

— jlynch630
स्रोत

नमस्कार, और PPCG में आपका स्वागत है! यह एक वैध कार्यक्रम नहीं है - या तो शामिल करें mainऔर एक वर्ग, या इसे एक लैन्ब्डा में बदलें: a,b->...

— NoOneIsHere

मैं इसे पोस्ट करने जा रहा था :) अच्छा पहला सबमिशन! आप के बाद अंतरिक्ष हटा सकते हैं ,: (x, y)=>(x,y)

— aloisdg

इसके अलावा सी # गोल्फ के लिए टिप्स आपको रूचि दे सकते हैं।

— aloisdg का कहना है कि Monica

1

नोड REPL, 8 12 बाइट्स

path.resolve

सौभाग्य से आपको require()REPL में मानक मॉड्यूल नहीं हैं ।

परीक्षण सूट

https://repl.it/Cclo/1

(यदि अंत में आउटपुट है true, तो यह मेल खाता है)

— पैट्रिक रॉबर्ट्स
स्रोत

1

जावास्क्रिप्ट, 210 बाइट्स

function p(a,b){d='.';e=d+d;s='/';t='split';u='splice';r=(b[0]===s?[]:a[t](s)).concat(b[t](s));for(i=0;i<r.length;r[i]===e&&r[u](i?i-1:i,i?2:1)?(i&&i--):i++)(!r[i]||r[i]===d)&&r[u](i,1)&&i--;return s+r.join(s)}

यहाँ परीक्षण सूट है

अर्धविराम के बजाय लाइनब्रेक के साथ:

function p(a,b) {
    d='.'
    e=d+d
    s='/'
    t='split'
    u='splice'

    r=(b[0]===s?[]:a[t](s)).concat(b[t](s))

    for(i=0;i<r.length;r[i]===e&&r[u](i?i-1:i,i?2:1)?(i&&i--):i++)
        (!r[i]||r[i]===d)&&r[u](i,1)&&i--

    return s+r.join(s)
}

— CShark
स्रोत

0

जावा 7, 83 बाइट्स

String p(String a,String b){return Paths.get(a).resolve(b).normalize().toString();}

normalizeरिश्तेदार संदर्भों से निपटने के लिए आवश्यक है। addके साथ शुरू होने वाले दूसरे पथ को संभालने के लिए उपयोग किया जाता है /, जो Paths.get(a, b)निर्दिष्ट के रूप में संभाल नहीं करेगा।

— jaxad0127
स्रोत

नमस्कार, और PPCG में आपका स्वागत है! यह एक अच्छी पहली पोस्ट है!

— NoOneIsHere

0

बैश, 38 बाइट्स

[[ $2 = /* ]]||p=$1
realpath -sm $p/$2

रूट विशेषाधिकारों की आवश्यकता नहीं है और मौजूदा या गैर-मौजूदा फ़ाइलों, निर्देशिकाओं या प्रतीकात्मक लिंक के बारे में कोई धारणा नहीं बनाता है।

Ideone पर इसका परीक्षण करें ।

यह काम किस प्रकार करता है

[[ $2 = /* ]]परीक्षण यदि दूसरी कमांड-लाइन तर्क के साथ शुरू होता है /।

यदि यह नहीं है, तो पथ सापेक्ष है और पहले कमांड-लाइन तर्क के लिए p=$1चर पी सेट करता है।

यह तरीका $p/$2है /$2यदि $2एक निरपेक्ष मार्ग है और $1/$2यदि यह एक वास्तविक है।

अंत में, realpath -sm $p/$2विहित निरपेक्ष पथ प्रिंट करता है $p/$2। -sस्विच बनाता realpath सांकेतिक लिंक की अनदेखी, और -mस्विच लापता घटकों।

— डेनिस
स्रोत

0

रूबी, 16 बाइट्स

चूंकि स्पष्ट रूप से मानक पुस्तकालय से एक विधि का उपयोग करने की अनुमति है:

File.expand_path

Repl.it पर परीक्षण सूट देखें ।

— जॉर्डन
स्रोत

चर के माध्यम से इनपुट की अनुमति नहीं है, लेकिन फ़ंक्शन सबमिशन, हैं, जिसका अर्थ है कि आपको इसे छोटा करना चाहिए File.expand_path:)

— नाथन मेरिल

मैं यह भी परीक्षण सूट के खिलाफ वास्तव में यह सुनिश्चित करने की सिफारिश करता हूं कि यह परीक्षण के सभी मामलों में सही ढंग से काम करता है।

— नाथन मेरिल

@NathanMerrill मैंने किया, लेकिन मैं आगे जाऊंगा और repl.it पर कुछ छड़ी करूंगा।

— जॉर्डन

परीक्षण सूट लिंक शामिल करने के लिए संपादित किया गया।

— जॉर्डन

0

जीएनयू सेड , 81 59 + 1 = 60 बाइट्स

-rझंडे के लिए +1 बाइट । एसटीडीआईएन पर इनपुट एक एकल स्थान से अलग होने की उम्मीद करता है।

s:.+ /::
s:/? :/:
:
s:/$|[^/]+/+\.\.|\.(/|$):\1:
t
s:^/*:/:

इसे ऑनलाइन आज़माएं!

व्याख्या

s:.+ /::  # If the second argument starts with a slash, drop the first argument
s:/? :/:  # Join the first and second arguments with a slash, dropping duplicate slashes
:
  s:/$|[^/]+/+\.\.|\.(/|$):\1:  # Drop trailing slashes, resolve double and single dots
  t                             # If the above substitution was made, branch to :
s:^/*:/:  # Ensure output begins with a single slash

— जॉर्डन
स्रोत

0

Zsh , 15 बाइट्स

a=$1/$2
<<<$a:a

:aसंशोधक वास्तव में ऐसा करता है।

इसे ऑनलाइन आज़माएं!

— GammaFunction
स्रोत

निर्देशिका गणना

परीक्षण के मामलों

रेटिना , 44 बाइट्स

पायथन, 53 बाइट्स

बैच, 282 281 279 276 बाइट्स

पायथन 2, 265 260 254 बाइट्स

पायथन, 142 137 बाइट्स

बैश, 41 बाइट्स

सी #, 43 बाइट्स

नोड REPL, 8 12 बाइट्स

परीक्षण सूट

जावास्क्रिप्ट, 210 बाइट्स

जावा 7, 83 बाइट्स

बैश, 38 बाइट्स

यह काम किस प्रकार करता है

रूबी, 16 बाइट्स

जीएनयू सेड , 81 59 + 1 = 60 बाइट्स

व्याख्या

Zsh , 15 बाइट्स