Combinations with repetitions: Difference between revisions

:A: 6: <math>\{\mathrm{iced}, \mathrm{iced}\}</math>; <math>\{\mathrm{iced}, \mathrm{jam}\}</math>; <math>\{\mathrm{iced}, \mathrm{plain}\}</math>; <math>\{\mathrm{jam}, \mathrm{jam}\}</math>; <math>\{\mathrm{jam}, \mathrm{plain}\}</math>; <math>\{\mathrm{plain}, \mathrm{plain}\}</math>.

<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;

end Combinations;</langsyntaxhighlight>

<langsyntaxhighlight lang="clojure">

</langpre>

Using [http://www-.graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation lexicographic next bit permutation] to generate combinations with repetitions.

<syntaxhighlight lang ="d">import std.stdio, std.range ;

const struct CombRep {

immutable uint nt, nc ;

private const ulong[] combVal;

"validValid only for nt + nc <= 64 (ulong bit size)") ;

} body nt = numType ;{

ncnt = numChoice numType;

if(nc == 0) return numChoice;

auto vif (nc == (1UL << (nt - 10)) - 1 ;

// init to smallest number that has nt-1 bit setreturn;

//ulong av set bit= is(1UL metaphored<< as(nt a- _type_1)) seperator- 1;

// limitInit isto thesmallest largestnumber that has nt-1 bit set number that has nc zero-bit

// a zero-set bit meansis ametaphored _choice_as betweena _type_ seperatorsseperator.

while(vimmutable limit <= limit)v << {nc;

ulong[] if(v == 0) break localCombVal;

// Limit is the auto t = (v | (vlargest nt- 1)) +bit 1set ;number //that gethas next nt-1 bit numbernc

// v = t | ((((t & zero-t)bit / (v &a zero-v))bit >>means 1)a -_choice_ 1)between ;_type_

return break val2set(combVal[idx]);

return 1 ;

uint// typeIdxConvert =bit 0,pattern bitLimitto =selection nt + nc - 1 ;set

immutable uint[] setbitLimit = nt + nc - 1;

foreach(bitNum;uint typeIdx = 0..bitLimit);

foreach (immutable bitNum; 0 .. typeIdx++ ;bitLimit)

set ~= typeIdx ;

return set ;

// forFor finite Random Access Range.

auto combRep(R)(R types, in uint numChoice) /*pure*/ nothrow @safe

if if(hasLength!R && isRandomAccessRange!R) {

ElementType!R[][] result ;

foreach(iElementType!R[] r; s)

foreach (immutable r ~= types[i]; ;s)

result ~= r ~= types[i];

void main() @safe {

foreach (const e; combRep(["iced", "jam", "plain"], 2))

writefln("%-(%5s %)", e) ;

writeflnwriteln("Ways to select 3 from 10 types is %d", CombRep(10,3).length) ;

[<pre> iced, jam]iced

[ iced, plain] jam

[ jam, plain] jam

[plain, jam plain]

combsWithRep 0:: Int _-> =[a] -> [[a]]

combsWithRep k xxs@(x:xs) = map (x:) (combsWithRep (k-1) xxs) ++ combsWithRep k xs

print $ combsWithRep 2 ["iced", "jam", "plain"]

print $ countCombsWithRep 3 [1 .. 10]</syntaxhighlight>

<langsyntaxhighlight lang="j"> 2 rcomb ;:'iced jam plain'

#3 rcomb i.10 NB. # ways to choose 3 items from 10 with replacementrepetitions

220</langsyntaxhighlight>

<langsyntaxhighlight lang="java">

<langsyntaxhighlight lang="java">

<langsyntaxhighlight PicoLisplang="picolisp">(de combrep (N Lst)

(combrep N (cdr Lst)) ) ) ) )</langsyntaxhighlight>

<langsyntaxhighlight PureBasiclang="purebasic">Procedure nextCombination(Array combIndex(1), elementCount)

PrintN("Combinations of " + Str(kn) + " dougnutsdougnut types taken " + Str(nk) + " at a time with repetitions.")

EndIf </langsyntaxhighlight>The nextCombination() procedure operates on an array of indexes to produce the next combination. This generalization allows producing a combination from any collection of elements. nextCombination() returns the value #False when the indexes have reach their maximum values and are then reset.

<pre>Combinations of 23 dougnutsdougnut types taken 32 at a time with repetitions.

<langsyntaxhighlight lang="python">>>> from itertools import combinations_with_replacement

>>> </langsyntaxhighlight>

/*This REXX programversion showsuses a settype of combinationsanonymous with repetitionsrecursion. */

Do i=1 To endns

!j=! _index.i

l=l endthing.j

else doEnd

Say e=xl

iced,icednext

{{works with|Ruby 1|2.9.20}}

(lambda ((null? lst) k'())

(cond ((null? lst) ' ())else

((= k 1) (map list lst))append

(elsemap

(appendlambda (x)

(mapcons (car lst) x))

(lambdacombs-with-rep (x- k 1) lst))

(combs-with-rep k (cons (carcdr lst) x)))))

<langsyntaxhighlight lang="tcl">package require Tcl 8.5

puts [llength [combrepl {1 2 3 4 5 6 7 8 9 10} 3]]</langsyntaxhighlight>