web-dev-qa-db-de.com

Java + Zählt Duplikate aus dem int-Array, ohne eine Collection oder ein anderes zwischengeordnetes Array zu verwenden

Als Teil des Java-Interview-Fragepapiers habe ich folgendes Problem zu lösen: Ich wundere mich jedoch, ob ich es ohne Collection oder Zwischenarray implementieren kann.

Frage: - Duplikate aus dem int-Array zählen, ohne eine Collection oder ein anderes Zwischenarray zu verwenden 

Input values:- {7,2,6,1,4,7,4,5,4,7,7,3, 1}  

Output:- Number of duplicates values: 3
         Duplicates values: 7, 4, 1

Ich habe folgende Lösung implementiert, wurde aber noch nicht abgeschlossen. Hat jemand eine Idee? Vielen Dank.

public static void duplicate(int numbers[]) {

    for (int i = 0; i < numbers.length; i++) {

        boolean duplicate = false;
        int j = 0;

        while (j < i){

            if ((i != j) && numbers[i] == numbers[j]) {
                duplicate = true;
            }

            j++;
        }

        if (duplicate) {
            System.out.print(numbers[i] + " ");
        }
    }
}
8
Channa

Der einfachste Weg, dieses Problem zu lösen, besteht darin, zuerst das Array zu sortieren und dann einfach durch das Array zu gehen und Duplikate zu zählen, wenn Sie auf sie stoßen:

int[] numbers = new int[]{7,2,6,1,4,7,4,5,4,7,7,3,1};
int temp = 0;

// I chose to do a bubble sort of the array,
// but you are free to use any method you wish (e.g. Arrays.sort)
System.out.print("Duplicates values: ");
for (int i=0; i < numbers.length; ++i) {
    for (int j=1; j < (numbers.length - i); ++j) {
        if (numbers[j-1] > numbers[j]) {
            temp = numbers[j-1];
            numbers[j-1] = numbers[j];
            numbers[j] = temp;
        }
    }
}


// walk through the sorted array and count duplicates
int numDup = 0, dupCount = 0;
int previous = -1;
for (int i=0; i < numbers.length; ++i) {
    if (numbers[i] == previous) {
        ++numDup;
        if (numDup == 1) {
            ++dupCount;
            if (dupCount == 1) {
                System.out.print(numbers[i]);
            }
            else {
                System.out.print(", " + numbers[i]);
            }
        }
    }
    else {
        previous = numbers[i];
        numDup = 0;
    }
}

System.out.println("\nNumber of duplicates values: " + dupCount);

Ausgabe:

Duplicates values: 1, 4, 7
Number of duplicates values: 3

Beachten Sie, dass meine Ausgabereihenfolge umgekehrt ist, da Sie das gesamte Array durchlesen müssen, bevor Sie wissen, wie viele Duplikate Sie insgesamt haben. Ich möchte auch darauf hinweisen, dass der einzige Zustand, den diese Lösung verwendet, das Eingabearray selbst ist, und hier und da ein paar int varibles.

Dieser Code wurde in IntelliJ getestet und funktioniert ordnungsgemäß.

8
Tim Biegeleisen

Einverstanden mit Tim @ Tim-Biegeleisen. Nur eine kleine Änderung. Verwenden Sie die Arrays, um das Array zu sortieren.

öffentliche Klasse DuplicateClass {

public static void main(String[] args) {
    int[] values = { 7, 2, 6, 1, 4, 7, 4, 5, 4, 7, 7, 3, 1 };
    duplicate(values);
}

public static void duplicate(int numbers[]) {
    Arrays.sort(numbers);
    int previous = numbers[0] - 1;
    ;
    int dupCount = 0;

    for (int i = 0; i < numbers.length; ++i) {
        if (numbers[i] == previous) {
            ++dupCount;
        } else {
            previous = numbers[i];
        }
    }
    System.out.println("There were " + dupCount + " duplicates in the array.");
}

}

2
Crazy Developer

