1、消除重复数字
'''
题目描述:给定一个正整数,给出消除重复数字以后最大的整数
输入描述:正整数,注意考虑长整数
输出描述:消除重复数字以后的最大整数
输入样例:423234
输出样例:432
'''
num = int(input())
ls1 = list(str(num))
ls2 = list(set(ls1))
# ls2.sort(reverse=True)
ls2=sorted(ls2, reverse=True)
str1 = "".join(ls2)
print(int(str1))
2、郑骰子
'''
华为机试—掷骰子游戏
在掷骰子游戏中。会依据所掷数字在地图中前进几步。前进完毕后须要依据当前地图位置所看到的的障碍进行对应操作,当中障碍表示:
1)9:无障碍
2)1:停掷一轮,即下轮所掷数字无效。
3)2:后退两步,假设已经到起点不再后退。
4)3:奖励前进一步
假设在游戏过程中,已经走到地图终点,则游戏结束。依据输入的地图数组,和5个骰子数的数组,返回终于玩家前进了多少步。
演示样例
1)输入:map_len = 15, map = {9,1,9,9,9,2,9,9,9,9,9,9,9,9,9}。dice_val = {1,2,1,3,1},
返回:4
2)输入:map_len = 16, map = {9,9,9,9,9,1,9,3,9,9,2,9,9,9,9,9},dice_val = {2,1,4,1,6},
返回:15
'''
'''
#include
void dice(int map_len, int* map, int* dice_val, int* output)
{
int step=0, i;
for(i=0; i<5; i++)
{
step = step + dice_val[i];
if(step>=map_len - 1)
{
step = map_len - 1;
break;
}
else if(map[step] == 1)
i++;
else if(map[step] == 2)
{
if(step>1)
step = step - 2;
else
step = 0;
}
else if(map[step] == 3)
step++;
}
*output = step;
printf("the output is %d\n",*output);
}
int main()
{
int map_len = 15, map[] = {9,1,9,9,9,2,9,9,9,9,9,9,9,9,9}, dice_val[] = {1,2,1,3,1};//4
//int a=0 , * output=&a;
int output[1];
dice(map_len, map, dice_val, output);
int map_len1 = 16, map1[] = {9,9,9,9,9,1,9,3,9,9,2,9,9,9,9,9}, dice_val1[] = {2,1,4,1,6};//15
//int a1=0 , * output1=&a1;
int output1[1];
dice(map_len1, map1, dice_val1, output1);
return 0;
}
'''
3、打印任务排序
'''
打印任务顺序
#include "stdafx.h"
#include
void printOrder(const int input[], int len, int output[])
{
if(len <= 0)
{
printf("Input Error!\n");
return;
}
//打印顺序标识
int iPrintFlag = 0;
//用list缓存数组
std::list TempList;
for(int i = 0; i < len; ++i)
{
TempList.push_back(input[i]);
}
do
{
bool bFlag = false;
int iHead = TempList.front();
std::list::iterator it;
for(it = TempList.begin(); it != TempList.end(); ++it)
{
if(iHead < *it)
{
bFlag = true;
break;
}
}
if(bFlag) //存在比头结点大的值
{
//将头元素放到末尾
TempList.pop_front();
TempList.push_back(iHead);
}
else
{
//直接打印,删除头元素
TempList.pop_front();
for(int i = 0; i < len; ++i)
{
if(input[i] == iHead)
{
output[i] = iPrintFlag;
iPrintFlag++;
}
}
}
}while(TempList.size() > 0);
}
int _tmain(int argc, _TCHAR* argv[])
{
int input[3] = {9,3,5};
int output[3] = {0};
printOrder(input, 3, output);
for(int i = 0; i < 3; ++i)
{
printf("%d,", output[i]);
}
system("pause");
return 0;
}
'''
4、字母计数法
'''
题目描述:
写出一个程序,接受一个有字母和数字以及空格组成的字符串,和一个字符,然后输出输入字符串中含有该字符的个数。不区分大小写。
输入描述:
输入一个有字母和数字以及空格组成的字符串,和一个字符。
输出描述:
输出输入字符串中含有该字符的个数。
作者:soeben
链接:https://www.jianshu.com/p/28d4fa0acbca
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
'''
defget_num():
in_str = input()
a = input()
num = 0
if(len(a)==0) and(len(a)>1):
return"重新输入"
else:
fori inin_str.lower():
ifi == a.lower():
num +=1
returnnum
print(get_num())
5、数字排列
a = input()
ls = a.split(",")
ls.sort()
out_str = ",".join(ls)
print(out_str)
6、电报翻译
# 2、假设电报中用(.)表示1,用中划线(-)表示0,点与中划线的序列,能够编译成一个二进制数(可以看做无符号数)。二进制数转换成整数,映射表对应英文字母。
# 多个点、中划线间用#隔开(多个连续#号算作一个) 电报没有点、中划线只有#时电报内容为空,二进制数值超过映射表输出“ERROR” 具体映射标见代码中
'''
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(http://System.in);
while (sc.hasNext()) {
String input = sc.nextLine();
String result= trans(input);
System.out.println(result);
}
sc.close();
}
private static String trans(String input) {
if(input ==null || input.length()==0)
return "ERROR";
char[] charArray = input.toCharArray();
int count=0;
for (int i = 0; i < charArray.length; i++) {
if(charArray[i]=='#')
count++;
if(charArray[i]!='#' && charArray[i]!='.'&&charArray[i]!='-')
return "ERROR";
}
String nothing ="";
if(count == charArray.length)
return nothing;
StringBuilder sb = new StringBuilder();
String[] split = input.split("#");
for (int i = 0; i < split.length; i++) {
if (split[i].equals("")||split[i].equals(" ")) {
continue;
}else{
String back= binarytrans(split[i]);
if(back.equals("ERROR"))
return back;
sb.append(back);
}
}
return sb.toString();
}
private static String binarytrans(String str) {
String[] myDictionary =new String[]{"F","G","R","S","T","L","M","N","O","P","Q",
"W","X","Y","Z","U","A","G","H","I","J","K",
"B","C","D","E","l","m","n","o","p","i","j","k","f","g","h",
"a","b","c","d","e","q","r","w","x","y","z","s","t","u","v"};
StringBuilder sb = new StringBuilder();
char[] cs = str.toCharArray();
for (int i = 0; i < cs.length; i++) {
if(cs[i]=='.'){
sb.append("1");
}else if (cs[i]=='-') {
sb.append("0");
}
}
int num=Integer.valueOf(sb.toString(),2);
if(num<0 || num>51)
return "ERROR";
if(num>=0 && num<=51)
return myDictionary[num];
return "ERROR";
}
}
'''
7、集五福
'''
集五福作为近年来大家喜闻乐见迎新春活动,集合爱国福、富强福、和谐福、友善福、敬业福即可分享超大红包
以0和1组成的长度为5的字符串代表每个人所得到的福卡,每一位代表一种福卡,1表示已经获得该福卡,单类型福卡不超过1张,随机抽取一个小于10人团队,求该团队最多可以集齐多少套五福?
输入描述:
输入若干个"11010"、”00110"的由0、1组成的长度等于5位字符串,代表的指定团队中每个人福卡获得情况
注意1:1人也可以是一个团队
注意2:1人可以有0到5张福卡,但福卡不能重复
输出描述:
输出该团队能凑齐多少套五福
示例1
输入
11001,11101
输出
0
示例2
输入
11101,10111
'''
defget_count():
a = input()
lists = a.split(',')
count = 0
forli inlists:
ifint(li) == 11111:
count += 1
returncount
print(get_count())
# java实现
'''
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
getWFCount();
}
//获取五福套数
public static void getWFCount() {
System.out.println("请输入一组由0和1组成的5位字符串,中间用,号分割:");
System.out.println("如:10110,11001");
System.out.println("请输入:");
while(true){
Scanner sc = new Scanner(http://System.in);
String s = sc.next();
if(null == s || "" == s ){
System.out.println("输入有误,请重新输入:");
continue;
}else{
String[] sq = s.split(",");
int[] list = {0,0,0,0,0};
for(String sPart:sq){
if(sPart.length() != 5){
System.out.println("输入有误,请重新输入:");
continue;
}
if(!sPart.matches("[01]{5}")){
System.out.println("输入有误,请重新输入:");
continue;
}
for(int i=0;i
if(sPart.charAt(i) == '1'){
int n= list[i];
n++;
list[i] = n;
}
}
}
for(int i =0;i < list.length - 1;i++)
{
for(int j = 0;j < list.length - 1-i;j++)// j开始等于0,
{
if(list[j] < list[j+1])
{
int temp = list[j];
list[j] = list[j+1];
list[j+1] = temp;
}
}
}
// System.out.println(Arrays.toString(list));
System.out.println("该团队能凑齐"+list[4]+"套五福");
sc.close();
break;
}
}
}
}
'''
8、仿LISP运算
'''
LISP语言唯一的语法就是括号要配对。
形如 (OP P1 P2 …),括号内元素由单个空格分割。
其中第一个元素OP为操作符,后续元素均为其参数,参数个数取决于操作符类型
注意:参数 P1, P2 也有可能是另外一个嵌套的 (OP P1 P2 …)
当前OP类型为add/sub/mul/div(全小写),分别代表整数的加减乘除法。简单起见,所以OP参数个数为2
举例
-输入:(mul 3 -7)输出:-21
输入:(add 1 2) 输出:3
输入:(sub (mul 2 4) (div 9 3)) 输出 :5
输入:(div 1 0) 输出:error
'''
'''
import java.util.Scanner;
import java.util.Stack;
public class Main {
//(sub (mul 2 4) (div 9 3))
public static void main(String[] args) {
Scanner scanner = new Scanner(http://System.in);
String line = scanner.nextLine();
calculatorLISP(line);
scanner.close();
}
private static void calculatorLISP(String str) {
Stack numStack = new Stack();
Stack operStack =new Stack();
int mark = 0;
int paramOne = 0;
int paramTwo = 0;
for(int i = 0; i < str.length() ; i++) {
char c = str.charAt(i);
if(c == '('){
operStack.push(str.substring(i+1,i+4));
i+=4;
mark = i+1;
}else if(c == ')'){
if(mark < i){
numStack.push(Integer.valueOf(str.substring(mark,i)));
i++;
mark = i+1;
}
paramTwo = numStack.pop();
paramOne = numStack.pop();
calc(numStack,operStack,paramOne,paramTwo);
}else{
if(c == ' '){
if(mark < i){
numStack.push(Integer.valueOf(str.substring(mark,i)));
mark = i + 1;
}
}
}
}
while(!operStack.isEmpty()) {
paramTwo = numStack.pop();
paramOne = numStack.pop();
calc(numStack,operStack,paramOne,paramTwo);
}
System.out.println(numStack.pop().toString());
}
public static void calc(Stack numStack,Stack operStack,int paramOne, int paramTwo){
switch(operStack.pop()) {
case "add":
numStack.push(paramOne + paramTwo);
break;
case "sub":
numStack.push(paramOne - paramTwo);
break;
case "mul":
numStack.push(paramOne * paramTwo);
break;
case "div":
if(paramTwo == 0) {
System.out.println("error");
}else{
numStack.push(paramOne / paramTwo);
}
break;
}
}
}
'''
9、清一色
'''题目描述:
清一色是麻将番种之一,指由一种花色的序数牌组成的和牌。数字1-9,每个数字最多有4张牌。我们不考虑具体花色,我们只看数字组合。
刻子:三张一样的牌;如: 111, 222, 333, ..., 999
顺子:三张连续的牌;如: 123, 234, 345, ..., 789
对子:两张相同的牌;如: 11, 22, 33, ..., 99
需要实现一个程序,判断给定牌,是否可以和牌(胡牌)。
和牌要求:
- 麻将牌张数只能是 2, 5, 8, 11, 14
- 给定牌可以组合成,除1个对子以外其他都是刻子或顺子
举例:
- "11" -> "11", 1对子,可以和牌
- "11122233" -> "111"+"222"+"33", 2刻子,1对子,可以
- "11223344567" -> "11"+"234"+"234"+"567", 1对子,3顺子,可以
-> "123"+"123"+"44"+"567", 另一种组合,也可以
输入描述:
合法C字符串,只包含'1'-'9',且已经按从小到大顺序排好;字符串长度不超过15。同一个数字最多出现4次,与实际相符。
输出描述:
C字符串,"yes"或者"no"
示例1
输入:2244
输出:no'''
'''
#include
#include
using namespace std;
// 判断麻将是否和牌
bool canSuccess(const string &s) {
// 字符串长度不符合
if (s.length() < 2 || s.length() >= 15) return false;
// 剩下的2张牌为对子则和牌否则不能和牌
if (s.length() == 2) return s[0] == s[1];
bool flag = false;
auto begin= s.begin(), end = s.end();
while (end - begin > 2)
{
// 判断是否有刻子
if (*begin == *(begin + 1) && *begin == *(begin + 2))
{
// 去掉刻子后递归处理
string tmp1(s.begin(), begin);
string tmp2(begin + 3, end);
flag |= canSuccess(tmp1 + tmp2);
}
// 判断是否有顺子
else if (*begin + 1 == *(begin + 1)) {
// 顺子中间的牌可能有多张相同的,遍历找到第一个不同的
int midSameCount = 0;
char mid = *(begin + 1);
auto iter = begin + 1;
while (*iter == mid)
{
midSameCount++;
// 如果递归到字符串末则标记后退出循环
if (++iter == end)
{
midSameCount = -1;
break;
}
}
// 处理有顺子的情况
if (midSameCount > 0 && mid + 1 == *iter) {
// 去掉顺子后递归处理
string tmp1(s.begin(), begin);
string tmp2;
tmp2.insert(0, midSameCount - 1, mid);
string tmp3(iter + 1, end);
flag |= canSuccess(tmp1 + tmp2 + tmp3);
}
}
++begin;
}
return flag;
}
int main()
{
string input;
getline(cin, input);
bool flag = canSuccess(input);
cout << (flag ? "yes" : "no") << endl;
}
'''
10、七进制加法
# 题目:要求键盘输入两个七进制【0-6】数,以空格分开,计算两者之和输出,例如:
# 输入:16 1
# 输出:20
#
# 思路:这个题目跟十进制加法一样,不同的就是十进制是逢十进一,七进制是逢七进一。从个位开始加,
# 判断跟7的关系,如果大于七就向前进一,当前位写成个位和与7之差,依次按位加即可。
m, n = map(str, input().strip().split(" "))
m_list, n_list = list(m), list(n) # 存成字符数组,方便按位加
m_list.reverse() # 翻转,方便从个位开始加
n_list.reverse()
# 加数和被加数补齐,防止数组越界,短者高位补0
iflen(m_list) > len(n_list):
result = [''] * (len(m_list) + 1) # 保存和,多一位是防止最高位也有进一的情况
n_list = n_list + [0] * (len(m_list) - len(n_list))
else:
result = [''] * (len(n_list) + 1)
m_list = m_list + [0] * (len(n_list) - len(m_list))
flag = False
fori inrange(max(len(m_list), len(n_list))):
ifflag: # 如果上一位有进1,本位和需要加上上一位进的1
plus = int(n_list[i]) + int(m_list[i]) + 1
else:
plus = int(n_list[i]) + int(m_list[i])
ifplus >= 7: # 本位大于7,本位存本位和-7,并向前进一
result[i] = str(plus - 7)
flag = True
else:
result[i] = str(plus)
flag = False
ifflag: # 最高位最终向前进1,和也需要向前进1
result[-1] = str(1)
result.reverse()
print(''.join(result).strip())
11、找字符串中出现次数最多的字符
# 问题:给定一个字符串,找出其中出现次数最多的字母?
# 拓展:如果出现次数一样的字母,按照字母顺序就输出第一个
# 思路: 利用collections 工具中的Counter,对列表中元素出现的频率进行排序。
# Counter返回值是一个按元素出现频率降序排列的Counter对象,它是字典的子类,因此可以使用字典的方法
fromcollections importCounter
defget_max_char(str):
count = Counter(str)
#以为count现在是一个对象,利用他的属性--count.values()取出其中的值
count_list = list(count.values())
max_value = max(count_list)
max_list = []
fork, v incount.items():
ifv == max_value:
max_list.append(k)
# max_list = sorted(max_list) #加这个排序的原因是,如果你找到 两个或两个以上的具有相同的频率的字母, 返回那个先出现在字母表中的字母
# return max_list[0]
returnmax_list
str1 = 'abcdacdgjkdka'
print(get_max_char(str1))
12、找出字符串中第一个只出现一次的字符
# 问题:在一个字符串(0<=字符串长度<=10000,全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置,
# 如果没有则返回 -1(需要区分大小写).
# 解答:可以用HashMap统计每个字符对应的次数,然后再遍历这个map找出第一个
defget_first():
str1 = input()
iflen(str1)>=0 andlen(str1)<=10000:
fori instr1:
ifstr1.count(i) == 1:
returni
else:
return-1
else:
return"重新输入"
print(get_first())
13、循环链表检测
# 有一个数组a[N]顺序存放0~N-1,要求每隔两个数删掉一个数,到末尾时循环至开头继续进行,求最后一个被删掉的数的原始下标位置。
# 以8个数(N=7)为例:{0,1,2,3,4,5,6,7},0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除
'''
#include
#include
using namespace std;
typedef struct node* ptrtonext;
typedef ptrtonext List;
typedef ptrtonext Position;
struct node {
int data;
ptrtonext next;
};
List createlist(int n)
{
Position p1, p2;
Position head = NULL;
p1 = (Position)malloc(sizeof(struct node));
p1->data = 0;
p1->next = NULL;
head = p1;
p2 = p1;
for (int i = 1; i
{
p1 = (Position)malloc(sizeof(struct node));
p1->data = i;
p1->next = NULL;
p2->next = p1;
p2 = p1;
}
p2->next = head;
return head;
}
int main()
{
Position head, p1, p2;
int N;
cin >> N;
head = createlist(N);
p1 = head;
for (; p1->next != p1;)
{
p1 = p1->next;
p2 = p1->next;
p1->next = p2->next;
p1 = p1->next;
free(p2);
}
cout << p1->data;
while (1);
}
'''
14、数据分类
# 题目描述:
#
# 输入描述:
# 一组输入整数序列I和一组规则整数序列R,I和R序列的第一个整数为序列的个数(个数不包含第一个整数);整数范围为0
# ~0xFFFFFFFF,序列个数不限
#
# 输出描述:
# 从R依次中取出R < i >,对I进行处理,找到满足条件的I < j >:
#
# I < j > 整数对应的数字需要连续包含R < i > 对应的数字。比如R < i > 为23,I < j > 为231,那么I < j > 包含了R < i >,条件满足 。
#
# 按R < i > 从小到大的顺序:
#
# (1)
# 先输出R < i >;
#
# (2)
# 再输出满足条件的I < j > 的个数;
#
# (3)
# 然后输出满足条件的I < j > 在I序列中的位置索引(从0开始);
#
# (4)
# 最后再输出I < j >。
#
# 附加条件:
#
# (1)
# R < i > 需要从小到大排序。相同的R < i > 只需要输出索引小的以及满足条件的I < j >,索引大的需要过滤掉
#
# (2)
# 如果没有满足条件的I < j >,对应的R < i > 不用输出
#
# (3)
# 最后需要在输出序列的第一个整数位置记录后续整数序列的个数(不包含“个数”本身)
#
#
#
# 序列I:15, 123, 456, 786, 453, 46, 7, 5, 3, 665, 453456, 745, 456, 786, 453, 123(第一个15表明后续有15个整数)
#
# 序列R:5, 6, 3, 6, 3, 0(第一个5表明后续有5个整数)
#
# 输出:30, 3, 6, 0, 123, 3, 453, 7, 3, 9, 453456, 13, 453, 14, 123, 6, 7, 1, 456, 2, 786, 4, 46, 8, 665, 9, 453456, 11, 456, 12, 786
#
# 说明:
#
# 30 - ---后续有30个整数
#
# 3 - ---从小到大排序,第一个R < i > 为0,但没有满足条件的I < j >,不输出0,而下一个R < i > 是3
#
# 6 - -- 存在6个包含3的I < j >
#
# 0 - -- 123
# 所在的原序号为0
#
# 123 - -- 123
# 包含3,满足条件
#
'''
#include "hw.h"
//Q24数据分类处理
string Int2Str(int num)
{
string str;
while(num)
{
str.push_back(num%10 + '0');
num /= 10;
}
reverse(str.begin(),str.end());
return str;
}
int Q24DataClassfied()
{
string si = "15 123 456 786 453 46 7 5 3 665 453456 745 456 786 453 123";
string sr = "5 6 3 6 3 0";
while(1)
{
//读取数据
string str;
vector vsi; //记录I
for(unsigned int i = 0; i < si.size(); i++)
{
if(' ' == si[i])
{
vsi.push_back(str);
str.clear();
}
str.push_back(si[i]);
}
vsi.push_back(str);
str.clear();
//getline(cin,sr);
vector vsr; //记录R
for (unsigned int i = 0; i < sr.size(); i++)
{
if(' ' == sr[i])
{
vsr.push_back(str);
str.clear();
}
str.push_back(sr[i]);
}
vsr.push_back(str);
str.clear();
//先对vsr排序,然后再去除重复
sort(vsr.begin(),vsr.end());
vector nvr;
if(vsr.size() > 1)
nvr.push_back(vsr[1]);
for (unsigned int i = 2; i < sr.size(); i++)
{
if(vsr[i] != vsr[i - 1])
nvr.push_back(vsr[i]);
}
vector ostr;//记录输出序列
for (unsigned int i = 1; i < nvr.size(); i++)
{
vector temp;
for(unsigned int j = 1; j < vsi.size(); j++)
{
int pos = vsi[j].find(nvr[i],j);
if(pos != string::npos)
{
temp.push_back(Int2Str(j));
temp.push_back(vsi[j]);
}
}
if(temp.size() > 0)
{
ostr.push_back(Int2Str(temp.size()/2));
ostr.insert(ostr.end(),temp.begin(),temp.end());
}
}
cout << ostr.size() << " ";
for (unsigned int i = 0; i < ostr.size(); i++)
{
cout << " " << ostr[i];
}
}
return 0;
}
'''
15、简单运算式计算
# 通过键盘输入100以内正整数的加、减运算式,请编写一个程序输出运算结果字符串。
# 输入字符串的格式为:“操作数1 运算符 操作数2”,“操作数”与“运算符”之间以一个空格隔开。
#
# 补充说明:
# 1、操作数为正整数,不须要考虑计算结果溢出的情况。
# 2、若输入算式格式错误,输出结果为“0”。
#
# 要求实现函数:
# void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr);
#
# 【输入】 pInputStr: 输入字符串
# lInputLen: 输入字符串长度
# 【输出】 pOutputStr: 输出字符串,空间已经开辟好,与输入字符串等长;
#
# 【注意】仅仅须要完毕该函数功能算法,中间不须要有不论什么IO的输入输出
#
# 演示样例
# 输入:“4 + 7” 输出:“11”
# 输入:“4 - 7” 输出:“-3”
# 输入:“9 ++ 7” 输出:“0” 注:格式错误
#
#
# 分析:先切割字符串,分别取得两个操作数和一个运算符, 然后再做一些非法推断, 最后进行运算操作;
'''
package com.wenj.test;
/**
*
* @author wenj91-PC
*
*/
public class TestArithmetic {
public static void main(String args[]){
String strIn = "9 ++ 7";
TestArithmetic ta = new TestArithmetic();
System.out.println(ta.arithmetic(strIn));
}
public int arithmetic(String strIn){
String strTemp = strIn;
String[] strArr = strTemp.split(" ");
int a, b;
try{
a = Integer.parseInt(strArr[0]);
b = Integer.parseInt(strArr[2]);
}catch(Exception e){
return 0;
}
String mid = strArr[1];
char[] strC = mid.toCharArray();
if(strC.length > 1){
return 0;
}
switch(strC[0]){
case '+':
return (a+b);
case '-':
return (a-b);
default:
return 0;
}
}
}
'''
16、单词排序输出
# 题目描述:
# 对输入的单词进行字典序排序输出,字典序定义:
#
# 1.单词中字母比较不区分大小写,两个单词先以第一个字母作为排序的基准,
# 如果第一个字母相同,就用第二个字母为基准,
# 如果第二个字母相同就以第三个字母为基准。
# 依此类推,如果到某个字母不相同,字母顺序在前的那个单词顺序在前。
# 2.当一个短单词和一个长单词的开头部分都相同(即短单词是长单词从首字母开始的一部分),短单词顺序在前。
# 3.字母大小写不同的相同单词,只输出一次。
#
# 输入描述:不超过255个字符中,单词间用空格进行分隔,为简单起见,单词不包含连字符,无其它标点符号。
# 输出描述:输出排序后的单词,单词之间用空格隔开(最后不带空格),重复的单词只输出一次。
importre
defzdx(sword):
l = []
temp = sword.split(" ")
fori intemp:
ifi.lower() not in[j.lower() forj inl]:
l.append(i)
return" ".join(sorted(l, key=str.lower))
while True:
s = input("请输入用空格进行分隔的单词:")
iflen(s) <= 255:
p = re.compile(r"^[a-zA-Z\s]{0,255}$")
ifp.match(s):
print("输入合格:" + s)
test = zdx(s)
print("按字典序排列输出为:%s" % test)
break
else:
print("输入只能是字母或空格,请重新输入!")
else:
print("输入不得超过255个字符,请重新输入!")
本文提供了一系列编程挑战题,包括字符串处理、数学运算、数据结构操作等,旨在锻炼读者的编程能力和逻辑思维。

被折叠的 条评论
为什么被折叠?



