aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Update all new Tasks

Browse source
This commit is contained in:
Ingy döt Net 2015-02-20 09:02:09 -05:00
parent 00a190b0a6
commit 91df62d461
5697 changed files with 93386 additions and 804 deletions
Download patch file Download diff file Expand all files Collapse all files

27
Task/Order-disjoint-list-items/00DESCRIPTION Normal file
View file

@ -0,0 +1,27 @@
Given <code>M</code> as a list of items and another list <code>N</code> of items chosen from <code>M</code>, create <code>M'</code> as a list with the ''first'' occurrences of items from N sorted to be in one of the set of indices of their original occurrence in <code>M</code> but in the order given by their order in <code>N</code>. That is, items in <code>N</code> are taken from <code>M</code> without replacement, then the corresponding positions in <code>M'</code> are filled by successive items from <code>N</code>.
For example:
:if <code>M</code> is <code>'the cat sat on the mat'</code>
:And <code>N</code> is <code>'mat cat'</code>
:Then the result <code>M'</code> is <code>'the mat sat on the cat'</code>.
The words not in <code>N</code> are left in their original positions.
If there are duplications then only the first instances in <code>M</code> up to as many as are mentioned in <code>N</code> are potentially re-ordered.
For example:
:<code>M = 'A B C A B C A B C'</code>
:<code>N = 'C A C A'</code>
Is ordered as:
:<code>M' = 'C B A C B A A B C'</code>
Show the output, here, for at least the following inputs:
<pre>Data M: 'the cat sat on the mat' Order N: 'mat cat'
Data M: 'the cat sat on the mat' Order N: 'cat mat'
Data M: 'A B C A B C A B C' Order N: 'C A C A'
Data M: 'A B C A B D A B E' Order N: 'E A D A'
Data M: 'A B' Order N: 'B'
Data M: 'A B' Order N: 'B A'
Data M: 'A B B A' Order N: 'B A'</pre>
;Cf:
* [[Sort disjoint sublist]]

21
Task/Order-disjoint-list-items/AutoHotkey/order-disjoint-list-items.ahk Normal file
View file

@ -0,0 +1,21 @@
Data := [ {M: "the cat sat on the mat", N: "mat cat"}
, {M: "the cat sat on the mat", N: "cat mat"}
, {M: "A B C A B C A B C", N: "C A C A"}
, {M: "A B C A B D A B E", N: "E A D A"}
, {M: "A B", N: "B"}
, {M: "A B", N: "B A"}
, {M: "A B B A", N: "B A"} ]
for Key, Val in Data
Output .= Val.M " :: " Val.N " -> " OrderDisjointList(Val.M, Val.N) "`n"
MsgBox, % RTrim(Output, "`n")
OrderDisjointList(M, N) {
ItemsN := []
Loop, Parse, N, % A_Space
ItemsN[A_LoopField] := ItemsN[A_LoopField] ? ItemsN[A_LoopField] + 1 : 1
N := StrSplit(N, A_Space)
Loop, Parse, M, % A_Space
Result .= (ItemsN[A_LoopField]-- > 0 ? N.Remove(1) : A_LoopField) " "
return RTrim(Result)
}

35
Task/Order-disjoint-list-items/Bracmat/order-disjoint-list-items.bracmat Normal file
View file

@ -0,0 +1,35 @@
( ( odli
= M N NN item A Z R
. !arg:(?M.?N)
& :?NN
& whl
' ( !N:%?item ?N
& ( !M:?A !item ?Z
& !A (.) !Z:?M
& !NN !item:?NN
|
)
)
& :?R
& whl
' ( !M:?A (.) ?M
& !NN:%?item ?NN
& !R !A !item:?R
)
& !R !M
)
& (the cat sat on the mat.mat cat)
(the cat sat on the mat.cat mat)
(A B C A B C A B C.C A C A)
(A B C A B D A B E.E A D A)
(A B.B)
(A B.B A)
(A B B A.B A)
: ?tests
& whl
' ( !tests:(?M.?N) ?tests
& put$("Data M:" !M)
& put$("\tOrder N:" !N)
& out$(\t odli$(!M.!N))
)
);

51
Task/Order-disjoint-list-items/D/order-disjoint-list-items.d Normal file
View file

