Arrays 最小唯一数组和
我得到了一个面试问题，我的算法只通过了给定的示例测试用例，并没有通过所有的测试用例 问题：给定一个已排序的整数数组，通过向重复元素添加一些数字以使唯一元素的和最小，返回数组的和，从而使每个元素都是唯一的 即，如果数组中的所有元素都是唯一的，则返回总和。 如果某些元素是重复的，则增加它们以确保所有元素都是唯一的，从而使这些唯一元素的总和最小 一些示例：Arrays 最小唯一数组和,arrays,algorithm,Arrays,Algorithm,我得到了一个面试问题，我的算法只通过了给定的示例测试用例，并没有通过所有的测试用例 问题：给定一个已排序的整数数组，通过向重复元素添加一些数字以使唯一元素的和最小，返回数组的和，从而使每个元素都是唯一的 即，如果数组中的所有元素都是唯一的，则返回总和。 如果某些元素是重复的，则增加它们以确保所有元素都是唯一的，从而使这些唯一元素的总和最小 一些示例： input1[]={2,3,4,5}=>返回19=2+3+4+5（所有元素都是唯一的，所以只需将它们相加） input2[]={1,2,2}=>
=>input1[]={2,3,4,5}
=2+3+4+5（所有元素都是唯一的，所以只需将它们相加）返回19
=>input2[]={1,2,2}
=1+2+3（索引2是重复的，所以增加它）返回6
=>input3[]={2,2,4,5}
=2+3+4+5（索引1是重复的，所以增加它）返回14
static int minUniqueSum(int[] A) {
int n = A.length;
int sum = A[0];
int prev = A[0];
for( int i = 1; i < n; i++ ) {
int curr = A[i];
if( prev == curr ) {
curr = curr+1;
sum += curr;
}
else {
sum += curr;
}
prev = curr;
}
return sum;
}
有些人抱怨这个问题不清楚。我想让你知道这个问题。没有明确说明添加的数字是否只允许正数或正数和负数。给出三个输入和输出示例，以及一些您不允许看到的其他输入和输出案例，编写一个程序来传递所有其他未看到的输入/输出案例。这就是问题所在。例如，在重复值较多的情况下，您的算法将失败 二,二,二 你会得到7而不是9 使用您的算法的最小修复是：
static int minUniqueSum(int[] A) {
int n = A.length;
int sum = A[0];
int prev = A[0];
for( int i = 1; i < n; i++ ) {
int curr = A[i];
if( prev >= curr ) {
curr = prev+1;
}
sum += curr;
prev = curr;
}
return sum;
}
static int minUniqueSum（int[]A）{
int n=A.长度；
整数和=A[0]；
int-prev=A[0]；
对于（int i=1；i=当前）{
curr=prev+1；
}
总和+=货币；
上一次=当前；
}
回报金额；
}
*正如注释中指出的，无需对已排序的数组进行排序。如果允许向任何输入添加负值，则最小值仅为第N个三角形数，其中N是数组中的元素数。（我假设我们只处理调整后数组的正数，因为我们可以使它任意小（负数） 因此，您的算法只是寻找一对相同的连续值。如果未找到，则返回总和else
N*（N+1）/2相反，如果只有重复的元素可以调整，那么方法是在连续元素之间找到漏洞，并用以前“排队”的值填充它们元素是不相关的，只需要一个计数器。下面是一个C#解决方案，我假设对元素的调整必须是正值。这意味着我们不能倒退并填补未使用的漏洞，从而简化了问题
int F()
{
int[] a = {2, 2, 2, 3, 8, 9}; // sorted list
int n = 0; /* num */ int p = 0; /* prev; zero is an invalid value in the list */
int q = 0; /* queue */ int s = 0; /* sum */
for (int i = 1; i < a.Length; i++)
{
n = a[i];
if (n == p)
q++; // increment queue on duplicate number
else
{
// for every hole between array values, decrement queue and add to the sum
for (int j = 1; q > 0 && j < n - p; j++, q--)
s += p + j;
s += (p = n);
}
}
// flush the queue
for (; q > 0; q--)
s += ++n;
return s;
}
inta[]={1,2,2,3,5,6,6,6}；那么数组中的元素和是什么呢
根据上述问题陈述，它将是{1,2,3,4,5,6,7,8,9}
解决方案
公共静态无效唯一和（）{
int a[]={1,2,2,3,5,6,6,6,6}；
int n=a.长度；
整数和=a[0]；
int-prv=a[0]；
对于（inti=1；i您可以尝试以下代码
int a[] = {1, 1 , 1};
ArrayList<Integer> arr = new ArrayList<Integer>();
HashMap hash = new HashMap();
for(int i=0;i<a.length;i++){
arr.add(a[i]);
}
int sum = 0;
hash.put(0, arr.get(0));
sum = (int) hash.get(0);
for(int i=1;i<arr.size();i++){
for(int j=1;j<=a.length;j++){
if(hash.containsValue((arr.get(i)))){
arr.set(i, arr.get(i)+1);
}else{
hash.put(i, arr.get(i));
sum += (int) hash.get(i);
break;
}
}
}
System.out.println(sum);
inta[]={1,1,1}；
ArrayList arr=新的ArrayList（）；
HashMap hash=新的HashMap（）；
对于（inti=0；ipublicstaticintminsum（intarr[]）{
for（int i=0；i在java中使用集合有很大帮助，
这里我使用HashMap，因为它存储每个唯一键的值
hashmap中的键是数组元素，值是数组中出现的计数数
package uniquesum;
import java.util.*;
public class Uniquesum {
static HashMap<Integer, Integer> hp = new HashMap<Integer, Integer>();
static int Sum(int arr[]){
int sum=0;
Arrays.sort(arr);
hp.put(arr[0], 1);
for(int i=1; i<arr.length; i++){
if(hp.containsKey(arr[i])){
Integer val = hp.get(arr[i]);
hp.put(arr[i], val+1);
hp.put(arr[i]+val, 1);
}
else{
hp.put(arr[i], 1);
}
}
for(Map.Entry m:hp.entrySet()){
sum = sum + (int)m.getKey();
}
return sum;
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int arr[] = new int [n];
for(int i=0; i<n;i++){
arr[i] = scan.nextInt();
}
System.out.println("Sum is " + Sum(arr));
}
}
package uniquesum；
导入java.util.*；
公共类唯一金额{
静态HashMap hp=newhashmap（）；
静态整数和（整数arr[]{
整数和=0；
数组。排序（arr）；
hp.put（arr[0]，1）；
对于（inti=1；i我喜欢这样，没有排序
// Complete the getMinimumUniqueSum function below.
static int getMinimumUniqueSum(int[] arr) {
int sum = 0;
ArrayList < Integer > arrayList = new ArrayList < Integer > (arr.length);
arrayList.add(arr[0]);
for (int i = 1; i < arr.length; i++) {
int val = arr[i];
while (arrayList.contains(val)) {
val++;
}
arrayList.add(val);
}
for (int i = 0; i < arrayList.size(); i++) {
sum += arrayList.get(i);
}
return sum;
}
//完成下面的getMinimumUniqueSum函数。
静态int getMinimumUniqueSum（int[]arr）{
整数和=0；
ArrayListArrayList=新的ArrayList（arr.length）；
arrayList.add（arr[0]）；
对于（int i=1；i
它通过了所有（13）个测试用例。根据您对隐藏I/O的描述，这可能是一个HackerRank测试问题。更好的说明问题的方法是“给定一个排序的数字数组，通过以最小化数组和的方式递增（一次递增num+）使数字不同。”
该问题只允许递增，即一次将一个数字增加1。这也确保数组始终保持排序。
所以{1,2,4,4,7,7,8}-->{1,2,4,5,7,8,9}
这就是解决方案的问题所在。
工作解决方案（JAVA 7）
:
public static int getMinimumUniqueSum（列表arr）{
int sum=0，val=0；
ArrayListArrayList=新的ArrayList（arr.size（））；
arrayList.add（arr.get（0））；
对于（int i=1；i
在JavaScript中
var list = [1, 1, 1, 10, 3, 2];
function minUniqueSum(arr) {
const temp = arr.reduce((acc, cur) => {
while (acc.includes(cur)) cur++;
acc.push(cur);
return acc;
}, []);
console.log(temp); // [1, 2, 3, 10, 4, 5]
return temp.reduce((acc, cur) => acc + cur, 0);
}
var result = minUniqueSum(list);
console.log(result); // 25
虽然此解决方案基于java，但思维过程可以应用于任何地方
您的解决方案几乎是正确和优化的。使用多个for循环将大大降低速度，因此，如果
for(int i=0; i<arr.length-1;i++){
if(arr[i]==arr[i+1]){
arr[i+1]= arr[i+1]+1;
}
}
int sum=0;
for(int i=0; i<arr.length;i++){
sum=sum+arr[i];
}
System.out.println("sum: "+sum);
return sum;
}
package uniquesum;
import java.util.*;
public class Uniquesum {
static HashMap<Integer, Integer> hp = new HashMap<Integer, Integer>();
static int Sum(int arr[]){
int sum=0;
Arrays.sort(arr);
hp.put(arr[0], 1);
for(int i=1; i<arr.length; i++){
if(hp.containsKey(arr[i])){
Integer val = hp.get(arr[i]);
hp.put(arr[i], val+1);
hp.put(arr[i]+val, 1);
}
else{
hp.put(arr[i], 1);
}
}
for(Map.Entry m:hp.entrySet()){
sum = sum + (int)m.getKey();
}
return sum;
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int arr[] = new int [n];
for(int i=0; i<n;i++){
arr[i] = scan.nextInt();
}
System.out.println("Sum is " + Sum(arr));
}
}
// Complete the getMinimumUniqueSum function below.
static int getMinimumUniqueSum(int[] arr) {
int sum = 0;
ArrayList < Integer > arrayList = new ArrayList < Integer > (arr.length);
arrayList.add(arr[0]);
for (int i = 1; i < arr.length; i++) {
int val = arr[i];
while (arrayList.contains(val)) {
val++;
}
arrayList.add(val);
}
for (int i = 0; i < arrayList.size(); i++) {
sum += arrayList.get(i);
}
return sum;
}
public static int getMinimumUniqueSum(List <Integer> arr){
int sum = 0, val = 0;
ArrayList < Integer > arrayList = new ArrayList < Integer > (arr.size());
arrayList.add(arr.get(0));
for (int i = 1; i < arr.size(); i++) {
val = arr.get(i);
while (arrayList.contains(val)) {
val++;
}
arrayList.add(val);
}
for (int i = 0; i < arrayList.size(); i++) {
sum += arrayList.get(i);
}
return sum;
}
var list = [1, 1, 1, 10, 3, 2];
function minUniqueSum(arr) {
const temp = arr.reduce((acc, cur) => {
while (acc.includes(cur)) cur++;
acc.push(cur);
return acc;
}, []);
console.log(temp); // [1, 2, 3, 10, 4, 5]
return temp.reduce((acc, cur) => acc + cur, 0);
}
var result = minUniqueSum(list);
console.log(result); // 25
public static double calculateMinSumSorted(int[] input){
double sum = input[0];
long prev = input[0];
long cur;
for(int i = 1 ; i < input.length ; i++){
cur = input[i];
if(cur <= prev){
cur = ++prev;
}
prev = cur;
sum += cur;
}
return sum;
}
@Test
public void testSimpleArray(){
double test1 = muas.calculateMinSumSorted(new int[]{1,2,3,4});
Assert.assertEquals(10, test1, 0.1);
}
@Test
public void testBeginningSameValues(){
double test1 = muas.calculateMinSumSorted(new int[]{2,2,3,4});
Assert.assertEquals(14, test1, 0.1);
}
@Test
public void testEndingSameValues(){
double test1 = muas.calculateMinSumSorted(new int[]{1,2,4,4});
Assert.assertEquals(12, test1, 0.1);
}
@Test
public void testAllSameValues(){
double test1 = muas.calculateMinSumSorted(new int[]{1,1,1,1});
Assert.assertEquals(10, test1, 0.1);
}
@Test
public void testOverMaxIntResult(){
double test1 = muas.calculateMinSumSorted(new int[]{1,2,3,3,4,4,4,4,4,Integer.MAX_VALUE});
System.out.println(test1);
Assert.assertEquals(2147483692.0, test1, 0.1);
}
@Test
public void testDoubleMaxIntArray(){
double test1 = muas.calculateMinSumSorted(new int[]{2,2,3,4,5,6,7,8,9, Integer.MAX_VALUE, Integer.MAX_VALUE});
Assert.assertEquals(4294967349.0, test1, 0.1);
}
@Test
public void testDoubleMinIntArray(){
double test1 = muas.calculateMinSumSorted(new int[]{Integer.MIN_VALUE, Integer.MIN_VALUE,2,2,3,4,5,6,7,8,9});
Assert.assertEquals(-4294967241.0, test1, 0.1);
}
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
/* No sorting required. Works even with random list */
public static int getMinUniqueSum(List<Integer> list)
{
Set<Integer> set = new HashSet<Integer>();
int sum = 0;
for (Integer val : list)
{
if(!set.add(val))
{
while(true)
{
Integer temp = val + 1;
if(set.add(temp))
{
sum = sum + temp;
break;
}
}
}
else
{
sum = sum + val;
}
}
return sum;
}
public static void main(String[] args)
{
Scanner s = new Scanner(System.in);
System.out.println("Enter size of the list");
int n = s.nextInt();
List<Integer> list = new ArrayList<Integer>(n);
System.out.println("Enter " + n + " elements of the list");
for(int i = 0; i < n; i++)
list.add(s.nextInt());
s.close();
System.out.println("MinUniqueSum = " + getMinUniqueSum(list));
}
}
countdups _ _ [] = []
countdups first prev (x:xs)
| (prev >= x) && (first /= True) = (prev+1) : countdups False (prev+1) xs
| otherwise = x: countdups False x xs
minsum list = sum $ countdups True 0 (sort list)
[2,3,4,5]
minsum = 14
[1,2,3]
minsum = 6
[2,3,4,5]
minsum = 14
[1,2,3,4,7]
minsum = 17
[1,2,3,4,5,10]
minsum = 25
[1,2,3,4]
minsum= 10
[1,2,3,4,5,6,7,8,9,2147483647]
minsum= 2147483692