Das sind alles großartige Antworten. Eine andere ist, ein int/double zu verwenden und seine Bits zu setzen, wenn Sie auf eine Zahl stoßen. Dies funktioniert, wenn die Werte des Arrays je nach verwendetem Typ unter 32/64 liegen. 

Unten sehen Sie ein Beispiel, wie Sie dies mit einer Ganzzahl tun würden. 

public class SetThoseBits{

    // 0000 0000 0000 0000 000 0000 0000 0000
    public static int data = 0; 

    public static void main(String [] args){

        // Gurantee that the numbers are less than 32
        int[] values = { 7, 2, 6, 1, 4, 7, 4, 5, 4, 7, 7, 3, 1 };
        duplicates(values);

    }

    public static void duplicates(int [] values){

        for(int i : values){

            if(testBit(i)){
                System.out.println("Duplicate :" + i);
            } else{
                setBit(i);
            }
            //printBits();
        }

        System.out.println("Finished!");
    }

    // Sets the bit at a specific position
    public static void setBit(int index){
        data = data | (1 << index);
    }

    // This function will test the bit at the index of the given integer
    // If it's set, it returns true
    public static boolean testBit(int index){
        return ((data & (1 << index)) != 0);
    }

    public static void printBits(){

        for (int x = 31; x >= 0; x--){
            if(testBit(x)){
                System.out.print("1");
            } else{
                System.out.print("0");
            }
        }
        System.out.println("0");
    }

}

Ich glaube, dass die anderen Antworten besser sind, wenn Sie Ihre Frage beantworten. Aber als Alternative zu demonstrieren, zeigen Sie, dass Sie dynamisch darüber nachdenken. Wenn sich die Anforderungen der Frage etwas geändert haben, könnte diese Antwort angemessener sein. 

Wenn Sie nur die Duplikate bei geringstem Platzbedarf nachverfolgen müssen, können Sie etwas Ähnliches wie oben ausführen oder die BitSet-Klasse von Java verwenden, um Ihnen das Leben zu erleichtern. 

http://docs.Oracle.com/javase/7/docs/api/Java/util/BitSet.html

Edit: Es ist auch möglich, Werte über 64 zu setzen, wenn Sie eine Funktion erstellen, die ein Byte-Array wie die BitSet-Klasse enthält. Für diese genaue Frage ist dies nicht hilfreich, da es nicht erforderlich ist, ein Array oder eine Sammlung zu verwenden. 

1
Pumphouse

Ich denke, das ist auch eine Möglichkeit, es zu berechnen:

public class App {
    public static void main(String[] args) {
        Integer[] intArr = { 7, 2, 6, 1, 4, 7, 4 };
        List<Integer> listInt = Arrays.asList(intArr);

        Map<Integer, Integer> map = new HashMap<>();
        Integer dupCount = 0;
        StringBuilder dupvalues = new StringBuilder();

        for (Integer integer : intArr) {
            int times = Collections.frequency(listInt, integer);
            if (map.containsKey(integer)) {
                dupvalues.append(integer).append(",");
                dupCount++;
            } else
                map.put(integer, times);
        }
        System.out.println("There were " + dupCount + " duplicates in the array. The value are : "+dupvalues);
    }
}
0
user5778069

Es gibt eine Methode, mit der Sie Math.abs verwenden können. Sie sollten das Vorzeichen positiv überprüfen. Wenn es positiv ist, machen Sie es negativ. Wenn negativ, ist dies die duplizierte Nummer oder die wiederholte Nummer. Beispiel: A [] = {1, 1, 2, 3, 2} I = 0; Überprüfen Sie das Vorzeichen von A [abs (A [0])], das ist A [1]. A [1] ist positiv, also mache es negativ. Array wird jetzt zu {1, -1, 2, 3, 2}

i = 1; Überprüfen Sie das Vorzeichen von A [abs (A [1])], das ist A [1]. A [1] ist negativ, also ist A [1] eine Wiederholung. Dann fügen Sie einfach all diese wiederholten Zahlen in eine Liste ein und drucken Sie die Größe der Liste.

Der Code in Python lautet 

    from astropy.extern.ply.cpp import xrange
