大家一起来做题目--求独立数的个数

Question

我先来一个，题目没有标准答案，仁者见仁，智者见智，一起学习交流～～～public class Arrays {

public static int seqSearch(int[] arr, int first, int last, int target) {
   // 在[first,last)的范围内遍历数组，如果有值与target匹配，则返回索引值，
   // 否则返回-1
   for (int i = first; i < last; i++)
    if (arr[i] == target)
     return i;
   // 如果没有return，没有匹配成功，则返回-1
   return -1;
}

public static boolean isUnique(int []arr,int target){ //判断一个数是否为独立数
int index=Arrays.seqSearch(arr, 0, arr.length, target);  
//找到这个数的第一个索引，这个数必定存在，因为它本来就是这个数组里的一个数
int index1=Arrays.seqSearch(arr, index+1, arr.length, target);
//看看是否存在第二个这样的数，如果存在，则不是独立数，否则是独立数
if(index1==-1)
return true;
return false;
}

public static int numUnique(int []arr){ //求出一个数组里的独立数个数
int uniqueNum=0;  //定义一个累加器
for(int i=0;i<arr.length;i++)  //依次遍历
if(Arrays.isUnique(arr, arr[i]))
uniqueNum++;
return uniqueNum;
}

public static void main(String args[]){ //测试
int []intVals={3,1,5,1,9,5,7,2,3,8,4};
System.out.println(numUnique(intVals));
}
}

Answer 1

看看我的吧：public class Test1
{    public static void main(String[] args)
    {
        int[] intVals = {3, 1, 5, 1, 9, 5, 7, 2, 3, 8, 4};
        System.out.println(singleNum(intVals));
    }    public static int singleNum(int[] num)
    {
        int flag = 0, sum = 0;
        for (int a : num)
        {
            for (int i = 0; i < num.length; i++)
            {
                if (num[i] == a)
                {
                    flag++;
                }
            }
            if (1 == flag)
            {
                sum++;
            }
            flag = 0;
        }
        return sum;    }
}

Answer 2

public class Single{
public static void main(String args[]){
Int [] temp = {1,2,3,5,2,4,6,2,5,3,2,4};
temp = getnums(temp); } private Int[] getnums(int[] temp ){
String s = temp.toString();
str = str.replaceAll("(?s)(.)(?=.*\\1)", ""); } }

Answer 3

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;public class Test {
public static void main(String args[]) {
int[] intVals = { 3, 1, 5, 1, 9, 5, 7, 2, 3, 8, 4 };
System.out.println("非独立数：" + Arrays.toString(getNums(intVals)));
} private static int[] getNums(int[] intVals) {
Set<Integer> allSet = new HashSet<Integer>();
Set<Integer> repeatSet = new HashSet<Integer>();
for (int i : intVals) {
if (!allSet.add(i)) {
repeatSet.add(i);
}
}
allSet.removeAll(repeatSet);
int[] result = new int[allSet.size()];
Integer[] temp = allSet.toArray(new Integer[allSet.size()]);
for (int i = 0; i < result.length; i++) {
result[i] = temp[i];
}
return result;
}
}

Answer 4

这就是Java区处C++区的区别。

Answer 5

随便写写,简单实现,不考虑其他
public class Dulishu {
private int count=0;//计数器,计算有多少个非独立数

public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
/**
 * 计算非独立数个数
 * @param d
 */
public void findDulishu(int d[]){
for(int i = 0; i < d.length; i++){
for(int j = i+1; j < d.length; j++){
//判断是否是非独立数
if(d[i] == d[j]){
// System.out.println("相等的数是: " + d[j]);
count++;//是,计数器加1
break;//是,跳出此循环
}
}
}
}


public static void main(String[] args){
Dulishu dulishu = new Dulishu();

int []intVals={3,1,5,1,9,5,7,2,3,8,4};
int count;
dulishu.findDulishu(intVals);
// System.out.println("intVals length is : " + intVals.length);
count = intVals.length - dulishu.getCount();//计算有多少独立数
// System.out.println("dulishu count is : " + dulishu.getCount());
System.out.println("intVals 中独立数个数是: " + count);

}
}

Answer 6

其实数据结构里处理分成有序数据处理、无序数据处理。有序数据处理比较常见，一般先排序后处理。无需数据处理里最常见的是用hash法，也有针对特定情况的无需排序即可处理的方案。另外在数据量特别小的时候，一般不值得做排序。

Answer 7

