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_dir
ou 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 é:
- Teste se o segundo caminho é relativo. Nesse caso, insira os diretórios do caminho absoluto no início do segundo caminho.
- Se algum dos diretórios for
..
, remova-o e o diretório anterior. Se for o primeiro diretório, basta removê-lo. - Se algum dos diretórios estiver
.
, remova-o. - 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!
fonte
mkdir $patha; cd $patha; mkdir $pathb; cd $pathb; echo `abspath`
(ou algo assim)?Respostas:
Retina , 44 bytes
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.)
fonte
Python, 53 bytes
fonte
Lote,
282281279276 bytesIrritantemente, 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).
fonte
call
e: x`, não?Python 2,
265260254 bytesfonte
Python,
142137 bytesfonte
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.
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):
Tentativa anterior de 30 bytes (requer a existência de diretórios):
cd $ 1; [$ 2] && cd $ 2; echopwd
fonte
mkdir -p
ter certeza de que eles existem.C #, 43 bytes
Guardado 1 byte graças a @aloisdg
Path.Combine
reúne os argumentos ePath.GetFullPath
resolve os..\
sfonte
main
e uma classe, ou altere-o para um lanbda:a,b->
...,
:(x, y)
=>(x,y)
Nó REPL,
812 bytesFelizmente, 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
true
correspondente)fonte
Javascript, 210 bytes
Aqui está o conjunto de testes
Com quebras de linha em vez de ponto e vírgula:
fonte
Java 7, 83 bytes
normalize
é necessário para lidar com referências relativas.add
é usado para manipular o segundo caminho que começa com/
, quePaths.get(a, b)
não manipula conforme especificado.fonte
Bash, 38 bytes
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=$1
define a variável p para o primeiro argumento da linha de comando.Desta forma,
$p/$2
é/$2
se$2
é um caminho absoluto e$1/$2
se ele é um realtive.Por fim,
realpath -sm $p/$2
imprime o caminho absoluto canônico de$p/$2
. O-s
comutador faz com que o caminho real ignore os links simbólicos e os-m
componentes ausentes do comutador.fonte
Ruby, 16 bytes
Como aparentemente é permitido usar um método da biblioteca padrão :
Veja a suíte de testes em repl.it .
fonte
File.expand_path
:)GNU sed ,
8159 + 1 = 60 bytes+1 byte para
-r
sinalizador. Espera que a entrada no STDIN separe por um único espaço.Experimente online!
Explicação
fonte
Zsh , 15 bytes
O
:a
modificador faz exatamente isso.Experimente online!
fonte