In tất cả các tổ hợp có thể có của các phần tử r trong một mảng có kích thước n đã cho

Bạn đã cân nhắc sử dụng getenv() chưa?

Ngoài ra, sử dụng phương pháp của bạn, nếu bạn muốn xem hạt nhân coi kích thước đầu cuối là gì (tốt hơn trong trường hợp đầu cuối được thay đổi kích thước), bạn sẽ cần sử dụng TIOCGWINSZ, trái ngược với TIOCGSIZE của bạn, như vậy

Tôi hơi muộn về chủ đề này, nhưng nghĩ rằng tôi có thể giúp được ai đó

Bạn có thể sử dụng

[(1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 2, 1), (1, 2, 2), (1, 2, 3), (1, 3, 1),
 (1, 3, 2), (1, 3, 3), (2, 1, 1), (2, 1, 2), (2, 1, 3), (2, 2, 1), (2, 2, 2),
 (2, 2, 3), (2, 3, 1), (2, 3, 2), (2, 3, 3), (3, 1, 1), (3, 1, 2), (3, 1, 3), 
(3, 2, 1), (3, 2, 2), (3, 2, 3), (3, 3, 1), (3, 3, 2), (3, 3, 3)]

[(1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 2, 1), (1, 2, 2), (1, 2, 3), (1, 3, 1),
 (1, 3, 2), (1, 3, 3), (2, 1, 1), (2, 1, 2), (2, 1, 3), (2, 2, 1), (2, 2, 2),
 (2, 2, 3), (2, 3, 1), (2, 3, 2), (2, 3, 3), (3, 1, 1), (3, 1, 2), (3, 1, 3), 
(3, 2, 1), (3, 2, 2), (3, 2, 3), (3, 3, 1), (3, 3, 2), (3, 3, 3)]

from itertools import product

n = [1, 2, 3]

result = product(n, repeat=3) # You can change the repeat more then n length

print(list(result))

đầu ra

[(1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 2, 1), (1, 2, 2), (1, 2, 3), (1, 3, 1),
 (1, 3, 2), (1, 3, 3), (2, 1, 1), (2, 1, 2), (2, 1, 3), (2, 2, 1), (2, 2, 2),
 (2, 2, 3), (2, 3, 1), (2, 3, 2), (2, 3, 3), (3, 1, 1), (3, 1, 2), (3, 1, 3), 
(3, 2, 1), (3, 2, 2), (3, 2, 3), (3, 3, 1), (3, 3, 2), (3, 3, 3)]

Một ví dụ khác, nhưng thay đổi đối số lặp lại

from itertools import product

n = [1, 2, 3]

result = product(n, repeat=4) # Changing repeat to 4
print(list(result))

đầu ra

(1, 1, 2, 3), (1, 1, 3, 1), (1, 1, 3, 2), (1, 1, 3, 3), (1, 2, 1, 1), 
(1, 2, 1, 2), (1, 2, 1, 3), (1, 2, 2, 1), (1, 2, 2, 2), (1, 2, 2, 3), 
(1, 2, 3, 1), (1, 2, 3, 2), (1, 2, 3, 3), (1, 3, 1, 1), (1, 3, 1, 2), 
(1, 3, 1, 3), (1, 3, 2, 1), (1, 3, 2, 2), (1, 3, 2, 3), (1, 3, 3, 1), 
(1, 3, 3, 2), (1, 3, 3, 3), (2, 1, 1, 1), (2, 1, 1, 2), (2, 1, 1, 3), 
(2, 1, 2, 1), (2, 1, 2, 2), (2, 1, 2, 3), (2, 1, 3, 1), (2, 1, 3, 2),
 (2, 1, 3, 3), (2, 2, 1, 1), (2, 2, 1, 2), (2, 2, 1, 3), (2, 2, 2, 1), 
