lisp点坐标x轴可以乘除吗_机试编程题

本文提供了一系列编程挑战题,包括字符串处理、数学运算、数据结构操作等,旨在锻炼读者的编程能力和逻辑思维。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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个字符,请重新输入!")

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值