绝对值最小--Java实现

题目详情

给你一个数组A[n],请你计算出ans=min(|A[i]+A[j]|)(0<=i,j<n).

例如:A={1, 4, -3},

则:

|A[0] + A[0]| = |1 + 1| = 2.

|A[0] + A[1]| = |1 + 4| = 5.

|A[0] + A[2]| = |1 + (-3)| = 2.

|A[1] + A[1]| = |4 + 4| = 8.

|A[1] + A[2]| = |4 + (-3)| = 1.

|A[2] + A[2]| = |(-3) + (-3)| = 6.

所以ans=1.

输入描述:

有多组测数数据,每组数据有两行,第一行包含一个正整数n(0<n<=100000),第二行包含n个整数,分别表示A[0],A[1],A[2],....,A[n-1],(|A[i]|<2^30)。

输入以文件结束。

输出描述:

对于每组数据,输出相应的答案。

答题说明

输入样例:

3

1 4 -3

1

2

3

-1 -2 -5

3

1 2 3

2

0 5

输出样例:

1

4

2

2

0

实现思路:

1.穷举思路:

对数组中每对数值的和的绝对值进行比较,选出最小的。本来以为这样为超时,但没想到通过了。。。

Java代码:

代码获取地址:https://github.com/liuhao123/ACM

package com.liuhao.acm.csdn;

import java.io.BufferedInputStream;
import java.util.Scanner;

/**
 * @author liuhao
 * 绝对值最小
 * 给你一个数组A[n],请你计算出ans=min(|A[i]+A[j]|)(0<=i,j<n).
 */
public class MinAbsoluteValue2 {

	public static void main(String[] args) {

		Scanner sc = new Scanner(new BufferedInputStream(System.in));

		while(sc.hasNext()){
			int n = sc.nextInt();
			int[] inputArr = new int[n];

			for(int i=0; i<n;i++){
				inputArr[i] = sc.nextInt();
			}

			System.out.println(minAbsoluteValue(inputArr));
		}

		sc.close();

//		//测试数据
//		int[] testArr1 = {1,2,3,4,23,45,67,4};
//		int[] testArr2 = {-32,-34,-53,-354,-67};
//		int[] testArr3 = {1,2,3,4,23,45,67,0,-32,-34,6,-53,-354,-67};
//		int[] testArr4 = {1,2,3,4,23,45,67,-32,-34,6,-53,-354,-67};
//		int[] testArr5 = {1,2,3,4,23,45,67,-32,-34,6,-53,-354,-68};
//
//		System.out.println(minAbsoluteValue(testArr1));
//		System.out.println(minAbsoluteValue(testArr2));
//		System.out.println(minAbsoluteValue(testArr3));
//		System.out.println(minAbsoluteValue(testArr4));
//		System.out.println(minAbsoluteValue(testArr5));

	}

	private static int minAbsoluteValue(int[] inputArr){

		int ans = Math.abs(2 * inputArr[0]);

		for(int i=0;i<inputArr.length;i++){
			for(int j=i; j<inputArr.length;j++){
				if(ans > Math.abs(inputArr[i] + inputArr[j])){
					ans = Math.abs(inputArr[i] + inputArr[j]);
				}
			}
		}

		return ans;
	}

}

2.对数组中的数据进行分析

若数组中有0,则结果肯定为0;

否则,若全是正数或全是负数,则结果是其中的绝对值最小的;

若既有正数又有负数,那么再进行思路1中的步骤。

Java代码:

package com.liuhao.acm.csdn;

import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Scanner;

/**
 * @author liuhao
 * 绝对值最小
 * 给你一个数组A[n],请你计算出ans=min(|A[i]+A[j]|)(0<=i,j<n).
 */
public class MinAbsoluteValue {