(2, 2, 2, 2), (2, 2, 2, 3), (2, 2, 3, 1), (2, 2, 3, 2), (2, 2, 3, 3), 
(2, 3, 1, 1), (2, 3, 1, 2), (2, 3, 1, 3), (2, 3, 2, 1), (2, 3, 2, 2), 
(2, 3, 2, 3), (2, 3, 3, 1), (2, 3, 3, 2), (2, 3, 3, 3), (3, 1, 1, 1), 
(3, 1, 1, 2), (3, 1, 1, 3), (3, 1, 2, 1), (3, 1, 2, 2), (3, 1, 2, 3), 
(3, 1, 3, 1), (3, 1, 3, 2), (3, 1, 3, 3), (3, 2, 1, 1), (3, 2, 1, 2), 
(3, 2, 1, 3), (3, 2, 2, 1), (3, 2, 2, 2), (3, 2, 2, 3), (3, 2, 3, 1), 
(3, 2, 3, 2), (3, 2, 3, 3), (3, 3, 1, 1), (3, 3, 1, 2), (3, 3, 1, 3), 
(3, 3, 2, 1), (3, 3, 2, 2), (3, 3, 2, 3), (3, 3, 3, 1), (3, 3, 3, 2), 
(3, 3, 3, 3)]```

Trong bài toán “In tất cả các tổ hợp có thể có của các phần tử R trong một mảng có kích thước N đã cho”, chúng ta đã cho một mảng có kích thước n. Tìm tất cả các kết hợp kích thước r trong mảng

Định dạng đầu vào

Dòng đầu tiên và duy nhất chứa số nguyên N

Dòng thứ hai chứa n số nguyên cách nhau bởi dấu cách

Dòng thứ ba chứa số nguyên R

Định dạng đầu ra

In tất cả các Tổ hợp có thể có của các Phần tử R của một mảng đã cho sao cho mỗi dòng chứa chính xác một tổ hợp

Hạn chế

• 1<=N<=10
• 1<=a[i]<=10^9

Thí dụ

4 
1 2 3 4
2

1 2
1 3
1 4
2 3
2 4
3 4

thuật toán

Trong phương pháp này, ý tưởng chính là tạo một mảng tạm thời ans[] có kích thước R và lưu trữ kết quả trong đó

Chúng tôi tạo một mảng tạm thời 'dữ liệu []' để lưu trữ từng đầu ra một. Ý tưởng là bắt đầu từ chỉ mục đầu tiên (chỉ mục = 0) trong data[], sửa từng phần tử tại chỉ mục này và lặp lại cho các chỉ mục còn lại. Đặt mảng đầu vào là {1, 2, 3, 4, 5} và r là 3. Trước tiên, chúng tôi sửa 1 tại chỉ mục 0 trong dữ liệu [], sau đó lặp lại cho các chỉ mục còn lại, sau đó chúng tôi sửa 2 tại chỉ mục 0 và lặp lại. Cuối cùng, chúng tôi sửa lỗi 3 và lặp lại cho các chỉ mục còn lại. Khi số phần tử trong data[] bằng r (kích thước của tổ hợp), chúng tôi in data[]

1. Bắt đầu từ chỉ mục đầu tiên trong ans[], sửa từng phần tử tại chỉ mục này và lặp lại cho các chỉ mục còn lại

2. Nếu mảng ans[] đầy thì in mảng ans[]

Thực hiện

Chương trình C++ để in tất cả các kết hợp có thể có của các phần tử R trong một mảng có kích thước N đã cho

#include 
using namespace std; 

void combination(int arr[], int data[], int start, int end, int index, int r) 
{ 
  if(index == r) 
  { 
    for (int j = 0; j < r; j++) 
      cout << data[j] << " "; 
    cout << endl; 
    return; 
  } 
  for(int i = start; i <= end && end - i + 1 >= r - index; i++) 
  { 
    data[index] = arr[i]; 
    combination(arr, data, i+1, end, index+1, r); 
  } 
} 

int main() 
{ 
  int n;
  cin>>n;
  int a[n];
  for(int i=0;i>a[i];
  }
  int r;
  cin>>r;
  int data[r]; 
  combination(a,data,0,n-1,0,r);
} 

Chương trình Java để in tất cả các kết hợp có thể có của các phần tử R trong một mảng có kích thước N đã cho

import java.util.ArrayList;
import java.util.Scanner;
class sum
{
    public static void combination(int arr[], int data[], int start, int end, int index, int r) 
    { 
            if(index == r) 
            { 
                    for(int j = 0; j < r; j++) 
                           System.out.print(data[j]+" "); 
                    System.out.println();
                    return; 
            } 
            for(int i = start; i <= end && end - i + 1 >= r - index; i++) 
            { 
                    data[index] = arr[i]; 
                    combination(arr, data, i+1, end, index+1, r); 
            } 
    } 
    public static void main(String[] args)
    {
        Scanner sr = new Scanner(System.in);
        int n = sr.nextInt();
        int a[] = new int [n];
        for(int i=0;i
5
105 21 35 10 183
3
105 21 35 
105 21 10 
105 21 183 
105 35 10 
105 35 183 
105 10 183 
21 35 10 
21 35 183 
21 10 183 
35 10 183
Phân tích độ phức tạp
Thời gian phức tạp
O(nCr) trong đó n là kích thước của mảng đã cho và r là số phần tử mà chúng ta lấy để kết hợp