Find common directory path: Difference between revisions

{{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>

=={{header|Arturo}}==

paths: map lst => [split.by:"/" &]

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

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

{{out}}

=={{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|BASIC256}}==

{{trans|GW-BASIC}}

y = "/home/user1/tmp/covert/operator"

z = "/home/user1/tmp/coven/members"

REM Task description says no trailing slash, so...

a = i - 1

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

@echo off

setlocal enabledelayedexpansion

endlocal

exit /b

{{out}}

<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|C++}}==

#include <iostream>

#include <string>

std::string::size_type found = compareString.rfind( separator , maxCharactersCommon ) ;

return compareString.substr( 0 , found ) ;

Output:

<pre>

=={{header|Clojure}}==

(defn common-prefix [sep paths]

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

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

=={{header|Common Lisp}}==

The strings represent file paths, so instead of treating them as simple strings, this uses the specialized pathname functions, which are more robust and generic.

(defun common-directory-path (&rest paths)

(do* ((pathnames (mapcar #'(lambda (path) (cdr (pathname-directory (pathname path)))) paths)) ; convert strings to lists of subdirectories

((null (cdr rem)) (make-pathname :directory (cons :absolute (subseq (first pathnames) 0 pos)))) ; take the common sublists and convert back to a pathname

(setq pos (min pos (mismatch (first rem) (second rem) :test #'string-equal))) )) ; compare two paths

=={{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|Delphi}}==

{{libheader| System.SysUtils}}

program Find_common_directory_path;

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

Readln;

{{out}}

<pre>/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

=={{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:

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"

Or, expressed directly in applicative terms:

import Data.List.Split (splitOn)

, "/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}}

=={{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;

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

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

=={{header|MATLAB}} / {{header|Octave}}==

function lcp = longest_common_dirpath(varargin)

ix = find(varargin{1}=='/');

longest_common_dirpath('/home/user1/tmp/coverage/test', '/home/user1/tmp/covert/operator', '/home/user1/tmp/coven/members')

{{out}}

=={{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 =

result = result[0 .. result.rfind(sep)]

Output:

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

=={{header|OCaml}}==

if List.mem [] paths

then (List.rev acc) else

] in

print_endline (common_prefix "/" dirs);

(uses the module <code>[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Str.html Str]</code>, str.cma)

=={{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}}

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

For cross-platform operation, simply use the split_path and join_path builtins (not pwa/p2js compatible) instead of split and join.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">common_directory_path</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">paths</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">sep</span><span style="color: #0000FF;">=</span><span style="color: #008000;">'/'</span><span style="color: #0000FF;">)</span>

<span style="color: #008000;">"/home/user1/tmp/coven/members"</span><span style="color: #0000FF;">}</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">common_directory_path</span><span style="color: #0000FF;">(</span><span style="color: #000000;">test</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|PHP}}==

/*

}

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

}

=={{header|Picat}}==

===Using maxof/2===

Using <code>maxof/2</code> to get the longest common prefix.

maxof( (common_prefix(Dirs, Path,Len), append(_,"/",Path)), Len).

append(Prefix,_,L)

end,

===Mode-directed tabling===

Using mode-directed tabling for maximizing the length.

common_prefix2(Dirs,Path,'/',_Len).

Prefix.last() == Last

end,

For the directories

=={{header|PicoLisp}}==

(glue Chr

(make

(apply find

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

Output:

<pre>(commonPath

=={{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|Prolog}}==

%! directory_prefix(PATHs,STOP0,PREFIX)

.

{{out}}

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

Since Python 3.5 os.path.commonpath function can be used:

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

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

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|Raku}}==

(formerly Perl 6)

my @dirs = </home/user1/tmp/coverage/test

/home/user1/tmp/covert/operator

say "The longest common path is $prefix";

Output:

<pre>

</pre>

If you'd prefer a pure FP solution without side effects, you can use this:

my @dirs := </home/user1/tmp/coverage/test

/home/user1/tmp/covert/operator

last unless all(@comps[*]»[$column]) eq @comps[0][$column];

take @comps[0][$column] // last;

Or here's another factoring, that focuses on building the result with cumulative sequences and getting the solution with `first`:

my @dirs = </home/user1/tmp/coverage/test

/home/user1/tmp/covert/operator

sub is_common_prefix { so $^prefix eq all(@dirs).substr(0, $prefix.chars) }

=={{header|REXX}}==

@. = /*the default for all file lists (null)*/

@.1 = '/home/user1/tmp/coverage/test'

if common=='' then common= "/" /*if no common directory, assume home. */

say 'common directory path: ' common /* [↑] handle trailing / delimiter*/

{{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>

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

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|Standard ML}}==

| takeWhileEq (_, []) = []

| takeWhileEq (x :: xs, y :: ys) =

]

=={{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|Wren}}==

var count = paths.count

if (count == 0) return ""

]

System.write("The common directory path is: ")

{{out}}

=={{header|Yabasic}}==

{{trans|GW-BASIC}}

y$ = "/home/user1/tmp/covert/operator"

z$ = "/home/user1/tmp/coven/members"

REM Task description says no trailing slash, so...

a = i - 1

=={{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>