判断字符串中是否有'B','T'和数字

可以使用正则表达式来判断字符串中是否有'B','T'和数字，具体代码如下：

import re

def check_string(s):
    pattern = r'[BT\d]'
    match = re.search(pattern, s)
    if match:
        return True
    else:
        return False

这里使用了 Python 的 re 模块来进行正则表达式匹配，其中 pattern 表示匹配规则，r 表示将字符串转换为原始字符串，[BT\d] 表示匹配字符集中的任意一个字符，包括'B'、'T'和数字。如果在字符串 s 中找到了匹配的字符，则返回 True，否则返回 False。

相关问题

设计一个算法，统计输入字符串中各个不同字符出现的频度。设字符串中的合法字符为‘A’～‘Z’这26个字母和‘0’～‘9’这10个数字（串的存储结构自行选择）

可以使用散列表（哈希表）来统计每个字符出现的频度。

具体实现步骤如下：

1. 创建一个长度为 36 的数组，分别对应26个字母和10个数字，用来存储每个字符出现的频度。

2. 遍历输入字符串的每个字符，判断其是否为合法字符。如果是，就在对应的数组位置上加 1。

3. 最后遍历数组，输出每个字符及其出现的频度。

代码实现示例：

def count_frequency(s):
    freq = [0] * 36  # 初始化频度数组
    for c in s:
        if c.isalpha():
            index = ord(c.upper()) - ord('A')
        elif c.isdigit():
            index = ord(c) - ord('0') + 26
        else:
            continue
        freq[index] += 1  # 统计频度
    # 输出结果
    for i in range(26):
        print(chr(i + ord('A')), ':', freq[i])
    for i in range(10):
        print(chr(i + ord('0')), ':', freq[i+26])

# 测试代码
s = 'AaBbCc0123456789'
count_frequency(s)

输出结果为：

A : 2
B : 2
C : 2
D : 0
E : 0
F : 0
G : 0
H : 0
I : 0
J : 0
K : 0
L : 0
M : 0
N : 0
O : 0
P : 0
Q : 0
R : 0
S : 0
T : 0
U : 0
V : 0
W : 0
X : 0
Y : 0
Z : 0
0 : 1
1 : 1
2 : 1
3 : 1
4 : 1
5 : 1
6 : 1
7 : 1
8 : 1
9 : 1

给定一个字符串s,s中只包含数字,请返回s中最长的特殊的回文子串的长度 特殊的回文子串t满足 ·t进行任何次交换后可以变成一个回文字符申 输入格式 输入第一行包含一个字符串s。 数据范围 1s≤10^5 输出格式 特殊的回文子串的最长长度用C语言怎么写

### 回答1：
C++代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

bool check(string s)
{
int n = s.size();
for (int i = 0, j = n - 1; i < j; i ++, j --)
if (s[i] != s[j])
return false;
return true;
}

int main()
{
string s;
cin >> s;

int n = s.size();
int ans = 0;

for (int i = 0; i < n; i ++)
for (int j = i; j < n; j ++)
{
string t = s.substr(i, j - i + 1);
if (!check(t)) continue;
for (int k = i; k <= j; k ++)
for (int l = k + 1; l <= j; l ++)
{
swap(t[k - i], t[l - i]);
if (check(t)) ans = max(ans, j - i + 1);
swap(t[k - i], t[l - i]);
}
}

cout << ans << endl;

return 0;
}

### 回答2：
首先，我们可以使用双指针法来解决这个问题。

算法步骤如下：

1. 定义两个指针left和right，分别指向字符串s的开头和结尾。
2. 当left < right时，循环执行以下步骤：
a. 如果s[left]和s[right]相等，则将left向右移动一位，将right向左移动一位。
b. 如果s[left]和s[right]不相等，则返回字符串s的长度（即s的长度就是一个特殊的回文子串的最长长度）。
3. 如果循环结束时left >= right，则返回1（表示字符串s是一个特殊的回文子串）。

C语言代码示例：

#include <stdio.h>
#include <string.h>

int longestSpecialPalindromeLength(char* s) {
    int len = strlen(s);
    int left = 0, right = len - 1;
    
    while (left < right) {
        if (s[left] == s[right]) {
            left++;
            right--;
        } else {
            return len;
        }
    }
    
    return 1;
}

int main() {
    char s[100000];
    scanf("%s", s);
    
    int length = longestSpecialPalindromeLength(s);
    printf("%d\n", length);
    
    return 0;
}

注意：代码中假设不会输入空字符串。并且为了方便起见，将字符串s的最大长度限定为100000，可以根据实际需求进行调整。

### 回答3：
在C语言中，可以使用以下代码来解决该问题：

#include<stdio.h>
#include<string.h>

int isPalindrome(char *str, int start, int end) {
    while (start < end) {
        if (str[start] != str[end]) {
            return 0;
        }
        start++;
        end--;
    }
    return 1;
}

int specialPalindromeLength(char *s) {
    int length = strlen(s);
    int max_length = 0;
    
    for (int i = 0; i < length; i++) {
        for (int j = length - 1; j >= i; j--) {
            if ((j - i + 1) <= max_length) {
                break;
            }
            if (isPalindrome(s, i, j)) {
                int unique = 1;
                for (int k = i; k <= j; k++) {
                    if (s[k] != s[i]) {
                        unique = 0;
                        break;
                    }
                }
                if (unique == 1) {
                    max_length = j - i + 1;
                    break;
                }
            }
        }
    }
    
    return max_length;
}

int main() {
    char s[100000];
    scanf("%s", s);
    int result = specialPalindromeLength(s);
    printf("%d\n", result);
    return 0;
}

该代码首先定义了一个函数`isPalindrome`，用于判断一个字符串是否是回文串。该函数接受一个字符串指针和起始位置和结束位置的索引，并通过比较字符来判断是否是回文串。

接下来，定义了一个函数`specialPalindromeLength`，它接收一个字符串，并返回字符串中最长的特殊回文子串的长度。在这个函数中，使用两个嵌套循环来遍历所有可能的子串，并通过调用`isPalindrome`函数来判断是否是回文字符串。如果是回文串，还需判断是否是特殊回文子串（即子串中只有一种字符），如果是特殊回文子串，更新最长长度。

在主函数`main`中，首先读取输入的字符串，并调用`specialPalindromeLength`函数来计算最长特殊回文子串的长度，并打印结果。

注意，该代码中的字符串长度假设不超过100000，可以根据实际情况进行调整。