@ -0,0 +1,51 @@
import std.stdio, std.string, std.algorithm, std.array, std.range,
std.conv;
T[] orderDisjointArrayItems(T)(in T[] data, in T[] items)
pure /*nothrow*/ @safe {
int[] itemIndices;
foreach (item; items.dup.sort().uniq) {
immutable int itemCount = items.count(item);
assert(data.count(item) >= itemCount,
text("More of ", item, " than in data"));
auto lastIndex = [-1];
foreach (immutable _; 0 .. itemCount) {
immutable start = lastIndex.back + 1;
lastIndex ~= data[start .. $].countUntil(item) + start;
}
itemIndices ~= lastIndex.dropOne;
}
itemIndices.sort();
auto result = data.dup;
foreach (index, item; zip(itemIndices, items))
result[index] = item;
return result;
}
void main() {
immutable problems =
"the cat sat on the mat | mat cat
the cat sat on the mat | cat mat
A B C A B C A B C | C A C A
A B C A B D A B E | E A D A
A B | B
A B | B A
A B B A | B A
|
A | A
A B |
A B B A | A B
A B A B | A B
A B A B | B A B A
A B C C B A | A C A C
A B C C B A | C A C A"
.splitLines.map!(r => r.split("|")).array;
foreach (immutable p; problems) {
immutable a = p[0].split;
immutable b = p[1].split;
writefln("%s | %s -> %-(%s %)", p[0].strip, p[1].strip,
orderDisjointArrayItems(a, b));
}
}

57
Task/Order-disjoint-list-items/Go/order-disjoint-list-items.go Normal file
View file

@ -0,0 +1,57 @@
package main
import (
"fmt"
"sort"
"strings"
)
type indexSort struct {
val sort.Interface
ind []int
}
func (s indexSort) Len() int { return len(s.ind) }
func (s indexSort) Less(i, j int) bool { return s.ind[i] < s.ind[j] }
func (s indexSort) Swap(i, j int) {
s.val.Swap(s.ind[i], s.ind[j])
s.ind[i], s.ind[j] = s.ind[j], s.ind[i]
}
func disjointSliceSort(m, n []string) []string {
s := indexSort{sort.StringSlice(m), make([]int, 0, len(n))}
used := make(map[int]bool)
for _, nw := range n {
for i, mw := range m {
if used[i] || mw != nw {
continue
}
used[i] = true
s.ind = append(s.ind, i)
break
}
}
sort.Sort(s)
return s.val.(sort.StringSlice)
}
func disjointStringSort(m, n string) string {
return strings.Join(
disjointSliceSort(strings.Fields(m), strings.Fields(n)), " ")
}
func main() {
for _, data := range []struct{ m, n string }{
{"the cat sat on the mat", "mat cat"},
{"the cat sat on the mat", "cat mat"},
{"A B C A B C A B C", "C A C A"},
{"A B C A B D A B E", "E A D A"},
{"A B", "B"},
{"A B", "B A"},
{"A B B A", "B A"},
} {
mp := disjointStringSort(data.m, data.n)
fmt.Printf("%s → %s » %s\n", data.m, data.n, mp)
}
}

23
Task/Order-disjoint-list-items/Icon/order-disjoint-list-items.icon Normal file
View file

@ -0,0 +1,23 @@
procedure main(A)
every write(" -> ",odli("the cat sat on the mat","mat cat"))
every write(" -> ",odli("the cat sat on the mat","cat mat"))
every write(" -> ",odli("A B C A B C A B C","C A C A"))
every write(" -> ",odli("A B C A B D A B E","E A D A"))
every write(" -> ",odli("A B","B"))
every write(" -> ",odli("A B","B A"))
every write(" -> ",odli("A B B A","B A"))
end
procedure odli(M,N)
writes(M," :: ",N)
Mp := ""
P := N ||:= " "
(M||" ") ? while item := tab(upto(' '))||move(1) do {
if find(item,P) then {
P ?:= 1(tab(find(item)),move(*item))||tab(0)
N ?:= (item := tab(upto(' '))||move(1), tab(0))
}
Mp ||:= item
}
return Mp
end

9
Task/Order-disjoint-list-items/J/order-disjoint-list-items-1.j Normal file
View file