	public static void main(String[] args) {

		Scanner sc = new Scanner(new BufferedInputStream(System.in));

		while(sc.hasNext()){
			int n = sc.nextInt();
			int[] inputArr = new int[n];

			for(int i=0; i<n;i++){
				inputArr[i] = sc.nextInt();
			}

			System.out.println(minAbsoluteValue(inputArr));
		}

		sc.close();

//		//测试数据
//		int[] testArr1 = {1,2,3,4,23,45,67,4};
//		int[] testArr2 = {-32,-34,-53,-354,-67};
//		int[] testArr3 = {1,2,3,4,23,45,67,0,-32,-34,6,-53,-354,-67};
//		int[] testArr4 = {1,2,3,4,23,45,67,-32,-34,6,-53,-354,-67};
//		int[] testArr5 = {1,2,3,4,23,45,67,-32,-34,6,-53,-354,-68};
//
//		System.out.println(minAbsoluteValue(testArr1));
//		System.out.println(minAbsoluteValue(testArr2));
//		System.out.println(minAbsoluteValue(testArr3));
//		System.out.println(minAbsoluteValue(testArr4));
//		System.out.println(minAbsoluteValue(testArr5));

	}

	private static int minAbsoluteValue(int[] inputArr){

		Arrays.sort(inputArr);

		//若数组中包含0,则最小值肯定是0
		if(Arrays.binarySearch(inputArr, 0) >= 0){
			return 0;
		}else{

			//若原数组全为正数,那么最小值就是正数组之中的最小值*2
			if(-1 - Arrays.binarySearch(inputArr, 0) == 0){
				return 2 * inputArr[0];
			}
			//若全为负数,则最小值肯定是负数组之中最大值*-2
			else if(-1 - Arrays.binarySearch(inputArr, 0) == inputArr.length){
				return -2 * inputArr[inputArr.length-1];
			}
			//既有正数又有负数
			else{
				int ans = Math.abs(2 * inputArr[0]);

				for(int i=0;i<inputArr.length;i++){
					for(int j=i; j<inputArr.length;j++){
						if(ans > Math.abs(inputArr[i] + inputArr[j])){
							ans = Math.abs(inputArr[i] + inputArr[j]);
						}
					}
				}

				return ans;
			}
		}
	}

}

代码获取地址:https://github.com/liuhao123/ACM

绝对值最小--Java实现

时间: 2024-09-30 10:24:26

绝对值最小--Java实现的相关文章

百度:求绝对值最小的数

我只是从网上搜集的,下面的代码或许有错误. 看了会Hadoop,和传华聊了会,他说,他们那三等奖8000,:打算要回宿舍了,不经意间看到了这个题,貌似简单,其实还是比较有难度的. 一段时间只能干一件事就行了. 有一个已经排序的数组(升序),数组中可能有正数.负数或0,求数组中元素的绝对值最小的数,要求,不能用顺序比较的方法(复杂度需要小于O(n)),可以使用任何语言实现,例如,数组{-20,-13,-4, 6, 77,200} ,绝对值最小的是-4. 算法实现的基本思路:找到负数和正数的分界点,

绝对值最小

题目描述:  给你一个数组A[n],请你计算出ans=min(|A[i]+A[j]|)(0<=i,j<n). 例如:A={1, 4, -3}, 则: |A[0] + A[0]| = |1 + 1| = 2. |A[0] + A[1]| = |1 + 4| = 5. |A[0] + A[2]| = |1 + (-3)| = 2. |A[1] + A[1]| = |4 + 4| = 8. |A[1] + A[2]| = |4 + (-3)| = 1. |A[2] + A[2]| = |(-3)

[经典面试题]排序数组中绝对值最小元素

[题目] 题目为: 有一个已经排序的数组(升序),数组中可能有正数.负数或0,求数组中元素的绝对值最小的数,要求,不能用顺序比较的方法(复杂度需要小于O(n)),可以使用任何语言实现 例如,数组{-20,-13,-4, 6, 77,200} ,绝对值最小的是-4. [分析] 给定数组是已经排好序的,且是升序,没有重复元素. 一个简单的思路,就是一次性遍历数组,求出数组的元素的绝对值的最小值,这样的时间复杂度为O(n). 但是,这样就浪费了题目的一个条件:数组是已经排好序的.所以,需要对原来的题目

