Non-continuous subsequences: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Picat}}: code tag for predicates) |
m (→{{header|Wren}}: Minor tidy) |
||
(2 intermediate revisions by 2 users not shown) | |||
Line 33:
{{trans|Python}}
<
I seq.empty
R I s >= 3 {[[Int]()]} E [[Int]]()
Line 45:
print(ncsub(Array(1..3)))
print(ncsub(Array(1..4)))
print(ncsub(Array(1..5)))</
{{out}}
Line 56:
=={{header|Ada}}==
===Recursive===
<
procedure Test_Non_Continuous is
Line 92:
Put_NCS ((1,2,3,4)); New_Line;
Put_NCS ((1,2,3,4,5)); New_Line;
end Test_Non_Continuous;</
{{out}}
Line 127:
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}
<
MODE SEQMODE = CHAR;
MODE SEQ = [1:0]SEQMODE;
Line 161:
print((seq, new line))
# OD # )
END; test non continuous</
{{out}}
<pre>
Line 191:
Note: This specimen can only handle sequences of length less than ''bits width'' of '''bits'''.
<
MODE SEQ = [1:0]SEQMODE;
MODE YIELDSEQ = PROC(SEQ)VOID;
Line 237:
print((seq, new line))
# OD # )
)</
{{out}}
<pre>
Line 262:
ahk forum: [http://www.autohotkey.com/forum/viewtopic.php?p=277328#277328 discussion]
<
MsgBox % noncontinuous("1,2,3,4", ",")
Line 281:
ToBin(n,W=16) { ; LS W-bits of Binary representation of n
Return W=1 ? n&1 : ToBin(n>>1,W-1) . n&1
}</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
list1$() = "1", "2", "3", "4"
PRINT "For [1, 2, 3, 4] non-continuous subsequences are:"
Line 316:
NEXT g%
NEXT s%
ENDPROC</
{{out}}
<pre>
Line 345:
=={{header|Bracmat}}==
<
= sub
. ( sub
Line 365:
& noncontinuous$(e r n i t)
);
</syntaxhighlight>
</lang>▼
{{out}}
<pre>e n t
Line 386:
=={{header|C}}==
Note: This specimen can only handle lists of length less than the number of bits in an '''int'''.
<
#include <stdio.h>
Line 405:
return 0;
}</
Example use:
<pre>
Line 419:
Using "consecutive + gap + any subsequence" to produce disjointed sequences:
<
#include <stdio.h>
#include <stdlib.h>
Line 443:
return 0;
}</
===Recursive method===
Using recursion and a state transition table.
<
typedef unsigned char sint;
Line 496:
pick(c - 1, 0, s_blnk, v + 1, 0);
return 0;
}</
<pre>% ./a.out 1 2 3 4
1 3
Line 507:
=={{header|C sharp}}==
<
using System.Collections.Generic;
using System.Linq;
Line 536:
static bool IsContinuous(List<int> list) => list[list.Count - 1] - list[0] + 1 == list.Count;
}</
{{out}}
<pre>
Line 547:
=={{header|C++}}==
<
/*
* Nigel Galloway, July 19th., 2017 - Yes well is this any better?
Line 563:
uint next() {return g;}
};
</syntaxhighlight>
Which may be used as follows:
<
int main(){
N n(4);
while (n.hasNext()) std::cout << n.next() << "\t* " << std::bitset<4>(n.next()) << std::endl;
}
</syntaxhighlight>
{{out}}
<pre>
Line 580:
</pre>
I can count the length of the sequence:
<
int main(){
N n(31);
int z{};for (;n.hasNext();++z); std::cout << z << std::endl;
}
</syntaxhighlight>
{{out}}
<pre>
Line 595:
Here's a simple approach that uses the clojure.contrib.combinatorics library to generate subsequences, and then filters out the continuous subsequences using a naïve subseq test:
<
(use '[clojure.contrib.combinatorics :only (subsets)])
Line 612:
(filter (of-min-length 2) (non-continuous-subsequences [:a :b :c :d]))
</syntaxhighlight>
=={{header|CoffeeScript}}==
Use binary bitmasks to enumerate our sequences.
<
is_contigous_binary = (n) ->
# return true if binary representation of n is
Line 674:
num_solutions = non_contig_subsequences(arr).length
console.log "for n=#{n} there are #{num_solutions} solutions"
</syntaxhighlight>
{{out}}
Line 702:
looking at the screen wondering what's wrong for about half an hour -->
<
(labels ((subsequences (tail &optional (acc '()) (result '()))
"Return a list of the subsequence designators of the
Line 722:
(map-into subsequence-d 'first subsequence-d)))
(let ((nc-subsequences (delete-if #'continuous-p (subsequences list))))
(map-into nc-subsequences #'designated-sequence nc-subsequences))))</
{{trans|Scheme}}
<
(labels ((recurse (s list)
(if (endp list)
Line 741:
(recurse s xs))
(recurse (+ s 1) xs)))))))
(recurse 0 list)))</
=={{header|D}}==
===Recursive Version===
{{trans|Python}}
<
if (seq.length) {
typeof(return) aux;
Line 763:
foreach (const nc; [1, 2, 3, 4, 5].ncsub)
nc.writeln;
}</
{{out}}
<pre>[[1, 3]]
Line 786:
===Faster Lazy Version===
This version doesn't copy the sub-arrays.
<
T[] seq;
Line 828:
counter++;
assert(counter == 16_776_915);
}</
===Generator Version===
This version doesn't copy the sub-arrays, and it's a little slower than the opApply-based version.
<
Generator!(T[]) ncsub(T)(in T[] seq) {
Line 865:
foreach (const nc; [1, 2, 3, 4, 5].ncsub)
nc.writeln;
}</
=={{header|Elixir}}==
{{trans|Erlang}}
<
defp masks(n) do
maxmask = trunc(:math.pow(2, n)) - 1
Line 892:
IO.inspect RC.ncs([1,2,3])
IO.inspect RC.ncs([1,2,3,4])
IO.inspect RC.ncs('abcd')</
{{out}}
Line 904:
Erlang's not optimized for strings or math, so this is pretty inefficient. Nonetheless, it works by generating the set of all possible "bitmasks" (represented as strings), filters for those with non-continuous subsequences, and maps from that set over the list. One immediate point for optimization that would complicate the code a bit would be to compile the regular expression, the problem being where you'd put it.
<
-export([ncs/1]).
Line 927:
ncs(List) ->
lists:map(fun(Mask) -> apply_mask_to_list(Mask, List) end,
masks(length(List))).</
{{out}}
Line 940:
=={{header|F_Sharp|F#}}==
===Generate only the non-continuous subsequences===
<
(*
A function to generate only the non-continuous subsequences.
Line 949:
let rec fg n = seq{if n>0 then yield! seq{1..((1<<<n)-1)}|>fn n; yield! fg (n-1)|>fn n}
Seq.collect fg ({1..(n-2)})
</syntaxhighlight>
This may be used as follows:
<
let Ng ng = N ng |> Seq.iter(fun n->printf "%2d -> " n; {0..(ng-1)}|>Seq.iter (fun g->if (n&&&(1<<<g))>0 then printf "%d " (g+1));printfn "")
Ng 4
</syntaxhighlight>
{{out}}
<pre>
Line 979:
</pre>
===Generate all subsequences and filter out the continuous===
<
(*
A function to filter out continuous subsequences.
Line 990:
|(n,_) ->n
{5..(1<<<n)-1}|>Seq.choose(fun i->if fst({0..n-1}|>Seq.takeWhile(fun n->(1<<<(n-1))<i)|>Seq.fold(fun n g->fn (n,(i&&&(1<<<g)>0)))(0,0)) > 1 then Some(i) else None)
</syntaxhighlight>
Again counting the number of non-continuous subsequences
<pre>
Line 1,012:
=={{header|FreeBASIC}}==
{{trans|BBC BASIC}}
<
Dim As Integer i, j, g, n, r, s, w
Dim As String a, b, c
Line 1,044:
Print "Para [e, r, n, i, t] las subsecuencias no continuas son:"
Subsecuencias_no_continuas(lista2())
Sleep</
{{out}}
<pre>
Line 1,075:
=={{header|Go}}==
Generate the power set (power sequence, actually) with a recursive function, but keep track of the state of the subsequence on the way down. When you get to the bottom, if state == non-continuous, then include the subsequence. It's just filtering merged in with generation.
<
import "fmt"
Line 1,113:
fmt.Println(" ", s)
}
}</
{{out}}
<pre>
Line 1,128:
===Generalized monadic filter===
<
fenceM p q s [] = guard (q s) >> return []
Line 1,136:
return $ f x ys
ncsubseq = fenceM [((:), action even), (flip const, action odd)] (>= 3) 0</
{{out}}
Line 1,150:
This implementation works by computing templates of all possible subsequences of the given length of sequence, discarding the continuous ones, then applying the remaining templates to the input list.
<
ncs xs = map (map fst . filter snd . zip xs) $
filter (not . continuous) $
mapM (const [True,False]) xs</
===Recursive===
Recursive method with powerset as helper function.
<
poset = foldr (\x p -> p ++ map (x:) p) [[]]
Line 1,167:
nc [_] [] = [[]]
nc (_:x:xs) [] = nc [x] xs
nc xs (y:ys) = (nc (xs++[y]) ys) ++ map (xs++) (tail $ poset ys)</
{{out}}
Line 1,187:
A disjointed subsequence is a consecutive subsequence followed by a gap,
then by any nonempty subsequence to its right:
<
disjoint a = concatMap (cutAt a) [1..length a - 2] where
Line 1,194:
(left, _:right) = splitAt n s
main = print $ length $ disjoint [1..20]</
Build a lexicographic list of consecutive subsequences,
and a list of all subsequences, then subtract one from the other:
<
subseqs = foldr (\x s -> [x] : map (x:) s ++ s) []
Line 1,211:
disjoint s = (subseqs s) `minus` (consecs s)
main = mapM_ print $ disjoint [1..4]</
=={{header|J}}==
We select those combinations where the end of the first continuous subsequence appears before the start of the last continuous subsequence:
<
firstend=:1 0 i.&1@E."1 ]
laststart=: 0 1 {:@I.@E."1 ]
noncont=: <@#~ (#~ firstend < laststart)@allmasks</
Example use:
<
┌───┬───┬───┬─────┬─────┐
│2 4│1 4│1 3│1 3 4│1 2 4│
Line 1,231:
└──┴──┴──┴───┴───┴──┴──┴───┴──┴───┴───┴────┴───┴───┴────┴────┘
#noncont i.10
968</
Alternatively, since there are relatively few continuous sequences, we could specifically exclude them:
<
noncont=: <@#~ (allmasks -. contmasks)</
(we get the same behavior from this implementation)
=={{header|Java}}==
<
public static void main(String args[]) {
Line 1,256:
}
}
}</
<pre>12 4
Line 1,268:
{{works with|SpiderMonkey}}
<
var non_continuous = new Array();
for (var i = 0; i < ary.length; i++) {
Line 1,291:
load('json2.js'); /* http://www.json.org/js.html */
print(JSON.stringify( non_continuous_subsequences( powerset([1,2,3,4]))));</
{{out}}
Line 1,305:
subsets, we will use the powerset approach, and accordingly begin by
defining subsets/0 as a generator.
<
def subsets:
if length == 0 then []
Line 1,320:
def non_continuous_subsequences:
(length | non_continuous_indices) as $ix
| [.[ $ix[] ]] ;</
'''Example''':
To show that the above approach can be used for relatively large n, let us count the number of non-continuous subsequences of [0, 1, ..., 19].
<
count( [range(0;20)] | non_continuous_subsequences)
</syntaxhighlight>
{{out}}
$ jq -n -f powerset_generator.jq
Line 1,339:
'''Iterator and Functions'''
<
import Base.IteratorSize, Base.iterate, Base.length
Line 1,397:
@printf "%7d → %d\n" x length(NCSubSeq(x))
end
</
<pre>
Testing NCSubSeq for 4 items:
Line 1,446:
=={{header|Kotlin}}==
<
fun <T> ncs(a: Array<T>) {
Line 1,478:
val ca = arrayOf('a', 'b', 'c', 'd', 'e')
ncs(ca)
}</
{{out}}
Line 1,507:
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Non_continuous_subsequences (item$(), display){
Function positions(n) {
Line 1,558:
Non_continuous_subsequences ("1","2","3","4","5","6","7","8","9","0"), false
clipboard doc$
</syntaxhighlight>
{{out}}
Line 1,691:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
We make all the subsets then filter out the continuous ones:
<
n=5
Select[Subsets[Range[n]],GoodBad]</
{{out}}
<pre>{{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}}</pre>
Line 1,699:
=={{header|Nim}}==
{{trans|Python}}
<
proc ncsub[T](se: seq[T], s = 0): seq[seq[T]] =
Line 1,717:
echo "ncsub(", toSeq 1.. 3, ") = ", ncsub(toSeq 1..3)
echo "ncsub(", toSeq 1.. 4, ") = ", ncsub(toSeq 1..4)
echo "ncsub(", toSeq 1.. 5, ") = ", ncsub(toSeq 1..5)</
{{out}}
<pre>ncsub(@[1, 2, 3]) = @[@[1, 3]]
Line 1,727:
{{trans|Generalized monadic filter}}
<
[] ->
if s >= 3 then
Line 1,748:
fence (s + 1) xs
let ncsubseq = fence 0</
{{out}}
Line 1,763:
=={{header|Oz}}==
A nice application of finite set constraints. We just describe what we want and the constraint system will deliver it:
<
fun {NCSubseq SeqList}
Seq = {FS.value.make SeqList}
Line 1,787:
end
in
{Inspect {NCSubseq [1 2 3 4]}}</
=={{header|PARI/GP}}==
Just a simple script, but it's I/O bound so efficiency isn't a concern. (Almost all subsequences are non-contiguous so looping over all possibilities isn't that bad. For length 20 about 99.98% of subsequences are non-contiguous.)
<
nonContigSubseq(v)={
for(i=5,2^#v-1,
Line 1,800:
};
nonContigSubseq([1,2,3])
nonContigSubseq(["a","b","c","d","e"])</
{{out}}
<pre>[1, 3]
Line 1,822:
=={{header|Perl}}==
<
sub non_continuous {
my ($idx, $has_gap) = @_;
Line 1,839:
$max = 20;
print "found ", non_continuous(1), " sequences\n";</
{{out}}
<pre>found 1048365 sequences</pre>
Line 1,847:
mean non-contiguous until you actually take something later.<br>
Counts non-contiguous subsequences of sequences of length 1..20 in under half a second
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
Line 1,880:
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
Line 1,898:
This approach uses <code>power_set/1</code> (from the <code>util</code> module) to get the proper indices.
<
go =>
Line 1,919:
% get all the index positions that are non-continuous
non_cont_ixs(N) = [ P: P in power_set(1..N), length(P) > 1, P.last() - P.first() != P.length-1].</
{{out}}
Line 1,952:
=={{header|PicoLisp}}==
{{trans|Scheme}}
<
(let S 0
(recur (S Lst)
Line 1,966:
(mapcar '((YS) (cons X YS))
(recurse S XS) )
(recurse (inc S) XS) ) ) ) ) ) ) )</
=={{header|Pop11}}==
Line 1,973:
variables to keep track if subsequence is continuous.
<
lvars acc = [], gap_started = false, is_continuous = true;
define do_it(l1, l2);
Line 1,996:
enddefine;
ncsubseq([1 2 3 4 5]) =></
{{out}}
Line 2,003:
=={{header|PowerShell}}==
<
{
$sc = $S.count
Line 2,071:
}
( NonContinuous-SubSequence 'a','b','c','d','e' ) | Select-Object length, @{Name='value';Expression={ $_ } } | Sort-Object length, value | ForEach-Object { $_.value }</
=={{header|Prolog}}==
Line 2,077:
We explain to Prolog how to build a non continuous subsequence of a list L, then we ask Prolog to fetch all the subsequences.
<syntaxhighlight lang="prolog">
% fetch all the subsequences
ncsubs(L, LNCSL) :-
Line 2,103:
reverse(L, [_|SL1]),
reverse(SL1, SL)).
</syntaxhighlight>
Example :
<
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]]</
=={{header|Python}}==
{{trans|Scheme}}
<
if seq:
x = seq[:1]
Line 2,119:
return [x + ys for ys in ncsub(xs, s + p1)] + ncsub(xs, s + p2)
else:
return [[]] if s >= 3 else []</
{{out}}
Line 2,133:
A faster Python + Psyco JIT version:
<
import psyco
Line 2,172:
psyco.full()
n = 10 if len(argv) < 2 else int(argv[1])
print len( ncsub(range(1, n)) )</
=={{header|Quackery}}==
Line 2,178:
A sequence of n items has 2^n possible subsequences, including the empty sequence. These correspond to the numbers 0 to 2^n-1, where a one in the binary expansion of the number indicates inclusion in the subsequence of the corresponding item in the sequence. Non-continuous subsequences correspond to numbers where the binary expansion of the number has a one, followed by one or more zeroes, followed by a one.
<
[ 0 swap
Line 2,215:
' [ 1 2 3 4 ] ncsubs echo cr
$ "quackery" ncsubs 72 wrap$</
{{out}}
Line 2,242:
The idea behind this is to loop over the possible lengths of subsequence, finding all subsequences then discarding those which are continuous.
<
{
n <- length(x)
Line 2,258:
# Example usage
ncsub(1:4)
ncsub(letters[1:5])</
=={{header|Racket}}==
Take a simple <tt>subsets</tt> definition:
<
(define (subsets l)
(if (null? l) '(())
(append (for/list ([l2 (subsets (cdr l))]) (cons (car l) l2))
(subsets (cdr l)))))
</syntaxhighlight>
since the subsets are returned in their original order, it is also a sub-sequences function.
Now add to it a "state" counter which count one for each chunk of items included or excluded. It's always even when we're in an excluded chunk (including the beginning) and odd when we're including items -- increment it whenever we switch from one kind of chunk to the other. This means that we should only include subsequences where the state is 3 (included->excluded->included) or more. Note that this results in code that is similar to the "Generalized monadic filter" entry, except a little simpler.
<
#lang racket
(define (non-continuous-subseqs l)
Line 2,283:
(non-continuous-subseqs '(1 2 3 4))
;; => '((1 2 4) (1 3 4) (1 3) (1 4) (2 4))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|rakudo|2015-09-24}}
<syntaxhighlight lang="raku"
@list.combinations.grep: { 1 != all( .[ 0 ^.. .end] Z- .[0 ..^ .end] ) }
}
Line 2,294:
say non_continuous_subsequences( 1..3 )».gist;
say non_continuous_subsequences( 1..4 )».gist;
say non_continuous_subsequences( ^4 ).map: {[<a b c d>[.list]].gist};</
{{out}}
<pre>((1 3))
Line 2,302:
=={{header|REXX}}==
This REXX version also works with non-numeric (alphabetic) items (as well as numbers).
<
parse arg list /*obtain optional argument from the CL.*/
if list='' | list=="," then list= 1 2 3 4 5 /*Not specified? Then use the default.*/
Line 2,334:
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
s: if arg(1)==1 then return ''; return word( arg(2) 's', 1) /*simple pluralizer.*/</
{{out|output|text= when using the input of: <tt> 1 2 3 4 </tt>}}
<pre>
Line 2,444:
=={{header|Ring}}==
<
# Project : Non-continuous subsequences
Line 2,503:
next
return items
</syntaxhighlight>
Output:
<pre>
Line 2,537:
Uses code from [[Power Set]].
<
def func_power_set
inject([[]]) { |ps,item| # for each item in the Array
Line 2,558:
p (1..4).to_a.non_continuous_subsequences
p (1..5).to_a.non_continuous_subsequences
p ("a".."d").to_a.non_continuous_subsequences</
{{out}}
Line 2,568:
</pre>
It is not the value of the array element and when judging continuation in the position, it changes as follows.
<
def continuous?(seq)
seq.each_cons(2) {|a, b| return false if index(a)+1 != index(b)}
Line 2,575:
end
p %w(a e i o u).non_continuous_subsequences</
{{out}}
Line 2,581:
=={{header|Scala}}==
<
private def seqR(s: String, c: String, i: Int, added: Int): Unit = {
Line 2,593:
seqR("1234", "", 0, 0)
}</
=={{header|Scheme}}==
{{trans|Generalized monadic filter}}
<
(let recurse ((s 0)
(lst lst))
Line 2,614:
(map (lambda (ys) (cons x ys))
(recurse s xs))
(recurse (+ s 1) xs)))))))</
{{out}}
Line 2,625:
=={{header|Seed7}}==
<
const func array bitset: ncsub (in bitset: seq, in integer: s) is func
Line 2,654:
writeln(seq);
end for;
end func;</
{{out}}
Line 2,667:
=={{header|Sidef}}==
{{trans|Perl}}
<
static current = [];
Line 2,684:
say non_continuous(1, 3);
say non_continuous(1, 4);
say non_continuous("a", "d");</
{{out}}
<pre>
Line 2,696:
{{trans|Generalized monadic filter}}
<
if s >= 3 then
[[]]
Line 2,716:
fence (s + 1) xs
fun ncsubseq xs = fence 0 xs</
{{out}}
Line 2,731:
This Tcl implementation uses the ''subsets'' function from [[Power Set]], which is acceptable as that conserves the ordering, as well as a problem-specific test function ''is_not_continuous'' and a generic list filter ''lfilter'':
<
set res [list [list]]
foreach e $l {
Line 2,753:
% lfilter is_not_continuous [subsets {1 2 3 4}]
{1 3} {1 4} {2 4} {1 2 4} {1 3 4}</
=={{header|Ursala}}==
Line 2,759:
To do it the lazy programmer way, apply the powerset library function to the list, which will generate all continuous and non-continuous subsequences of it, and then delete the subsequences that are also substrings (hence continuous) using a judicious combination of the built in substring predicate (K3), negation (Z), and distributing filter (K17) operator suffixes. This function will work on lists of any type. To meet the requirement for structural equivalence, the list items are first uniquely numbered (num), and the numbers are removed afterwards (rSS).
<
noncontinuous = num; ^rlK3ZK17rSS/~& powerset
Line 2,765:
#show+
examples = noncontinuous 'abcde'</
{{out}}
Line 2,787:
=={{header|VBScript}}==
{{trans|BBC BASIC}}
<
Function noncontsubseq(l)
Line 2,819:
WScript.Echo "List: [" & Join(list, ", ") & "]"
nn = noncontsubseq(list)
WScript.Echo nn & " non-continuous subsequences" </
{{out}}
<pre>
Line 2,835:
{{libheader|Wren-fmt}}
Needed a bit of doctoring to do the character example as Wren only has strings.
<
var ncs = Fn.new { |a|
Line 2,870:
System.print()
var ca = ["a", "b", "c", "d", "e"]
ncs.call(ca)</
{{out}}
<pre>
1 3
1 4
2 4
1 2 4
1 3 4
a c
a d
a e
b d
b e
c e
a b d
a b e
a c d
a c e
a d e
b c e
b d e
a b c e
a b d e
a c d e
=={{header|XPL0}}==
{{trans|Wren}}
<syntaxhighlight lang "XPL0">proc NCS(A, Size, Char);
int A, Size, Char;
int C, M;
proc Generate(M, K, C); \recursive
int M, K, C;
int I, J;
[if K = M then
[if C(M-1) # C(0)+M-1 then
[for I:= 0 to M-1 do
[if Char then ChOut(0, A(C(I)))
else IntOut(0, A(C(I)));
ChOut(0, ^ );
];
CrLf(0);
];
]
else
[for J:= 0 to Size-1 do
[if K = 0 or J > C(K-1) then
[C(K):= J;
Generate(M, K+1, C);
];
];
];
];
[C:= Reserve(Size*4);
for M:= 2 to Size-1 do Generate(M, 0, C);
];
int A, CA;
[A:= [1, 2, 3, 4];
NCS(A, 4, false);
CrLf(0);
CA:= [^a, ^b, ^c, ^d, ^e];
NCS(CA, 5, true);
]</syntaxhighlight>
{{out}}
<pre>
Line 2,900 ⟶ 2,966:
=={{header|zkl}}==
{{trans|JavaScript}}
<
pwerSet(ary).filter(fcn(list){(not isContinuous(list)) })
}
Line 2,908 ⟶ 2,974:
return(True);
}
non_continuous_subsequences(T(1,2,3,4)).println();</
<
(0).pump(list.len(),List,List,Utils.Helpers.pickNFrom.fp1(list),
T(T,Void.Write,Void.Write) ) .append(list)
}</
<
pwerSet(str.split("")).apply("concat")
.filter('wrap(substr){ (not str.holds(substr)) })
}
brokenSubsequences("1234").println();</
{{out}}
<pre>
|