@ -0,0 +1,9 @@
disjorder=:3 :0&.;:
:
clusters=. (</. i.@#) x
order=. x i.&~. y
need=. #/.~ y
from=. ;need (#{.)each (/:~order){clusters
to=. ;need {.!._ each order{clusters
(from{x) to} x
)

14
Task/Order-disjoint-list-items/J/order-disjoint-list-items-2.j Normal file
View file

@ -0,0 +1,14 @@
'the cat sat on the mat' disjorder 'mat cat'
the mat sat on the cat
'the cat sat on the mat' disjorder 'cat mat'
the cat sat on the mat
'A B C A B C A B C' disjorder 'C A C A'
C B A C B A A B C
'A B C A B D A B E' disjorder 'E A D A'
D B C D B E A B A
'A B' disjorder 'B'
A B
'A B' disjorder 'B A'
B A
'A B B A' disjorder 'B A'
B A B A

50
Task/Order-disjoint-list-items/Java/order-disjoint-list-items.java Normal file
View file

@ -0,0 +1,50 @@
import java.util.Arrays;
import java.util.BitSet;
import org.apache.commons.lang3.ArrayUtils;
public class OrderDisjointItems {
public static void main(String[] args) {
final String[][] MNs = {{"the cat sat on the mat", "mat cat"},
{"the cat sat on the mat", "cat mat"},
{"A B C A B C A B C", "C A C A"}, {"A B C A B D A B E", "E A D A"},
{"A B", "B"}, {"A B", "B A"}, {"A B B A", "B A"}, {"X X Y", "X"}};
for (String[] a : MNs) {
String[] r = orderDisjointItems(a[0].split(" "), a[1].split(" "));
System.out.printf("%s | %s -> %s%n", a[0], a[1], Arrays.toString(r));
}
}
// if input items cannot be null
static String[] orderDisjointItems(String[] m, String[] n) {
for (String e : n) {
int idx = ArrayUtils.indexOf(m, e);
if (idx != -1)
m[idx] = null;
}
for (int i = 0, j = 0; i < m.length; i++) {
if (m[i] == null)
m[i] = n[j++];
}
return m;
}
// otherwise
static String[] orderDisjointItems2(String[] m, String[] n) {
BitSet bitSet = new BitSet(m.length);
for (String e : n) {
int idx = -1;
do {
idx = ArrayUtils.indexOf(m, e, idx + 1);
} while (idx != -1 && bitSet.get(idx));
if (idx != -1)
bitSet.set(idx);
}
for (int i = 0, j = 0; i < m.length; i++) {
if (bitSet.get(i))
m[i] = n[j++];
}
return m;
}
}

4
Task/Order-disjoint-list-items/Perl-6/order-disjoint-list-items-1.pl6 Normal file
View file

@ -0,0 +1,4 @@
sub order-disjoint-list-items(\M, \N) {
my \bag = N.BagHash;
M.map: { bag{$_}-- ?? N.shift !! $_ }
}

12
Task/Order-disjoint-list-items/Perl-6/order-disjoint-list-items-2.pl6 Normal file
View file

@ -0,0 +1,12 @@
for q:to/---/.comb(/ [\S+]+ % ' ' /).map({[.words]})
the cat sat on the mat mat cat
the cat sat on the mat cat mat
A B C A B C A B C C A C A
A B C A B D A B E E A D A
A B B
A B B A
A B B A B A
X X Y X
A X Y A
---
-> $m, $n { say "\n$m ==> $n\n", order-disjoint-list-items($m, $n) }

21
Task/Order-disjoint-list-items/Perl/order-disjoint-list-items.pl Normal file
View file

@ -0,0 +1,21 @@
sub dsort {
my ($m, $n) = @_;
my %h;
$h{$_}++ for @$n;
map $h{$_}-- > 0 ? shift @$n : $_, @$m;
}
for (split "\n", <<"IN")
the cat sat on the mat | mat cat
the cat sat on the mat | cat mat
A B C A B C A B C | C A C A
A B C A B D A B E | E A D A
A B | B
A B | B A
A B B A | B A
IN
{
my ($a, $b) = map([split], split '\|');
print "@$a | @$b -> @{[dsort($a, $b)]}\n";
}

37
Task/Order-disjoint-list-items/Python/order-disjoint-list-items.py Normal file
View file

@ -0,0 +1,37 @@
from __future__ import print_function
def order_disjoint_list_items(data, items):
#Modifies data list in-place
itemindices = []
for item in set(items):
itemcount = items.count(item)
#assert data.count(item) >= itemcount, 'More of %r than in data' % item
lastindex = [-1]
for i in range(itemcount):
lastindex.append(data.index(item, lastindex[-1] + 1))
itemindices += lastindex[1:]
itemindices.sort()
for index, item in zip(itemindices, items):
data[index] = item
if __name__ == '__main__':
tostring = ' '.join
for data, items in [ (str.split('the cat sat on the mat'), str.split('mat cat')),
(str.split('the cat sat on the mat'), str.split('cat mat')),
(list('ABCABCABC'), list('CACA')),
(list('ABCABDABE'), list('EADA')),
(list('AB'), list('B')),
(list('AB'), list('BA')),
(list('ABBA'), list('BA')),
(list(''), list('')),
(list('A'), list('A')),
(list('AB'), list('')),
(list('ABBA'), list('AB')),
(list('ABAB'), list('AB')),
(list('ABAB'), list('BABA')),
(list('ABCCBA'), list('ACAC')),
(list('ABCCBA'), list('CACA')),
]:
print('Data M: %-24r Order N: %-9r' % (tostring(data), tostring(items)), end=' ')
order_disjoint_list_items(data, items)
print("-> M' %r" % tostring(data))

1
Task/Order-disjoint-list-items/README Normal file
View file

@ -0,0 +1 @@
Data source: http://rosettacode.org/wiki/Order_disjoint_list_items

40
Task/Order-disjoint-list-items/REXX/order-disjoint-list-items.rexx Normal file
View file

@ -0,0 +1,40 @@
/*REXX program orders a disjoint list of M items with a list of N items.*/
used = '0'x /*indicates word has been parsed.*/
@. = /*placeholder indicates e─o─array*/
@.1 = " the cat sat on the mat | mat cat " /*string.*/
@.2 = " the cat sat on the mat | cat mat " /*string.*/
@.3 = " A B C A B C A B C | C A C A " /*string.*/
@.4 = " A B C A B D A B E | E A D A " /*string.*/
@.5 = " A B | B " /*string.*/
@.6 = " A B | B A " /*string.*/
@.7 = " A B B A | B A " /*string.*/
@.8 = " | " /*string.*/
@.9 = " A | A " /*string.*/
@.10 = " A B | " /*string.*/
@.11 = " A B B A | A B " /*string.*/
@.12 = " A B A B | A B " /*string.*/
@.13 = " A B A B | B A B A " /*string.*/
@.14 = " A B C C B A | A C A C " /*string.*/
@.15 = " A B C C B A | C A C A " /*string.*/
/* [↓] process each input string*/
do j=1 while @.j\==''; r.= /*nullify the replacement string.*/
parse var @.j m '|' n /*parse input string into M & N.*/
mw=words(m); do i=mw for mw by -1; x=word(m,i); !.i=x; $.x=i; end
/* [↑] build ! and $ arrays. */
do k=1 for words(n)%2 by 2 /* [↓] process the N array. */
_=word(n,k); v=word(n,k+1) /*get an order word & replacement*/
p1=wordpos(_,m); p2=wordpos(v,m) /*positions of word & replacement*/
if p1==0 | p2==0 then iterate /*if either not found, skip 'em. */
if $._>>$.v then do; r.p2=!.p1; r.p1=!.p2; end /*switch words.*/
else do; r.p1=!.p1; r.p2=!.p2; end /*don't switch.*/
!.p1=used; !.p2=used; m= /*mark as used.*/
do i=1 for mw; m=m !.i; x=word(m,i); !.i=x; $.x=i; end
end /*k*/ /* [↑] rebuild the ! & $ arrays.*/
mp= /*the MP (M') string (so far).*/
do q=1 for mw; if !.q==used then mp=mp r.q /*use original. */
else mp=mp !.q /*use substitute*/
end /*q*/ /* [↑] re-build the (output) str*/
/*═══════════════════════════════*/
say @.j '───►' space(mp) /*display the new text reordered.*/
end /*j*/ /* [↑] end of processing N words*/
/*stick a fork in it, we're done.*/

37
Task/Order-disjoint-list-items/Racket/order-disjoint-list-items.rkt Normal file
View file

@ -0,0 +1,37 @@
#lang racket
(define disjorder
(match-lambda**
(((list) n) '())
((m (list)) m)
(((list h m-tail ...) (list h n-tail ...))
(list* h (disjorder m-tail n-tail)))
;; the (not g/h) below stop greedy matching of the list which
;; would pick out orderings from the right first.
(((list h (and (not g) m-tail-left) ... g m-tail-right ...)
(list g (and (not h) n-tail-left) ... h n-tail-right ...))
(disjorder `(,g ,@m-tail-left ,h ,@m-tail-right)
`(,g ,@n-tail-left ,h ,@n-tail-right)))
(((list h m-tail ...) n)
(list* h (disjorder m-tail n)))))
(define (report-disjorder m n)
(printf "Data M: ~a Order N: ~a -> ~a~%"
(~a #:min-width 25 m) (~a #:min-width 10 n) (disjorder m n)))
;; Do the task tests
(report-disjorder '(the cat sat on the mat) '(mat cat))
(report-disjorder '(the cat sat on the mat) '(cat mat))
(report-disjorder '(A B C A B C A B C) '(C A C A))
(report-disjorder '(A B C A B D A B E) '(E A D A))
(report-disjorder '(A B) '(B))
(report-disjorder '(A B) '(B A))
(report-disjorder '(A B B A) '(B A))
;; Do all of the other python tests
(report-disjorder '() '())
(report-disjorder '(A) '(A))
(report-disjorder '(A B) '())
(report-disjorder '(A B B A) '(A B))
(report-disjorder '(A B A B) '(A B))
(report-disjorder '(A B A B) '(B A B A))
(report-disjorder '(A B C C B A) '(A C A C))
(report-disjorder '(A B C C B A) '(C A C A))

17
Task/Order-disjoint-list-items/Ruby/order-disjoint-list-items.rb Normal file
View file

@ -0,0 +1,17 @@
test_data = [
'the cat sat on the mat', 'mat cat',
'the cat sat on the mat', 'cat mat',
'A B C A B C A B C' , 'C A C A',
'A B C A B D A B E' , 'E A D A',
'A B' , 'B',
'A B' , 'B A',
'A B B A' , 'B A',
'the cat sat on the chair', 'chair cat']
test_data.each_slice(2) do |str, order|
result, order_items = str.dup, order.split
re = Regexp.union(order_items.uniq)
offsets = str.enum_for(:scan, re).map{ ($~.begin(0) ... $~.end(0)) } # $~ is last MatchData object
order_items.zip(offsets).reverse_each{|item, offset| result[offset] = item}
puts "Data M: %-24s Order N: %-10s-> M' %-12s" % [str, order, result]
end

5
Task/Order-disjoint-list-items/Scala/order-disjoint-list-items-1.scala Normal file
View file

@ -0,0 +1,5 @@
def order[T](input: Seq[T], using: Seq[T], used: Seq[T] = Seq()): Seq[T] =
if (input.isEmpty || used.size >= using.size) input
else if (using diff used contains input.head)
using(used.size) +: order(input.tail, using, used :+ input.head)
else input.head +: order(input.tail, using, used)

14
Task/Order-disjoint-list-items/Scala/order-disjoint-list-items-2.scala Normal file
View file

@ -0,0 +1,14 @@
val tests = List(
"the cat sat on the mat" -> "mat cat",
"the cat sat on the mat" -> "cat mat",
"A B C A B C A B C" -> "C A C A",
"A B C A B D A B E" -> "E A D A",
"A B" -> "B",
"A B" -> "B A",
"A B B A" -> "B A"
)
tests.foreach{case (input, using) =>
val done = order(input.split(" "), using.split(" "))
println(f"""Data M: $input%-24s Order N: $using%-9s -> Result M': ${done mkString " "}""")
}

13
Task/Order-disjoint-list-items/Tcl/order-disjoint-list-items-1.tcl Normal file
View file

@ -0,0 +1,13 @@
proc orderDisjoint {theList theOrderList} {
foreach item $theOrderList {incr n($item)}
set is {}
set i 0
foreach item $theList {
if {[info exist n($item)] && [incr n($item) -1] >= 0} {
lappend is $i
}
incr i
}
foreach item $theOrderList i $is {lset theList $i $item}
return $theList
}

18
Task/Order-disjoint-list-items/Tcl/order-disjoint-list-items-2.tcl Normal file
View file

@ -0,0 +1,18 @@
proc orderDisjoint {theList theOrderList} {
foreach item $theOrderList {incr n($item)}
set is -
set i 0
foreach item $theList {
if {[info exist n($item)] && [incr n($item) -1] >= 0} {
lappend is $i
}
incr i
}
set i 0
foreach item $theOrderList {
if {[incr n($item)] <= 1} {
lset theList [lindex $is [incr i]] $item
}
}
return $theList
}

11
Task/Order-disjoint-list-items/Tcl/order-disjoint-list-items-3.tcl Normal file
View file

@ -0,0 +1,11 @@
foreach {items order} {
"the cat sat on the mat" "mat cat"
"the cat sat on the mat" "cat mat"
"A B C A B C A B C" "C A C A"
"A B C A B D A B E" "E A D A"
"A B" "B"
"A B" "B A"
"A B B A" "B A"
} {
puts "'$items' with '$order' => '[orderDisjoint $items $order]'"
}