Longest common suffix: Difference between revisions
Content deleted Content added
Drkameleon (talk | contribs) Added Arturo implementation |
|||
(9 intermediate revisions by 9 users not shown) | |||
Line 9:
=={{header|11l}}==
<
I sa.empty
R ‘’
Line 28:
print(lcs([‘Sunday’, ‘Monday’, ‘Tuesday’]))
print(lcs([‘Sunday’, ‘Monday’, ‘Tuesday’, ‘day’]))
print(lcs([‘Sondag’, ‘Maandag’, ‘Dinsdag’, ‘Woensdag’]))</
{{out}}
Line 39:
=={{header|Action!}}==
<
BYTE Func Equals(CHAR ARRAY a,b)
Line 156:
texts(0)=t12 texts(1)=t13
Test(texts,2)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Longest_common_suffix.png Screenshot from Atari 8-bit computer]
Line 171:
=={{header|Ada}}==
<
with Ada.Text_Io.Unbounded_IO;
Line 243:
Test (Case_5);
Test (Case_6);
end Longest_Common_Suffix;</
{{out}}
<pre>
Line 257:
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Based on the Algol 68 sample for the Longest Common Prefix task.
<
PRIO COMMONSUFFIX = 1;
OP COMMONSUFFIX = ( STRING a, b )STRING:
Line 320:
test suffix( ( "prefix", "suffix" ), "fix" );
test suffix( ( "send", "lend" ), "end" )
END</
{{out}}
<pre>
Line 336:
=={{header|APL}}==
{{works with|Dyalog APL}}
<
{{out}}
<pre> lcs 'baabababc' 'baabc' 'bbbabc'
Line 356:
The simplest solution in AppleScript seems to be to reverse the strings, apply the [https://www.rosettacode.org/wiki/Longest_common_prefix#AppleScriptObjC AppleScriptObjC] solution for the [https://www.rosettacode.org/wiki/Longest_common_prefix Longest common prefix] task, and reverse the result.
<
use framework "Foundation"
Line 400:
longestCommonSuffix({"prefix", "suffix"}) --> "fix"
longestCommonSuffix({"remark", "spark", "aardvark"}) --> "ark"
longestCommonSuffix({"ectoplasm", "banana"}) --> ""</
===Functional===
and for more productivity, and higher re-use of library functions, we can write a functional definition (rather than a procedure):
<
Line 740:
set my text item delimiters to dlm
str
end unlines</
{{Out}}
<pre>['throne', 'sousaphone', 'tone'] -> 'one'
Line 749:
=={{header|Arturo}}==
<
ret: ""
idx: 0
Line 771:
print lcs ["throne" "dungeon"]
print lcs ["cheese"]
print lcs ["prefix" "suffix"]</
{{out}}
Line 782:
=={{header|AutoHotkey}}==
<
for num, v in StrSplit(data.1)
for i, word in data
Line 788:
return num=1 ? "" : SubStr(word, 2-num)
return SubStr(word, 1-num)
}</
Examples:<
. "`n" Longest_common_suffix(["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"])
. "`n" Longest_common_suffix(["throne", "throne"])
Line 798:
. "`n" Longest_common_suffix(["prefix", "suffix"])
. "`n" Longest_common_suffix(["bar", "foobar"])
return</
{{out}}
<pre>day
Line 810:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f LONGEST_COMMON_SUFFIX.AWK
BEGIN {
Line 847:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 862:
=={{header|BaCon}}==
<
LOCAL x, size
Line 884:
PRINT "The common suffix is: '", Common_Suffix$("longest common suffix"), "'"
PRINT "The common suffix is: '", Common_Suffix$("prefix suffix"), "'"
PRINT "The common suffix is: '", Common_Suffix$(""), "'"</
{{out}}
<pre>The common suffix is: 'abc'
Line 893:
=={{header|C}}==
<
#include <stdlib.h>
#include <string.h>
Line 1,020:
case6();
return 0;
}</
{{out}}
<pre>[`baabababc` `baabc` `bbbabc` ] -> `abc`
Line 1,030:
=={{header|C++}}==
<
#include <string>
#include <vector>
Line 1,082:
for (auto t : tests) test(t);
return 0;
}</
{{out}}
<pre>["baabababc", "baabc", "bbabc"] -> `abc`
Line 1,093:
=={{header|Cowgol}}==
<
include "strings.coh";
Line 1,170:
test(&test4[0], @sizeof test4);
test(&test5[0], @sizeof test5);
test(&test6[0], @sizeof test6);</
{{out}}
<pre>["baabababc", "baabc", "bbbabc"] -> `abc`
Line 1,181:
=={{header|D}}==
{{trans|Kotlin}}
<
import std.stdio;
Line 1,222:
writeln(test, " -> `", lcs(test), '`');
}
}</
{{out}}
<pre>["baabababc", "baabc", "bbbabc"] -> `abc`
Line 1,235:
{{libheader| Types}}
{{Trans|Ring}}
<syntaxhighlight lang="delphi">
program Longest_common_suffix;
Line 1,342:
end.
</syntaxhighlight>
{{out}}
Line 1,353:
Longest common suffix = abc
</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang=text>
func$ right s$ i .
return substr s$ (len s$ - i + 1) i
.
func$ lcs list$[] .
if len list$[] = 0
return ""
.
ref$ = list$[1]
for s$ in list$[]
if len s$ < len ref$
ref$ = s$
.
.
for i = 1 to len ref$
sub$ = right ref$ i
for s$ in list$[]
if right s$ i <> sub$
return right ref$ (i - 1)
.
.
.
return ref$
.
print lcs [ "Sunday" "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" ]
print lcs [ "throne" "throne" ]
print lcs [ "throne" "dungeon" ]
print lcs [ "cheese" ]
print lcs [ "prefix" "suffix" ]
</syntaxhighlight>
{{out}}
<pre>
day
throne
cheese
fix
</pre>
=={{header|ed}}==
Partially inspired by [[#sed]] solution.
<syntaxhighlight lang="sed">
H
g/.*/s//&|/
,j
g/\([^|]*\)|\([^|]*\1|\)*$/s//&: \1/
,p
Q
</syntaxhighlight>
{{out}}
<pre>$ ed -s longest-suffix.input < longest-suffix.ed
Newline appended
Sunday|Monday|Tuesday|: day</pre>
=={{header|Factor}}==
{{works with|Factor|0.99 2020-07-03}}
<
sequences.extras ;
Line 1,368 ⟶ 1,427:
{ "baabababc" "baabc" "bbbabc" } lcs .
{ "baabababc" "baabc" "bbbazc" } lcs .
{ "" } lcs .</
{{out}}
<pre>
Line 1,375 ⟶ 1,434:
""
</pre>
=={{header|FreeBASIC}}==
{{trans|Ring}}
<
Dim As Integer longitud = Ubound(pre)
Dim As Integer lenList(longitud)
Line 1,413 ⟶ 1,471:
Print !"\n\nThe longest common suffix is: "; longPrefix
Sleep</
{{out}}
<pre>There are 3 words in the list: baabababc baabc bbbabc
Line 1,422 ⟶ 1,480:
=={{header|Go}}==
{{trans|Wren}}
<
import (
Line 1,473 ⟶ 1,531:
fmt.Printf("%v -> \"%s\"\n", test, lcs(test))
}
}</
{{out}}
Line 1,487 ⟶ 1,545:
=={{header|Haskell}}==
This task clearly needs a little more work to bring it up to the usual standard – it's rather underspecified, and bereft of test samples – but one response, for the moment, might be something like:
<
longestCommonSuffix :: [String] -> String
Line 1,515 ⟶ 1,573:
, "dag"
]
]</
{{Out}}
<pre>day
Line 1,522 ⟶ 1,580:
=={{header|J}}==
<
test1 =: 'baabababc';'baabc';'bbabc'
Line 1,530 ⟶ 1,588:
tests =: test1;test2;test3;<test4
echo@((1{":),' -> ', 1{":@<@lcs) each tests
exit''</
{{out}}
Line 1,541 ⟶ 1,599:
=={{header|Java}}==
{{trans|Kotlin}}
<
public class App {
Line 1,589 ⟶ 1,647:
}
}
}</
{{out}}
<pre>[baabababc, baabc, bbbabc] -> `abc`
Line 1,599 ⟶ 1,657:
=={{header|JavaScript}}==
<
'use strict';
Line 1,788 ⟶ 1,846:
// MAIN ---
return main();
})();</
{{Out}}
<pre>Longest common suffix:
Line 1,802 ⟶ 1,860:
This entry uses `longest_common_prefix` from [[Longest_common_suffix#jq]] and so the definition is not repeated here.
<syntaxhighlight lang="jq">
# Input: an array of strings
def longest_common_suffix:
Line 1,811 ⟶ 1,869:
| longest_common_prefix
| r
end;</
'''Test Cases'''
<
["baabababc","baabc","bbbabc"],
["baabababc","baabc","bbbazc"],
Line 1,823 ⟶ 1,881:
test
</syntaxhighlight>
{{out}}
<pre>
Line 1,835 ⟶ 1,893:
=={{header|Julia}}==
<
n, nmax = 0, minimum(length, strings)
nmax == 0 && return ""
Line 1,846 ⟶ 1,904:
println(longestcommonsuffix(["baabababc","baabc","bbbabc"]))
println(longestcommonsuffix(["baabababc","baabc","bbbazc"]))
println(longestcommonsuffix([""]))</
<pre>
abc
Line 1,854 ⟶ 1,912:
=={{header|Kotlin}}==
{{trans|Go}}
<
val le = a.size
if (le == 0) {
Line 1,898 ⟶ 1,956:
println("$test -> `${lcs(test)}`")
}
}</
{{out}}
<pre>[baabababc, baabc, bbbabc] -> `abc`
Line 1,908 ⟶ 1,966:
=={{header|Ksh}}==
<
# Longest common suffix
Line 1,955 ⟶ 2,013:
done
echo
</
<pre>
( Sunday Monday Tuesday Wednesday Thursday Friday Saturday ) -> 'day'
Line 1,966 ⟶ 2,024:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
LCS[x_List] := Module[{l, s},
If[Length[x] > 0,
Line 1,986 ⟶ 2,044:
LCS[{""}]
LCS[{}]
LCS[{"ectoplasm", "banana"}]</
{{out}}
<pre>"one"
Line 1,999 ⟶ 2,057:
=={{header|Nim}}==
<
func lcs(list: varargs[string]): string =
Line 2,024 ⟶ 2,082:
test()
test("prefix", "suffix")
test("send", "lend")</
{{out}}
Line 2,038 ⟶ 2,096:
=={{header|Perl}}==
Based on [[Longest_common_prefix]] Perl entry.
<
use warnings;
use feature 'say';
Line 2,056 ⟶ 2,114:
[ '' ]) {
say qq{'@$words' ==> '@{[lcs(@$words)]}';
}</
{{out}}
Line 2,069 ⟶ 2,127:
=={{header|Phix}}==
Phix allows negative indexes, with -1 as the last element [same as $], and -length(s) the first element of s, so we can just do this:
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">longestcommonsuffix</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">strings</span><span style="color: #0000FF;">)</span>
Line 2,101 ⟶ 2,159:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%v ==> \"%s\"\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">longestcommonsuffix</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
{{out}}
<pre>
Line 2,115 ⟶ 2,173:
Pending a fuller task statement and some test samples:
{{works with|Python|3}}
<
from itertools import takewhile
Line 2,164 ⟶ 2,222:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>day
Line 2,173 ⟶ 2,231:
<code>commonprefix</code> is defined at [[Longest common prefix#Quackery]].
<
witheach
[ reverse nested join ]
Line 2,180 ⟶ 2,238:
$ "monday tuesday wednesday thursday friday saturday sunday"
nest$ commonsuffix echo$</
{{out}}
Line 2,189 ⟶ 2,247:
{{works with|Rakudo|2020.07}}
<syntaxhighlight lang="raku"
return '' unless +@words;
my $min = @words».chars.min;
Line 2,206 ⟶ 2,264:
('one, Hey!', 'three, Hey!', 'ale, Hey!', 'me, Hey!'),
'suffix',
''</
{{out}}
<pre>("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday") - LCS: >day<
Line 2,218 ⟶ 2,276:
=={{header|REXX}}==
Essentially, this REXX version simply reversed the strings, and then finds the longest common ''prefix''.
<
parse arg z; z= space(z) /*obtain optional arguments from the CL*/
if z==''|z=="," then z='baabababc baabc bbbabc' /*Not specified? Then use the default.*/
Line 2,236 ⟶ 2,294:
say /*stick a fork in it, we're all done. */
if m==0 then say 'There is no common suffix.'
else say 'The longest common suffix is: ' right( word(z, 1), m)</
{{out|output|text= when using the default input:}}
<pre>
Line 2,245 ⟶ 2,303:
=={{header|Ring}}==
<
load "stdlib.ring"
Line 2,292 ⟶ 2,350:
next
return cStr2
</syntaxhighlight>
{{out}}
<pre>
Line 2,300 ⟶ 2,358:
bbbabc
Longest common suffix = abc
</pre>
=={{header|Ruby}}==
Testcases taken from Go.
<syntaxhighlight lang="ruby">tests = [["baabababc", "baabc", "bbbabc"],
["baabababc", "baabc", "bbbazc"],
["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
["longest", "common", "suffix"],
["suffix"],
[""],
]
def lcs(ar)
i = (0..ar.first.size).detect{|s| ar.all?{|word| word.end_with? ar.first[s..-1]} }
ar.first[i..-1]
end
tests.each{|test| p lcs(test) }
</syntaxhighlight>
{{out}}
<pre>"abc"
"c"
"day"
""
"suffix"
""
</pre>
=={{header|sed}}==
<syntaxhighlight lang="sed">$q
N
s/\(.*\)\(\n\).*\1$/\2\1/
D</syntaxhighlight><pre>
$ printf '%s\n' Sunday '' Monday Tuesday | sed -f suffix.sed
$ printf '%s\n' Sunday Monday Tuesday | sed -f suffix.sed
day
$ printf '%s\n' Sunday Monday | sed -f suffix.sed
nday
</pre>
=={{header|Standard ML}}==
<
let
val commonSuffix = fn (s0, s1) =>
Line 2,320 ⟶ 2,415:
in
fn [] => "" | x :: xs => foldl commonSuffix x xs
end</
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">
fn lcs(a []string) string {
// Special cases first
match a.len {
0 {
return ""
}
1 {
return a[0]
}
else {}
}
le0 := a[0].len
mut min_len := le0
for i in 1..a.len {
if a[i].len < min_len {
min_len = a[i].len
}
}
if min_len == 0 {
return ""
}
mut res := ""
a1 := a[1..]
for i := 1; i <= min_len; i++ {
suffix := a[0][le0-i..]
for e in a1 {
if e.index(suffix) or {0} + suffix.len != e.len {
return res
}
}
res = suffix
}
return res
}
// Normally something like this would be a Testlcs function in *_test.go
// and use the testing package to report failures.
fn main() {
for l in [
["baabababc", "baabc", "bbbabc"],
["baabababc", "baabc", "bbbazc"],
["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
["longest", "common", "suffix"],
["suffix"],
[""],
] {
println("lcs($l) = ${lcs(l)}")
}
}</syntaxhighlight>
{{out}}
<pre>Same as Go entry</pre>
=={{header|Wren}}==
<
if (a.count == 0) return ""
if (a.count == 1) return a[0]
Line 2,347 ⟶ 2,497:
[""]
]
for (test in tests) System.print("%(test) -> \"%(lcs.call(test))\"")</
{{out}}
Line 2,357 ⟶ 2,507:
[suffix] -> "suffix"
[] -> ""
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang "XPL0">include xpllib; \for StrRev
proc LCS(N, Strs); \Show longest common suffix
int N; char Strs;
int I, J, C;
[for I:= 0 to N-1 do \work with reversed strings
StrRev(@Strs(I,0));
J:= 0;
loop [C:= Strs(0,J);
if C = 0 then quit;
for I:= 1 to N-1 do
if Strs(I,J) # C then quit;
J:= J+1;
];
ChOut(0, ^");
for I:= J-1 downto 0 do
ChOut(0, Strs(0,I));
ChOut(0, ^");
CrLf(0);
for I:= 0 to N-1 do \undo reversal (for extra credit?)
StrRev(@Strs(I,0));
];
int Tests, I;
[Tests:= [
[3, "baabababc","baabc","bbbabc"],
[3, "baabababc","baabc","bbbazc"],
[7, "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
[3, "longest", "common", "suffix"],
[1, "suffix"],
[1, ""] ];
for I:= 0 to 6-1 do
LCS(Tests(I,0), @Tests(I,1));
]</syntaxhighlight>
{{out}}
<pre>
"abc"
"c"
"day"
""
"suffix"
""
</pre>
|