def printrepeat(arr):
    print("The repeating elements are: ")
    list =[]
    for i in xrange(0,len(arr)):
        ch = abs(arr[i])

        if arr[ch] > 0:
            arr[ch] = (-1)*arr[ch];

        else: list.append(arr[ch])

    print(len(list))    




# driver code

arr = [1 , 3 , 2 , 2 , 1,3]
printrepeat(arr)            

Lösung 2: 2 Zeiger nehmen

class Abc1{
    public static void main(String[] args) {

   int[] a = {1, 1, 2, 3, 2};
   countDuplicates(a);
}

    private static void countDuplicates(int[] a) {
        int c = 0 ;
        for(int  i = 0 ; i < a.length ; i++) {

            for(int j = i+1 ; j < a.length;j++) {
                if(a[i] == a[j]) {c++ ;}
            }//for
        }//for1
        System.out.println("dup => " + c);
    }

}

Lösung 3: HashSet

class Abc1{
    public static void main(String[] args) {

  String a = "Gini Gina Protijayi";
   countDuplicates(a);
}

    private static void countDuplicates(String aa) {
        List<Character> list= new ArrayList<>();
       Set<Character> set = new HashSet<>();
       // remove all the whitespaces 
       String a = aa.replaceAll("\\s+","");
       for(  char ch : a.toCharArray()) {

           if(!set.contains(ch)) {
               set.add(ch);
           }//if
           else {if(!list.contains(ch) ) {list.add(ch);}      }
       }//for
       System.out.println("number of duplicate characters in the string =>" + list.size());
       System.out.println(list);
    }

}

Lösung: 4 (dasselbe Konzept wie Lösung 1, aber der Code ist in Java)

import Java.util.ArrayList;
import Java.util.List;

public class AA {

    public static void main(String[] args) {
         int a[] = {4, 2, 4, 5, 2, 3, 1};
         printRepeat(a);


    }

    private static void printRepeat(int[] a) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < a.length; i++) {
            if( a[Math.abs(a[i])]  > 0) {
                a[Math.abs(a[i])] = (-1)*  a[Math.abs(a[i])] ; 
            }//if
            else {
                System.out.println( "Duplicate numbers => " + Math.abs(a[i])         );
                list.add(Math.abs(a[i]));
                System.out.println("list => " + list);
                System.out.println("list.size() or the count of duplicates => " + list.size());
            }//else

        }//for

    }//print
    }
0
Soudipta Dutta

Beibehalten einer zusätzlichen Variablen zum Verwalten der Zählung sowie Sortierung des Arrays in der Anfangsphase.

public static void main(String[] args) {
        int[] numbers = { 7, 2, 6, 1, 4, 7, 4, 5, 4, 7, 7, 3, 1 };
        Arrays.sort(numbers);
        System.out.println("Sorted Array is :: = " + Arrays.toString(numbers));

        int count = 0;
        int tempCount = 0; // to keep local count of matched numbers
        String duplicates = "";
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] == numbers[i - 1]) {
                if ((tempCount == 0)) { // If same number is repeated more than
                                        // two times, like 444, 7777
                    count = count + 1;
                    tempCount = tempCount + 1;
                    duplicates = duplicates.concat(Integer.toString(numbers[i])
                            + ",");
                }
            } else {
                tempCount = 0;
            }
        }

        System.out.println("No of duplicates :: = " + count);
        System.out.println("Duplicate Numbers are :: = " + duplicates);
    }

Ausgabe

Sorted Array is :: = [1, 1, 2, 3, 4, 4, 4, 5, 6, 7, 7, 7, 7]
No of duplicates :: = 3
Duplicate Numbers are :: = 1,4,7,
0
Ankur Singhal

