tasks a-s
This commit is contained in:
Ingy döt Net
parent
47bf37c096
commit
b83f433714
12433 changed files with 156208 additions and 123 deletions
11
Task/Non-continuous-subsequences/0DESCRIPTION
Normal file
11
Task/Non-continuous-subsequences/0DESCRIPTION
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
Consider some sequence of elements. (It differs from a mere set of elements by having an ordering among members.)
|
||||
|
||||
A ''subsequence'' contains some subset of the elements of this sequence, in the same order.
|
||||
|
||||
A ''continuous'' subsequence is one in which no elements are missing between the first and last elements of the subsequence.
|
||||
|
||||
Note: Subsequences are defined ''structurally'', not by their contents. So a sequence ''a,b,c,d'' will always have the same subsequences and continuous subsequences, no matter which values are substituted; it may even be the same value.
|
||||
|
||||
'''Task''': Find all non-continuous subsequences for a given sequence. Example: For the sequence ''1,2,3,4'', there are five non-continuous subsequences, namely ''1,3''; ''1,4''; ''2,4''; ''1,3,4'' and ''1,2,4''.
|
||||
|
||||
'''Goal''': There are different ways to calculate those subsequences. Demonstrate algorithm(s) that are natural for the language.
|
||||
2
Task/Non-continuous-subsequences/1META.yaml
Normal file
2
Task/Non-continuous-subsequences/1META.yaml
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
---
|
||||
note: Discrete math
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
PROC test non continuous = VOID: BEGIN
|
||||
MODE SEQMODE = CHAR;
|
||||
MODE SEQ = [1:0]SEQMODE;
|
||||
MODE YIELDSEQ = PROC(SEQ)VOID;
|
||||
|
||||
PROC gen ncs =
|
||||
( SEQ tail, # To generate subsequences of #
|
||||
SEQ head, # Already generated #
|
||||
BOOL contiguous,# It is still continuous #
|
||||
YIELDSEQ yield
|
||||
) VOID:
|
||||
BEGIN
|
||||
IF NOT contiguous ANDTH UPB head > 1 THEN
|
||||
yield (head)
|
||||
FI;
|
||||
IF UPB tail /= 0 THEN
|
||||
[UPB head+1]SEQMODE new head;
|
||||
new head [:UPB head] := head;
|
||||
FOR i TO UPB tail DO
|
||||
new head [UPB new head] := tail [i];
|
||||
gen ncs
|
||||
( tail[i + 1:UPB tail],
|
||||
new head,
|
||||
contiguous ANDTH (i = LWB tail OREL UPB head = 0),
|
||||
yield
|
||||
)
|
||||
OD
|
||||
FI
|
||||
END # put ncs #;
|
||||
|
||||
# FOR SEQ seq IN # gen ncs(("a","e","i","o","u"), (), TRUE, # ) DO ( #
|
||||
## (SEQ seq)VOID:
|
||||
print((seq, new line))
|
||||
# OD # )
|
||||
END; test non continuous
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
MODE SEQMODE = STRING;
|
||||
MODE SEQ = [1:0]SEQMODE;
|
||||
MODE YIELDSEQ = PROC(SEQ)VOID;
|
||||
|
||||
PROC gen ncs = (SEQ seq, YIELDSEQ yield)VOID:
|
||||
BEGIN
|
||||
IF UPB seq - 1 > bits width THEN stop FI;
|
||||
[UPB seq]SEQMODE out; INT upb out;
|
||||
|
||||
BITS lim := 16r1 SHL UPB seq;
|
||||
BITS upb k := lim SHR 1;
|
||||
# assert(lim); #
|
||||
|
||||
BITS empty = 16r000000000; # const #
|
||||
|
||||
FOR j TO ABS lim-1 DO
|
||||
INT state := 1;
|
||||
BITS k1 := upb k;
|
||||
WHILE k1 NE empty DO
|
||||
BITS b := BIN j AND k1;
|
||||
CASE state IN
|
||||
# state 1 # IF b NE empty THEN state +:= 1 FI,
|
||||
# state 2 # IF b EQ empty THEN state +:= 1 FI,
|
||||
# state 3 #
|
||||
BEGIN
|
||||
IF b EQ empty THEN GO TO continue k1 FI;
|
||||
upb out := 0;
|
||||
BITS k2 := upb k; FOR i WHILE k2 NE empty DO
|
||||
IF (BIN j AND k2) NE empty THEN out[upb out +:= 1] := seq[i] FI;
|
||||
k2 := k2 SHR 1
|
||||
OD;
|
||||
yield(out[:upb out]);
|
||||
k1 := empty # empty: ending containing loop #
|
||||
END
|
||||
ESAC;
|
||||
continue k1: k1 := k1 SHR 1
|
||||
OD
|
||||
OD
|
||||
END;
|
||||
|
||||
main:(
|
||||
[]STRING seqs = ("a","e","i","o","u");
|
||||
# FOR SEQ seq IN # gen ncs(seqs, # ) DO ( #
|
||||
## (SEQ seq)VOID:
|
||||
print((seq, new line))
|
||||
# OD # )
|
||||
)
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
with Ada.Text_IO; use Ada.Text_IO;
|
||||
|
||||
procedure Test_Non_Continuous is
|
||||
type Sequence is array (Positive range <>) of Integer;
|
||||
procedure Put_NCS
|
||||
( Tail : Sequence; -- To generate subsequences of
|
||||
Head : Sequence := (1..0 => 1); -- Already generated
|
||||
Contiguous : Boolean := True -- It is still continuous
|
||||
) is
|
||||
begin
|
||||
if not Contiguous and then Head'Length > 1 then
|
||||
for I in Head'Range loop
|
||||
Put (Integer'Image (Head (I)));
|
||||
end loop;
|
||||
New_Line;
|
||||
end if;
|
||||
if Tail'Length /= 0 then
|
||||
declare
|
||||
New_Head : Sequence (Head'First..Head'Last + 1);
|
||||
begin
|
||||
New_Head (Head'Range) := Head;
|
||||
for I in Tail'Range loop
|
||||
New_Head (New_Head'Last) := Tail (I);
|
||||
Put_NCS
|
||||
( Tail => Tail (I + 1..Tail'Last),
|
||||
Head => New_Head,
|
||||
Contiguous => Contiguous and then (I = Tail'First or else Head'Length = 0)
|
||||
);
|
||||
end loop;
|
||||
end;
|
||||
end if;
|
||||
end Put_NCS;
|
||||
begin
|
||||
Put_NCS ((1,2,3)); New_Line;
|
||||
Put_NCS ((1,2,3,4)); New_Line;
|
||||
Put_NCS ((1,2,3,4,5)); New_Line;
|
||||
end Test_Non_Continuous;
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
MsgBox % noncontinuous("a,b,c,d,e", ",")
|
||||
MsgBox % noncontinuous("1,2,3,4", ",")
|
||||
|
||||
noncontinuous(list, delimiter)
|
||||
{
|
||||
stringsplit, seq, list, %delimiter%
|
||||
n := seq0 ; sequence length
|
||||
Loop % x := (1<<n) - 1 { ; try all 0-1 candidate sequences
|
||||
If !RegExMatch(b:=ToBin(A_Index,n),"^0*1*0*$") { ; drop continuous subsequences
|
||||
Loop Parse, b
|
||||
t .= A_LoopField ? seq%A_Index% " " : "" ; position -> number
|
||||
t .= "`n" ; new sequences in new lines
|
||||
}
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
ToBin(n,W=16) { ; LS W-bits of Binary representation of n
|
||||
Return W=1 ? n&1 : ToBin(n>>1,W-1) . n&1
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
DIM list1$(3)
|
||||
list1$() = "1", "2", "3", "4"
|
||||
PRINT "For [1, 2, 3, 4] non-continuous subsequences are:"
|
||||
PROCnon_continuous_subsequences(list1$())
|
||||
DIM list2$(4)
|
||||
list2$() = "1", "2", "3", "4", "5"
|
||||
PRINT "For [1, 2, 3, 4, 5] non-continuous subsequences are:"
|
||||
PROCnon_continuous_subsequences(list2$())
|
||||
END
|
||||
|
||||
DEF PROCnon_continuous_subsequences(l$())
|
||||
LOCAL i%, j%, g%, n%, r%, s%, w%, a$, b$
|
||||
n% = DIM(l$(),1)
|
||||
FOR s% = 0 TO n%-2
|
||||
FOR g% = s%+1 TO n%-1
|
||||
a$ = "["
|
||||
FOR i% = s% TO g%-1
|
||||
a$ += l$(i%) + ", "
|
||||
NEXT
|
||||
FOR w% = 1 TO n%-g%
|
||||
r% = n%+1-g%-w%
|
||||
FOR i% = 1 TO 2^r%-1 STEP 2
|
||||
b$ = a$
|
||||
FOR j% = 0 TO r%-1
|
||||
IF i% AND 2^j% b$ += l$(g%+w%+j%) + ", "
|
||||
NEXT
|
||||
PRINT LEFT$(LEFT$(b$)) + "]"
|
||||
NEXT i%
|
||||
NEXT w%
|
||||
NEXT g%
|
||||
NEXT s%
|
||||
ENDPROC
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
( ( noncontinuous
|
||||
= sub
|
||||
. ( sub
|
||||
= su a nc
|
||||
. !arg:(?su.?nc)
|
||||
& !su
|
||||
: %
|
||||
%?a
|
||||
( %:[%(sub$(!sjt.!nc !a))
|
||||
| ?
|
||||
& !nc:~
|
||||
& out$(!nc !a)
|
||||
& ~
|
||||
)
|
||||
)
|
||||
& sub$(dummy !arg.)
|
||||
|
|
||||
)
|
||||
& noncontinuous$(e r n i t)
|
||||
);
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int c, char **v)
|
||||
{
|
||||
unsigned int n = 1 << (c - 1), i = n, j, k;
|
||||
assert(n);
|
||||
|
||||
while (i--) {
|
||||
if (!(i & (i + (i & -(int)i)))) // consecutive 1s
|
||||
continue;
|
||||
|
||||
for (j = n, k = 1; j >>= 1; k++)
|
||||
if (i & j) printf("%s ", v[k]);
|
||||
|
||||
putchar('\n');
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
void binprint(unsigned int n, unsigned int m)
|
||||
{
|
||||
char c[sizeof(n) * 8 + 1];
|
||||
int i = 0;
|
||||
while (m >>= 1) c[i++] = n & m ? '#' : '-';
|
||||
c[i] = 0;
|
||||
puts(c);
|
||||
}
|
||||
|
||||
int main(int c, char **v)
|
||||
{
|
||||
unsigned int n, gap, left, right;
|
||||
if (c < 2 || ! (n = 1 << atoi(v[1]))) n = 16;
|
||||
|
||||
for (gap = 2; gap < n; gap <<= 1)
|
||||
for (left = gap << 1; left < n; left |= left << 1)
|
||||
for (right = 1; right < gap; right++)
|
||||
binprint(left | right, n);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#include <stdio.h>
|
||||
|
||||
typedef unsigned char sint;
|
||||
enum states { s_blnk = 0, s_tran, s_cont, s_disj };
|
||||
|
||||
/* Recursively look at each item in list, taking both choices of
|
||||
picking the item or not. The state at each step depends on prvious
|
||||
pickings, with the state transition table:
|
||||
blank + no pick -> blank
|
||||
blank + pick -> contiguous
|
||||
transitional + no pick -> transitional
|
||||
transitional + pick -> disjoint
|
||||
contiguous + no pick -> transitional
|
||||
contiguous + pick -> contiguous
|
||||
disjoint + pick -> disjoint
|
||||
disjoint + no pick -> disjoint
|
||||
At first step, before looking at any item, state is blank.
|
||||
Because state is known at each step and needs not be calculated,
|
||||
it can be quite fast.
|
||||
*/
|
||||
unsigned char tbl[][2] = {
|
||||
{ s_blnk, s_cont },
|
||||
{ s_tran, s_disj },
|
||||
{ s_tran, s_cont },
|
||||
{ s_disj, s_disj },
|
||||
};
|
||||
|
||||
void pick(sint n, sint step, sint state, char **v, unsigned long bits)
|
||||
{
|
||||
int i, b;
|
||||
if (step == n) {
|
||||
if (state != s_disj) return;
|
||||
for (i = 0, b = 1; i < n; i++, b <<= 1)
|
||||
if ((b & bits)) printf("%s ", v[i]);
|
||||
putchar('\n');
|
||||
return;
|
||||
}
|
||||
|
||||
bits <<= 1;
|
||||
pick(n, step + 1, tbl[state][0], v, bits); /* no pick */
|
||||
pick(n, step + 1, tbl[state][1], v, bits | 1); /* pick */
|
||||
}
|
||||
|
||||
int main(int c, char **v)
|
||||
{
|
||||
if (c - 1 >= sizeof(unsigned long) * 4)
|
||||
printf("Too many items");
|
||||
else
|
||||
pick(c - 1, 0, s_blnk, v + 1, 0);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
(use '[clojure.contrib.combinatorics :only (subsets)])
|
||||
|
||||
(defn of-min-length [min-length]
|
||||
(fn [s] (>= (count s) min-length)))
|
||||
|
||||
(defn runs [c l]
|
||||
(map (partial take l) (take-while not-empty (iterate rest c))))
|
||||
|
||||
(defn is-subseq? [c sub]
|
||||
(some identity (map = (runs c (count sub)) (repeat sub))))
|
||||
|
||||
(defn non-continuous-subsequences [s]
|
||||
(filter (complement (partial is-subseq? s)) (subsets s)))
|
||||
|
||||
|
||||
(filter (of-min-length 2) (non-continuous-subsequences [:a :b :c :d]))
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
is_contigous_binary = (n) ->
|
||||
# return true if binary representation of n is
|
||||
# of the form 1+0+
|
||||
# examples:
|
||||
# 0 true
|
||||
# 1 true
|
||||
# 100 true
|
||||
# 110 true
|
||||
# 1001 false
|
||||
# 1010 false
|
||||
|
||||
# special case zero, or you'll get an infinite loop later
|
||||
return true if n == 0
|
||||
|
||||
# first remove 0s from end
|
||||
while n % 2 == 0
|
||||
n = n / 2
|
||||
|
||||
# next, take advantage of the fact that a continuous
|
||||
# run of 1s would be of the form 2^n - 1
|
||||
is_power_of_two(n + 1)
|
||||
|
||||
is_power_of_two = (m) ->
|
||||
while m % 2 == 0
|
||||
m = m / 2
|
||||
m == 1
|
||||
|
||||
seq_from_bitmap = (arr, n) ->
|
||||
# grabs elements from array according to a bitmap
|
||||
# e.g. if n == 13 (1101), and arr = ['a', 'b', 'c', 'd'],
|
||||
# then return ['a', 'c', 'd'] (flipping bits to 1011, so
|
||||
# that least significant bit comes first)
|
||||
i = 0
|
||||
new_arr = []
|
||||
while n > 0
|
||||
if n % 2 == 1
|
||||
new_arr.push arr[i]
|
||||
n -= 1
|
||||
n /= 2
|
||||
i += 1
|
||||
new_arr
|
||||
|
||||
non_contig_subsequences = (arr) ->
|
||||
# Return all subsqeuences from an array that have a "hole" in
|
||||
# them. The order of the subsequences is not specified here.
|
||||
|
||||
# This algorithm uses binary counting, so it is limited to
|
||||
# small lists, but large lists would be unwieldy regardless.
|
||||
bitmasks = [0...Math.pow(2, arr.length)]
|
||||
(seq_from_bitmap arr, n for n in bitmasks when !is_contigous_binary n)
|
||||
|
||||
arr = [1,2,3,4]
|
||||
console.log non_contig_subsequences arr
|
||||
for n in [1..10]
|
||||
arr = [1..n]
|
||||
num_solutions = non_contig_subsequences(arr).length
|
||||
console.log "for n=#{n} there are #{num_solutions} solutions"
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
> coffee non_contig_subseq.coffee
|
||||
[ [ 1, 3 ],
|
||||
[ 1, 4 ],
|
||||
[ 2, 4 ],
|
||||
[ 1, 2, 4 ],
|
||||
[ 1, 3, 4 ] ]
|
||||
for n=1 there are 0 solutions
|
||||
for n=2 there are 0 solutions
|
||||
for n=3 there are 1 solutions
|
||||
for n=4 there are 5 solutions
|
||||
for n=5 there are 16 solutions
|
||||
for n=6 there are 42 solutions
|
||||
for n=7 there are 99 solutions
|
||||
for n=8 there are 219 solutions
|
||||
for n=9 there are 466 solutions
|
||||
for n=10 there are 968 solutions
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
(defun all-subsequences (list)
|
||||
(labels ((subsequences (tail &optional (acc '()) (result '()))
|
||||
"Return a list of the subsequence designators of the
|
||||
subsequences of tail. Each subsequence designator is a
|
||||
list of tails of tail, the subsequence being the first
|
||||
element of each tail."
|
||||
(if (endp tail)
|
||||
(list* (reverse acc) result)
|
||||
(subsequences (rest tail) (list* tail acc)
|
||||
(append (subsequences (rest tail) acc) result))))
|
||||
(continuous-p (subsequence-d)
|
||||
"True if the designated subsequence is continuous."
|
||||
(loop for i in subsequence-d
|
||||
for j on (first subsequence-d)
|
||||
always (eq i j)))
|
||||
(designated-sequence (subsequence-d)
|
||||
"Destructively transforms a subsequence designator into
|
||||
the designated subsequence."
|
||||
(map-into subsequence-d 'first subsequence-d)))
|
||||
(let ((nc-subsequences (delete-if #'continuous-p (subsequences list))))
|
||||
(map-into nc-subsequences #'designated-sequence nc-subsequences))))
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
(defun all-subsequences2 (list)
|
||||
(labels ((recurse (s list)
|
||||
(if (endp list)
|
||||
(if (>= s 3)
|
||||
'(())
|
||||
'())
|
||||
(let ((x (car list))
|
||||
(xs (cdr list)))
|
||||
(if (evenp s)
|
||||
(append (mapcar (lambda (ys) (cons x ys))
|
||||
(recurse (+ s 1) xs))
|
||||
(recurse s xs))
|
||||
(append (mapcar (lambda (ys) (cons x ys))
|
||||
(recurse s xs))
|
||||
(recurse (+ s 1) xs)))))))
|
||||
(recurse 0 list)))
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
import std.stdio;
|
||||
|
||||
T[][] ncsub(T)(in T[] seq, in int s=0) pure nothrow {
|
||||
if (seq.length) {
|
||||
T[][] aux;
|
||||
foreach (ys; ncsub(seq[1..$], s + !(s % 2)))
|
||||
aux ~= seq[0] ~ ys;
|
||||
return aux ~ ncsub(seq[1..$], s + s % 2);
|
||||
} else
|
||||
return new T[][](s >= 3, 0);
|
||||
}
|
||||
|
||||
void main() {
|
||||
writeln(ncsub([1, 2, 3]));
|
||||
writeln(ncsub([1, 2, 3, 4]));
|
||||
foreach (nc; ncsub([1, 2, 3, 4, 5]))
|
||||
writeln(nc);
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
struct Ncsub(T) {
|
||||
T[] seq;
|
||||
|
||||
int opApply(int delegate(ref int[]) dg) const {
|
||||
immutable int n = seq.length;
|
||||
int result;
|
||||
auto S = new int[n];
|
||||
|
||||
FOR_I:
|
||||
foreach (i; 1 .. 1 << seq.length) {
|
||||
int len_S;
|
||||
bool nc = false;
|
||||
foreach (j; 0 .. seq.length + 1) {
|
||||
immutable int k = i >> j;
|
||||
if (k == 0) {
|
||||
if (nc) {
|
||||
auto auxS = S[0 .. len_S];
|
||||
result = dg(auxS);
|
||||
if (result)
|
||||
break FOR_I;
|
||||
}
|
||||
break;
|
||||
} else if (k % 2) {
|
||||
S[len_S] = seq[j];
|
||||
len_S++;
|
||||
} else if (len_S)
|
||||
nc = true;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
void main() {
|
||||
import std.array, std.range;
|
||||
//assert(iota(24).array().Ncsub!int().walkLength() == 16_776_915);
|
||||
auto r = array(iota(24));
|
||||
int counter;
|
||||
foreach (s; Ncsub!int(r))
|
||||
counter++;
|
||||
assert(counter == 16_776_915);
|
||||
}
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
const ( // state:
|
||||
m = iota // missing: all elements missing so far
|
||||
c // continuous: all elements included so far are continuous
|
||||
cm // one or more continuous followed by one or more missing
|
||||
cmc // non-continuous subsequence
|
||||
)
|
||||
|
||||
func ncs(s []int) [][]int {
|
||||
if len(s) < 3 {
|
||||
return nil
|
||||
}
|
||||
return append(n2(nil, s[1:], m), n2([]int{s[0]}, s[1:], c)...)
|
||||
}
|
||||
|
||||
var skip = []int{m, cm, cm, cmc}
|
||||
var incl = []int{c, c, cmc, cmc}
|
||||
|
||||
func n2(ss, tail []int, seq int) [][]int {
|
||||
if len(tail) == 0 {
|
||||
if seq != cmc {
|
||||
return nil
|
||||
}
|
||||
return [][]int{ss}
|
||||
}
|
||||
return append(n2(append([]int{}, ss...), tail[1:], skip[seq]),
|
||||
n2(append(ss, tail[0]), tail[1:], incl[seq])...)
|
||||
}
|
||||
|
||||
func main() {
|
||||
ss := ncs([]int{1, 2, 3, 4})
|
||||
fmt.Println(len(ss), "non-continuous subsequences:")
|
||||
for _, s := range ss {
|
||||
fmt.Println(" ", s)
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
action p x = if p x then succ x else x
|
||||
|
||||
fenceM p q s [] = guard (q s) >> return []
|
||||
fenceM p q s (x:xs) = do
|
||||
(f,g) <- p
|
||||
ys <- fenceM p q (g s) xs
|
||||
return $ f x ys
|
||||
|
||||
ncsubseq = fenceM [((:), action even), (flip const, action odd)] (>= 3) 0
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
continuous = null . dropWhile not . dropWhile id . dropWhile not
|
||||
ncs xs = map (map fst . filter snd . zip xs) $
|
||||
filter (not . continuous) $
|
||||
mapM (const [True,False]) xs
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
import Data.List
|
||||
|
||||
poset = foldr (\x p -> p ++ map (x:) p) [[]]
|
||||
|
||||
ncsubs [] = [[]]
|
||||
ncsubs (x:xs) = tail $ nc [x] xs
|
||||
where
|
||||
nc [_] [] = [[]]
|
||||
nc (_:x:xs) [] = nc [x] xs
|
||||
nc xs (y:ys) = (nc (xs++[y]) ys) ++ map (xs++) (tail $ poset ys)
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
import Data.List (subsequences, tails, delete)
|
||||
|
||||
disjoint a = concatMap (cutAt a) [1..length a - 2] where
|
||||
cutAt s n = [a ++ b | b <- delete [] (subsequences right),
|
||||
a <- init (tails left) ] where
|
||||
(left, _:right) = splitAt n s
|
||||
|
||||
main = print $ length $ disjoint [1..20]
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
import Data.List (inits, tails)
|
||||
|
||||
subseqs [] = []
|
||||
subseqs (x:xs) = [x] : map (x:) s ++ s where s = subseqs xs
|
||||
|
||||
consecs x = concatMap (tail.inits) (tails x)
|
||||
|
||||
minus [] [] = []
|
||||
minus (a:as) bb@(b:bs)
|
||||
| a == b = minus as bs
|
||||
| otherwise = a:minus as bb
|
||||
|
||||
disjoint s = (subseqs s) `minus` (consecs s)
|
||||
|
||||
main = mapM_ print $ disjoint [1..4]
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
allmasks=: 2 #:@i.@^ #
|
||||
firstend=:1 0 i.&1@E."1 ]
|
||||
laststart=: 0 1 {:@I.@E."1 ]
|
||||
noncont=: <@#~ (#~ firstend < laststart)@allmasks
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
noncont 1+i.4
|
||||
┌───┬───┬───┬─────┬─────┐
|
||||
│2 4│1 4│1 3│1 3 4│1 2 4│
|
||||
└───┴───┴───┴─────┴─────┘
|
||||
noncont 'aeiou'
|
||||
┌──┬──┬──┬───┬───┬──┬──┬───┬──┬───┬───┬────┬───┬───┬────┬────┐
|
||||
│iu│eu│eo│eou│eiu│au│ao│aou│ai│aiu│aio│aiou│aeu│aeo│aeou│aeiu│
|
||||
└──┴──┴──┴───┴───┴──┴──┴───┴──┴───┴───┴────┴───┴───┴────┴────┘
|
||||
#noncont i.10
|
||||
968
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
contmasks=: a: ;@, 1 <:/~@i.&.>@i.@+ #
|
||||
noncont=: <@#~ (allmasks -. contmasks)
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
function non_continuous_subsequences(ary) {
|
||||
var non_continuous = new Array();
|
||||
for (var i = 0; i < ary.length; i++) {
|
||||
if (! is_array_continuous(ary[i])) {
|
||||
non_continuous.push(ary[i]);
|
||||
}
|
||||
}
|
||||
return non_continuous;
|
||||
}
|
||||
|
||||
function is_array_continuous(ary) {
|
||||
if (ary.length < 2)
|
||||
return true;
|
||||
for (var j = 1; j < ary.length; j++) {
|
||||
if (ary[j] - ary[j-1] != 1) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
load('json2.js'); /* http://www.json.org/js.html */
|
||||
|
||||
print(JSON.stringify( non_continuous_subsequences( powerset([1,2,3,4]))));
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
GoodBad[i_List]:=Not[MatchQ[Differences[i],{1..}|{}]]
|
||||
n=5
|
||||
Select[Subsets[Range[n]],GoodBad]
|
||||
|
|
@ -0,0 +1 @@
|
|||
{{1,3},{1,4},{1,5},{2,4},{2,5},{3,5},{1,2,4},{1,2,5},{1,3,4},{1,3,5},{1,4,5},{2,3,5},{2,4,5},{1,2,3,5},{1,2,4,5},{1,3,4,5}}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
let rec fence s = function
|
||||
[] ->
|
||||
if s >= 3 then
|
||||
[[]]
|
||||
else
|
||||
[]
|
||||
|
||||
| x :: xs ->
|
||||
if s mod 2 = 0 then
|
||||
List.map
|
||||
(fun ys -> x :: ys)
|
||||
(fence (s + 1) xs)
|
||||
@
|
||||
fence s xs
|
||||
else
|
||||
List.map
|
||||
(fun ys -> x :: ys)
|
||||
(fence s xs)
|
||||
@
|
||||
fence (s + 1) xs
|
||||
|
||||
let ncsubseq = fence 0
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
declare
|
||||
fun {NCSubseq SeqList}
|
||||
Seq = {FS.value.make SeqList}
|
||||
proc {Script Result}
|
||||
%% the result is a subset of Seq
|
||||
{FS.subset Result Seq}
|
||||
|
||||
%% at least one element of Seq is missing
|
||||
local Gap in
|
||||
{FS.include Gap Seq}
|
||||
{FS.exclude Gap Result}
|
||||
%% and this element is between the smallest
|
||||
%% and the largest elements of the subsequence
|
||||
Gap >: {FS.int.min Result}
|
||||
Gap <: {FS.int.max Result}
|
||||
end
|
||||
|
||||
%% enumerate all such sets
|
||||
{FS.distribute naive [Result]}
|
||||
end
|
||||
in
|
||||
{Map {SearchAll Script} FS.reflect.lowerBoundList}
|
||||
end
|
||||
in
|
||||
{Inspect {NCSubseq [1 2 3 4]}}
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
sub non_continuous_subsequences ( *@list ) {
|
||||
powerset(@list).grep: { 1 != all( .[ 0 ^.. .end] Z- .[0 ..^ .end] ) }
|
||||
}
|
||||
|
||||
sub powerset ( *@list ) {
|
||||
reduce( -> @L, $n { [ @L, @L.map: {[ .list, $n ]} ] }, [[]], @list );
|
||||
}
|
||||
|
||||
say ~ non_continuous_subsequences( 1..3 )».perl;
|
||||
say ~ non_continuous_subsequences( 1..4 )».perl;
|
||||
say ~ non_continuous_subsequences( ^4 ).map: {[<a b c d>[.list]].perl};
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
my ($max, @current);
|
||||
sub non_continuous {
|
||||
my ($idx, $has_gap, $found) = @_;
|
||||
|
||||
for ($idx .. $max) {
|
||||
push @current, $_;
|
||||
# print "@current\n" if $has_gap; # uncomment for huge output
|
||||
$found ++ if $has_gap;
|
||||
$found += non_continuous($_ + 1, $has_gap) if $_ < $max;
|
||||
pop @current;
|
||||
$has_gap = @current; # don't set gap flag if it's empty still
|
||||
}
|
||||
$found;
|
||||
}
|
||||
|
||||
$max = 20; # 1048365 sequences, 10 seconds-ish
|
||||
print "found ", non_continuous(1), " sequences\n";
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
(de ncsubseq (Lst)
|
||||
(let S 0
|
||||
(recur (S Lst)
|
||||
(ifn Lst
|
||||
(and (>= S 3) '(NIL))
|
||||
(let (X (car Lst) XS (cdr Lst))
|
||||
(ifn (bit? 1 S) # even
|
||||
(conc
|
||||
(mapcar '((YS) (cons X YS))
|
||||
(recurse (inc S) XS) )
|
||||
(recurse S XS) )
|
||||
(conc
|
||||
(mapcar '((YS) (cons X YS))
|
||||
(recurse S XS) )
|
||||
(recurse (inc S) XS) ) ) ) ) ) ) )
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
define ncsubseq(l);
|
||||
lvars acc = [], gap_started = false, is_continuous = true;
|
||||
define do_it(l1, l2);
|
||||
dlocal gap_started;
|
||||
lvars el, save_is_continuous = is_continuous;
|
||||
if l2 = [] then
|
||||
if not(is_continuous) then
|
||||
cons(l1, acc) -> acc;
|
||||
endif;
|
||||
else
|
||||
front(l2) -> el;
|
||||
back(l2) -> l2;
|
||||
not(gap_started) and is_continuous -> is_continuous;
|
||||
do_it(cons(el, l1), l2);
|
||||
save_is_continuous -> is_continuous;
|
||||
not(l1 = []) or gap_started -> gap_started;
|
||||
do_it(l1, l2);
|
||||
endif;
|
||||
enddefine;
|
||||
do_it([], rev(l));
|
||||
acc;
|
||||
enddefine;
|
||||
|
||||
ncsubseq([1 2 3 4 5]) =>
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
[[1 3] [1 4] [2 4] [1 2 4] [1 3 4] [1 5] [2 5] [1 2 5] [3 5] [1 3 5]
|
||||
[2 3 5] [1 2 3 5] [1 4 5] [2 4 5] [1 2 4 5] [1 3 4 5]]
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
Function SubSequence ( [Array] $S, [Boolean] $all=$false )
|
||||
{
|
||||
$sc = $S.count
|
||||
if( $sc -gt ( 2 - [Int32] $all ) ) {
|
||||
[void] $sc--
|
||||
0..$sc | ForEach-Object {
|
||||
$gap = $_
|
||||
"$( $S[ $_ ] )"
|
||||
if( $gap -lt $sc )
|
||||
{
|
||||
SubSequence ( ( $gap + 1 )..$sc | Where-Object { $_ -ne $gap } ) ( ( $gap -ne 0 ) -or $all ) | ForEach-Object {
|
||||
[String]::Join( ',', ( ( [String]$_ ).Split(',') | ForEach-Object {
|
||||
$lt = $true
|
||||
} {
|
||||
if( $lt -and ( $_ -gt $gap ) )
|
||||
{
|
||||
$S[ $gap ]
|
||||
$lt = $false
|
||||
}
|
||||
$S[ $_ ]
|
||||
} {
|
||||
if( $lt )
|
||||
{
|
||||
$S[ $gap ]
|
||||
}
|
||||
}
|
||||
) )
|
||||
}
|
||||
}
|
||||
}
|
||||
#[String]::Join( ',', $S)
|
||||
} else {
|
||||
$S | ForEach-Object { [String] $_ }
|
||||
}
|
||||
}
|
||||
|
||||
Function NonContinuous-SubSequence ( [Array] $S )
|
||||
{
|
||||
$sc = $S.count
|
||||
if( $sc -eq 3 )
|
||||
{
|
||||
[String]::Join( ',', $S[ ( 0,2 ) ] )
|
||||
} elseif ( $sc -gt 3 ) {
|
||||
[void] $sc--
|
||||
$gaps = @()
|
||||
$gaps += ( ( NonContinuous-SubSequence ( 1..$sc ) ) | ForEach-Object {
|
||||
$gap1 = ",$_,"
|
||||
"0,{0}" -f ( [String]::Join( ',', ( 1..$sc | Where-Object { $gap1 -notmatch "$_," } ) ) )
|
||||
} )
|
||||
$gaps += 1..( $sc - 1 )
|
||||
2..( $sc - 1 ) | ForEach-Object {
|
||||
$gap2 = $_ - 1
|
||||
$gaps += ( ( SubSequence ( $_..$sc ) ) | ForEach-Object {
|
||||
"$gap2,$_"
|
||||
} )
|
||||
}
|
||||
#Write-Host "S $S gaps $gaps"
|
||||
$gaps | ForEach-Object {
|
||||
$gap3 = ",$_,"
|
||||
"$( 0..$sc | Where-Object { $gap3 -notmatch ",$_," } | ForEach-Object {
|
||||
$S[$_]
|
||||
} )" -replace ' ', ','
|
||||
}
|
||||
} else {
|
||||
$null
|
||||
}
|
||||
}
|
||||
|
||||
( NonContinuous-SubSequence 'a','b','c','d','e' ) | Select-Object length, @{Name='value';Expression={ $_ } } | Sort-Object length, value | ForEach-Object { $_.value }
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
% fetch all the subsequences
|
||||
ncsubs(L, LNCSL) :-
|
||||
setof(NCSL, one_ncsubs(L, NCSL), LNCSL).
|
||||
|
||||
% how to build one subsequence
|
||||
one_ncsubs(L, NCSL) :-
|
||||
extract_elem(L, NCSL);
|
||||
( sublist(L, L1),
|
||||
one_ncsubs(L1, NCSL)).
|
||||
|
||||
% extract one element of the list
|
||||
% this element is neither the first nor the last.
|
||||
extract_elem(L, NCSL) :-
|
||||
length(L, Len),
|
||||
Len1 is Len - 2,
|
||||
between(1, Len1, I),
|
||||
nth0(I, L, Elem),
|
||||
select(Elem, L, NCS1),
|
||||
( NCSL = NCS1; extract_elem(NCS1, NCSL)).
|
||||
|
||||
% extract the first or the last element of the list
|
||||
sublist(L, SL) :-
|
||||
(L = [_|SL];
|
||||
reverse(L, [_|SL1]),
|
||||
reverse(SL1, SL)).
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
?- ncsubs([a,e,i,o,u], L).
|
||||
L = [[a,e,i,u],[a,e,o],[a,e,o,u],[a,e,u],[a,i],[a,i,o],[a,i,o,u],[a,i,u],[a,o],[a,o,u],[a,u],[e,i,u],[e,o],[e,o,u],[e,u],[i,u]]
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
def ncsub(seq, s=0):
|
||||
if seq:
|
||||
x = seq[:1]
|
||||
xs = seq[1:]
|
||||
p2 = s % 2
|
||||
p1 = not p2
|
||||
return [x + ys for ys in ncsub(xs, s + p1)] + ncsub(xs, s + p2)
|
||||
else:
|
||||
return [[]] if s >= 3 else []
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
from sys import argv
|
||||
import psyco
|
||||
|
||||
def C(n, k):
|
||||
result = 1
|
||||
for d in xrange(1, k+1):
|
||||
result *= n
|
||||
n -= 1
|
||||
result /= d
|
||||
return result
|
||||
|
||||
# http://oeis.org/A002662
|
||||
nsubs = lambda n: sum(C(n, k) for k in xrange(3, n+1))
|
||||
|
||||
def ncsub(seq):
|
||||
n = len(seq)
|
||||
result = [None] * nsubs(n)
|
||||
pos = 0
|
||||
|
||||
for i in xrange(1, 2 ** n):
|
||||
S = []
|
||||
nc = False
|
||||
for j in xrange(n + 1):
|
||||
k = i >> j
|
||||
if k == 0:
|
||||
if nc:
|
||||
result[pos] = S
|
||||
pos += 1
|
||||
break
|
||||
elif k % 2:
|
||||
S.append(seq[j])
|
||||
elif S:
|
||||
nc = True
|
||||
return result
|
||||
|
||||
from sys import argv
|
||||
import psyco
|
||||
psyco.full()
|
||||
n = 10 if len(argv) < 2 else int(argv[1])
|
||||
print len( ncsub(range(1, n)) )
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
ncsub <- function(x)
|
||||
{
|
||||
n <- length(x)
|
||||
a <- seq_len(n)
|
||||
seqlist <- list()
|
||||
for(i in 2:(n-1))
|
||||
{
|
||||
seqs <- combn(a, i) # Get all subseqs
|
||||
ok <- apply(seqs, 2, function(x) any(diff(x)!=1)) # Find noncts ones
|
||||
newseqs <- unlist(apply(seqs[,ok], 2, function(x) list(x)), recursive=FALSE) # Convert matrix to list of its columns
|
||||
seqlist <- c(seqlist, newseqs) # Append to existing list
|
||||
}
|
||||
lapply(seqlist, function(index) x[index])
|
||||
}
|
||||
# Example usage
|
||||
ncsub(1:4)
|
||||
ncsub(letters[1:5])
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
/*REXX program to list non-continuous subsequences (NCS), given a seq.*/
|
||||
parse arg list /*the the list from the CL.*/
|
||||
if list='' then list=1 2 3 4 5 /*Specified? Use default. */
|
||||
say 'list=' space(list); say /*show list to the terminal*/
|
||||
w=words(list) ; #=0 /*# words in list; # of NCS*/
|
||||
$=left(123456789,w) /*build a string of digits.*/
|
||||
tail=right($,max(0,w-2)) /*construct a "fast" tail. */
|
||||
|
||||
do j=13 to left($,1) || tail /*step through the list. */
|
||||
if verify(j,$)\==0 then iterate /*Not one of the chosen? */
|
||||
f=left(j,1) /*the first digit of j. */
|
||||
NCS=0 /*not non-continuous subseq*/
|
||||
do k=2 to length(j); _=substr(j,k,1) /*pick off a single digit. */
|
||||
if _ <= f then iterate j /*if next digit ≤ then skip*/
|
||||
if _ \== f+1 then NCS=1 /*it's OK as of now. */
|
||||
f=_ /*we now got a new next dig*/
|
||||
end /*k*/
|
||||
|
||||
if \NCS then iterate /*¬OK? Then skip this num.*/
|
||||
#=#+1 /*Eureka! We found one. */
|
||||
x= /*the beginning of the NCS.*/
|
||||
do m=1 for length(j) /*build a thingy to display*/
|
||||
x=x word(list,substr(j,m,1)) /*pick off a number to show*/
|
||||
end /*m*/
|
||||
|
||||
say 'a non-continuous subsequence: ' x /*show a non-cont. subseq. */
|
||||
end /*j*/
|
||||
|
||||
if #==0 then #='no' /*make it more gooder Eng. */
|
||||
say; say # "non-continuous subsequence"s(#) 'were found.'
|
||||
exit /*stick a fork in it, we're done.*/
|
||||
/*──────────────────────────────────S subroutine───────────────────────*/
|
||||
s: if arg(1)==1 then return ''; return word(arg(2) 's',1) /*plurals.*/
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
class Array
|
||||
def func_power_set
|
||||
inject([[]]) { |ps,item| # for each item in the Array
|
||||
ps + # take the powerset up to now and add
|
||||
ps.map { |e| e + [item] } # it again, with the item appended to each element
|
||||
}
|
||||
end
|
||||
|
||||
def non_continuous_subsequences
|
||||
func_power_set.find_all {|seq| not seq.continuous}
|
||||
end
|
||||
|
||||
def continuous
|
||||
each_cons(2) {|a, b| return false if a+1 != b}
|
||||
true
|
||||
end
|
||||
end
|
||||
|
||||
p (1..3).to_a.non_continuous_subsequences
|
||||
p (1..4).to_a.non_continuous_subsequences
|
||||
p (1..5).to_a.non_continuous_subsequences
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
(define (ncsubseq lst)
|
||||
(let recurse ((s 0)
|
||||
(lst lst))
|
||||
(if (null? lst)
|
||||
(if (>= s 3)
|
||||
'(())
|
||||
'())
|
||||
(let ((x (car lst))
|
||||
(xs (cdr lst)))
|
||||
(if (even? s)
|
||||
(append
|
||||
(map (lambda (ys) (cons x ys))
|
||||
(recurse (+ s 1) xs))
|
||||
(recurse s xs))
|
||||
(append
|
||||
(map (lambda (ys) (cons x ys))
|
||||
(recurse s xs))
|
||||
(recurse (+ s 1) xs)))))))
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
fun fence s [] =
|
||||
if s >= 3 then
|
||||
[[]]
|
||||
else
|
||||
[]
|
||||
|
||||
| fence s (x :: xs) =
|
||||
if s mod 2 = 0 then
|
||||
map
|
||||
(fn ys => x :: ys)
|
||||
(fence (s + 1) xs)
|
||||
@
|
||||
fence s xs
|
||||
else
|
||||
map
|
||||
(fn ys => x :: ys)
|
||||
(fence s xs)
|
||||
@
|
||||
fence (s + 1) xs
|
||||
|
||||
fun ncsubseq xs = fence 0 xs
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
proc subsets l {
|
||||
set res [list [list]]
|
||||
foreach e $l {
|
||||
foreach subset $res {lappend res [lappend subset $e]}
|
||||
}
|
||||
return $res
|
||||
}
|
||||
proc is_not_continuous seq {
|
||||
set last [lindex $seq 0]
|
||||
foreach e [lrange $seq 1 end] {
|
||||
if {$e-1 != $last} {return 1}
|
||||
set last $e
|
||||
}
|
||||
return 0
|
||||
}
|
||||
proc lfilter {f list} {
|
||||
set res {}
|
||||
foreach i $list {if [$f $i] {lappend res $i}}
|
||||
return $res
|
||||
}
|
||||
|
||||
% lfilter is_not_continuous [subsets {1 2 3 4}]
|
||||
{1 3} {1 4} {2 4} {1 2 4} {1 3 4}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
#import std
|
||||
|
||||
noncontinuous = num; ^rlK3ZK17rSS/~& powerset
|
||||
|
||||
#show+
|
||||
|
||||
examples = noncontinuous 'abcde'
|
||||
Loading…
Add table
Add a link
Reference in a new issue