Shortest common supersequence: Difference between revisions
m
syntax highlighting fixup automation
m (→{{header|Phix}}: syntax coloured) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 18:
{{trans|C++}}
<
I x.empty
R y
Line 30:
R x[0]‘’scs(x[1..], y)
print(scs(‘abcbdab’, ‘bdcaba’))</
{{out}}
Line 39:
=={{header|Ada}}==
{{trans|C++}}
<
procedure Shortest is
Line 75:
Exercise ("abcbdab", "bdcaba");
Exercise ("WEASELS", "WARDANCE");
end Shortest;</
{{out}}
<pre>
Line 84:
=={{header|ALGOL 68}}==
{{Trans|C++}}
<
PRIO SCS = 1;
# returns the shortest common supersequence of x and y #
Line 102:
print( ( "abcbdab" SCS "bdcaba", newline ) )
END</
{{out}}
<pre>
Line 110:
=={{header|C}}==
The C99 code here isn't all that different from Levenstein distance calculation.
<
#include <string.h>
Line 163:
printf("SCS(%s, %s) -> %s\n", x, y, res);
return 0;
}</
{{out}}
<pre>
Line 171:
=={{header|C sharp}}==
{{trans|Java}}This is based on the Java version, but with added caching.
<
{
Dictionary<(string, string), string> cache = new();
Line 205:
}
}
</syntaxhighlight>
{{out}}
<pre>abdcabdab</pre>
Line 211:
=={{header|C++}}==
{{trans|Java}}
<
std::string scs(std::string x, std::string y) {
Line 234:
std::cout << res << '\n';
return 0;
}</
{{out}}
<pre>abdcabdab</pre>
Line 240:
=={{header|D}}==
{{trans|Racket}}
<
dstring scs(in dstring x, in dstring y) nothrow @safe {
Line 256:
void main() @safe {
scs("abcbdab", "bdcaba").writeln;
}</
{{out}}
<pre>abdcabdab</pre>
Line 264:
{{works with|Elixir|1.3}}
uses 'LCS' from [[Longest common subsequence#Elixir|here]]
<
def scs(u, v) do
lcs = LCS.lcs(u, v) |> to_charlist
Line 278:
u = "abcbdab"
v = "bdcaba"
IO.puts "SCS(#{u}, #{v}) = #{SCS.scs(u, v)}"</
{{out}}
Line 287:
=={{header|Factor}}==
{{trans|Julia}}
<
MEMO:: scs ( x y -- seq )
Line 300:
} cond ;
"abcbdab" "bdcaba" scs print</
{{out}}
<pre>
Line 308:
=={{header|Go}}==
{{trans|Kotlin}}
<
import (
Line 363:
v := "bdcaba"
fmt.Println(scs(u, v))
}</
{{out}}
Line 371:
=={{header|Haskell}}==
{{trans|C++}}
<
scs [] ys = ys
scs xs [] = xs
Line 383:
| otherwise = y : vs
main = putStrLn $ scs "abcbdab" "bdcaba"</
{{out}}
<pre>abdcabdab</pre>
=={{header|Java}}==
{{trans|D}}
<
private static boolean isEmpty(String s) {
return null == s || s.isEmpty();
Line 415:
System.out.println(scs("abcbdab", "bdcaba"));
}
}</
{{out}}
<pre>abdcabdab</pre>
Line 423:
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<
# Uses recursion, taking advantage of jq's TCO
def lcs:
Line 459:
| .sb ;
[ "abcbdab", "bdcaba" ] | scs</
{{out}}
<pre>
Line 467:
=={{header|Julia}}==
{{trans|D}}
<
@memoize function scs(x, y)
Line 484:
println(scs("abcbdab", "bdcaba"))
</syntaxhighlight>
{{out}}
<pre>
Line 492:
=={{header|Kotlin}}==
Uses 'lcs' function from [[Longest common subsequence#Kotlin]]:
<
fun lcs(x: String, y: String): String {
Line 524:
val v = "bdcaba"
println(scs(u, v))
}</
{{out}}
Line 532:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
RosettaShortestCommonSuperSequence[aa_String, bb_String] :=
Module[{lcs, scs, a = aa, b = bb},
Line 556:
]
RosettaShortestCommonSuperSequence["abcbdab", "bdcaba"]
RosettaShortestCommonSuperSequence["WEASELS", "WARDANCE"]</
{{out}}
<pre>bdcabcbdaba
Line 563:
=={{header|Nim}}==
{{trans|Kotlin}}
<
if x.len == 0 or y.len == 0: return
let x1 = x[0..^2]
Line 591:
let u = "abcbdab"
let v = "bdcaba"
echo scs(u, v)</
{{out}}
Line 597:
=={{header|Perl}}==
<
my( $u, $v ) = @_;
return '' unless length($u) and length($v);
Line 628:
printf "Longest common subsequence: %s\n", lcs $u, $v;
printf "Shortest common supersquence: %s\n", scs $u, $v;
</syntaxhighlight>
{{out}}
<pre>Strings abcbdab bdcaba
Line 637:
=={{header|Phix}}==
{{trans|Python}}
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">longest_common_subsequence</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>
Line 679:
<span style="color: #0000FF;">?</span><span style="color: #000000;">shortest_common_supersequence</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"abcbdab"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"bdcaba"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">shortest_common_supersequence</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"WEASELS"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"WARDANCE"</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
Line 687:
=={{header|Python}}==
<syntaxhighlight lang="python">
# Use the Longest Common Subsequence algorithm
Line 709:
# append remaining characters
return scs + a + b
</syntaxhighlight>
{{out}}
<pre>
Line 719:
=={{header|Racket}}==
{{trans|C}}This program is based on the C implementation, but use memorization instead of dynamic programming. More explanations about the memorization part in http://blog.racket-lang.org/2012/08/dynamic-programming-versus-memoization.html .
<
(struct link (len letters))
Line 751:
(list->string (link-letters (scs/list (string->list x) (string->list y)))))
(scs "abcbdab" "bdcaba")</
{{out}}
<pre>"abdcabdab"</pre>
Line 759:
Using 'lcs' routine from [[Longest_common_subsequence#Raku|Longest common subsequence task]]
<syntaxhighlight lang="raku"
return "" unless $xstr && $ystr;
my ($x, $xs, $y, $ys) = $xstr.substr(0, 1), $xstr.substr(1), $ystr.substr(0, 1), $ystr.substr(1);
Line 782:
printf "Strings: %s %s\n", $u, $v;
printf "Longest common subsequence: %s\n", lcs $u, $v;
printf "Shortest common supersquence: %s\n", scs $u, $v;</
{{out}}
<pre>Strings: abcbdab bdcaba
Line 790:
=={{header|REXX}}==
{{trans|RING}}
<
parse arg u v . /*obtain optional arguments from the CL*/
if u=='' | u=="," then u= 'abcbdab' /*Not specified? Then use the default.*/
Line 805:
end /*n*/
say
say 'shortest common supersequence=' $ /*stick a fork in it, we're all done. */</
{{out|output|text= when using the default inputs:}}
<pre>
Line 829:
=={{header|Ring}}==
<
# Project : Shortest common supersequence
Line 851:
next
see svect
</syntaxhighlight>
Output:
<pre>
Line 860:
{{trans|Tcl}}
uses 'lcs' from [[Longest common subsequence#Ruby|here]]
<
def scs(u, v)
Line 887:
u = "abcbdab"
v = "bdcaba"
puts "SCS(#{u}, #{v}) = #{scs(u, v)}"</
{{out}}
Line 897:
{{trans|Perl}}
Uses the ''lcs'' function defined [http://rosettacode.org/wiki/Longest_common_subsequence#Sidef here].
<
var ls = lcs(u, v).chars
var pat = Regex('(.*)'+ls.join('(.*)')+'(.*)')
Line 907:
}
say scs("abcbdab", "bdcaba")</
{{out}}
<pre>
Line 915:
=={{header|Tcl}}==
This example uses either of the <code>lcs</code> implementations from [[longest common subsequence#Tcl|here]], assumed renamed to <tt>lcs</tt>…
<
set lcs [lcs $u $v]
set scs ""
Line 945:
append scs [string range $u $ui end] [string range $v $vi end]
return $scs
}</
Demonstrating:
<
set v "bdcaba"
puts "SCS($u,$v) = [scs $u $v]"</
{{out}}
<pre>SCS(abcbdab,bdcaba) = abdcabdab</pre>
Line 955:
=={{header|Wren}}==
{{trans|Kotlin}}
<
lcs = Fn.new { |x, y|
if (x.count == 0 || y.count == 0) return ""
Line 991:
var u = "abcbdab"
var v = "bdcaba"
System.print(scs.call(u, v))</
{{out}}
Line 1,000:
=={{header|zkl}}==
{{trans|C}}
<
fcn init(l=0,c="",lnk=Void){ len,letter,next=l,c,lnk; }
}
Line 1,027:
lp:=lnk[0][0]; while(lp){ out.write(lp.letter); lp=lp.next; }
out.close()
}</
<
{{out}}
<pre>
|