精华内容
下载资源
问答
  • 例如:Integer[] NoNum ={1,2,3,5,7,8,9,10,13} 输出的结果为 1-3,5,7-10,13
  • java获取一维数组中连续数字分成几个连续数字数组 比如{12,13,14,23,24,34,45,46,47,48,56} 分成【12,13,14】【23,24】【34】【45,46,47,48】【56】等 public static int[][] getContinuousNumber(int[] array) ...

    java获取一维数组中连续数字分成几个连续的数字数组

    比如{12,13,14,23,24,34,45,46,47,48,56} 分成【12,13,14】【23,24】【34】【45,46,47,48】【56】等

    public static int[][] getContinuousNumber(int[] array)
    	{
    	    int[][]arrays=new int[array.length][array.length];
    	    //二维数组的i和j
    		int i=0;
    		int j=0;
    		//记录当前最大值为数组的第一个,减一是为了保证后面数组的第一个大于最大值,添加进入二维数组
    		int max=array[0]-1;
    		for(int k=0;k<array.length;k++)
    		{
    			//当不是连续数字的时候,放到下一个数组里面,并且把j设置为0,最大值为当前值-1
    			if(array[k]!=max+1)
    			{
    				i++;
    				j=0;
    				max=array[k]-1;
    			}
    			arrays[i][j]=array[k];
    			max=array[k];
    			j++;
    		}
    		return arrays;
    	}

    public static void main(String[] args) {
    		
    		int[] array={12,13,14,23,24,34,45,46,47,48,56};
    		int[][] arrays=lianxushuzi.getContinuousNumber(array);
    		for(int i=0;i<arrays.length;i++)
    		{
    			System.out.println(Arrays.toString(arrays[i]));
    		}
    	}


    针对上面的情况,二维数组太浪费空间,所以采用list方式去获取连续的数字最大的数组。

    这次会获取到【45,46,47,48】

    public static Integer[] getMaxContinuousNumber(int[] array)
    	{
    		ArrayList<Integer> maxArrays=new ArrayList<Integer>();
    		ArrayList<Integer> nowArrays=new ArrayList<Integer>();
    		int max=array[0]-1;
    		for(int i=0;i<array.length;i++)
    		{
    			if(array[i]!=max+1)
    			{
    				max=array[i]-1;
    				nowArrays.clear();
    			}
    			nowArrays.add(array[i]);
    			max=array[i];
    			if(nowArrays.size()>=maxArrays.size())
    			{
    				//maxArrays=nowArrays;这种情况是吧nowdays的地址赋值给了maxarrays的地址,这样以后只要nowarrays的地址改变,maxarrays的值也会改变
    			    maxArrays=(ArrayList<Integer>) nowArrays.clone();
    			}
    		} 
    		return (Integer[]) maxArrays.toArray(new Integer[]{});
    	}

    展开全文
  • 匹配ABC4或者AB44 ,A,B,C为任意不相等数字java中匹配上诉规则应该是怎样的? 正则菜鸟,求解答,谢过
  • java 寻找连续出现的数字

    千次阅读 2013-09-21 01:25:38
    给定数组(where_to_find),给定要寻找的数字(number_to_find) 和 该数字出现的次数(num_of_occs), 若数组中该数字实际出现的次数至少为给定的数字出现的次数,则返回true,反之 false. public ...

    还是学校的数据结构的小作业

    先来看题,

    /**
    	 * Returns true iff the vector passed as argument contains at least 
    	 * the required number of occurrences of the integer passed as argument.
    	 * It returns false otherwise.
    	 * 
    	 * @param  number_to_find  the number we are looking for in the vector
    	 * @param  num_of_occs     the minimum number of consecutive occurrences of number_to_find
    	 * @param  where_to_find   the vector where number_to_find is to be sought for 
    	 * @return true if the number is found consecutively the stated number of times 
    	 */	
    

    给定数组(where_to_find),给定要寻找的数字(number_to_find) 和 该数字出现的次数(num_of_occs),

    若数组中该数字实际出现的次数至少为给定的数字出现的次数,则返回true,反之 false.

    public boolean n_integers(int number_to_find, int num_of_occs, int where_to_find[])


    n integers(1, 2, {1,2,3,3,3})    -------->    false
    n integers(3, 2, {1,2,3,3,3})    -------->    true
    n integers(3, 3, {1,2,3,3,3})    -------->    true
    n integers(3, 4, {1,2,3,3,3})    -------->    false


    package n_Ints;
    
    public class Check_consecutive_integers {
    
    	
    	public boolean n_integers(int number_to_find, int num_of_occs, int where_to_find[]) {
    
    		int n = 0;
    		
    		if(where_to_find.length<num_of_occs)
    			return false;
    		
    		for(int i=0; i<where_to_find.length && n<num_of_occs; i++){
    			if(where_to_find[i]==number_to_find)
    				n++;
    			else
    				n=0;			
    		}
    		
    		return n== num_of_occs;
    	}
    }

    附上Tester

    package n_Ints;
    
    import java.util.Arrays;
    import java.io.BufferedWriter;
    import java.io.FileWriter;
    import java.lang.management.ManagementFactory;
    
    
    public class Tester_1 {
    	static boolean correct = true;
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		
    		try {
    		      String[] ids = ManagementFactory.getRuntimeMXBean().getName()
    			  .split("@");
    		      BufferedWriter bw = new BufferedWriter(new FileWriter("pid"));
    		      bw.write(ids[0]);
    		      bw.close();
    		} catch (Exception e) {
    		    System.out.println("Avisa al profesor de fallo sacando el PID");
    		}
    
    		
    		int s0[] = {0,1,2,3,4,5,6};
    				
    		do_check(3, 1, s0,false);
    		do_check(1, 0, s0,true);
    		do_check(1, 1, s0,true);
    		do_check(1, 6, s0,true);
    		do_check(3, 7, s0,false);
    		do_check(3, 0, s0,false);
    		do_check(1, 7, s0,false);
    		
    		int s1[] = {4,4,4,4,1,2,2,6,6,6,6,6,6,3,3,3,5,5,5,5,5};
    		do_check(0, 0, s1,true);
    		do_check(1, 0, s1,false);
    		
    		do_check(1, 1, s1,true);
    		do_check(2, 1 , s1,false);
    		do_check(3, 1 , s1,false);
    		
    		do_check(0, 2, s1,true);
    		do_check(1, 2, s1,true);
    		do_check(2, 2, s1,true);
    		do_check(3, 2, s1,false);
    		do_check(4, 2, s1,false);
    		
    		do_check(0, 3, s1,true);
    		do_check(2, 3, s1,true);
    		do_check(3, 3, s1,true);
    		do_check(4, 3, s1,false);
    		do_check(5, 3, s1,false);
    		
    		do_check(0, 4, s1,true);
    		do_check(1, 4, s1,true);
    		do_check(2, 4, s1,true);
    		do_check(3, 4, s1,true);
    		do_check(4, 4, s1,true);
    		do_check(5, 4, s1,false);
    		do_check(6, 4, s1,false);
    
    		do_check(0, 5, s1,true);
    		do_check(1, 5, s1,true);
    		do_check(2, 5, s1,true);
    		do_check(3, 5, s1,true);
    		do_check(4, 5, s1,true);
    		do_check(5, 5, s1,true);
    		do_check(6, 5, s1,false);
    		do_check(7, 5, s1,false);
    		
    		do_check(0, 6, s1,true);
    		do_check(1, 6, s1,true);
    		do_check(2, 6, s1,true);
    		do_check(3, 6, s1,true);
    		do_check(4, 6, s1,true);
    		do_check(5, 6, s1,true);
    		do_check(6, 6, s1,true);
    		do_check(7, 6, s1,false);
    		do_check(8, 6, s1,false);
    	
    		do_check(0, 7, s1,true);
    		do_check(1, 7, s1,false);
    		do_check(2, 7, s1,false);
    		do_check(3, 7, s1,false);
    		do_check(4, 7, s1,false);
    		do_check(5, 7, s1,false);
    		do_check(6, 7, s1,false);
    		do_check(7, 7, s1,false);
    		do_check(8, 7, s1,false);
    		
    		if (correct)
    			System.out.println("Test OK.");
    	}
    	
    	static void do_check(int ocs, int num, int vec[], boolean expected) {
    		Check_consecutive_integers checker = new Check_consecutive_integers();
    		if (checker.n_integers(num, ocs, vec) != expected) {
    			System.out.println("The array " + Arrays.toString(vec) + " does not have " + ocs + " occurence(s) of " + num);
    			correct = false;
    		}
    	}
    }
    






    展开全文
  • package hebin; import java.util.ArrayList; ... * 将连续数字合并为一段 * Created by tower on 13-12-29. */ public class MergerDataForSegment { public static void main(String[] arg
    package hebin;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 将连续的数字合并为一段
     * Created by tower on 13-12-29.
     */
    public class MergerDataForSegment {
        public static void main(String[] args) {
            int[] data = {1, 3, 6, 7, 8, 9, 10, 13, 14, 15, 16, 19, 20};
            int size = data.length;
            int curr = -1;
            int next = -1;
            List<Integer> list = new ArrayList<Integer>();
            for (int i = 0; i < size; i++) {
                curr = data[i];
                if (i == 0) {
                    System.out.println(curr);
                    list.add(curr);//第一个元素
                }
                if ((i + 1) == size) {
                    list.add(data[i]);//最后一个元素
                    break;
                }
                next = data[i + 1];
                if (Math.abs((curr - next)) == 1) {
    
                } else {
                    System.out.println(curr + "--" + next);//前一段段尾,后一段段头
                    list.add(curr);
                    list.add(next);
                }
    
            }
            //每2个作为1段
            int total = list.size();
            for (int i = 0; i < total; i++) {
                System.out.print(list.get(i) + " ");
            }
        }
    }
    


    展开全文
  • java多线程连续打印字母数字问题

    千次阅读 2016-08-10 20:08:33
    //2.写两个线程,一个线程打印1-52,另一个线程答应字母A-Z。...//数字每打印两个或字母每打印一个就执行o.wait()。在o.wait()之前不要忘了写o.notify() package homework2; import com.sun.swing
    //2.写两个线程,一个线程打印1-52,另一个线程答应字母A-Z。
    //打印顺序为12A34B56C……5152Z。通过使用线程之间的通信协调关系。
    //注:分别给两个对象构造一个对象o,

    //数字每打印两个或字母每打印一个就执行o.wait()。在o.wait()之前不要忘了写o.notify()


    package homework2;
    
    import com.sun.swing.internal.plaf.synth.resources.synth;
    
    public class Test2 {
    public static void main(String[] args) {
    	Object object = new Object();
    	shuzi shuzi = new shuzi(object);
    	zimu zimu = new zimu(object);
    	Thread t = new Thread(shuzi);
    	Thread t1 = new Thread(zimu);
    	t.start();//数字线程先运行
    	t1.start();
    }
    }
    class shuzi implements Runnable{
         private Object object;
         //声明类的引用
    	public shuzi(Object object) {
    		this.object = object;
    	}
    
    	public void run() {
    	   synchronized (object) {//上锁
    		for(int i=1;i<53;i++){
    			System.out.print(i);
    			if(i%2==0){
    				object.notifyAll();//唤醒线程
    				try {
    					object.wait();
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    	}
    	
    }
    
    class zimu implements Runnable{
    	private Object object;
    	public zimu(Object object) {
    	
    		this.object = object;
    	}
    	public void run() {
    		synchronized (object) {
    			for(int j=65;j<91;j++){
    				char c = (char)j;
    				System.out.print(c);
    				object.notifyAll();
    				try {
    					object.wait();
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    	
    }




    方法2:

    public class Test {
    	public static void main(String[] args) {
            O o = new O();
            A a = new A(o);
            B b = new B(o);
            Thread t = new Thread(a);
            Thread t1 = new Thread(b);
            t.start();//数字的线程先运行
            t1.start();
             
    	}
    }
    class O{
    	boolean flag = false;//没有
    	public synchronized void set() throws InterruptedException{
    		for(int i=1;i<52;i++){
    			if(this.flag == true){
    				this.wait();
    			}
    			if(i%2==0){
    			this.flag=true;
    			this.notifyAll();
    			}
    			System.out.print(i);
    		}
    		
    	}
    	public synchronized void get() throws InterruptedException{
    		for(int j =65;j<91;j++){
    			if(this.flag == false){
    				this.wait();
    			}
    			char c = (char)j;
    			System.out.print(c);
    			this.flag = false;
    			this.notify();
    		}
    	}
    }
    class A implements Runnable{
        O o = new O();
        
    	public A(O o) {
    		super();
    		this.o = o;
    	}
    
    	public void run() {
    		try {
    			o.set();
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    	}
    	
    }
    class B implements Runnable{
    	O o = new O();
    	
    public B(O o) {
    		super();
    		this.o = o;
    	}
    
    public void run() {
    	try {
    		o.get();
    	} catch (InterruptedException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	}
    	
    }
    }


    展开全文
  • 示例:"1abc123abc123" 处理之后为 "1... 2、 依次找出一个连续数字串的头尾下标  3、找到一组头尾下标后就执行一次swap(char[] ch, int start, int end),这个函数的作用是使数组ch,索引start~end的范围内元素反转。
  • 怎么取得整型数组中连续相同的数字并输出打印,用java实现,也就是输出副本,只输出那些连续相同的数字
  • 读入一个字符串str,输出字符串str中的连续最长的数字串 输入描述: 个测试输入包含1个测试用例,一个字符串str,长度不超过255。 输出描述: 在一行内输出str中里连续最长的数字串。 示例1 输入 abcd...
  • Java篇—字符串中连续最长的数字

    千次阅读 2019-08-13 11:54:07
    读入一个字符串str,输出字符串str中连续最长的数字串 输入描述: 每个测试输入包含1个测试用例,一个字符串str,长度不超过255。 输出描述: 在一行内输出str中里连续最长的数字串和长度。 输入样例: abcd...
  • )){ System.out.println("包含15位连续数字,并且包含注册号"); }[/color]
  • java实现递归连续

    万次阅读 多人点赞 2019-07-30 08:53:08
    递归连续数 以下程序打印出0~9的数字,请补充缺少的代码。 public class MyTest { public static void f(int begin, int end) { __________________; System.out.println(begin); f(begin+1, end); ...
  • ![图片说明]... 如上图所示 6x7的矩阵 某一条斜线上含有4个连续相同的1 诸如此类的,如何判断 传递需要连续相同数字的个数 num 返回布尔值即可 public static boolean checkDiagonal(int number){ ...... }
  • java实现不连续处断开

    万次阅读 多人点赞 2019-07-30 08:48:50
    连续处断开 下列代码运行结果为: ...即把一个串从数字连续的位置断开。试完善之。 String s = "12345234568923456789"; String t = "1"; for(int i=1; i<s.length(); i++) { if(s.charAt(i)==s.charA...
  • import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.Arrays; public class NumberSplit { public StringBuffer getString(String str) {  StringBuffer strbuf = new ...
  • 牛课题:字符串中找出连续最长的数字串 题目描述: 读入一个字符串str,输出字符串str中的连续最长的数字串 输入描述: 个测试输入包含1个测试用例,一个字符串str,长度不超过255。输出描述: 在一行内输出str...
  • Java 数字格式化

    千次阅读 2014-12-25 11:51:56
    java.text.NumberFormat 是所有数值格式的抽象基类。 该类提供了格式化和分析数值的接口。 NumberFormat 也提供了确定哪个语言环境具有数值格式以及它们名字的方法。 double myNumber = 23323.3323232323; ...
  • * 不能全是相同的数字或者字母(如:000000、111111、aaaaaa) * @param str str.length()>0 * @return 全部相同返回true */ public static boolean equalStr(String numOrStr){ boolean flag =...
  • Java字符串排序中文+数字

    万次阅读 2013-09-15 16:34:49
    编写日期: 2013年9月15日 ... 解决思路: 在Java中,排序需要...1. 使用正则表达式来判断数字,多个连续数字作为一组, 2. 一次检索出数字组合, 3. 检出下一组数字,如果有,则进入步骤4,否则进入步骤6. 4. 如果两组
  • java实现连续数的公倍数

    万次阅读 多人点赞 2019-07-30 08:58:11
    但也并非纯粹的偶然:60是个优秀的数字,它的因子比较多。 事实上,它是1至6的每个数字的倍数。即1,2,3,4,5,6都是可以除尽60。 我们希望寻找到能除尽1至n的的每个数字的最小整数。 不要小看这个数字,它可能十分大,...
  • 给定一个int数组,写一个函数判断该数组中的所有数字是否能组成连续数字。如[1,3,4,6,2,5]能组成连续数字,【1,2,5,4,7】不能。数组中的数也可能重复 。 代码: public static boolean lianxu1(int []intArr)
  • 求字符串中相邻数字的长度,比如“qw123gh3456”返回4,“2345”返回3 数字必须是相邻的。 //推荐测试数据  127, 12456, we1we, we1235rt56 public static StringBuffer getContinuousNumber(String str) ...
  • Java数字金额大写转换

    千次阅读 2013-04-21 17:44:24
    需求:读入一个浮点数值,将其转化为中文金额的大写形式。...2.当金额中含有连续的0时,只需写一个“零”即可。如10005表示为:壹万零伍元整。3.10的表示形式。如120表示为:壹佰贰拾元整。而10则表示为:拾元整。
  • 输入5个数字,如果数组中有0则0可以替代任何数字,判断该数组中的数字是否是连续数字
  • 从一副扑克中随机抽取5张牌,判断是不是顺子(5张牌数字连续,大小王为任意数字)。 代码 import java.util.Arrays; import java.util.Random; /** * Created by GuanDS on 2018/8/23. */ public class Check5...
  • java判断数字0-9输入的次数

    千次阅读 2018-11-05 21:01:43
    import java.util.Scanner; public class Count_numbers { public static void main(String[] args) { Scanner in = new Scanner(System.in); int[] Numbers = new int[10]; int x = ...
  • java获取数组连续相同元素下标

    千次阅读 2016-07-01 14:14:02
    java判断数组连续相同项以及不连续的项下标

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 90,944
精华内容 36,377
关键字:

java比较数字是连续

java 订阅