写段代码，定义一个字符串常量，字符串中只有大小写字母和整数，_阿里巴巴笔试题

凌宇Ly

编辑于 2017-11-22 16:32:00 回复(0)

北极企鹅@

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

	public static void main(String[] args) {
		
		long sum = new Main().sumOfIntInStr("9fil3dj11P0jAsf11j");
		System.out.println(sum);
	}
	
	public long sumOfIntInStr(String input){
		
		Map<Integer, Integer> map = new HashMap<>();
		
		Pattern pattern = Pattern.compile("\\d+");
		Matcher matcher = pattern.matcher(input);
		while (matcher.find()) {
			Integer curI = Integer.valueOf(matcher.group());
			if(map.containsKey(curI)){
				map.put(curI, map.get(curI) + 1);
			}else {
				map.put(curI, 1);
			}
		}
		
		long curMaxCnt = 0;
		Integer maxKey = 0;
		for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
			if(entry.getValue() > curMaxCnt){
				curMaxCnt = entry.getValue();
				maxKey = entry.getKey();
			}
		}
		return curMaxCnt * maxKey;
	}

}

发表于 2017-08-22 13:34:45 回复(1)

╭Stop＿＇卜

const str = '9fil3dj11P0jAsf11j9dj9dj'

const testNum = /[0-9]$/

let num = ''

const targets = []

