Câu hỏi này đã được hỏi trước đây bằng các ngôn ngữ khác, nhưng không phải bằng delphi sau khi tìm kiếm SO. Đã thấy câu hỏi này:Cách tạo hoán vị với các ký tự lặp lạiCâu hỏi này:Tạo tất cả các kết hợp của bảng chữ cái tùy ý với độ dài tùy ýVà điều này:Làm cách nào để tạo kết hợp các chuỗi có độ dài cố định bằng cách sử dụng một bộ ký tự?Vì vậy, vấn đề này không phải là mới, nhưng tôi đang gặp khó khăn khi dịch bất kỳ nội dung nào sang Delphi.

Điều tôi muốn làm là tạo các kết hợp chứa các ký tự lặp lại, ví dụ: Nếu chúng tôi có một chuỗi ký tự (do người dùng chỉ định): ABC và chúng tôi muốn tạo độ dài ba ký tự (cũng là độ dài do người dùng chỉ định), Tôi nhận được:AAA AAB AAC ABA ABB ABC ACA ACB ACC BAA BAB BAC v.v...

Mã này dường như làm điều này, nhưng trong C++:

int N_LETTERS = 4;
bảng chữ cái char[] = {'a', 'b', 'c', 'd'};

std::vector get_all_words(độ dài int)
{
  std::vector chỉ mục (độ dài, 0);
  std::vector từ;

  trong khi (đúng)
  {
    std::string word(độ dài);
    cho (int i = 0; i < chiều dài; ++i)
      từ[i] = bảng chữ cái[chỉ mục[i]];
    từ.push_back(word);

cho (int i = chiều dài-1; ; --i)
{ 
  nếu (i < 0) trả về các từ;
  chỉ mục[i]++;
  nếu (chỉ mục[i] == N_LETTERS)
    chỉ số[i] = 0;
  khác
    phá vỡ;
    }
  }
}

Điều này dường như làm điều tương tự:

    #include 
    #include 
    #include 
    #include 
    #include 
    using namespace std;

void displayPermutation(hoán vị chuỗi[], độ dài int){
    int i;
    cho (i=0;i<>
        cout<<>
    }
    cout << endl;
}

void getPermutations(string operatorBank[], int operatorCount, 
        hoán vị chuỗi [], int permutationLength, int curIndex){
    int i;
    // dừng điều kiện đệ quy
    if(curIndex == permutationLength){
        displayPermutation(hoán vị, chiều dài hoán vị);
    }
    khác{
        for(i = 0; i < operatorCount; i++){
            hoán vị[curIndex] = operatorBank[i];
            getPermutations(operatorBank,operatorCount, hoán vị,
                hoán vịLength,curIndex+1);
        }
    }
}

int chính()
   {
       int toán tửCount = 4;
       int hoán vịLength = 3;
       chuỗi operatorBank[] = {"+","-","*","/"};
       hoán vị chuỗi [] = {"","","",""} // chuỗi trống
       int curIndex = 0;
       getPermutations(operatorBank,operatorCount, hoán vị,
                               hoán vịLength,curIndex);
   return 0;
   }

Gần nhất với những gì tôi muốn trong delphi được tìm thấy ở đây, nhưng nó không cho phép AAA Ví dụ: http://www.swissdelphicenter.ch/torry/showcode.php?id=1032

Không, nếu bạn đoán thì đây không phải là bài tập về nhà. Không có động lực nào khác, chỉ là học tập.

Chỉnh sửa 3:Đã xóa tất cả mã không liên quan khỏi câu hỏi để giúp người khác đọc và nhận câu trả lời bên dưới dễ dàng hơn. Hãy xem câu trả lời để biết 2 cách khác nhau để đạt được điều này: một cách sử dụng đệ quy và cách kia sử dụng hàm đếm.

câu trả lời hay nhất

Ví dụ bạn đưa ra khiến việc này phức tạp hơn nhiều so với mức cần thiết, ít nhất là theo ý kiến ​​​​của tôi.

Những gì bạn đang thực sự nhìn thấy là một số có 3 chữ số trong cơ số 3. Bạn có thể đếm từ 0 đến 3³ = 27, sau đó chuyển đổi từng số thành cơ số 3 (sử dụng 'A', 'B' và 'C' cho các số của bạn thay vì '0', '1' và '2').

Trong C++, quá trình chuyển đổi trông như thế này:

std::string cvt(int in) {
    const int cơ sở tĩnh = 3;
    hằng số tĩnh int = 3;
    std::string ret;

    for (int i = 0; i
        ret.push_back('A' + trong % base);
        trong /= cơ sở;
    }
    return std::string(ret.rbegin(), ret.rend());
}

Với các phép biến đổi thích hợp, việc tạo ra tất cả các kết hợp rất đơn giản:

vì (int i = 0; i < 27; i++)
    std::cout << cvt(i) << "\t";

Tôi nghĩ rằng hầu như không có vấn đề cơ học thuần túy nào khi chuyển đổi cái này sang Delphi - phân bổ từ = Thay đổi thành :=,% trở nên mod, phép chia số nguyên trở thành div,for Vòng lặp trở thành một cái gì đó như với i = 0 đến 27 thì làm , vân vân. Phần tẻ nhạt nhất (nhưng cuối cùng lại rất đơn giản) có lẽ là giải quyết một thực tế là trong C++,ký tự Chỉ là một loại số nguyên nhỏ mà bạn có thể thực hiện các phép toán số nguyên thông thường. Ít nhất nếu bộ nhớ phục vụ tôi một cách chính xác, thì trong Pascal (hoặc các dẫn xuất như Delphi), bạn cần mệnh lệnh Chuyển đổi ký tự thành số thứ tự và yêu cầu chr Chuyển đổi từ thứ tự trở lại ký tự. Vì thế 'A' + theo % cơ sở; cuối cùng sẽ trở nên giống hơn chr(ord('A') + trong cơ sở mod);

Tuy nhiên, như tôi đã nói, có vẻ như gần như toàn bộ bản dịch có thể/nên gần như hoàn toàn là máy móc, không có bất kỳ thay đổi thực sự nào về cách hoạt động của thuật toán cơ bản hoặc bất kỳ điều gì tương tự.

Về thuật toán - tạo các tổ hợp ký tự dựa trên chuỗi và độ dài tùy ý - tương tự như hoán vị, chúng tôi đã tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/20369409/