Para esse desafio, você receberá um caminho absoluto e um "novo" (que pode ser absoluto ou relativo) e precisará retornar o caminho final.

Por exemplo, se seu diretório atual fosse /var/tmp/test:

my_dirou my_dir/ deveria retornar/var/tmp/test/my_dir

../../my_dir deve retornar /var/my_dir

/my_dir/./ deve retornar /my_dir

../../../../../ deve retornar /

Para ser mais pedante:

• Um diretório é uma string não-vazia que consiste de caracteres alfanuméricos e os símbolos -, _ou.
• Um caminho é uma lista de 0 ou mais diretórios , separados usando /. Um caminho absoluto começa com a /, um caminho relativo não. Os caminhos podem incluir um final /.

Você precisa "resolver" o segundo caminho, dado o primeiro caminho.

O processo de resolução é:

1. Teste se o segundo caminho é relativo. Nesse caso, insira os diretórios do caminho absoluto no início do segundo caminho.
2. Se algum dos diretórios for .., remova-o e o diretório anterior. Se for o primeiro diretório, basta removê-lo.
3. Se algum dos diretórios estiver ., remova-o.
4. Saída o caminho absoluto final. Você não deve produzir um final /.

Você não precisa lidar com entradas incorretas. Os comandos devem funcionar, independentemente de os diretórios transmitidos existirem na sua máquina. Você pode assumir que tudo é um diretório, mesmo que tenha uma extensão.

Casos de teste

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

Este é um código de golfe , então faça seus envios o mais curto possível no seu idioma favorito!

Retina , 44 bytes

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

^$
/

A entrada deve ser os dois caminhos separados por um único espaço.

Experimente online! (A primeira linha ativa um conjunto de testes separado por avanço de linha.)

Python, 53 bytes

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

Lote, 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

Irritantemente, expressões em lote geralmente não gostam de variáveis ​​vazias. Editar: salvou 1 byte graças a @ CᴏɴᴏʀO'Bʀɪᴇɴ e 2 bytes graças a @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ (e vários bytes em outras respostas também, embora ainda não creditados).

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

Esse script bash tem o efeito colateral de criar diretórios se eles não existirem, mas deve atender aos requisitos. Obrigado Karl e Neil por suas melhorias.

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

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

Se você não gostar do stderr quando o segundo argumento for uma sequência vazia, poderá testá-lo da seguinte forma (48 bytes):

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

Tentativa anterior de 30 bytes (requer a existência de diretórios): cd $ 1; [$ 2] && cd $ 2; echopwd

C #, 43 bytes

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

Guardado 1 byte graças a @aloisdg

Path.Combinereúne os argumentos e Path.GetFullPathresolve os ..\s

Nó REPL, 8 12 bytes

path.resolve

Felizmente, você não precisa require()usar módulos padrão no REPL.

Suíte de teste

https://repl.it/Cclo/1

(Se a saída no final for truecorrespondente)

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

Aqui está o conjunto de testes

Com quebras de linha em vez de ponto e vírgula:

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

normalizeé necessário para lidar com referências relativas. addé usado para manipular o segundo caminho que começa com /, que Paths.get(a, b)não manipula conforme especificado.

Bash, 38 bytes

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

Não requer privilégios de root e não faz suposições sobre arquivos, diretórios ou links simbólicos existentes ou não existentes.

Teste em Ideone .

Como funciona

[[ $2 = /* ]]testa se o segundo argumento da linha de comando começa com /.

Caso contrário, o caminho é relativo e p=$1define a variável p para o primeiro argumento da linha de comando.

Desta forma, $p/$2é /$2se $2é um caminho absoluto e $1/$2se ele é um realtive.

Por fim, realpath -sm $p/$2imprime o caminho absoluto canônico de $p/$2. O -scomutador faz com que o caminho real ignore os links simbólicos e os -mcomponentes ausentes do comutador.

Ruby, 16 bytes

Como aparentemente é permitido usar um método da biblioteca padrão :

File.expand_path

Veja a suíte de testes em repl.it .

GNU sed , 81 59 + 1 = 60 bytes

+1 byte para -rsinalizador. Espera que a entrada no STDIN separe por um único espaço.

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

Experimente online!

Explicação

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

O :amodificador faz exatamente isso.

Experimente online!