CSDN挑战编程——《绝对值最小》

绝对值最小 题目详情: 给你一个数组A[n],请你计算出ans=min(|A[i]+A[j]|)(0<=i,j<n). 例如:A={1, 4, -3}, 则: |A[0] + A[0]| = |1 + 1| = 2. |A[0] + A[1]| = |1 + 4| = 5. |A[0] + A[2]| = |1 + (-3)| = 2. |A[1] + A[1]| = |4 + 4| = 8. |A[1] + A[2]| = |4 + (-3)| = 1. |A[2] + A[2]| = |(

找出有序数组中绝对值最小的数

问题: 一个有序数组,值有可能有负值,也有可能没有,现需要找出其中绝对值最小的值. 方法1: 遍历数组,找到绝对值最小值,时间复杂度O(n),n为元素个数. 方法2: 二分查找,因为数组有序,可以利用二分查找,时间复杂度O(logn). 分析步骤: 如果第一个数为正数,说明整个数组没有负数,直接返回第一个数 如果最后一个数为负数,说明整个数组没有正数,直接返回最后一个数 数组元素有正有负,说明绝对值最小的元素肯定在正负数交界处,需要二分查找上场: 如果a[mid]<0,因为数组是升序,说明绝对值

A题之绝对值最小问题

时间:2014.05.08 地点:基地 -------------------------------------------------------------------------- 一.题目详情 给你一个数组A[n],请你计算出ans=min(|A[i]+A[j]|)(0<=i,j<n). 例如:A={1, 4, -3}, 则: |A[0] + A[0]| = |1 + 1| = 2. |A[0] + A[1]| = |1 + 4| = 5. |A[0] + A[2]| = |1 +

(笔试题)将数组分成两组,使两组的和的差的绝对值最小

题目: 数组中的数分为两组,给出一个算法,使得两个组的和的差的绝对值最小数组中的数的取值范围是0<x<100,元素个数也是大于0,小于100比如a[]={2,4,5,6,7},得出的两组数{2,4,,6}和{5,7},abs(sum(a1)-sum(a2))=0; 比如{2,5,6,10},abs(sum(2,10)-sum(5,6))=1,所以得出的两组数分别为{2,10}和{5,,6}. 思路: 初看问题,感觉好像是个组合问题,通过暴力穷举解决问题. 但仔细想想,问题可以转换成,从数组中找

整数数组中两两之差绝对值最小的值

题目1: 有一个整数数组,请求出两两之差绝对值最小的值,记住,只要得出最小值即可,不需要求出是哪两个数. 题目2:请求出最小连续子序列绝对值和,也就是求连续子序列之和的绝对值最小值 针对问题1: 方法<1>:暴力的方式.遍历所有的两个数的差,记录最小值.算法的复杂度O(n2) 方法<2>:两个数要想差的绝对值最小,肯定是需要两个数大小相近.故有思路:先对数组进行排序,然后遍历一遍,相邻的数相减,记录绝对值最小的数. 方法<3>:将现在的问题进行转化: 设这个整数数组是a

求数组中绝对值最小的元素

给定一个有序数组a(从小到大排列),数组中的数据有正有负,找出这个数组中的绝对值最小的元素.最先到的自然是从头到尾依次遍历数组中的每个元素,找出绝对值最小的元素.这是最简单的方法,不过它并没有用到数组有序这个特性,现在我们来看看有没有更好的方法.题目要求在数组中查找元素,并且此数组有序,那么可以想到用二分法来处理. 首先我们先看一下如果数组中元素全部为正数或者全部为负数的情况: 如果a[0]>0,那么数组中所有元素均为正数,则a[0]为绝对值最小的元素 如果a[len-1]<0,那么数组中所有