Find common directory path: Difference between revisions

 

Test your routine using the forward slash '/' character as the directory separator and the following three strings as input paths:

 

If your language has a routine that performs this function (even if it does not have a changeable separator character), then mention it as part of the task.

 

<br><br>

=={{header|11l}}==

{{trans|C}}

 

V pos = 0

L

‘/home/user1/tmp/coverage/test’,

‘/home/user1/tmp/covert/operator’,

 

{{out}}

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

 

);

end Test_Common_Path;

Output:

<pre>

 

=={{header|Aime}}==

{

integer e;

 

0;

 

=={{header|ALGOL 68}}==

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

 

 

CHAR dir sep = "/"; # Assume POSIX #

);

print((dir name(common prefix(dir list)), new line))

Output:

<pre>

/home/user1/tmp

</pre>

 

=={{header|AutoHotkey}}==

Dir2 := "/home/user1/tmp/covert/operator"

Dir3 := "/home/user1/tmp/coven/members"

Else Break

 

Message box shows:

<pre>/home/user1/tmp</pre>

 

=={{header|AWK}}==

# paths[count], where sep is a single-character directory separator.

function common_dir(paths, count, sep, b, c, f, i, j, p) {

a[3] = "/home/user1/tmp/coven/members"

print common_dir(a, 3, "/")

 

Prints <tt>/home/user1/tmp</tt>.

Also, under FreeBASIC, the <code>pathSep</code> arg to <code>commonPath$</code> could be made optional, or even system-dependent.

 

 

DATA "/home/user2", "/home/user1/tmp/covert/operator", "/home/user1/tmp/coven/members"

commonPath$ = tmpstr1

END IF

 

=={{header|Batch File}}==

@echo off

setlocal enabledelayedexpansion

endlocal

exit /b

{{out}}

<pre>

/home/user1/tmp/

</pre>

 

=={{header|BBC BASIC}}==

path$(1) = "/home/user1/tmp/coverage/test"

NEXT J%

UNTIL I% = 0

 

=={{header|C}}==

 

int common_len(const char *const *names, int n, char sep)

 

return 0;

 

=={{header|C sharp|C#}}==

 

using System;

using System.Collections.Generic;

}

 

 

=={{header|D}}==

This code uses the std.algorithm.commonPrefix function that finds the common prefix of two ranges.

 

string commonDirPath(in string[] paths, in string sep = "/") pure {

"/home/user1/tmp/coven/members"];

writeln(`The common path is: "`, paths.commonDirPath, '"');

{{out}}

<pre>The common path is: "/home/user1/tmp"</pre>

 

=={{header|Elixir}}==

{{trans|Ruby}}

def common_directory_path(dirs, separator \\ "/") do

dir1 = Enum.min(dirs) |> String.split(separator)

 

dirs = ~w( /home/user1/tmp/coverage/test /home/user1/tmp/covert/operator /home/user1/tmp/coven/members )

 

{{out}}

 

=={{header|Erlang}}==

-module( find_common_directory ).

 

 

keep_common( Components, Acc ) -> [X || X <- Components, Y <- Acc, X =:= Y].

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

 

let (|SeqNode|SeqEmpty|) s =

 

printfn "The common preffix is: %A" (String.Join("/", (commonPrefix args)))

Output for the given task input

<pre>The common preffix is: "/home/user1/tmp"</pre>

 

=={{header|Factor}}==

[ shorter? ] 2keep ? ;

 

 

: common-prefix ( seq separator -- prefix )

 

( scratchpad ) {

=={{header|FreeBASIC}}==

{{Trans|Visual Basic}}

' compile: fbc.exe -s console cdp.bas

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>/home/user1/tmp/coverage/test

/home/user1/tmp/coven/members

/ <- common</pre>

 

=={{header|Gambas}}==

Dim sFolder As String[] = ["/home/user1/tmp/coverage/test", "/home/user1/tmp/covert/operator", "/home/user1/tmp/coven/members"]

Dim sSame As String

Print Mid(sSame, 1, RInStr(sSame, "/") - 1)

 

Output:

<pre>

E.g. (<code>/home/user1, /home/user1/foo, /home/user1/bar</code>) should result in <code>/home/user1</code>, not <code>/home</code>.

 

 

import (

fmt.Println("Common path:", c)

}

 

=={{header|Groovy}}==

Solution:

def pathParts = paths.collect { it.split(delim) }

pathParts.transpose().inject([match:true, commonParts:[]]) { aggregator, part ->

aggregator

}.commonParts.join(delim)

 

Test:

'/home/user1/tmp/coverage/test',

'/home/user1/tmp/covert/operator',

'/home/user1/tmp/covert/test',

'/home/user1/tmp/coven/test',

 

Output:

{{works with|GW-BASIC}}

{{works with|Chipmunk Basic}}

 

Because most BASICs don't have any sort of parsing functions built in, we have to deal with the entire string (rather than checking one level at a time).

Note that if the root directory is the common path, this reports the same as no match found (i.e. blank result).

 

 

110 X$ = "/home/user1/tmp/coverage/test"

350 A = L0 - 1

360 P$ = LEFT$(X$, A)

 

Output:

=={{header|Haskell}}==

 

 

-- Return the common prefix of two lists.

"/home/user1/tmp/covert/operator",

"/home/user1/tmp/coven/members"

 

import Data.List.Split (splitOn)

 

 

 

main :: IO ()

main =

[ "/home/user1/tmp/coverage/test"

, "/home/user1/tmp/covert/operator"

, "/home/user1/tmp/coven/members"

{{Out}}

<pre>/home/user1/tmp</pre>

 

=={{header|HicEst}}==

 

minLength = MIN( LEN(a), LEN(b), LEN(c) )

WRITE(Messagebox, Name) "No common directory for", a, b, c

ENDIF

 

=={{header|Icon}} and {{header|Unicon}}==

write(lcdsubstr(["/home/user1/tmp/coverage/test","/home/user1/tmp/covert/operator","/home/user1/tmp/coven/members"]))

end

if not match(s,x) then fail

return s

 

=={{header|J}}==

'''Solution:'''

getCommonPrefix =: {. ;@{.~ 0 i.~ *./@(="1 {.)

 

 

'''Example:'''

getCommonPrefix >paths

/home/user1/tmp/cove

'/' getCommonDirPath paths

 

'''Note:'''

This alternative formulation of parseDirs provides cross-platform support, without the need to specify the path separator.

=={{header|Java}}==

{{works with|Java|1.5+}}

This example is case-sensitive.

public static String commonPath(String... paths){

String commonPath = "";

System.out.println(commonPath(paths2));

}

Output:

<pre>/home/user1/tmp/

 

A slightly modified version of the previous program, only the method commonPath() is changed.

static String commonPath(String... paths){

String commonPath = "";

return commonPath;

}

 

=={{header|JavaScript}}==

/**

* Given an array of strings, return an array of arrays, containing the

 

console.log(`Common path is: ${commonPath(cdpInput)}`);

 

{{out}}

Common path is: /home/user1/tmp

</pre>

 

=={{header|jq}}==

def maximal_initial_subarray:

(map( .[0] ) | unique) as $u

[.[] | split(slash)] | maximal_initial_subarray | join(slash) ;

 

 

Assuming the above jq program is in a file named common_path.jq and that the file directories.txt contains the three given directory strings quoted with double quotation marks:

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

0 < length(ds) || return ""

1 < length(ds) || return String(ds[1])

 

println("Comparing:\n - ", join(test, "\n - "))

 

{{out}}

 

=={{header|Kotlin}}==

 

fun findCommonDirPath(paths: List<String>, separator: Char): String {

println("The common directory path of:\n\n$pathsToPrint\n")

println("is '${findCommonDirPath(paths, '/')}'")

 

{{out}}

 

=={{header|Lasso}}==

 

local(

}

 

 

Output:

 

=={{header|Liberty BASIC}}==

path$(2) = "/home/user1/tmp/covert/operator"

path$(3) = "/home/user1/tmp/coven/members"

end if

wend

 

=={{header|Lingo}}==

_player.itemDelimiter = sep

 

end repeat

return pathes[1].item[1..commonCnt]

pathes.add("/home/user1/tmp/coverage/test")

pathes.add("/home/user1/tmp/covert/operator")

 

put getCommonPath(pathes, "/")

 

=={{header|MapBasic}}==

Derived from the [https://www.rosettacode.org/wiki/Find_common_directory_path#BASIC BASIC] example above

 

 

Declare Sub Main

PRINT "Common path is " + commonPath(x(), Sep)

 

 

=={{header|Maple}}==

dirpath:=proc(a,b,c)

local dirtemp,dirnew,x;

end use;

end proc;

 

[Fold[LongestCommonSubsequence, First[x] , Rest[x]]]

 

FindCommonDirectory[{"/home/user1/tmp/coverage/test", "/home/user1/tmp/covert/operator", "/home/user1/tmp/coven/members"}]

 

=={{header|Maxima}}==

substring(a, 1, catch(for i thru n do (

if not cequal(charat(a, i), charat(b, i)) then throw(i)), n + 1)))$

 

commonpath(["c:/files/banister.jpg", "c:/files/bank.xls", "c:/files/banana-recipes.txt"]);

 

=={{header|MUMPS}}==

NEW D,SEP,EQ,LONG,DONE,I,J,K,RETURN

SET D(1)="/home/user1/tmp/coverage/test"

WRITE !,"The longest common directory is: ",RETURN

KILL D,SEP,EQ,LONG,DONE,I,J,K,RETURN

Usage:<pre>

USER>D FCD^ROSETTA

 

=={{header|Nim}}==

 

proc commonprefix(paths: openarray[string], sep = "/"): string =

if paths.len == 0: return ""

block outer:

for path in paths:

if not path.startsWith(result):

break outer

 

Output:

<pre>/home/user1/tmp</pre>

 

=={{header|OCaml}}==

 

 

 

"/home/user1/tmp/coverage/test";

"/home/user1/tmp/covert/operator";

"/home/user1/tmp/coven/members";

 

 

=={{header|OpenEdge/Progress}}==

i_cdirs AS CHAR,

i_cseparator AS CHAR

RETURN cresult.

 

 

findCommonDir(

'/home/user1/tmp/coverage/test' + '~n' +

'/'

)

 

Output

=={{header|Oz}}==

With a few helper functions, we can express the solution like this in Oz:

fun {CommonPrefix Sep Paths}

fun {GetParts P} {String.tokens P Sep} end

["/home/user1/tmp/coverage/test"

"/home/user1/tmp/covert/operator"

 

=={{header|PARI/GP}}==

my(s="");

v=apply(t->Vec(t),v);

if(vecmax(apply(length,v))==vecmin(apply(length,v)),concat(v[1]),s)

};

 

=={{header|Perl}}==

A solution which lets the regex engine do all the work ''(it operates on the concatenation of the given paths delimited by null-bytes, which should be safe since null-bytes are not allowed inside paths)'':

 

my $sep = shift;

my $paths = join "\0", map { $_.$sep } @_;

$paths =~ /^ ( [^\0]* ) $sep [^\0]* (?: \0 \1 $sep [^\0]* )* $/x;

return $1;

 

A more conventional solution, which tallies up all potential prefixes from the given paths and then looks for the longest one that occurred the same number of times as there are paths:

 

 

sub common_prefix {

return first { $prefixes{$_} == @paths } reverse sort keys %prefixes;

 

'''Testing:'''

 

/home/user1/tmp/covert/operator

/home/user1/tmp/coven/members);

 

{{out}}

<pre>/home/user1/tmp</pre>

 

=={{header|Phix}}==

Note: if the testset contains /home/user1/tmp the result is /home/user1, with /home/user1/tmp/ instead of that, it is /home/user1/tmp<br>

To change that behaviour, simply remove both the [1..-2]<br>

{{out}}

<pre>

 

=={{header|PHP}}==

 

/*

}

 

 

 

 

/* A more compact string-only version, which I assume would be much faster */

}

 

 

=={{header|PicoLisp}}==

(glue Chr

(make

(apply find

(mapcar '((L) (split (chop L) Chr)) Lst)

Output:

<pre>(commonPath

 

-> "/home/user1/tmp"</pre>

=={{header|Pike}}==

"/home/user1/tmp/covert/operator",

"/home/user1/tmp/coven/members" });

string cp = String.common_prefix(paths);

cp = cp[..sizeof(cp)-search(reverse(cp), "/")-2];

 

=={{header|PowerBASIC}}==

{{Trans|Visual Basic}}

#DIM ALL

#COMPILER PBCC 6

CON.WAITKEY$

 

{{out}}

<pre>/home/user1/tmp/coverage/test

=={{header|PowerShell}}==

 

<#

.Synopsis

}

}

 

Sample execution:

"C:\a\b\c\d\e","C:\a\b\e\f","C:\a\b\c\d\x" | Get-CommonPath

C:\a\b

 

=={{header|PureBasic}}==

 

Simply by checking the catalog names until they mismatch and add up the correct parts, the task is accomplished.

Protected SOut$=""

Protected i, j, toggle

Next

ForEver

 

Example of implementation

t(0)="/home/user1/tmp/coverage/test"

t(1)="/home/user1/tmp/covert/operator"

t(2)="/home/user1/tmp/coven/members"

 

 

=={{header|Python}}==

The Python os.path.commonprefix function is [http://nedbatchelder.com/blog/201003/whats_the_point_of_ospathcommonprefix.html broken] as it returns common characters that may not form a valid directory path:

>>> os.path.commonprefix(['/home/user1/tmp/coverage/test',

'/home/user1/tmp/covert/operator', '/home/user1/tmp/coven/members'])

 

This result can be fixed:

return os.path.commonprefix(args).rpartition(sep)[0]

 

>>> commonprefix(['/home/user1/tmp/coverage/test',

'/home/user1/tmp/covert/operator', '/home/user1/tmp/coven/members'])

 

Even shorter:

>>> os.path.dirname(os.path.commonprefix(paths))

 

But it may be better to not rely on the faulty implementation at all:

>>> def allnamesequal(name):

return all(n==name[0] for n in name[1:])

'/home/user1/tmp/covert/operator', '/home/user1/tmp/coven/members'])

'/home/user1/tmp'

 

=={{header|R}}==

get_common_dir <- function(paths, delim = "/")

{

get_common_dir(paths) # "/home/user1/tmp"

 

 

=={{header|Racket}}==

#lang racket

 

"/home/user1/tmp/coven/members")

;; --> "/home/user1/tmp"

 

=={{header|REXX}}==

 

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

# Project : Find common directory path

 

end

return left(p[1], o-1)

Output:

<pre>

/home/user1/tmp

</pre>

 

Uses the standard library <code>[http://www.ruby-doc.org/stdlib/libdoc/abbrev/rdoc/index.html abbrev]</code> module: Given a set of strings, calculate the set of unambiguous abbreviations for those strings, and return a hash where the keys are all the possible abbreviations and the values are the full strings.

 

 

dirs = %w( /home/user1/tmp/coverage/test /home/user1/tmp/covert/operator /home/user1/tmp/coven/members )

 

common_prefix = dirs.abbrev.keys.min_by {|key| key.length}.chop # => "/home/user1/tmp/cove"

 

Implementing without that module:

path0, *paths = dirs.collect {|dir| dir.split(separator)}

uncommon_idx = path0.zip(*paths).index {|dirnames| dirnames.uniq.length > 1}

uncommon_idx = path0.length unless uncommon_idx # if uncommon_idx==nil

 

or method version

dir1, dir2 = dirs.minmax.map{|dir| dir.split(separator)}

dir1.zip(dir2).take_while{|dn1,dn2| dn1==dn2}.map(&:first).join(separator)

end

 

 

=={{header|Run BASIC}}==

' Find common directory to all directories

' and directories common with other Paths

html "</TABLE>"

wait

========= Common paths ================<br />

shows only the first few common paths..

</TR><TR><TD>11</TD><TD>/home/user1/tmp3/covert/operator</TD><TD>/home/user1/tmp3/</TD><TD>12</TD><TD>/home/user1/tmp3/coven/members</TD>

<TR></TABLE>

 

=={{header|Rust}}==

Rust has specific types for owned and borrowed paths. PathBuf is an 'owned' pointer to a path, Path is a borrow; this is similar to String and str, respectively.

 

use std::path::{Path, PathBuf};

 

}

}

 

=={{header|Scala}}==

===Naive===

This simple solution solves the task as given, but has oddities for edge cases due to the implementation of java.lang.String#split.

def commonPath(paths: List[String]): String = {

def common(a: List[String], b: List[String]): List[String] = (a, b) match {

)

println(commonPath(test))

Output:

<pre>/home/user1/tmp</pre>

===Advanced===

This implementation will handle various edge cases and relative paths. It also includes any common trailing '/' but callers can remove this if desired.

def commonPath(paths: List[String]): String = {

val SEP = "/"

assert(commonPath(List("/a/a/", "/a/b/")) == "/a/")

assert(commonPath(List("/a/b/", "/a/b/")) == "/a/b/")

 

=={{header|Seed7}}==

but they need to make sure that a path does not end with a slash.

 

 

const func integer: commonLen (in array string: names, in char: sep) is func

writeln("Common path: " <& names[1][.. length]);

end if;

 

Output:

 

=={{header|Sidef}}==

/home/user1/tmp/coverage/test

/home/user1/tmp/covert/operator

var unique_pref = dirs.map{.split('/')}.abbrev.min_by{.len};

var common_dir = [unique_pref, unique_pref.pop][0].join('/');

 

=={{header|Swift}}==

The below solution works only in swift in Linux.

 

 

 

 

var output:String = getPrefix(test)!

 

=={{header|Tcl}}==

proc pop {varname} {

upvar 1 $varname var

}

return [join $parts $separator]

 

<pre>% common_prefix {/home/user1/tmp/coverage/test /home/user1/tmp/covert/operator /home/user1/tmp/coven/members}

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

common=""

ENDIF

ENDLOOP

Output:

<pre>

=={{header|UNIX Shell}}==

The following is a pure Bourne Shell solution. The while loop controls the maximum depth to check paths.

#!/bin/sh

 

i=`expr $i + 1`

done

 

=={{header|Ursala}}==

The algorithm is to lex the paths into component directory names, and then find the greatest common prefix of those.

 

where <code>"s"</code> is a dummy variable representing the separator, <code>"p"</code> is a dummy variable representing the list of paths, and

*<code>sep</code> is second order function in the standard library that takes a separator character and returns a lexer mapping a string containing the separator to a list of the substrings found between occurrences of it

*<code>mat</code> is a second order function in the standard library that takes a separator character and returns a function that flattens a list of strings into a single string with copies of the separator inserted between them

Here is a version using operators instead of mnemonics for <code>map</code> and <code>reduce</code>.

Here is one in partly point-free form, using the composition operator (<code>+</code>).

Here it is in point-free form.

test program:

 

test =

'/home/user1/tmp/coverage/test',

'/home/user1/tmp/covert/operator',

output:

<pre>'/home/user1/tmp'</pre>

=={{header|VBScript}}==

{{works with|Windows Script Host|*}}

' Read the list of paths (newline-separated) into an array...

strPaths = Split(WScript.StdIn.ReadAll, vbCrLf)

' Remove the final "/"...

WScript.Echo Left(strPath, Len(strPath) - 1)

 

=={{header|Visual Basic}}==

{{works with|VBA|6.5}}

{{works with|VBA|7.1}}

Dim v As Variant

Dim Path() As String, s As String

"/"

 

 

=={{header|zkl}}==

"/home/user1/tmp/coven/members");

n:=Utils.zipWith('==,dirs.xplode()).find(False); // character pos which differs

n=dirs[0][0,n].rfind("/"); // find last "/"

{{out}}

<pre>