for (var i = 0; i < str.length; i++) {

const number = parseInt(str[i])

if (testNum.test(number)) {

num += number

} else {

if (num !== '') {

targets.push(num)

}

num = ''

}

let total = ''

const obj = {}

const n = 1

for (let j = 0; j < targets.length; j++) {

const param = parseInt(targets[j])

if (!obj[param]) {

obj[param] = n

} else {

obj[param] += n

}

const objs = Object.values(obj)

let targetParms = 0

for (var o = 0; o < objs.length; o++) {

const params = objs[o]

if (params > targetParms) {

targetParms = params

}

for (var l in obj) {

if (obj[l] === targetParms) {

total = l * targetParms

}

console.log(total, '~')

发表于 2021-06-10 11:43:16 回复(0)

cxccxc

典型字符串哈希（还有高精乘法，不过我没写）

#include<iostream>

#include<cstdio>

#include<cmath>

#include<algorithm>

#include<cstring>

#include<vector>

#include<map>

#include<queue>

#include<stack>

#define INF 1<<30

#define LL long long

#define ULL unsigned long long

#define P 131

usingnamespacestd;

chara[1000001];

intlen,lenh;

ULL tmph;

structc{

 ULL ha;

 ULL number;

 intnum=1;

}h[1000001];

boolcmp(c c1,c c2)

 returnc1.num>c2.num;

intmain()

 cin>>a;

 len=strlen(a);

 for(inti=0;i<len;i++)

  if(a[i]>='0'&&a[i]<='9')

   h[lenh].ha=h[lenh].ha*P+a[i];

   h[lenh].number=h[lenh].number*10+(a[i]-'0');

  elseif(h[lenh].ha!=0)

   intflag=0;

   for(inti=0;i<lenh;i++)

    if(h[i].ha==h[lenh].ha)

     h[i].num++;

     flag=1;

     h[lenh].ha=0;

     break;

   if(flag==0)lenh++;

 sort(h,h+lenh,cmp);

 cout<<h[0].number*h[0].num;

 return0;

发表于 2018-09-30 18:03:18 回复(0)

无名huster

1. 首先从这个串拿出所有的数字（一个for循环），将数字放在arrayList中

2. 创建一个hashMap，遍历arrayList，key==数字值，value==出现的次数

3. 遍历arrayList，得到在hashMap中出现次数最多的那个数字

4. 返回result =出现次数最多的那个数字 * 出现次数

发表于 2017-08-24 20:03:10 回复(0)

goer.lu

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		while (scanner.hasNext()) {
			String data = scanner.nextLine();
			String[] arrs = data.split("[a-zA-Z]{1,}");
			Map<String, Integer> datas = new HashMap<>();
			for (int i = 0; i < arrs.length; i++) {
				if (datas.containsKey(arrs[i])) {
					datas.put(arrs[i], datas.get(arrs[i])+1);
				}
				else {
					datas.put(arrs[i], 1);
				}
			}
			int maxalue = 0;
			String maxkey=null;
			for(String key : datas.keySet()){
				if (maxalue<datas.get(key)) {
					maxalue = datas.get(key);
					maxkey = key;
				}
			}
			int result = Integer.parseInt(maxkey)*maxalue;
			System.out.println(result);
		}
	}

}

发表于 2017-08-24 09:43:53 回复(1)

Holiday_12138

public int func(String s) {
	int maxCount = 0;
        int maxVal = 0;
	String[] strs = s.split("[^0-9]");
	HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
	for(int i = 0; i < strs.length; i++) {
		if(!"".equals(strs[i])) {
			int key = Integer.valueOf(strs[i]);
			if(map.containsKey(key)) {
                            map.put(key, map.get(key) + 1);
                        }
                        else {
                            map.put(key, 1);
                        }
                        if(maxCount < map.get(key)) {
                            maxCount = map.get(key);
                            maxValue = key;
                        }
                }
        }
        return maxValue * maxCount;
}

编辑于 2017-07-23 16:51:18 回复(7)

牛客8809317号

直接把所有非数字替换成分割符，split之后转成数组遍历一遍就有结果了。

发表于 2017-08-05 08:35:26 回复(0)

Frankiet

package NowCode.IT;

import java.util.HashMap;

/**
 * @Author: lei
 * @Data: 2020.3.22 19:54
 * @Description:
 * 写段代码，定义一个字符串常量，字符串中只有大小写字母和整数，输出字符串中的出现最多的数字的和？
 * 例如 ” 9fil3dj11P0jAsf11j ” 中出现最多的是11两次，输出22
 */
public class NumberSum {
	public static void main(String[] args) {
		String str = "9fi7l3dj11P0jA7sf11j11";
		System.out.println(get(str));
	}
	
	public static int get(String s){
		int res = 0;
		if(s == null || s.length() == 0)
			return res;
		HashMap<Integer, Integer> map = new HashMap<>();
		for(int i = 0;i < s.length();i++){
			if(s.charAt(i) <= '9' && s.charAt(i) >= '0') {
				int num = s.charAt(i) - '0';
				i++;
				while(i < s.length() && s.charAt(i) <= '1' && s.charAt(i) >= '0'){
					num = num * 10 + s.charAt(i) - '0';
					i++;
				}
				if(map.containsKey(num)){
					map.put(num, map.get(num)+1);
				}
				else
					map.put(num, 1);
			}
		}
		//找出现次数最多的那个key
		int count = 0;
		for(int i : map.keySet()) {
			if(count < map.get(i)){
				res = map.get(i) * i;
				count = map.get(i);
			}
		}
		return res;
	}
}//class end

编辑于 2020-03-22 21:26:56 回复(0)

黑の白

/*思路：
1、对字符串的字符进行遍历，看输入是否正确,排除输入掺杂其他字符或者输入全字母
2、使用ctype里的isalpha判断是否为字母，若不是则返回0，使用isdigit判断字符是否为数字，若不是则返回0
3、判断正确后，遍历字符串，将数字返回vetcor变量v1，对应下标返回v2
4、判断若v1的变量是否只有一个，若是，则直接输出；若不是，则根据v2的元素，是否有连续，将连续元素(下标连续)对应的v1元素转为10进制并存入v3
5、判断若v3的变量是否只有一个，若是，则直接输出；若不止一个，则先排序，然后v3中不同的数存入v4，,相同的数相加的和数存入v4，且v5表示得到v4对应数的个数
6、根据v5的值升序排列，将v4按v5的排序方法排序，则v4的最后的元素表示出现次数最多的数的和数
7、根据v5判断出现次数最多的数是否相同，若无，则只输出出现次数最多的数的和数，若有，则全部输出。
*/

#include <iostream>
#include <string>
#include <vector>
#include <ctype.h>
using namespace std;
int main()
{
    string str1;
    vector<int> v;
    cin >> str1;
    int i,n1;
    n1 = str1.size();

    /* 步骤2 */
    for (i = 0; i < n1; i++)
    {
        if ((isalpha(str1[i])) == 0)
        {
            if (isdigit(str1[i]) == 0)
            {
                cout << "error" << endl;
                return 0;
            }
        }
        if ((isdigit(str1[i])) == 0)
        {
            if (isalpha(str1[i]) == 0)
            {
                cout << "error" << endl;
                return 0;
            }
        }
    }
    for (i = 0; i < n1; i++)
    {
        if (isdigit(str1[i]) != 0)
        {
            v.push_back(i);
        }
    }
    if (v.empty())
    {
        cout << "error" << endl;
        return 0;
    }

    /* 步骤3 */
    vector<int> v1, v2;
    for (i = 0; i < n1; i++)
    {
        if ((isalpha(str1[i]))==0)
        {
            v1.push_back((int)(str1[i])-48);
            v2.push_back(i);
        }
    }

    /* 步骤4 */
    int n2,j,k,flag;
    j = 0;k = 0;
    n2 = v2.size();
    vector<int> v3;

    if (n2 == 1)
    {
        cout << v1[0] << endl;
        return 0;
    }
    else
    {
        for (i = 0; i < n2 - 1; i++)
        {
            if (v2[i] + 1 != v2[i + 1])
            {
                flag = 0;
            }
            else
            {
                flag = 1;
                k = k + 1;
            }
            while (i == n2 - 2)
            {
                if (v2[n2 - 2] + 1 != v2[n2 - 1])
                {
                    v3.push_back(v1[n2 - 1]);
                    break;
                }
                else
                {
                    flag = 0;
                    i = i + 1;
                }
            }


            if (flag == 0)
            {
                while (k >= 0)
                {
                    j = j + v1[i - k] * pow(10, k);
                    k--;
                }
                v3.push_back(j);
                j = 0; k = 0;
            }

        }
    }

    /* 步骤5 */
    int n3;
    n3 = v3.size();
    vector<int> v4;
    vector<int> v5;
    if (n3 == 1)
    {
        cout << v3[0] << endl;
        return 0;
    }
    else
    {
        for (i = 0; i < n3; i++)
        {
            for (j = i + 1; j < n3; j++)
            {
                if (v3[i]>v3[j])
                {
                    k = v3[i];
                    v3[i] = v3[j];
                    v3[j] = k;
                }
            }
        }

        k = 0; j = 0;
        int m;
        m = 0;
        for (i = 0; i < n3 - 1; i++)
        {
            if (v3[i] != v3[i + 1])
            {
                flag = 0;
            }
            else
            {
                flag = 1;
                k++;
            }

            while (i == n3 - 2)
            {
                if (v3[n3 - 2] != v3[n3 - 1])
                {
                    break;
                }
                else
                {
                    flag = 0;
                    i = i + 1;
                }
            }


            if (flag == 0)
            {
                while (k >= 0)
                {
                    j = j + v3[i - k];
                    k--;
                    m++;
                }
                v4.push_back(j);
                v5.push_back(m);
                j = 0; k = 0; m = 0;
            }
        }
        /* 步骤6 */
        int n5;
        n5 = v5.size();
        for (i = 0; i < n5; i++)
        {
            for (j = i + 1; j < n5; j++)
            {
                if (v5[i]>v5[j])
                {
                    k = v5[i];
                    v5[i] = v5[j];
                    v5[j] = k;

                    k = v4[i];
                    v4[i] = v4[j];
                    v4[j] = k;
                }
            }
        }
        /* 步骤7 */
        k = 1;
        for (i = n5 - 1; i > 0; i--)
        {
            if (v5[i] == v5[i - 1])
            {
                k = k + 1;
            }
            else
            {
                break;
            }

        }
        if (k != 1)
        {
            for (i = n5 - 1; i > n5 - k - 1; i--)
            {
                cout << v4[i] << ' ';
            }
            cout << endl;
        }
        else
        {
            cout << v4[n5 - 1] << ' ';
        }
    }
    return 0;
}

结果验证：

编辑于 2019-08-29 16:36:18 回复(0)

mnlu

public class Test { public static void main(String[] args) { String str = &quot;9fil3dj11P0jAs11j&quot;; String replace = str.replaceAll(&quot;[a-zA-Z]&quot;, &quot;*&quot;); String[] split = replace.split(&quot;[\\*]+&quot;); ArrayList&lt;string&gt; strings = new ArrayList&lt;&gt;(); for (String s : split) { strings.add(s); } HashMap&lt;string&gt; map = new HashMap&lt;&gt;(); for (int i = 0; i &lt; strings.size(); i++) { String el = strings.get(i); for (int j = 0; j &lt; strings.size(); j++) { int count = 1; if (el == strings.get(j)) { count++; } map.put(strings.get(j), count); } } Integer reduce = map.values().stream().reduce(0, Integer::max); map.entrySet().stream() .filter(e-&gt;e.getValue().equals(reduce)) .forEach(e -&gt; System.out.println(Integer.parseInt(e.getKey())*e.getValue())); } }&lt;/string&gt;&lt;/string&gt;

编辑于 2019-04-27 21:45:57 回复(0)

加菲童鞋123

看见看见可

发表于 2019-03-18 12:51:23 回复(0)

YouthLuck

发表于 2018-08-14 10:00:47 回复(0)

阿喵儿


#coding=utf-8 a= raw_input("input a string:")
b= []
i= 0 while i< len(a):  if a[i]<='9'and a[i]>='0':  c= int(a[i])def func(i,a,c):  if a[i+1]<= '9' and a[i+1]>= '0':  m= int(a[i + 1])return func(i + 1, a, c * 10 + m)else:  return c  ma= func(i,a,c)
        b.append(ma)
        i= i+ ma/10  i= i+1  maxcount= list(map(lambda l:l*b.count(l),b))
maxcount.sort(reverse=True)print maxcount[0]

编辑于 2018-06-01 15:57:43 回复(1)

Spongebobmay

import re
s='9fil3dj11P0jAsf11j '
slist=re.sub("[a-zA-Z]+"," ",s).split(' ')
dicts={}
for sl in slist:
    if sl!='':
        if sl in dicts:
            dicts[sl]+=int(sl)
        else:
            dicts[sl]=int(sl)
print max(dicts.items(), key=lambda x: x[1])[1]

发表于 2018-05-05 11:23:35 回复(2)

褪色的回忆2018

public void printInfo(String str) {
        if (null != str && !"".equals(str)) {
            // 定义分隔符，用于把数字字符串分割成数字字符数组
            String splitStr = "-";
            // 先去除非数字字符
            String targetStr = str.replaceAll("[\\D]", splitStr);
            // 得到所有的数字，可能包含空字符串
            String[] allNums = targetStr.split(splitStr);
            if (allNums.length > 0) {
                // 用于存放所有字符的出现次数
                List<Integer> listCount = new ArrayList<>();
                // 存储每一个字符的出现次数
                Map<String, Integer> map = new HashMap<>();
                // 存储最多的次数
                int maxCount = 0;
                for (String numStr : allNums) {
                    // 不存储空字符
                    if ("".equals(numStr)) {
                        continue;
                    }
                    // 得到每个字符的出现次数
                    int countNum = countNum(targetStr, numStr);
                    // 存储出现最多的次数
                    if (countNum > maxCount) {
                        maxCount = countNum;
                    }
                    // 存储出现次数
                    listCount.add(countNum);
                    // 集合以数字字符为key，字符出现的次数为value
                    map.put(numStr, countNum);
                }
                // 存储数据的集合
                Set<Entry<String, Integer>> entrySet = map.entrySet();
                // 打印符合条件的数字字符
                for (Entry<String, Integer> entry : entrySet) {
                    String num = entry.getKey();
                    Integer count = entry.getValue();
                    if (maxCount == count) {
                        System.out.println(num + " 出现次数最多，" + count + " 次，和为：" + count * Integer.parseInt(num));
                    } ;
                }
            } else {
                System.err.println("字符串中不包含数字！");
            }
        } else {
            System.err.println("字符串不能为空！");
        }
    }

    /**
     * 统计每个字符的出现次数
     * 
     * @param targetStr
     *            待匹配的字符串
     * @param numStr
     *            待匹配的数字字符串
     * @return 字符出现的次数
     */
    public int countNum(String targetStr, String numStr) {
        /**
         * 匹配数字字符（注：不能直接匹配numStr，会出现重复，
         * 比如：待匹配的字符："123a1234b12323wqd",匹配123就会匹配到3次，所以需要以非数字为分割线
         * 分为三种情况：分隔符在前面、分隔符在中间、分隔符在两边 ）
         */
        String numRegexp = "[\\D+]?(\\d+)[\\D+]?";
        Pattern pattern = Pattern.compile(numRegexp);
        Matcher matcher = pattern.matcher(targetStr);
        int count = 0;
        while (matcher.find()) {
            String group = matcher.group(1);
            if (group.equals(numStr)) {
                count++;
            }
        }
        return count;
    }

发表于 2018-03-15 21:48:55 回复(0)

牛客740946号

//c#版本
//1.使用正则表达式提取数字数组
//2.遍历数字数组，将重复数字用dic保存
//3.遍历dic,计算结果最大值

 string str = "9fil3dj11P0jAsf11j";
//1.使用正则表达式提取数字数组
string strReplace = System.Text.RegularExpressions.Regex.Replace(str, @"[^0-9]+", " ");
string[] szNum = strReplace.Split(' ');
//2.遍历数组，将重复数字用dic保存
 Dictionary<int, int> dicKeyValue = new Dictionary<int, int>();
int iNum;
for (int i = 0; i < szNum.Length; i++)
{
   if (szNum[i]=="")
   {
     continue;
   }
   iNum = Convert.ToInt32(szNum[i]);
   if (!dicKeyValue.ContainsKey(iNum))
   {
     dicKeyValue[iNum] = 1;
   }
   else
   {
     dicKeyValue[iNum]++;
   }
 }

//3.遍历dic,计算结果最大值
int result = 0;
foreach (KeyValuePair<int, int> temp in dicKeyValue)
{
  if (result < temp.Key * temp.Value)
  {
    result = temp.Key * temp.Value;
  }
}
Console.WriteLine("result=" + result);

编辑于 2018-02-25 13:51:05 回复(0)

FansinZhao

遍历一次，将字符串按照字符遍历，使用一个hashmap,如果按照key=数字字符:value=个数保存，同时添加一个最大key=max:value=key保存最大的，,在遍历到最后一个时，取出最大数字字符计算结婚即可

发表于 2017-10-18 10:27:26 回复(0)

牛客288493号

package jianzhioffer;
import java.util.*;
public class Main{
public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);

	while(sc.hasNext()){

		System.out.println(count(sc.next()));
	}
	sc.close();
}
    public static double count(String s){
        int n = s.length();
        if(n==0)return 0;
        HashMap<Double,Integer> map = new HashMap<>();
        
        int pre=0;
for(int i=0;i<n;i++){
if(s.charAt(i)<'A' && (i==n-1 || s.charAt(i+1)>='A')){
	
	double j = pre!=-1?Double.parseDouble(s.substring(pre,i+1)):(double)s.charAt(i)-'0';
int num = map.containsKey(j)?map.get(j):0;   
map.put(j,++num);
pre = -1;
}else if(s.charAt(i)<'A'){if(pre==-1)pre=i;}
else pre=-1;
}    
double res = 0;

for(Double i : map.keySet()){
res = Math.max(i*map.get(i),res);
}
return res;        
}
}