int []intVals={3,1,5,1,9,5,7,2,3,8,4};
int flag = 0;
int count = 0;
for(int i=0;i<intVals.length;i++){
for(int j=0;j<intVals.length;j++){
if(intVals[i]==intVals[j]){
flag ++;
}
if(flag >=2){
break;
}
}
if(flag < 2){
count++;
}
flag = 0;
}
System.out.println(count);
这感觉这样做没效率呀。

Answer 8

[code=Java ] 
int[] intVals = {3, 1, 5, 1, 9, 5, 7, 2, 3, 8, 4};
int size = intVals.length;
List[] judge = new List[size];
int count = 0; //记录独立数的个数
for (int i = 0; i < intVals.length; i++) {
int index = intVals[i] % size;
if(judge[index] == null){
judge[index] = new ArrayList<Integer>();
judge[index].add(intVals[i]);
count++;
}
else{
int sameIndex = 0;
for (int j = 0; j < judge[index].size(); j++) {
if(intVals[i] == (Integer)(judge[index].get(j))){
count--;
sameIndex = 1;
break;
}
}
if(sameIndex == 0){
count++;
}
}
}
System.out.println("记录独立数的个数: " +count);
[/code]

Answer 9

int [] a={3,1,5,1,9,5,7,2,3,8,4};
int [] b=new int [a.length];
for(int index:a)
{
b[index]++;
}
int index=0;
do
{
if(b[index]==1)
System.out.println("This is XXX number :"+index);
index++;
}while(index<a.length);

Answer 10

int [] a={3,1,5,1,9,5,7,2,3,8,4};
int [] b=new int [a.length];
for(int index:a)
{
b[index]++;
}
int index=0;
do
{
if(b[index]==1)
System.out.println("This is XXX number :"+index);
}while(++index<a.length);

Answer 11

public static void main(String[] args) {
        int []intVals={3,1,5,1,4,3,4,5,9};
        Set set=new HashSet();
        int length=intVals.length;
        int temp=length;
        int num=0;
        int setLength=0;
        for(int i=0;i<length;i++)
        {
            setLength=set.size();
            set.add(intVals[i]);
            if(set.size()==setLength)
            {
                num=temp-2;
                temp=temp-2;
            }
        }
        System.out.println(num);
    }

Answer 12

想法不错，不过没考虑周全
如果是这样呢？ int [] a={100,1,5,1,9,5,7,2,3,8,4}楼主在坛子里搜一下，会找到好答案的

Answer 13

这是我的：import java.util.HashMap;
import java.util.Map;public class Test1 {
public static void main(String[] args) { int[] temp = {1,2,3,4,2,3,1,34,4,3,42,345,3,6};
System.out.println(Test1.getOneS(temp));
}

public static int getOneS(int[] values){
int num = 0;
Map<String,Integer> map = new HashMap<String,Integer>();
for(int temp:values){
String srttemp = "" + temp;
map.put(srttemp, map.get(srttemp) == null?new Integer(1):map.get(srttemp) + 1);
}
for(String sKey:map.keySet()){
if(map.get(sKey).intValue() == 1) num++;
}
return num;
}
}

Answer 14

        //最笨的循环
public void GetCount() {
int[] intVals={3,1,5,1,9,5,7,2,3,8,4};
for (int i = 0,count=0; i < intVals.length; i++,count=0) {
for (int j = 0; j < intVals.length; j++) {
if (intVals[i]-intVals[j]==0)
{
count++;
}
}
if (count==1) {
System.out.println("独立数:"+intVals[i]);
}
}

}

Answer 15

哈哈。。新方法：public static int fun(int []a){
List list = new LinkedList();
Set set = new TreeSet();
for(int i=0;i<a.length;i++){
int value = a[i];
String valString = String.valueOf(value);
if(!list.contains(valString)){
list.add(valString);
}else{
set.add(valString);
}
}
return list.size()-set.size();
}不知道这样的效率如何。
我验正了一下，发现还是下面这种方法快点。int flag = 0;
int count = 0;
for(int i=0;i<intVals.length;i++){
for(int j=0;j<intVals.length;j++){
if(intVals[i]==intVals[j]){
flag ++;
}
if(flag >=2){
break;
}
}
if(flag < 2){
count++;
}
flag = 0;
}
System.out.println(count);使用的测试数据。int []intVals={3,1,5,1,9,5,7,2,3,8,4,10,22,199,10,20,32,
32,34,56,19,22,100,29,14,3,5,7,122,0,90,34,29,
199,324,85,33,100,22,33,44,55,66,77,88,99,100
,122,23,21,31,41,51,66,77,100,1000,200,133,33,99};

Answer 16

我觉得在第二个循环里面有时不需要循环a.lengh次，因为有重复就可以跳出这个循环开始外面的下一次的循环。