Longest common suffix: Difference between revisions

 

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

I sa.empty

R ‘’

print(lcs([‘Sunday’, ‘Monday’, ‘Tuesday’]))

print(lcs([‘Sunday’, ‘Monday’, ‘Tuesday’, ‘day’]))

 

{{out}}

day

dag

</pre>

 

=={{header|Ada}}==

with Ada.Text_Io.Unbounded_IO;

 

Test (Case_5);

Test (Case_6);

{{out}}

<pre>

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

test suffix( ( "prefix", "suffix" ), "fix" );

test suffix( ( "send", "lend" ), "end" )

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre> lcs 'baabababc' 'baabc' 'bbbabc'

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"

 

longestCommonSuffix({"prefix", "suffix"}) --> "fix"

longestCommonSuffix({"remark", "spark", "aardvark"}) --> "ark"

 

===Functional===

and for more productivity, and higher re-use of library functions, we can write a functional definition (rather than a procedure):

 

 

 

set my text item delimiters to dlm

str

{{Out}}

<pre>['throne', 'sousaphone', 'tone'] -> 'one'

['remark', 'spark', 'aardvark', 'lark'] -> 'ark'

['ectoplasm', 'banana', 'brick'] -> ''</pre>

 

=={{header|AutoHotkey}}==

for num, v in StrSplit(data.1)

for i, word in data

return num=1 ? "" : SubStr(word, 2-num)

return SubStr(word, 1-num)

. "`n" Longest_common_suffix(["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"])

. "`n" Longest_common_suffix(["throne", "throne"])

. "`n" Longest_common_suffix(["prefix", "suffix"])

. "`n" Longest_common_suffix(["bar", "foobar"])

{{out}}

<pre>day

fix

bar</pre>

 

=={{header|BaCon}}==

 

LOCAL x, size

PRINT "The common suffix is: '", Common_Suffix$("longest common suffix"), "'"

PRINT "The common suffix is: '", Common_Suffix$("prefix suffix"), "'"

{{out}}

<pre>The common suffix is: 'abc'

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

case6();

return 0;

{{out}}

<pre>[`baabababc` `baabc` `bbbabc` ] -> `abc`

[`suffix` ] -> `suffix`

[`` ] -> ``</pre>

 

=={{header|Cowgol}}==

include "strings.coh";

 

test(&test4[0], @sizeof test4);

test(&test5[0], @sizeof test5);

{{out}}

<pre>["baabababc", "baabc", "bbbabc"] -> `abc`

=={{header|D}}==

{{trans|Kotlin}}

import std.stdio;

 

writeln(test, " -> `", lcs(test), '`');

}

{{out}}

<pre>["baabababc", "baabc", "bbbabc"] -> `abc`

{{libheader| Types}}

{{Trans|Ring}}

program Longest_common_suffix;

 

end.

 

 

{{out}}

 

Longest common suffix = abc

</pre>

 

=={{header|Factor}}==

{{works with|Factor|0.99 2020-07-03}}

sequences.extras ;

 

{ "baabababc" "baabc" "bbbabc" } lcs .

{ "baabababc" "baabc" "bbbazc" } lcs .

{{out}}

<pre>

""

</pre>

 

=={{header|Go}}==

{{trans|Wren}}

 

import (

fmt.Printf("%v -> \"%s\"\n", test, lcs(test))

}

 

{{out}}

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

, "dag"

]

{{Out}}

<pre>day

 

=={{header|J}}==

 

test1 =: 'baabababc';'baabc';'bbabc'

tests =: test1;test2;test3;<test4

echo@((1{":),' -> ', 1{":@<@lcs) each tests

 

{{out}}

=={{header|Java}}==

{{trans|Kotlin}}

 

public class App {

}

}

{{out}}

<pre>[baabababc, baabc, bbbabc] -> `abc`

 

=={{header|JavaScript}}==

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Longest common suffix:

remark spark aardvark lark -> 'ark'

ectoplasm banana brick -> ''</pre>

 

=={{header|Julia}}==

n, nmax = 0, minimum(length, strings)

nmax == 0 && return ""

println(longestcommonsuffix(["baabababc","baabc","bbbabc"]))

println(longestcommonsuffix(["baabababc","baabc","bbbazc"]))

<pre>

abc

c

</pre>

 

=={{header|Kotlin}}==

{{trans|Go}}

val le = a.size

if (le == 0) {

println("$test -> `${lcs(test)}`")

}

{{out}}

<pre>[baabababc, baabc, bbbabc] -> `abc`

[suffix] -> `suffix`

[] -> ``</pre>

 

=={{header|Perl}}==

Based on [[Longest_common_prefix]] Perl entry.

use warnings;

use feature 'say';

 

sub lcs {

join '', reverse split '', (join("\0", @_) =~ /^ ([^\0]*) [^\0]* (?:\0 \1 [^\0]*)* $/sx)[0];

}

[ '' ]) {

say qq{'@$words' ==> '@{[lcs(@$words)]}';

 

{{out}}

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

{{out}}

<pre>

Pending a fuller task statement and some test samples:

{{works with|Python|3}}

 

from itertools import takewhile

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>day

dag</pre>

 

=={{header|Raku}}==

{{works with|Rakudo|2020.07}}

 

return '' unless +@words;

my $min = @words».chars.min;

('one, Hey!', 'three, Hey!', 'ale, Hey!', 'me, Hey!'),

'suffix',

{{out}}

<pre>("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday") - LCS: >day<

=={{header|REXX}}==

Essentially, &nbsp; this REXX version simply reversed the strings, &nbsp; and then finds the longest common &nbsp;''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.*/

say /*stick a fork in it, we're all done. */

if m==0 then say 'There is no common suffix.'

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

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

next

return cStr2

{{out}}

<pre>

bbbabc

Longest common suffix = abc

</pre>

 

=={{header|Standard ML}}==

let

val commonSuffix = fn (s0, s1) =>

in

fn [] => "" | x :: xs => foldl commonSuffix x xs

 

=={{header|Wren}}==

if (a.count == 0) return ""

if (a.count == 1) return a[0]

[""]

]

 

{{out}}

[suffix] -> "suffix"

[] -> ""

</pre>