发表于 2017-08-24 11:20:28 回复(0)

liberty_zheng

思路：思路还是比较简单的，先把每一位是数字的下标存储起来，下一步只要判断下标是否是连续数字，如果连续则
组成一个数字，由于无法判断连续是几位所以用递归会容易点，然后把所有数字存储，再根据
其出现频率排序，最后将频率最高的数字乘以其频率。
digit=[]
real_data={}
data=raw_input()
for i in range(len(data)):
    if data[i].isdigit():
        digit.append(i)
j=0
leng=len(digit)
def get_num(data,j):
    if len(data)==0:
        return ''
    temp=data[digit[j]]
    if j==len(digit)-1:
        return temp
    if digit[j]-digit[j+1]==-1:
        return temp+get_num(data,j+1)
    return temp
while j<=leng-1:
    temp=get_num(data,j)
    j+=len(temp)
    temp=int(temp)
    if temp in real_data:
        real_data[temp]=real_data.get(temp)+1
    else:
        real_data[temp]=1
real_data=sorted(real_data.items(),key=lambda x:x[1])
most=real_data[-1]
print most[0]*most[1]

编辑于 2017-08-04 10:50:42 回复(0)

写段代码，定义一个字符串常量，字符串中只有大小写字母和整数，

问题信息

热门推荐

相关试题