アルゴリズムに戻すべての組み合わせの要素からn
https://stackoverflow.com/questions/127704
-
02-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian質問
を書きたいと配列の文字引数として複数の文字が選択され画面が変更されます
と言いますの提供を配列で8文字を選択3文字から。してください:
8! / ((8 - 3)! * 3!) = 56
配列（または言葉）からなる3文字です。
解決
美術のコンピュータのプログラミング作量4:名前の由来3 ントのタートアッ特定の状況によりどうかについて?解決方法/評価
グレード
問題とするのはもちろんメモリとかなり早い問題を20要素を設定-- 20C3 =1140.する場合がございますのでおに対して繰り返し処理を実行するには設定で変更したものグレードアルゴリズムでまな催してきました。これらを生成し、次の組み合わせから前回と繰り返しを避ける.がこれらの多くの異なる。私たちの最大化を図りたいと思ってい違いは歴代の組み合わせ?小?など。
一部の論文に記述する灰色のコード:
この論文のトピック：
- 効率的な実施のEades、ヒッキーの読み隣接する交換結合生成アルゴリズム （PDF、コードPascal)
- 組合せ発電機
- 調査の組合せに灰色のコード (PostScript)
- アルゴリズムのグレード
チェイスのTwiddle(アルゴリズム)
Phillip Jば、`アルゴリズム382:組み合わせしてくれるかもしれないがNのオブジェ' (1970)
このアルゴリズムC...
指数の組み合わせを辞書的序(ショートブーツのアルゴリズム515)
を参照することも可能です組み合わせにより、そのインデックス(辞書的とする。この指標はある程度の変更は右から左に基づく指標を構築する事を目的としているものは回復しながら組み合わせです。
そして、設定{1,2,3,4,5,6}...やりたいの三点です。ということか{1,2,3}この違いの要素であるためには、軽微であります。{1,2,4}には変化が辞書的に番号2.その"変化"の最後の場所を占めの辞書的な商品を発送致します。第二に、ひとつの変化{1,3,4会期：}には変化が計変更ので、次位(本に比例した数の要素を元の通知非通知を設定できます。
方法は私の記載は、解体、そのままになっているから設定の指数いに逆かtrickier.こうして ショートブーツ を解決の問題です。に書いたも C計算し, が、軽微な変更に使用した、指定ではなく数範囲を代表するセットでいから0...n.注意：
- からの組み合わせは、順序付け{1,3,2}={1,2,3}--まれるためにする辞書的な.
- このメソッドは暗黙の前0は最初のものに設定。
指数の組み合わせを辞書的序(McCaffrey)
はありま 別の言い方:オプションが容易に把握し、プログラムでの最適化のショートブーツ。しかし、幸いな事にも発生しない二重の組み合わせ:
の設定 
を最大限に引き出すことが 
, では、 
.
例: 27 = C(6,4) + C(5,3) + C(2,2) + C(1,1).なので、第27回辞書的な組み合わせてもらうこととなる。は:{1,2,5,6}、これらの指標も設定したいのです。下記は一例です(存が必要である choose 機能は、リーダー:
(* this will find the [x] combination of a [set] list when taking [k] elements *)
let combination_maccaffery set k x =
(* maximize function -- maximize a that is aCb *)
(* return largest c where c < i and choose(c,i) <= z *)
let rec maximize a b x =
if (choose a b ) <= x then a else maximize (a-1) b x
in
let rec iterate n x i = match i with
| 0 -> []
| i ->
let max = maximize n i x in
max :: iterate n (x - (choose max i)) (i-1)
in
if x < 0 then failwith "errors" else
let idxs = iterate (List.length set) x k in
List.map (List.nth set) (List.sort (-) idxs)
小型、簡単な組み合わせの反復子
以下の二つのアルゴリズムの提供のための教。なども実施序で繰り返し処理する反復子および(より一般)フォルダ全体の組み合わせとなります。彼は早めに計算量O(nCk).のメモリ消費量は約 k.
まず初めに、反復子は、電話ユーザーに提供機能の各組み合わせ
let iter_combs n k f =
let rec iter v s j =
if j = k then f v
else for i = s to n - 1 do iter (i::v) (i+1) (j+1) done in
iter [] 0 0
より一般的なバージョンのユーザーに提供機能の状態変数の初期状態になる。が必要となるための状態と異なった状態のまな利用のためのループでは、使用再帰,
let fold_combs n k f x =
let rec loop i s c x =
if i < n then
loop (i+1) s c @@
let c = i::c and s = s + 1 and i = i + 1 in
if s < k then loop i s c x else f c x
else x in
loop 0 0 [] x
他のヒント
クライアントまで、フルのC#:
public static IEnumerable<IEnumerable<T>> Combinations<T>(this IEnumerable<T> elements, int k)
{
return k == 0 ? new[] { new T[0] } :
elements.SelectMany((e, i) =>
elements.Skip(i + 1).Combinations(k - 1).Select(c => (new[] {e}).Concat(c)));
}
使用量：
var result = Combinations(new[] { 1, 2, 3, 4, 5 }, 3);
結果：
123
124
125
134
135
145
234
235
245
345
短javaソリューション:
import java.util.Arrays;
public class Combination {
public static void main(String[] args){
String[] arr = {"A","B","C","D","E","F"};
combinations2(arr, 3, 0, new String[3]);
}
static void combinations2(String[] arr, int len, int startPosition, String[] result){
if (len == 0){
System.out.println(Arrays.toString(result));
return;
}
for (int i = startPosition; i <= arr.length-len; i++){
result[result.length - len] = arr[i];
combinations2(arr, len-1, i+1, result);
}
}
}
結果
[A, B, C]
[A, B, D]
[A, B, E]
[A, B, F]
[A, C, D]
[A, C, E]
[A, C, F]
[A, D, E]
[A, D, F]
[A, E, F]
[B, C, D]
[B, C, E]
[B, C, F]
[B, D, E]
[B, D, F]
[B, E, F]
[C, D, E]
[C, D, F]
[C, E, F]
[D, E, F]
あった再帰Pythonこうした問題をクリアできる?
def choose_iter(elements, length):
for i in xrange(len(elements)):
if length == 1:
yield (elements[i],)
else:
for next in choose_iter(elements[i+1:len(elements)], length-1):
yield (elements[i],) + next
def choose(l, k):
return list(choose_iter(l, k))
使用例:
>>> len(list(choose_iter("abcdefgh",3)))
56
そのために、シンプルさが人気です。
きっ配列の文字は以下のようなものです:"ABCDEFGH".いつの指標(i,j,k)を示す文字をご利用は、現在の単語から始まり:
A B C D E F G H ^ ^ ^ i j k
まずは異なりk、次のステップのようになる:
A B C D E F G H ^ ^ ^ i j k
場合は最後に到達するまで、変jとkします。
A B C D E F G H ^ ^ ^ i j k A B C D E F G H ^ ^ ^ i j k
だj達Gくもりん。
A B C D E F G H ^ ^ ^ i j k A B C D E F G H ^ ^ ^ i j k ...
記述コードをこのような形式になる
void print_combinations(const char *string)
{
int i, j, k;
int len = strlen(string);
for (i = 0; i < len - 2; i++)
{
for (j = i + 1; j < len - 1; j++)
{
for (k = j + 1; k < len; k++)
printf("%c%c%c\n", string[i], string[j], string[k]);
}
}
}
以下の再帰的アルゴリズムをピックのすべてのk-元素の組み合わせから順:
- 選択の最初の要素
iの組み合わせ - 融合
iそれぞれの組み合わせk-1要素の選択から再帰的に定要素によi.
繰り返し処理を実行し、上記の各 i セットになっています。
ナンバー）が必要ですので、必り、残りの要素としてよ i, のため、反復するこのように[3,5]ただ、[3]と[5]ではなく、回の消[5]+[3]).こうした条件を取得変動の代わりに組み合わせとなります。
このスレッドの有用と考え思Javascriptを解決するソリューションがポップに開いているのがfirebug.によってはJSエンジンの動きをタイムリーかつ少し時間が開始文字列は大きい。
function string_recurse(active, rest) {
if (rest.length == 0) {
console.log(active);
} else {
string_recurse(active + rest.charAt(0), rest.substring(1, rest.length));
string_recurse(active, rest.substring(1, rest.length));
}
}
string_recurse("", "abc");
出力は次のようにすべきである。
abc
ab
ac
a
bc
b
c
C++、以下のルーチンまですべての組み合わせで長距離（最初に,k)の間の範囲[初、昨):
#include <algorithm>
template <typename Iterator>
bool next_combination(const Iterator first, Iterator k, const Iterator last)
{
/* Credits: Mark Nelson http://marknelson.us */
if ((first == last) || (first == k) || (last == k))
return false;
Iterator i1 = first;
Iterator i2 = last;
++i1;
if (last == i1)
return false;
i1 = last;
--i1;
i1 = k;
--i2;
while (first != i1)
{
if (*--i1 < *i2)
{
Iterator j = k;
while (!(*i1 < *j)) ++j;
std::iter_swap(i1,j);
++i1;
++j;
i2 = k;
std::rotate(i1,j,last);
while (last != j)
{
++j;
++i2;
}
std::rotate(k,i2,last);
return true;
}
}
std::rotate(first,k,last);
return false;
}
使用できるようになります:
#include <string>
#include <iostream>
int main()
{
std::string s = "12345";
std::size_t comb_size = 3;
do
{
std::cout << std::string(s.begin(), s.begin() + comb_size) << std::endl;
} while (next_combination(s.begin(), s.begin() + comb_size, s.end()));
return 0;
}
この印刷に
123
124
125
134
135
145
234
235
245
345
static IEnumerable<string> Combinations(List<string> characters, int length)
{
for (int i = 0; i < characters.Count; i++)
{
// only want 1 character, just return this one
if (length == 1)
yield return characters[i];
// want more than one character, return this one plus all combinations one shorter
// only use characters after the current one for the rest of the combinations
else
foreach (string next in Combinations(characters.GetRange(i + 1, characters.Count - (i + 1)), length - 1))
yield return characters[i] + next;
}
}
短例Python:
def comb(sofar, rest, n):
if n == 0:
print sofar
else:
for i in range(len(rest)):
comb(sofar + rest[i], rest[i+1:], n-1)
>>> comb("", "abcde", 3)
abc
abd
abe
acd
ace
ade
bcd
bce
bde
cde
説明にあたっては再帰的方法を記述し、以下の例:
例:A B C D E
すべての組み合わせで3連する情報を表示します
- Aすべての組み合わせの2の(B C D E)
- Bの全ての組み合わせの2の(C D E)
- Cの全ての組み合わせの2の(D E)
単純再帰的アルゴリズムのウ
import Data.List
combinations 0 lst = [[]]
combinations n lst = do
(x:xs) <- tails lst
rest <- combinations (n-1) xs
return $ x : rest
まず定義する特別な場合は、選択ゼロです。が単一の結果は、空のリスト（リストが含まれ、空のlist).
N>0の x を通して各要素のリスト xs すべての要素の後に x.
rest ピ n - 1 要素から xs を再帰呼び出 combinations.最終結果の機能は、リストの各要素は x : rest （一覧する x ヘッドとして、 rest としてテール)毎に異なる値 x や rest.
> combinations 3 "abcde"
["abc","abd","abe","acd","ace","ade","bcd","bce","bde","cde"]
もちろん、ウものぐさのリストが発生し、必要に応じてできるので部分的に評価指数関数的に大きな組み合わせとなります。
> let c = combinations 8 "abcdefghijklmnopqrstuvwxyz"
> take 10 c
["abcdefgh","abcdefgi","abcdefgj","abcdefgk","abcdefgl","abcdefgm","abcdefgn",
"abcdefgo","abcdefgp","abcdefgq"]
そしてgranddaddy COBOL、malignedます。
その配列34要素の8バイト（純粋に恣意的な選択。) その考え方としては、列挙すべての可能な4要素の組み合わせ荷重ね合わせ表示することで配列に格納します。
た4つの指標それぞれの各位置におけるグループの4
の配列を処理しようになります:
idx1 = 1
idx2 = 2
idx3 = 3
idx4 = 4
まりidx4から4これで終了となりました。各idx4を組み合わせたユニークな グループです。時idx4が配列の最後にまで増加idx3を1に設定idx4にidx3+1.そしidx4のです。を進めていますこのように、充実idx3,idx2、idx1それぞれまでの位置idx1は以下の4つの配列になります。その仕上げのアルゴリズムです。
1 --- pos.1
2 --- pos 2
3 --- pos 3
4 --- pos 4
5
6
7
etc.
最初の反復回数：
1234
1235
1236
1237
1245
1246
1247
1256
1257
1267
etc.
であり，例：
01 DATA_ARAY.
05 FILLER PIC X(8) VALUE "VALUE_01".
05 FILLER PIC X(8) VALUE "VALUE_02".
etc.
01 ARAY_DATA OCCURS 34.
05 ARAY_ITEM PIC X(8).
01 OUTPUT_ARAY OCCURS 50000 PIC X(32).
01 MAX_NUM PIC 99 COMP VALUE 34.
01 INDEXXES COMP.
05 IDX1 PIC 99.
05 IDX2 PIC 99.
05 IDX3 PIC 99.
05 IDX4 PIC 99.
05 OUT_IDX PIC 9(9).
01 WHERE_TO_STOP_SEARCH PIC 99 COMP.
* Stop the search when IDX1 is on the third last array element:
COMPUTE WHERE_TO_STOP_SEARCH = MAX_VALUE - 3
MOVE 1 TO IDX1
PERFORM UNTIL IDX1 > WHERE_TO_STOP_SEARCH
COMPUTE IDX2 = IDX1 + 1
PERFORM UNTIL IDX2 > MAX_NUM
COMPUTE IDX3 = IDX2 + 1
PERFORM UNTIL IDX3 > MAX_NUM
COMPUTE IDX4 = IDX3 + 1
PERFORM UNTIL IDX4 > MAX_NUM
ADD 1 TO OUT_IDX
STRING ARAY_ITEM(IDX1)
ARAY_ITEM(IDX2)
ARAY_ITEM(IDX3)
ARAY_ITEM(IDX4)
INTO OUTPUT_ARAY(OUT_IDX)
ADD 1 TO IDX4
END-PERFORM
ADD 1 TO IDX3
END-PERFORM
ADD 1 TO IDX2
END_PERFORM
ADD 1 TO IDX1
END-PERFORM.
ここでは、エレガントな、ライト、汎用実装ラノ-スカラ座に記載の通り、 99Scalaの問題.
object P26 {
def flatMapSublists[A,B](ls: List[A])(f: (List[A]) => List[B]): List[B] =
ls match {
case Nil => Nil
case sublist@(_ :: tail) => f(sublist) ::: flatMapSublists(tail)(f)
}
def combinations[A](n: Int, ls: List[A]): List[List[A]] =
if (n == 0) List(Nil)
else flatMapSublists(ls) { sl =>
combinations(n - 1, sl.tail) map {sl.head :: _}
}
}
場合に利用できるSQL文法、例えば、使用している場合は、LINQへのアクセス分野の構造または配列、または直接アクセスデータベースとテーブルの"アルファベットの一つ一つのcharフィールド"の文字は、対応できる次のコード:
SELECT A.Letter, B.Letter, C.Letter
FROM Alphabet AS A, Alphabet AS B, Alphabet AS C
WHERE A.Letter<>B.Letter AND A.Letter<>C.Letter AND B.Letter<>C.Letter
AND A.Letter<B.Letter AND B.Letter<C.Letter
この戻りますすべての組み合わせで3文字かかわらず、どのように多くの文字を保持するテーブル"アルファベット"ができるようにしまし3,8,10,27ます。
ばんは全部での一な組み合わせ（したい"ACB"や"ABC"としてカウントする異なって、より表示するかどうか）を削除し、最終行（さと）で行われます。
投稿-編集：再読み込みの問題にかかわる問題と理解何が必要かというと、 一般 アルゴリズムだけではなく、一つのを選択した場合の3項目です。アダム-ヒューズ'答えを完了し、残念ながら投票しててこの解答の仕事をしたい時に3項目です。
別のC#のバージョンのぐさの組み合わせ指す"ことである。このバージョンを維持して単一の配列の指標を定義するマッピングのリストのすべての値の値の組み合わせる常に使用 O(k) 追加の間はスペース全体をサポートします。このコードを個別に組み合わせなどは、 O(k) ます。
public static IEnumerable<T[]> Combinations<T>(this T[] values, int k)
{
if (k < 0 || values.Length < k)
yield break; // invalid parameters, no combinations possible
// generate the initial combination indices
var combIndices = new int[k];
for (var i = 0; i < k; i++)
{
combIndices[i] = i;
}
while (true)
{
// return next combination
var combination = new T[k];
for (var i = 0; i < k; i++)
{
combination[i] = values[combIndices[i]];
}
yield return combination;
// find first index to update
var indexToUpdate = k - 1;
while (indexToUpdate >= 0 && combIndices[indexToUpdate] >= values.Length - k + indexToUpdate)
{
indexToUpdate--;
}
if (indexToUpdate < 0)
yield break; // done
// update combination indices
for (var combIndex = combIndices[indexToUpdate] + 1; indexToUpdate < k; indexToUpdate++, combIndex++)
{
combIndices[indexToUpdate] = combIndex;
}
}
}
試験コード:
foreach (var combination in new[] {'a', 'b', 'c', 'd', 'e'}.Combinations(3))
{
System.Console.WriteLine(String.Join(" ", combination));
}
出力：
a b c
a b d
a b e
a c d
a c e
a d e
b c d
b c e
b d e
c d e
ここで怠け者の評価版のアルゴリズムコードのC#:
static bool nextCombination(int[] num, int n, int k)
{
bool finished, changed;
changed = finished = false;
if (k > 0)
{
for (int i = k - 1; !finished && !changed; i--)
{
if (num[i] < (n - 1) - (k - 1) + i)
{
num[i]++;
if (i < k - 1)
{
for (int j = i + 1; j < k; j++)
{
num[j] = num[j - 1] + 1;
}
}
changed = true;
}
finished = (i == 0);
}
}
return changed;
}
static IEnumerable Combinations<T>(IEnumerable<T> elements, int k)
{
T[] elem = elements.ToArray();
int size = elem.Length;
if (k <= size)
{
int[] numbers = new int[k];
for (int i = 0; i < k; i++)
{
numbers[i] = i;
}
do
{
yield return numbers.Select(n => elem[n]);
}
while (nextCombination(numbers, size, k));
}
}
試験部
static void Main(string[] args)
{
int k = 3;
var t = new[] { "dog", "cat", "mouse", "zebra"};
foreach (IEnumerable<string> i in Combinations(t, k))
{
Console.WriteLine(string.Join(",", i));
}
}
ことを期待します！
った．アルゴリズムを使用したプロジェクトオイラー、python:
def missing(miss,src):
"Returns the list of items in src not present in miss"
return [i for i in src if i not in miss]
def permutation_gen(n,l):
"Generates all the permutations of n items of the l list"
for i in l:
if n<=1: yield [i]
r = [i]
for j in permutation_gen(n-1,missing([i],l)): yield r+j
の場合
n<len(l)
すべてすべての組み合わせが必要な繰り返し、必要なものです。
また、利用して思ったこと。
for comb in permutation_gen(3,list("ABCDEFGH")):
print comb
https://gist.github.com/3118596
ある実装が可能です。この機能をk-組み合わせ、すべての組み合わせ配列のオブジェクト。例:
k_combinations([1,2,3], 2)
-> [[1,2], [1,3], [2,3]]
combinations([1,2,3])
-> [[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]]
Array.prototype.combs = function(num) {
var str = this,
length = str.length,
of = Math.pow(2, length) - 1,
out, combinations = [];
while(of) {
out = [];
for(var i = 0, y; i < length; i++) {
y = (1 << i);
if(y & of && (y !== of))
out.push(str[i]);
}
if (out.length >= num) {
combinations.push(out);
}
of--;
}
return combinations;
}
Clojureバージョン:
(defn comb [k l]
(if (= 1 k) (map vector l)
(apply concat
(map-indexed
#(map (fn [x] (conj x %2))
(comb (dec k) (drop (inc %1) l)))
l))))
きっ配列の文字は以下のようなものです:"ABCDEFGH".いつの指標(i,j,k)を示す文字をご利用は、現在の単語から始まり:
A B C D E F G H ^ ^ ^ i j k
まずは異なりk、次のステップのようになる:
A B C D E F G H ^ ^ ^ i j k
場合は最後に到達するまで、変jとkします。
A B C D E F G H ^ ^ ^ i j k A B C D E F G H ^ ^ ^ i j k
だj達Gくもりん。
A B C D E F G H ^ ^ ^ i j k A B C D E F G H ^ ^ ^ i j k ...
function initializePointers($cnt) {
$pointers = [];
for($i=0; $i<$cnt; $i++) {
$pointers[] = $i;
}
return $pointers;
}
function incrementPointers(&$pointers, &$arrLength) {
for($i=0; $i<count($pointers); $i++) {
$currentPointerIndex = count($pointers) - $i - 1;
$currentPointer = $pointers[$currentPointerIndex];
if($currentPointer < $arrLength - $i - 1) {
++$pointers[$currentPointerIndex];
for($j=1; ($currentPointerIndex+$j)<count($pointers); $j++) {
$pointers[$currentPointerIndex+$j] = $pointers[$currentPointerIndex]+$j;
}
return true;
}
}
return false;
}
function getDataByPointers(&$arr, &$pointers) {
$data = [];
for($i=0; $i<count($pointers); $i++) {
$data[] = $arr[$pointers[$i]];
}
return $data;
}
function getCombinations($arr, $cnt)
{
$len = count($arr);
$result = [];
$pointers = initializePointers($cnt);
do {
$result[] = getDataByPointers($arr, $pointers);
} while(incrementPointers($pointers, count($arr)));
return $result;
}
$result = getCombinations([0, 1, 2, 3, 4, 5], 3);
print_r($result);
に基づく https://stackoverflow.com/a/127898/2628125, が、より抽象的なサイズのポインタ.
作成したシークエンサーデータのSQL Server2005このためには、掲載で自分のウェブサイト： http://www.jessemclain.com/downloads/code/sql/fn_GetMChooseNCombos.sql.htm
ここではショー使用量：
SELECT * FROM dbo.fn_GetMChooseNCombos('ABCD', 2, '')
結果:
Word
----
AB
AC
AD
BC
BD
CD
(6 row(s) affected)
ここでの私の提案で、C++
私に課そうとしたとして少しの制限反復子タイプとしてかなこのソリューションは直前の反復子は、できconst_iterator.この作品は、標準的な容器です。場合引数を作成するのではありません意味ですstd::invalid_argumnent
#include <vector>
#include <stdexcept>
template <typename Fci> // Fci - forward const iterator
std::vector<std::vector<Fci> >
enumerate_combinations(Fci begin, Fci end, unsigned int combination_size)
{
if(begin == end && combination_size > 0u)
throw std::invalid_argument("empty set and positive combination size!");
std::vector<std::vector<Fci> > result; // empty set of combinations
if(combination_size == 0u) return result; // there is exactly one combination of
// size 0 - emty set
std::vector<Fci> current_combination;
current_combination.reserve(combination_size + 1u); // I reserve one aditional slot
// in my vector to store
// the end sentinel there.
// The code is cleaner thanks to that
for(unsigned int i = 0u; i < combination_size && begin != end; ++i, ++begin)
{
current_combination.push_back(begin); // Construction of the first combination
}
// Since I assume the itarators support only incrementing, I have to iterate over
// the set to get its size, which is expensive. Here I had to itrate anyway to
// produce the first cobination, so I use the loop to also check the size.
if(current_combination.size() < combination_size)
throw std::invalid_argument("combination size > set size!");
result.push_back(current_combination); // Store the first combination in the results set
current_combination.push_back(end); // Here I add mentioned earlier sentinel to
// simplyfy rest of the code. If I did it
// earlier, previous statement would get ugly.
while(true)
{
unsigned int i = combination_size;
Fci tmp; // Thanks to the sentinel I can find first
do // iterator to change, simply by scaning
{ // from right to left and looking for the
tmp = current_combination[--i]; // first "bubble". The fact, that it's
++tmp; // a forward iterator makes it ugly but I
} // can't help it.
while(i > 0u && tmp == current_combination[i + 1u]);
// Here is probably my most obfuscated expression.
// Loop above looks for a "bubble". If there is no "bubble", that means, that
// current_combination is the last combination, Expression in the if statement
// below evaluates to true and the function exits returning result.
// If the "bubble" is found however, the ststement below has a sideeffect of
// incrementing the first iterator to the left of the "bubble".
if(++current_combination[i] == current_combination[i + 1u])
return result;
// Rest of the code sets posiotons of the rest of the iterstors
// (if there are any), that are to the right of the incremented one,
// to form next combination
while(++i < combination_size)
{
current_combination[i] = current_combination[i - 1u];
++current_combination[i];
}
// Below is the ugly side of using the sentinel. Well it had to haave some
// disadvantage. Try without it.
result.push_back(std::vector<Fci>(current_combination.begin(),
current_combination.end() - 1));
}
}
すべてのところにある、ここでしかできないこのO'camlコードです。アルゴリズムは明らからのコードの..
let combi n lst =
let rec comb l c =
if( List.length c = n) then [c] else
match l with
[] -> []
| (h::t) -> (combi t (h::c))@(combi t c)
in
combi lst []
;;
こちらはコードって書きましたJavaを計算して返しますべての組み合わせ"num"の要素から"outOf"です。
// author: Sourabh Bhat (heySourabh@gmail.com)
public class Testing
{
public static void main(String[] args)
{
// Test case num = 5, outOf = 8.
int num = 5;
int outOf = 8;
int[][] combinations = getCombinations(num, outOf);
for (int i = 0; i < combinations.length; i++)
{
for (int j = 0; j < combinations[i].length; j++)
{
System.out.print(combinations[i][j] + " ");
}
System.out.println();
}
}
private static int[][] getCombinations(int num, int outOf)
{
int possibilities = get_nCr(outOf, num);
int[][] combinations = new int[possibilities][num];
int arrayPointer = 0;
int[] counter = new int[num];
for (int i = 0; i < num; i++)
{
counter[i] = i;
}
breakLoop: while (true)
{
// Initializing part
for (int i = 1; i < num; i++)
{
if (counter[i] >= outOf - (num - 1 - i))
counter[i] = counter[i - 1] + 1;
}
// Testing part
for (int i = 0; i < num; i++)
{
if (counter[i] < outOf)
{
continue;
} else
{
break breakLoop;
}
}
// Innermost part
combinations[arrayPointer] = counter.clone();
arrayPointer++;
// Incrementing part
counter[num - 1]++;
for (int i = num - 1; i >= 1; i--)
{
if (counter[i] >= outOf - (num - 1 - i))
counter[i - 1]++;
}
}
return combinations;
}
private static int get_nCr(int n, int r)
{
if(r > n)
{
throw new ArithmeticException("r is greater then n");
}
long numerator = 1;
long denominator = 1;
for (int i = n; i >= r + 1; i--)
{
numerator *= i;
}
for (int i = 2; i <= n - r; i++)
{
denominator *= i;
}
return (int) (numerator / denominator);
}
}
簡潔なJavascriptの解
Array.prototype.combine=function combine(k){
var toCombine=this;
var last;
function combi(n,comb){
var combs=[];
for ( var x=0,y=comb.length;x<y;x++){
for ( var l=0,m=toCombine.length;l<m;l++){
combs.push(comb[x]+toCombine[l]);
}
}
if (n<k-1){
n++;
combi(n,combs);
} else{last=combs;}
}
combi(1,toCombine);
return last;
}
// Example:
// var toCombine=['a','b','c'];
// var results=toCombine.combine(4);
ここでは方法ですべての組み合わせで指定されたサイズからランダムな長さの文字列になります。類似quinmarsソリューションが作品のための多様な入力およびk.
このコードに変更できる包み込む、家"dabから入力'abcd'w k=3となる。
public void run(String data, int howMany){
choose(data, howMany, new StringBuffer(), 0);
}
//n choose k
private void choose(String data, int k, StringBuffer result, int startIndex){
if (result.length()==k){
System.out.println(result.toString());
return;
}
for (int i=startIndex; i<data.length(); i++){
result.append(data.charAt(i));
choose(data,k,result, i+1);
result.setLength(result.length()-1);
}
}
出力のための"abcde":
abc abd阿部acdエースade bcd紀元船上装置new船内装置cde
まっていクラスの取扱い共通的な機能のための二項の係数であるタイプの問題の問題に該当する.を行う以下の業務を行います:
すべての出力では、Kインデックスの素敵な形式のための者を選択するには、K、ファイルです。K-指数に置き換えることもできますより説明的な文字列やします。このメソッド解決の問題があるようにします。
に変換するK-指標の適切な指数のエントリのソート二項の係数。この技術はよりもかなり早く、古い版の技術に頼りになります。これにより使用数理物件固有のパスカルの三角形です。私の論文が語る。私は私の最初の発見この技術をもとることができると思いますか間違っています。
変換指数のソート、またはソートされた二項の係数テーブルに対応するK-スを作成します。
用途 マークDominus 法の算定には、二項の係数は、はるかにインパクトは小さいものがオーバーフローとして動作きます。
このクラスは、書きます。NETとC#のサンプルを管理に関連するオブジェクトの問題(もしあれば)を使用汎用の一覧です。このクラスのコンストラクタの取りbool価値というInitTableる場合にtrueを汎用のリストを保持するオブジェクトを管理します。この評価式値がfalseであれば、それはテーブルを作成します。ただし、このテーブルは必要ありませんが作を行うため、4します。アクセス用のメソッドを提供しているアクセスします。
が関連する試験クラスを示す使い方のクラスとしますので十分ご注意ください。で広範に試験した2例が知られていないもございます。
についてこのクラスおよびダウンロードコード参照 Tablizingの二項Coeffieicent.
すべきではないハードで変換しこのクラスをC++.
アルゴリズム
- カウントは1～2^n.
- 変換の各桁、バイナリ表現。
- 翻訳毎にonのビット素子の設定に基づきます。
クライアントまで、フルのC#:
void Main()
{
var set = new [] {"A", "B", "C", "D" }; //, "E", "F", "G", "H", "I", "J" };
var kElement = 2;
for(var i = 1; i < Math.Pow(2, set.Length); i++) {
var result = Convert.ToString(i, 2).PadLeft(set.Length, '0');
var cnt = Regex.Matches(Regex.Escape(result), "1").Count;
if (cnt == kElement) {
for(int j = 0; j < set.Length; j++)
if ( Char.GetNumericValue(result[j]) == 1)
Console.Write(set[j]);
Console.WriteLine();
}
}
}
なぜな仕組みになっているのか。
あbijection間のサブセットの要素を設定し、nビットのdnaの塩基配列を決定した。
することができ姿をどのように多くのサブセットが数dnaの塩基配列を決定した。
例えば、四つの要素を設定することができに代表される{0,1}X{0,1}×{0,1}×{0,1}(2^4)異なるdnaの塩基配列を決定した。
So- まいはカウントは1～2^nのすべての組み合わせとなります。 (または無視空を設けさせていただきます。） 次に、翻訳の桁の数字へのバイナリ表現。その代替要素の設定onのビット.
したい場合にのみk要素の結果が、印刷時kビットがon.
(たい場合はすべてのサブセットでの長さをサブセットを取り外してcnt/kElementます。)
（証明は、MITの無料教育用ソフトウェアの数学のためのコンピュータ科学、リーマンを用いることにより、部11.2.2. https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-fall-2010/readings/ )
飛び乗り、投稿の別の解決策です。このは汎用のJavaの実装です。入力： (int k) は要素数を選択し、 (List<T> list) のリストを選んでいます。リストを返すの組み合わせ (List<List<T>>).
public static <T> List<List<T>> getCombinations(int k, List<T> list) {
List<List<T>> combinations = new ArrayList<List<T>>();
if (k == 0) {
combinations.add(new ArrayList<T>());
return combinations;
}
for (int i = 0; i < list.size(); i++) {
T element = list.get(i);
List<T> rest = getSublist(list, i+1);
for (List<T> previous : getCombinations(k-1, rest)) {
previous.add(element);
combinations.add(previous);
}
}
return combinations;
}
public static <T> List<T> getSublist(List<T> list, int i) {
List<T> sublist = new ArrayList<T>();
for (int j = i; j < list.size(); j++) {
sublist.add(list.get(j));
}
return sublist;
}
