精华内容
下载资源
问答
  • 1.给定字符串,返回字符串中小写英文字母、数字以及其他字符出现的个数 package cn.r.string; public class StringTest1 { public static void main(String[] args) { // String str ="gdcsg68732dh87-%ghjg^"; ...

    练习

    1.给定字符串,返回字符串中小写英文字母、数字以及其他字符出现的个数

    package cn.r.string;
    
    public class StringTest1 {
        public static void main(String[] args) {
            //
            String str ="gdcsg68732dh87-%ghjg^";
            //给定统计变量
            int letter=0;//统计小写英文字母
            int number=0;//统计数字
    
            //遍历字符串
            for (int i=0;i<str.length();i++){
                char c=str.charAt(i);
    
                //判断获取字符是否是小写英文字母
                //
                if (c>='a'&&c<='z'){
                    letter++;
                }
                //判断获取字符是否是数字
                if(c>='0'&&c<='9'){
                    number++;
                }
            }
            //输出
            System.out.println("小写英文字母个数:"+letter+"数字个数:"+number);
        }
    }
    
    

    运行结果:

    在这里插入图片描述

    2.给定字符串,对字符串中的数字进行求和

    package cn.tedu.string;
    
    public class StringTest2 {
        public static void main(String[] args) {
            //
            String str="wvf347vv9shfbv0fdv3";
    
            //提供求和变量
            int sum=0;
    
            //遍历字符串
            for(int i=0;i<str.length();i++){
                //获取每个字符
                char c=str.charAt(i);
    
                //判断获取字符是否是数字
                if(c>='0'&&c<='9'){
                    //差值就是数字真实值
                    sum+=c-'0';//'3'-'0'
                }
            }
            System.out.println(sum);
    
        }
    }
    
    

    运行结果:

    在这里插入图片描述

    3.给定字符串,对字符串中的数字进行排序

    package cn.r.string;
    
    import java.util.Arrays;
    
    public class StringTest3 {
        public static void main(String[] args) {
            String str = "gdcsg68732dh87-%ghjg^";
            //新建数字存储字符串对象中的数字
            char[] cs = new char[str.length()];
            //计数变量、代表数组下标
            int index=0;
            //遍历字符串
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                //判断获取字符是否是数字
                if (c >= '0' && c <= '9') {
                    //把数字字符存储在新的数组中
                    cs[index++]=c;
                }
            }
            //缩容---index(代表字符串对象中数字字符的个数)
            cs = Arrays.copyOf(cs,index);
            //数组排序
            Arrays.sort(cs);
            //输出
            System.out.println(Arrays.toString(cs));
        }
    }
    

    运行结果:

    在这里插入图片描述
    4.给定字符串,输出每个字符出现的次数

    package cn.r.string;
    
    public class StringTest4 {
        public static void main(String[] args) {
            //4.给定字符串,输出每个字符出现的次数
            String str="asdfghjjjghdfsjha";
            //提供布尔数组表示字符串中每个字符的状态
            boolean[] bb=new boolean[str.length()];
    
            //给数组元素进行初始化
            //true---代表未统计  FALSE----代表已统计
            for (int i=0;i<bb.length;i++){
                bb[i]=true;
            }
            //遍历字符串
            for (int i=0;i<str.length();i++){
                //判断每个字符的状态
                if (bb[i]){
                    //进了判断说明未统计
                    //获取字符
                    char c=str.charAt(i);
                    //统计变量
                    int count=1;
                    //遍历后续字符
                    for (int j=i+1;j<str.length();j++){
                        //判断后续字符和当前字符是否重复
                        if (str.charAt(j)==c){
                            //改变后续字符状态
                            bb[j]=false;
                            //计数
                            count++;
                        }
                    }
                    //输出
                    System.out.println(c+"="+count);
                }
            }
        }
    }
    
    

    运行结果:

    在这里插入图片描述

    5.给定字符串String str=“订外卖";,转成字节数组根据字节数组的部分内容转成新的字符串对象,要求无论指定字节数组转成字符串对象的字节数多大,保证新的字符串对象没有?

    package cn.r.string;
    
    import java.io.UnsupportedEncodingException;
    
    public class StringTest6 {
        public static void main(String[] args) throws UnsupportedEncodingException {
            //6.给定字符串String str=“订外卖";,
            // 转成字节数组根据字节数组的部分内容转成新的字符串对象,
            // 要求无论指定字节数组转成字符串对象的字节数多大,
            // 保证新的字符串对象没有?
            String str="订外卖";
            //字符串对象内容转换成字节数组
            byte[] bs=str.getBytes("gbk");
            //给定字节数
            int n=6;
            //把字节数组部分内容转换成字符串对象
            String s=new String(bs,0,n,"gbk");
            //判断新串的最后一个字符和原串对应位置的字符是否一致
            if (s.charAt(s.length()-1)!=str.charAt(s.length()-1)){
                //进了判断说明未统计
                //把新串转换成字符数组
                char[] cs=s.toCharArray();
                //把除了字符数组最后一个字符以外都转换成对应的字符串对象
                s=new String(cs,0,s.length()-1);
            }
            //输出
            System.out.println(s);
        }
    }
    
    

    运行结果:

    在这里插入图片描述
    6.给定字符串,返回第一个字符出现的所有下标

    package cn.r.string;
    
    public class StringTest7 {
        public static void main(String[] args) {
            //7.给定字符串,返回第一个字符出现的所有下标 indexOf
    
            String str="wbhcfdshgwcgdchgcws";
    
            //获取字符串第一个字符
            char c=str.toCharArray()[0];
    
            //提供下标
            int index=0;
    
            //遍历字符串
            while (index!=str.length()){
                //返回第一次出现下标值
                index=str.indexOf(c,index);
                //判断下标是否是-1
                if (index!=-1){
                    System.out.println(index++);
                }else {
                    //结束循环
                    break;
                }
            }
        }
    }
    
    

    运行结果:

    在这里插入图片描述

    展开全文
  • 1.输入一个字符串,取出这个字符串中所有的数字求和。每个数字都是*独立的,*不连续。 现在只知道如何提取字符串中的数字 例:s=‘Abc34g8’ for I in s: I.isdigit() 或者 for I in s if I in [1,2...
  • 字符串求和

    2019-03-02 20:27:00
    实现字符串数字的减法 基本计算器(1) 基本计算器(2) 基本计算器(3) 一、题目:将整数字符串转成整数值{python) 给定一个字符串str,如果str符合日常书写的整数形式,并且属于32位整数的范围,返回所代表...

    目录

    一、题目:将整数字符串转成整数值{python)

    给定一个字符串str,如果str符合日常书写的整数形式,并且属于32位整数的范围,返回所代表的整数值,否则返回0。
    eg
    str = “123”,返回123.
    str = “023”,因为“023”不符合日常的书写习惯,所以返回0.
    str = “A23”,返回0;
    str = “0”,返回0;
    str= “2147483647”,返回2147483647.
    str = “2147483648”,因为溢出了,所以返回0;
    str = “-123”,返回-123;

    思路:

    空字符串输入、正负符号、非法字符、整型溢出【最难处理】

    1.  检查日常书写,非法字符
      • 第一个既不是负号,也不是数字的情况,如:‘A12’
      • 第一个是负号,但是整个字符串的长度只有1,或者负号后面跟个0的情况,如‘-“或者”-012“
      • 以0开头,而且整个字符串的长度大于1,如:‘012”
      • 从第二个开始依次遍历字符串,一旦出现不是数字的情况立即返回FALSE
    2. 字符转数字操作
      • 字符串为空或者字符串的长度为0
      • 字符串中存在不合法的字符
      • 第一个字符是否为负号的情况

    处理整数溢出:

    当发生溢出时,取最大或最小的int值。即大于正整数能表示的范围时返回MAX_INT:2147483647;小于负整数能表示的范围时返回MIN_INT:-2147483648。

    我们先设置一些变量:

    • sign用来处理数字的正负,当为正时sign > 0,当为负时sign < 0
    • n存放最终转换后的结果
    • c表示当前数字

    处理溢出:

    • 如果我们要转换的字符串是"2147483697",那么当我扫描到字符'9'时,判断出214748369 > MAX_INT / 10 = 2147483647 / 10 = 214748364(C语言里,整数相除自动取整,不留小数),则返回0;
    • 如果我们要转换的字符串是"2147483648",那么判断最后一个字符'8'所代表的数字8与MAX_INT % 10 = 7的大小,前者大,依然返回0。

    代码:

    复制代码
    #判断是否为合法
    def isValid(s):
        if s[0] != '-' and not s[0].isdigit():
            return False
        elif s[0] == '-' and (len(s) == 1 or s[1] == '0'):
            return False
        elif s[0] == '0' and len(s) > 1:
            return False
        for i in range(len(s)):
            if not s[i].isdigit():
                return False
        return True
    def convert(s):
        #判断为空
        if not s:
            return 0
        if not isValid(s):
            return 0
        sign = -1 if s[0] == '-' else 1
        q = 214748364 #-2^31 // 10
        maxr = 7
        res , cur = 0 , 0 
        start = 0 if sign == 1 else 1
        for i in range(start,len(s)): 
            cur = int(s[i])
            if res > q or res == q and cur > maxr:
                return 0
            res = res * 10 + cur 
        if sign and res == 2147483648:
            return 0
        return res * sign
    s = '2147483637'
    convert(s)
                    
    复制代码

    二、字符串中数字子串的求和

     给定一个字符串str,求其中全部数字串所代表的数字之和

      1. 忽略小数点,“ A1.3 ” 表示的数字就是包含两个数字 1 和 3

      2. 紧贴数字的左边出现 “-”,其连续出现的数量如果为奇数,就视为 负,如果为偶数,就视为 正 “ A-1BC--23” 表示的是 -1 和 23

    思路:时间复杂度是O(N),空间复杂度是O(1)

    首先定义三个变量, res表示目前的累加和,num表示当前收集到的数字,布尔型变量flag表示将num加到res中,num是正还是负.

    代码:

    复制代码
    def numSum(arr):
        if not arr:
            return 0
        num , res = 0 , 0
        flag = 1
        i = 0
        while i < len(arr):
            while i < len(arr) and arr[i] == '-':
                flag *= -1
                i += 1
            while i<len(arr) and arr[i].isdigit():
                num = num*10 + int(arr[i])
                i += 1
            if i<len(arr) and not arr[i].isdigit():
                i += 1
            if num:
                res += flag*num 
            num ,flag = 0 , 1
        return res
    arr = 'A1.3'
    numSum(arr)
    a="A-1BC--23"
    numSum(a)
    复制代码

    三、题目:公式字符串求值

    思路:采用栈存储数字和加减符号,乘除在放入栈中已计算出结果。变量pre记录数字。括号就递归。

    1、遇到数字:采用pre变量保存。

    2、遇到符号:存入栈中,存入之前先把栈中的乘除结果算出来

    3、遇到左括号:递归计算

    4、遇到右括号:计算栈中的结果。

     

    五、题目:基本计算器【只有 + ,- ,以及括号】

    实现一个基本的计算器来计算一个简单的字符串表达式的值。

    字符串表达式可以包含左括号 ( ,右括号 ),加号 + ,减号 -非负整数和空格  

    示例 1:

    输入: "1 + 1"
    输出: 2
    

    示例 2:

    输入: " 2-1 + 2 "
    输出: 3

    示例 3:

    输入: "(1+(4+5+2)-3)+(6+8)"
    输出: 23

    非递归思路:

    栈:

    采用栈存储遇到 ( 之前的结果。

    遇到 ),将栈中最后一个数弹出计算结果。

    处理过程:

    res记录结果,stack用来存结果【遇到()先存前面的结果】,sign记录符号+、-

    1. 遇到 + :sign = 1
    2. 遇到 - :sign = -1
    3. 遇到数字:【考虑‘42’两个字母一起的情况,采用循环】结果 res  += int (42) * sign
    4. 遇到 ’( ’:stack中加入 res和sign
    5. 遇到‘ ) ‘:stack弹出最后一个元素和倒数第二个元素来更新res
     

     

    代码1:

    复制代码
        def calculate(self, s):
            """
            :type s: str
            :rtype: int
            """
            if not s:
                return 0
    #stack存储遇到括号(之前的计算结果res
    #temp记录数字,【如‘42’两个数字一起出现的情况】
    #sign记录符号+,-
    #res记录计算结果
            stack,temp = [],''
            sign , res , i = 1 , 0 , 0 
            while i < len(s):
    #遇到字母:如果有两个数字同时出现,采用循环解决
    #res结果把符号相乘
                if s[i].isdigit():
                    while i<len(s) and s[i].isdigit():
                        temp += s[i]
                        i += 1
                    i -= 1
                    res += int(temp)*sign
    #遇到+,-,sign=1,-1
                elif s[i] == '+':
                    sign = 1
                elif s[i] == '-':
                    sign = -1 
    #遇到(,将前面的res和符号sign存入栈中,初始化res和sign
                elif s[i] == '(':
                    stack.append(res)
                    stack.append(sign)
                    res,sign = 0,1
    #遇到),将栈中原来的结果res和符号sign弹出和当前的res更新得到新的结果res
                elif s[i] == ')':
                    if stack:
                        sign_tmp = stack.pop()
                        res_tmp = stack.pop()
                    res = res_tmp + res*sign_tmp
                i += 1
                temp= ''
            return res    
    复制代码

    六、题目:基本计算器二【只有加减乘除,没有括号】

    实现一个基本的计算器来计算一个简单的字符串表达式的值。

    字符串表达式仅包含非负整数,+-*/ 四种运算符和空格  。 整数除法仅保留整数部分。

    示例 1:

    输入: "3+2*2"
    输出: 7
    

    示例 2:

    输入: " 3/2 "
    输出: 1

    示例 3:

    输入: " 3+5 / 2 "
    输出: 5

    非递归思路1:

    • 遇到数字:num存储
    • 遇到符号:
    1. +:栈存储:+num
    2. -:栈存储:-num
    3. *:num = 栈弹出最后一个元素 * num,再存入栈中
    4. /:num = 栈弹出最后一个元素 / num,再存入栈中

    如:'45/9',先num = 45,然后45前面默认为+ 符号,将45存入栈中,然后 sign =  / ,num = 9,判断sign == '/',将45弹出与num==9相除。

    即每个数字与其前面的符号相对应,sign和num。

    代码1:

    复制代码
    def calculate(self, s):
        if not s:
            return "0"
        stack, num, sign = [], 0, "+"
        for i in range(len(s)):
            if s[i].isdigit():
                num = num*10+ord(s[i])-ord("0")
            if (not s[i].isdigit() and not s[i].isspace()) or i == len(s)-1:
                if sign == "-":
                    stack.append(-num)
                elif sign == "+":
                    stack.append(num)
                elif sign == "*":
                    stack.append(stack.pop()*num)
                else:
                    tmp = stack.pop()
                    if tmp//num < 0 and tmp%num != 0:
                        stack.append(tmp//num+1)
                    else:
                        stack.append(tmp//num)
                sign = s[i]
                num = 0
        return sum(stack)
    复制代码

    非递归思路2:

    栈:

    • 遇到数字:就将数字存入栈中。【考虑两个数字一起出现的情况】
    • 遇到 * 或 / 就将乘或者除计算结束再存入栈中。【其中还要考虑是数字的情况】
      • 将栈最后一个元素弹出,然后与 【乘号或者除号后面一个元素的数字】进行计算得到新的结果再存进栈中
    • 遇到加减,sign = 1或-1

    结果:

    将栈中所有元素加总就可以了

    代码2:

    复制代码
    def calculate(self, s):
            """
            :type s: str
            :rtype: int
            """
            if not s:
                return 0
            # return eval(s)
            stack = []
            res,sign,i= 0,1,0
            num = ''
            ca = True
            while i < len(s):
                ss = s[i]
    #数字,考虑两个数字出现的情况,用循环
                if ss.isdigit():
                    while i<len(s) and s[i].isdigit():
                        num += s[i]
                        i += 1
                        ca = False
                    stack.append(int(num)*sign)
    #加减sign = 1或者-1
                elif ss == '+':
                    sign = 1
                elif ss == '-':
                    sign = -1
    #乘号,
                elif ss == '*':
                    #可能后面是空白符号
                    while not s[i].isdigit():
                        i += 1
                    #考虑两个数字一起出现
                    while i<len(s) and s[i].isdigit():
                        num += s[i]
                        i += 1
                        ca = False
                    #将栈最后一个元素和乘号*后面一个数字相乘
                    res = stack.pop() * int(num)
                    #将结果存入栈中
                    stack.append(res)
    #除号
                elif ss == '/':
                    value = stack.pop()
                    while not s[i].isdigit():
                        i += 1
                    while i<len(s) and s[i].isdigit():
                        num += s[i]
                        i += 1
                        ca = False
                    #m是用来限制除法取整的,如果除的结果是负数,则结果要加1,正数不用
                    m = value//int(num)
                    if value % int(num) != 0:
                        m += 1 if m < 0 else 0
                    #将除的结果加入栈中
                    res = int(m)
                    stack.append(res)
                if ca:
                    i += 1
                num , ca = '',True
            return sum(stack)                    
    复制代码

     


    七、题目:基本计算器三【既有乘除又有括号】

     

    这道题将一和二结合,就是遇到括号就递归,别的就都与题目二一样。

    思路:采用栈存储数字和加减符号,乘除在放入栈中已计算出结果。变量pre记录数字。括号就递归。

    1、遇到数字:采用pre变量保存。

    2、遇到符号:存入栈中,存入之前先把栈中的乘除结果算出来

    3、遇到左括号:递归计算

    4、遇到右括号:计算栈中的结果。

    复制代码
    def getValue(s):
        if not s:
            return 0
        return value(list(s),0)[0]
    #递归函数,遇到左括号
    def value(arr,i):
        deque = []
        pre = 0
        while i < len(arr) and arr[i] != ')':
            #如果是数字,用pre变量保存
            if arr[i].isdigit():
               pre = pre * 10 + int(arr[i])
               i += 1
            #如果是符号,加入栈中,但先要把栈中的乘除结果算出来。
            elif arr[i] != '(':
                mulNum(deque,pre)
                deque.append(arr[i])
                i += 1
                pre = 0
            #如果是左括号(,就递归。
            else:
                bra = value(arr,i+1)
                pre = bra[0]
                i = bra[1] + 1
        #如果是右括号)或者结束了,就求出最终结果。
        mulNum(deque,pre)
        return [addNum(deque),i]
    #乘除法计算          
    def mulNum(deque,pre):
        if deque:
            last = deque.pop()
            if last == '+' or last == '-':
                deque.append(last)
            else:
                cur = int(deque.pop())
                pre = pre * cur if last == '*' else cur / pre
        deque.append(pre)
    #加减法计算
    def addNum(deque):
        res = 0
        sign = 1
        while deque:
            cur = deque.pop(0)
            if cur == '-':
                sign = -1
            elif cur == '+':
                sign = 1
            else:
                res += sign * int(cur)
        return res
    exp = '48*((70-65)-43)+8*1*3+5/5'
    getValue(exp)
                
    复制代码

     

    转载于:https://www.cnblogs.com/Lee-yl/p/10462757.html

    展开全文
  • 字符串数字求和

    2016-03-22 17:12:00
    给定一个字符串,计算字符串中数值的个数并求和。其中还包含了负号-,若紧跟负号的是一个数值,则表示这是一个负数,若后面跟着的不是数字,则不表示什么输入:一个字符串 输出:数值个数 数值和 例子输入:312ab-2-...
    给定一个字符串,计算字符串中数值的个数并求和。其中还包含了负号-,若紧跟负号的是一个数值,则表示这是一个负数,若后面跟着的不是数字,则不表示什么 
    输入:一个字符串 输出:数值个数 数值和 例子 
    输入:312ab-2-- -9--a

    输出:3 301

    #include<stdio.h>
    #include <stdlib.h>
    #include<math.h>
    #include<string.h>
    int strToint(char* str)
    {
        int sign,sum,k,i,len,num;
        sign = 1;
        sum = i = 0;
        len = strlen(str);
        if(str[i]=='-')
        {
            sign = -sign;
            i++;
        }
        if(str[i]=='+')
        {
            i++;
        }
        num = 0;
        for(;i<len;i++)
        {
            //sum += sum*int(pow(10,num))+(str[i]-'0');
            sum = sum*10+(str[i]-'0');
            //num++;
        }
           
        return sum*sign;
    }
    int main()
    {
        int i,len,j;
        char str[1000001],tep[1000001],c;
        double b = 0.9999;
        int sum = 0;
        gets(str);
        len = strlen(str);
        //i = atoi(str);
        
    //b = atof(str);
        
    //printf("%lf\n",b);
        
    //sprintf(str,"%.3lf hello",b);
        
    //puts(str);
        j =0;
        for(i=0;i<len;i++)
        {
            c = str[i];
            if(str[i]=='-')
            {
                if(j>0)
                {
                    sum+=strToint(tep);//atoi(tep);
                    memset(tep, 0sizeof(tep));
                }
                j=0;
                if(str[i+1]>='0'&&str[i+1]<='9')
                {
                    tep[0]='-';
                    j++;    
                }
               
            }
            else
            {
                if(str[i]>='0'&&str[i]<='9')
                {
                    tep[j] = str[i];
                    j++;
                    //if(i==len-1)
                 }
                 else
                 {
                     tep[j]='\0';
                    if(j>0)
                    {
                        sum+=strToint(tep);//atoi(tep);
                        memset(tep, 0sizeof(tep));
                        j=0;
                     }
                  }
            }
            
        }
        if(j>0)
        {
          sum+=strToint(tep);    
        }
        printf("%d\n",sum);
        return 0;
        //312df-2ff--9

    } 

    转载于:https://www.cnblogs.com/lanshy/p/5307545.html

    展开全文
  • 文章目录字符串数字子串求和数字子串求和算法思路相应代码 字符串数字子串求和 数字子串求和 【题目】 给定一个字符串s,求其中全部数字串所代表的数字之和。 【要求】 忽略小数点字符,例如”A1.3″,其中包含...
  • 给定字符串求和

    2019-04-15 05:27:49
    2 当遇到不是数字的部分,将数字求和; 3 由于缺少最后要加的部分,故对最后一个数总体求和; 情况三:对输入任意的字符串进行情况二的操作; #include <stdio.h> #define N 100 int add_str(char *ps) {...

    情景1 给定字符串,求单个数字之和
    在这里插入图片描述
    结果为18.
    情景2 给定字符串,求连续数字之和
    在这里插入图片描述
    原理:
    1 如果遇到数字串,将其合成为数字;
    2 当遇到不是数字的部分,将数字求和;
    3 由于缺少最后要加的部分,故对最后一个数总体求和;

    情况三:对输入任意的字符串进行情况二的操作;
    #include <stdio.h>
    #define N 100
    int add_str(char *ps)
    {
    if(NULL==ps) {puts(“NULL input!”);return -1;}
    int n=0,s=0;
    while(*ps)
    {
    if(*ps>=‘0’&&ps<=‘9’) n=n10+*ps-‘0’;
    else {if(n) {printf("%d+",n);s+=n;n=0;}}
    ps++;
    }
    if(n) {s+=n;printf("%d=%d\n",n,s);}
    else printf("\b=%d\n",s);
    return s;
    }
    int main()
    {
    char str[N];
    int numadd;
    printf(“input string:”);
    gets(str);
    printf(“the string:%s\n”,str);
    numadd=add_str(str);
    if(numadd>=0) printf(“the str numadd:%d\n”,numadd);
    return 0;
    }

    展开全文
  • 输入为 非空 字符串且只包含数字1和0。 示例1: 输入: a = "11", b = "1" 输出: "100" 示例2: 输入: a = "1010", b = "1011" 输出: "10101" class Solution(object): def addBinary(self, a, b): """ :type a...
  • C++字符串数字子串求和

    千次阅读 2017-10-08 13:07:06
    //res记录结果 num记录数字 bool posi = true; for (int i = 0; i (); ++i) { if (str[i] - '0' || str[i] - '0' > 9) //'0' >= str[i] || str[i]>= 9 { res += num; num = 0; if (str[i] ...
  • 程序从命令行接入数字求和,如果接入的是字符串的解决办法 设计思想: 首先定义一个double类型的一维数组,然后在定义一个double型的变量sum,并赋值为0,用if循环判断从命令行是否有参数输入,如果没有则输出...
  • 思路:将数字字符串的形式保存;逐位进行求和; 细节:注意进位; public class BigIntegerTest { public static int[] add(String a, String b) { String[] strs = prepare(a, b); a = strs[0];...
  • sql字符串转换为数字求和Problem statement: Given a Binary Tree where each node has positive and negative values. Convert this to a tree where each node contains the sum of the left and right sub trees ...
  •  给定一个字符串str,求其中全部数字串所代表的数字之和。要求如下: 忽略小数点字符,例如“A1.3”,其中包含两个数字1和3. 如果紧贴数字子串的左侧出现字符“-”,当连续出现的数量为奇数时,则数字视为负,...
  • 字符串问题之 字符串中的数字子串求和 要求 1、 忽略小数点 如 A1.3 包含的是两个数字 1 和 3 2、紧贴数字子串的左侧出现字符“-” 连续次数为奇数时候 为负数 , 偶数时候为正数。 比如: “A-...
  • #定义一个乘法表函数,传入参数打印乘法表 def chengfa(num1,num2): for i in range(1,num1 + 1): for f in range(1,num2 + 1): num = i * f if i <= f: print("%d * %d = %d"%(i,f,num)) ...
  • 给定一个字符串str,求其中全部数字串所代表的数字之和。 要求 1.忽略小数点 2.考虑‘-’,如果有连续奇数个,则为负,如果有连续偶数个,就为正数。 举例: str=“A-1B–2C–D6E” return 7 思路: 判断是不是0-9 ...
  • 定义s1 = "123 98 234 23 345" s1 = "123 98 234 23 345" b1=s1.split(" ") print(b1) sum = 0 for n in b1: sum +=int(n) print(sum) 输出可以得到: 总结:先拆分字符串,然后遍历列表,然后在求和 2021年5月14日
  • 字符串数字子串的求和    给定一个字符串str,求其中全部数字串所代表的数字之和  1. 忽略小数点,“ A1.3 ” 表示的数字就是包含两个数字 1 和 3  2. 紧贴数字的左边出现 “-”,其连续出现的数量如果为...
  • //字符串数字子串的求和 public class NumSum{ //字符串数字子串的求和 public static int numSum(String str) { if(str==null) { return 0; } //字符串转换成数组 char[]charArr=str....
  • 从一串字符串中筛选出数字求和 #--coding:utf-8-- #author=‘maxh’ #字符串中的数字筛选出来存成列表,并求和 #整数,小数 import re def getSumFromString(str): numList = re.findall("\d+.?\d+", str) #筛选出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,609
精华内容 643
关键字:

字符串数字求和