Tổng Quan

Đăng Nhập Nohu83

Phương Pháp Nhanh Chóng Để Chuyển Chữ In Thành Chữ Thường Trong C++

Trong bài viết này, chúng ta sẽ khám phá các phương pháp hiệu quả để chuyển đổi chữ in thành chữ thường trong ngôn ngữ lập trình C++. Chúng ta sẽ phân tích và so sánh nhiều cách tiếp cận khác nhau, từ đó xác định phương pháp nhanh nhất dựa trên các kết quả thử nghiệm.


Phiên Bản Tóm Tắt (TL;DR)

  1. Không sử dụng #pragma GCC optimize:

    • Sử dụng hàm sau đây để chuyển đổi:
      1
      2
      3
      
      string strlwr_c_cr(const string& input) {
        return string(strlwr((char*)input.c_str()));
      }
      
  2. Với #pragma GCC optimize:

    • Hàm chuyển đổi tốt nhất là:
      1
      2
      3
      4
      5
      6
      7
      8
      9
      
      string strlwr_a_cr(const string& input) {
        string result = input;
        for (size_t i = 0; i < result.size(); ++i) {
          if (result[i] >= 'A' && result[i] <= 'Z') {
            result[i] += 32;
          }
        }
        return result;
      }
      
  3. Truyền tham số kiểu const string& str nhanh hơn so với string str.


Mã Thử Nghiệm

Dưới đây là đoạn mã dùng để kiểm tra hiệu suất của các phương pháp chuyển đổi:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
// Các tùy chọn tối ưu hóa khác...

#include <algorithm>
#include <chrono>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using namespace std;

// Định nghĩa các hàm chuyển đổi
string strlwr_a_cr(const string& input) {
  string result = input;
  for (size_t i = 0; i < result.size(); ++i) {
    if (result[i] >= 'A' && result[i] <= 'Z') {
      result[i] += 32;
    }
  }
  return result;
}

string strlwr_a(string input) {
  for (size_t i = 0; i < input.size(); ++i) {
    if (input[i] >= 'A' && input[i] <= 'Z') {
      input[i] += 32;
    }
  }
  return input;
}

// Các hàm khác...

void testfunc(ptr_cr func, const string& func_name, const string& str, int count) {
  // Đo thời gian thực thi
  auto start = chrono::high_resolution_clock::now();
  for (int i = 0; i < count; ++i) {
    func(str);
  }
  auto duration = chrono::duration_cast<chrono::microseconds>(
    chrono::high_resolution_clock::now() - start);
  results.push_back({func_name, duration.count()});
}

void print_results(int count) {
  // Hiển thị kết quả
  cout << "Kết quả:" << endl;
  sort(results.begin(), results.end(),
       [](const pair<string, int64_t>& a, const pair<string, int64_t>& b) {
         return a.second < b.second;
       });
  for (const auto& result : results) {
    cout << setw(7) << result.second << "ms"
         << "  trung bình:" << fixed << setprecision(4)
         << 1.0 * result.second / count
         << "  " << result.first << endl;
  }
}

int main() {
  // Thực hiện các bài kiểm tra...
}

Kết Quả Thử Nghiệm

Trường Hợp Không Sử Dụng #pragma GCC optimize

Hàm Thời Gian (ms) Trung Bình (ms/ký tự)
strlwr_a_tolower_cr 3378 0.0034
strlwr_a_cr 3618 0.0036
strlwr_a_bitwise_operation_cr 3979 0.0040

Hàm nhanh nhất: strlwr_a_tolower_cr.

Trường Hợp Sử Dụng #pragma GCC optimize

Hàm Thời Gian (ms) Trung Bình (ms/ký tự)
strlwr_a_cr 2178 0.0022
strlwr_e_cr 2365 0.0024
strlwr_a_tolower_cr 2382 0.0024

Hàm nhanh nhất: strlwr_a_cr.


Kiểm Tra Chức Năng

Đoạn mã dưới đây được sử dụng để kiểm tra tính chính xác của các hàm:

1
2
3
4
5
6
7
void solve() {
  string str = "TQuickBFJOveThLaD.0123456789!@#$%^&*()_+{}:'<>?";
  cout << str << setw(30) << "bản gốc" << endl;
  cout << strlwr_a_cr(str) << setw(30) << "strlwr_a_cr" << endl;
  cout << strlwr_a(str) << setw(30) << "strlwr_a" << endl;
  // Các hàm khác...
}

Kết Quả Kiểm Tra

Chuỗi Đầu Ra Hàm
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:’<>? strlwr_a_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:’<>? strlwr_a

Kết Luận

  • Không sử dụng tối ưu hóa: strlwr_a_tolower_cr là nhanh nhất.
  • Sử dụng tối ưu hóa: strlwr_a_cr là nhanh nhất.
  • Truyền tham số kiểu const string& nhanh hơn so với truyền theo giá trị.

Chúc bạn thành công trong việc áp dụng những kiến thức này vào dự án của mình!


Nếu có bất kỳ câu hỏi nào, xin vui lòng để lại bình luận.

Built with Hugo
Theme Stack thiết kế bởi Jimmy