Für diese Herausforderung erhalten Sie einen absoluten Pfad und einen "neuen" Pfad (der absolut oder relativ sein kann), und Sie müssen den endgültigen Pfad zurückgeben.

Zum Beispiel, wenn Ihr aktuelles Verzeichnis war /var/tmp/test:

my_diroder my_dir/ sollte zurückkehren/var/tmp/test/my_dir

../../my_dir sollte zurückkehren /var/my_dir

/my_dir/./ sollte zurückkehren /my_dir

../../../../../ sollte zurückkehren /

Um pedantischer zu sein:

• Ein Verzeichnis ist eine nicht leere Zeichenfolge , bestehend aus alphanumerischen Zeichen und die Symbole -, _, oder.
• Ein Pfad ist eine Liste von 0 oder mehr Verzeichnissen , die mit getrennt werden /. Ein absoluter Pfad beginnt mit a /, ein relativer Pfad nicht. Pfade können ein Ende enthalten /.

Sie müssen den zweiten Pfad unter Angabe des ersten Pfads "auflösen".

Der Lösungsprozess ist:

1. Testen Sie, ob der zweite Pfad relativ ist. Wenn ja, fügen Sie die Verzeichnisse des absoluten Pfads an den Anfang des zweiten Pfads ein.
2. Wenn eines der Verzeichnisse vorhanden ist .., entfernen Sie es und das vorhergehende Verzeichnis. Wenn es das erste Verzeichnis ist, entfernen Sie es einfach.
3. Wenn eines der Verzeichnisse vorhanden ist ., entfernen Sie es.
4. Geben Sie den endgültigen absoluten Pfad aus. Sie sollten kein Ende ausgeben /.

Sie müssen nicht mit falschen Eingaben umgehen. Die Befehle sollten funktionieren, unabhängig davon, ob die übergebenen Verzeichnisse tatsächlich auf Ihrem Computer vorhanden sind. Sie können davon ausgehen, dass alles ein Verzeichnis ist, auch wenn es eine Erweiterung hat.

Testfälle

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

Dies ist ein Code-Golf , also machen Sie Ihre Einsendungen so kurz wie möglich in Ihrer Lieblingssprache!

Retina , 44 Bytes

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

^$
/

Es wird erwartet, dass die Eingabe die zwei Pfade sind, die durch ein einzelnes Leerzeichen getrennt sind.

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Python, 53 Bytes

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

Batch, 282 281 279 276 Bytes

@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

Ärgerlicherweise mögen Batch-Ausdrücke im Allgemeinen keine leeren Variablen. Bearbeiten: 1 Byte dank @ CᴏɴᴏʀO'Bʀɪᴇɴ und 2 Byte dank @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ gespeichert (und eine Reihe von Bytes auch bei anderen Antworten, obwohl leider nicht im Abspann).

Python 2, 265 260 254 Bytes

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)

Python, 142 137 Bytes

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

Bash, 41 Bytes

Dieses Bash-Skript hat den Nebeneffekt, dass Verzeichnisse erstellt werden, wenn sie nicht vorhanden sind. Es sollte jedoch die Anforderungen erfüllen. Vielen Dank an Karl und Neil für eure Verbesserungen.

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

Verwendung: bash getpath.sh "absolute" "new"

Wenn Ihnen das stderr nicht gefällt, wenn das zweite Argument eine leere Zeichenfolge ist, können Sie es wie folgt testen (48 Byte):

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

Vorheriger 30-Byte-Versuch (es müssen Verzeichnisse vorhanden sein): cd $ 1; [$ 2] && cd $ 2; echopwd

C # 43 Bytes

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

1 Byte dank @aloisdg gespeichert

Path.Combinefasst die Argumente zusammen und Path.GetFullPathlöst das ..\s auf

Knoten REPL, 8 - 12 Bytes

path.resolve

Zum Glück müssen Sie require()in der REPL keine Standardmodule verwenden.

Test Suite

https://repl.it/Cclo/1

(Wenn die Ausgabe am Ende ist true, stimmt sie überein)

Javascript, 210 Bytes

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

Hier ist die Testsuite

Mit Zeilenumbrüchen anstelle von Semikolons:

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

Java 7, 83 Bytes

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

normalizewird benötigt, um mit relativen Referenzen umzugehen. addwird verwendet, um den zweiten Pfad zu behandeln /, der Paths.get(a, b)nicht wie angegeben behandelt wird.

Bash, 38 Bytes

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

Erfordert keine Root-Rechte und macht keine Annahmen über vorhandene oder nicht vorhandene Dateien, Verzeichnisse oder symbolische Links.

Teste es auf Ideone .

Wie es funktioniert

[[ $2 = /* ]]testet, ob das zweite Befehlszeilenargument mit beginnt /.

Ist dies nicht der Fall, ist der Pfad relativ und p=$1setzt die Variable p auf das erste Befehlszeilenargument.

Auf diese Weise $p/$2ist /$2if $2ein absoluter und $1/$2ein realistischer Pfad.

Zum Schluss wird realpath -sm $p/$2der kanonische absolute Pfad von gedruckt $p/$2. Der -sSchalter veranlasst Realpath , symbolische Verknüpfungen zu ignorieren, und dem -mSchalter fehlen Komponenten.

Ruby, 16 Bytes

Da anscheinend die Verwendung einer Methode aus der Standardbibliothek erlaubt ist:

File.expand_path

Sehen Sie sich die Test - Suite auf repl.it .

GNU sed , 81 59 + 1 = 60 Bytes

+1 Byte für -rFlag. Erwartet, dass die Eingabe in STDIN durch ein einzelnes Leerzeichen getrennt wird.

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

Probieren Sie es online!

Erläuterung

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

Zsh , 15 Bytes

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

Der :aModifikator macht genau das.

Probieren Sie es online!