Verwenden Sie unterhalb der Methode keine Sammlung, verwenden Sie einfach die Methode Arrays.sort (), um das Array in aufsteigender Reihenfolge als Standard zu sortieren. Beispiel: array = [9,3,9,3,9] sortiert nach [3,3,9,9] , 9]. Wenn Eingabe [9,9,9,9,9], ist das erwartete Ergebnis 1, da nur die wiederholte Anzahl 9 ist. Wenn Eingabe [9,3,9,3,9,255,255,1], ist das erwartete Ergebnis 3 , da wiederholte Zahlen 3,9255 sind. Bei Eingabe von [7,2,6,1,4,7,4,5,4,7,7,3,1] ist das erwartete Ergebnis 3, da wiederholte Zahlen 1,4,7 sind.

public static int findDuplicateCountsInArray(int[] nums) {
    // Sort the input array into default ascending order
    Arrays.sort(nums);
    int prev = nums[0];
    int count = 0;
    // Recording a number already a repeated one
    // e.g [9,9,9] the 3rd 9 will not increase duplicate count again
    boolean numAlreadyRepeated = false;
    for(int i = 1; i < nums.length; i++) {
        if(prev == nums[i] && !numAlreadyRepeated) {
            count++;
            numAlreadyRepeated = true;
        } else if(prev != nums[i]) {
            prev = nums[i];
            numAlreadyRepeated = false;
        }
    }
    return count;
}
0
Lampard

Dies ist die einfachste Lösung, die mir einfällt. Ich habe nur einen zusätzlichen Zähler hinzugefügt, damit Ganzzahlen mit zwei oder mehr Wiederholungen, die sich noch im Array befinden, ignoriert werden.

static int findNumber(int[] arr) 
{  
    int duplicateCounter = 0;

    System.out.print("Duplicates: ");

    for(int i = 0; i < arr.length; i++)
    {
        boolean duplicate = false;
        int numOfOccurrences = 1;

        for (int j = (i+1); j < arr.length; j++)
        {
            if (arr[i] == arr[j])
            {
                numOfOccurrences++;
                duplicate = true;
            }
        }
        if(numOfOccurrences == 2 && duplicate == true)
        {
            duplicateCounter++;
            System.out.print(arr[i] + " ");
        }
    }

    return duplicateCounter;
}

Mein Testlauf: Testlauf

Eingabe: 1, 2, 3, 4, 2, 4, 1, 1, 1

Duplikate: 2 4 1

Anzahl der Duplikate: 3

0
jaymaytay

Hier habe ich Code in Java geschrieben. Auch die eingegebenen Zahlen wurden als String betrachtet. Diese Frage wurde auch CODEWARS hinzugefügt. und ich hoffe diese einfache lösung hilft dir

public class countingduplicates {
  public static void main(String[] args) {
    int i=0,j=0,c=0,a=0;
    String text="7261474547731";
    text=text.toLowerCase();

    for(i=0; i<text.length(); i++) {
      for(j=0; j<text.length(); j++) {
        if(text.charAt(i) == text.charAt(j)) { 
          c++;
        }
      }

      System.out.println(text.charAt(i) + " occured " + c + " times");
      if(c>1) {
        a++;
      }  

      String d = String.valueOf(text.charAt(i)).trim();
      text = text.replaceAll(d,"");
      c = 0;
      i = 0; //cause i have trimmed the string and by default i increases by 1, so i have to assign it =0
      j = 0; //cause i have trimmed the string and by default j increases by 1, so i have to assign it =0
    }
  System.out.println("Total count of Duplicates:" + a);
  }
}
0
Mayank Shekhar
    int numbers[]={7,2,6,1,4,7,4,5,4,7,7,3, 1};
    String temp="";
    int count=0;
    Arrays.sort(numbers);

    for (int i = 0; i < numbers.length; i++) {

        boolean duplicate = false;
        for(int j = 0; j < numbers.length; j++) {
            if ((i != j) && numbers[i] == numbers[j]) {
                duplicate = true;
            }
        }

        if (duplicate) {
            if(!temp.contains(""+numbers[i]))
            {
            temp+=numbers[i]+", ";//adding a number if its duplicate
            count++;//counting unique duplicate number
            }
            System.out.print(numbers[i] + " ");
        }
    }
    System.out.println("\nDuplicates are: "+temp+" count: "+count);

Ausgabe:

 Duplicates are: 1, 4, 7,  count: 3
0
SatyaTNV