Supprimer les doublons du tableau entier
J'ai un problème avec ceci:
Ecrivez une méthode statique nommée removeDuplicates qui prend en entrée un tableau d'entiers et renvoie comme résultat un nouveau tableau d'entiers avec tous les doublons supprimés. Par exemple, si le tableau en entrée contient les éléments {4, 3, 3 , 4, 5, 2, 4} le tableau résultant Doit être {4, 3, 5, 2}
Voici ce que j'ai fait jusqu'à présent
public static int[] removeDuplicates(int []s){
int [] k = new int[s.length];
k[0]=s[0];
int m =1;
for(int i=1;i<s.length;++i){
if(s[i]!=s[i-1]){
k[m]=s[i];
++m;
}//endIF
}//endFori
return k;
}//endMethod
Pour conserver l'ordre et supprimer les doublons dans le tableau d'entiers, vous pouvez essayer ceci:
public void removeDupInIntArray(int[] ints){
Set<Integer> setString = new LinkedHashSet<Integer>();
for(int i=0;i<ints.length;i++){
setString.add(ints[i]);
}
System.out.println(setString);
}
J'espère que cela t'aides.
essaye ça -
public static int[] removeDuplicates(int []s){
int result[] = new int[s.length], j=0;
for (int i : s) {
if(!isExists(result, i))
result[j++] = i;
}
return result;
}
private static boolean isExists(int[] array, int value){
for (int i : array) {
if(i==value)
return true;
}
return false;
}
Tout d’abord, vous devez connaître la longueur sans doublons (doublons): longueur initiale moins le nombre de doublons. Créez ensuite un nouveau tableau de bonne longueur. Vérifiez ensuite chaque élément de la liste [] pour les doublons, si dup found - contrôle l'élément suivant, si dup n'est pas fondé - copie un élément dans un nouveau tableau.
public static int[] eliminateDuplicates(int[] list) {
int newLength = list.length;
// find length w/o duplicates:
for (int i = 1; i < list.length; i++) {
for (int j = 0; j < i; j++) {
if (list[i] == list[j]) { // if duplicate founded then decrease length by 1
newLength--;
break;
}
}
}
int[] newArray = new int[newLength]; // create new array with new length
newArray[0] = list[0]; // 1st element goes to new array
int inx = 1; // index for 2nd element of new array
boolean isDuplicate;
for (int i = 1; i < list.length; i++) {
isDuplicate = false;
for (int j = 0; j < i; j++) {
if (list[i] == list[j]) { // if duplicate founded then change boolean variable and break
isDuplicate = true;
break;
}
}
if (!isDuplicate) { // if it's not duplicate then put it to new array
newArray[inx] = list[i];
inx++;
}
}
return newArray;
}
Vous pouvez peut-être utiliser lambdaj ( télécharger ici , site web ), cette bibliothèque est très puissante pour la gestion des collections (..list, tableaux), le code suivant est très simple et fonctionne parfaitement:
import static ch.lambdaj.Lambda.selectDistinct;
import Java.util.Arrays;
import Java.util.List;
public class DistinctList {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1,3,4,2,1,5,6,8,8,3,4,5,13);
System.out.println("List with duplicates: " + numbers);
System.out.println("List without duplicates: " + selectDistinct(numbers));
}
}
Ce code montre:
List with duplicates: [1, 3, 4, 2, 1, 5, 6, 8, 8, 3, 4, 5, 13]
List without duplicates: [1, 2, 3, 4, 5, 6, 8, 13]
Sur une ligne, vous pouvez obtenir une liste distincte. Il s'agit d'un exemple simple, mais avec cette bibliothèque, vous pouvez en résoudre davantage.
selectDistinct(numbers)
Vous devez ajouter lambdaj-2.4.jar à votre projet. J'espère que cela vous sera utile.
Remarque: Ceci vous aidera à supposer que vous pouvez avoir des alternatives à votre code.
public int[] removeRepetativeInteger(int[] list){
if(list.length == 0){
return null;
}
if(list.length == 1){
return list;
}
ArrayList<Integer> numbers = new ArrayList<>();
for(int i = 0; i< list.length; i++){
if (!numbers.contains(list[i])){
numbers.add(list[i]);
}
}
Iterator<Integer> valueIterator = numbers.iterator();
int[] resultArray = new int[numbers.size()];
int i = 0;
while (valueIterator.hasNext()) {
resultArray[i] = valueIterator.next();
i++;
}
return resultArray;
}
Ce que vous devez faire est de vérifier pour chaque élément du second tableau si l'élément précédent est déjà présent ou non.
Vous pouvez utiliser une meilleure approche Utilisez HashSet et return set.
public static Set removeDuplicates(int []s){
Set<Integer> set = new HashSet<Integer>();
for(int i=0;i<s.length;++i){
set.add(s[i]);
}//endFori
return set;
}//endMethod
Si vous avez besoin de int Array, jetez un coup d'œil à ceci Java-hashsetinteger-int-array link.
Vous pouvez également placer les éléments du tableau dans une variable Set pour laquelle la sémantique précise ne pas contenir d'éléments dupliqués.
Ceci est une question d'entrevue. Question: Supprimez les doublons d'un tableau en place:
public class Solution4 {
public static void main(String[] args) {
int[] a = {1,1,2,3,4,5,6,6,7,8};
int countwithoutDuplicates = lengthofarraywithoutDuplicates(a);
for(int i = 0 ; i < countwithoutDuplicates ; i++) {
System.out.println(a[i] + " ");
}
}
private static int lengthofarraywithoutDuplicates(int[] a) {
int countwithoutDuplicates = 1 ;
for (int i = 1; i < a.length; i++) {
if( a[i] != a[i-1] ) {
a[countwithoutDuplicates++] = a[i];
}//if
}//for
System.out.println("length of array withpout duplicates = >" + countwithoutDuplicates);
return countwithoutDuplicates;
}//lengthofarraywithoutDuplicates
}
En Python:
def lengthwithoutduplicates(nums):
if not nums: return 0
if len(nums) == 1:return 1
# moving backwards from last element i.e.len(a) -1 to first element 0 and step is -1
for i in range(len(nums)-1,0,-1):
# delete the repeated element
if nums[i] == nums[i-1]: del nums[i]
# store the new length of the array without the duplicates in a variable
# and return the variable
l = len(a)
return l
a = [1, 1, 2, 3, 4, 5, 6, 6, 7, 8];
l = lengthwithoutduplicates(a)
for i in range(1,l):print(i)
En Python: lister la compréhension en utilisant énumérer
a = [1, 1, 2, 3, 4, 5, 6, 6, 7, 8]
aa = [ ch for i, ch in enumerate(a) if ch not in a[:i] ]
print(aa) # output => [1, 2, 3, 4, 5, 6, 7, 8]
essaye ça.
int numbers[] = {1,2,3,4,1,2,3,4,5,1,2,3,4};
numbers = Java.util.stream.IntStream.of(numbers).distinct().toArray();
hé tout ce que vous pouvez utiliser ce code que je crée !!!
import Java.util.*;
public class DistinctNumber {
public static void main(String[] args) {
int[] nums= {1,3,2,3,4,3,2,5,4,6};
int [] T2 = duplicate(nums);
for (int i = 0; i < T2.length; i++) {
System.out.println(T2[i]);
}
}
public static boolean exist(int x,int []A){
for (int i = 0; i < A.length; i++) {
if(x==A[i]){
return true;
}
}
return false;
}
public static int [] EliminateDuplicate(int [] numbers){
int [] B = new int[numbers.length];
int i=0,j=0;
for(i=0;i<numbers.length;i++){
if(!exist(numbers[i], B)){
B[j] = numbers[i];
j++;
}
}
int[] C = new int[j];
for (int k = 0; k < C.length; k++) {
C[k] = B[k];
}
return C;
}
}
Essaye ça
public static int[] removeDuplicates(int[] s) {
Integer[] array = new HashSet<Integer>(Arrays.asList(ArrayUtils.toObject(s))).toArray(new Integer[0]);
return ArrayUtils.toPrimitive(array);
}
Edit: Mise à jour avec Apache Lang pour convertir en primitives.
Vous pouvez également utiliser la bibliothèque Google de goyaves et utiliser ImmutableSet do
ImmutableSet.copyOf(myArray).asList();
Parcourez le tableau et remplissez un ensemble car les ensembles ne peuvent pas contenir de doublons. Copiez ensuite les éléments de l'ensemble dans un nouveau tableau et renvoyez-le. Ceci est montré ci-dessous:
public static int[] removeDuplicates(int[] array) {
// add the ints into a set
Set<Integer> set = new HashSet<Integer>();
for (int i = 0; i < array.length; i++) {
set.add(array[i]);
}
// copy the elements from the set into an array
int[] result = new int[set.size()];
int i = 0;
for (Integer u : set) {
result[i++] = u;
}
return result;
}
Vous pouvez faire naïvement cependant. Vous devez d’abord trier le tableau. Vous pouvez le faire en utilisant n'importe lequel des algorithmes de tri. J'ai utilisé le tri rapide. Et puis vérifier une position avec sa prochaine position. S'ils ne sont pas identiques, ajoutez de la valeur dans un nouveau tableau, sinon ignorez cette itération.
Exemple de code (Tri rapide):
public static void quickSort(int[] array, int low, int high) {
int i = low;
int j = high;
int pivot = array[low + (high - low) / 2];
while (i <= j) {
while (array[i] < pivot) i++;
while (array[j] > pivot) j--;
if (i <= j) {
exchange(array, i, j);
i++;
j--;
}
}
if (0 < j) quickSort(array, 0, j);
if (i < high) quickSort(array, i, high);
}
public static void exchange(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
Supprimer les doublons:
public static int[] removeDuplicate(int[] arrays) {
quickSort(arrays, 0, arrays.length - 1);
int[] newArrays = new int[arrays.length];
int count = 0;
for (int i = 0; i < arrays.length - 1; i++) {
if (arrays[i] != arrays[i + 1]) {
newArrays[count] = arrays[i];
count++;
}
}
return newArrays;
}
import Java.util.Arrays;
import Java.util.List;
import Java.util.stream.Collectors;
// Remove duplicates from a list of integers
public class IntegerUtils {
public static void main(String[] args) {
int intArray[] = {1, 2, 4, 2, 67, 4, 9};
List<Integer> uniqueList = removeDuplicates(intArray);
uniqueList.stream().forEach(p -> System.out.println(p));
}
public static List<Integer> removeDuplicates(int[] intArray) {
return Arrays.stream(intArray).boxed().distinct().collect(Collectors.toList());
}
}
public class DistinctNumbers{
public static void main(String[] args){
Java.util.Scanner input = new Java.util.Scanner(System.in);
System.out.print("Enter ten numbers: ");
int[] numbers = new int[10];
for(int i = 0; i < numbers.length; ++i){
numbers[i] = input.nextInt();
}
System.out.println("The distinct numbers are:");
System.out.println(Java.util.Arrays.toString(eliminateDuplicates(numbers)));
}
public static int[] eliminateDuplicates(int[] list){
int[] distinctList = new int[list.length];
boolean isDuplicate = false;
int count = list.length-1;
for(int i = list.length-1; i >= 0; --i){
isDuplicate = false;
for(int j = i-1; j >= 0 && !isDuplicate; --j){
if(list[j] == list[i]){
isDuplicate = true;
}
}
if(!isDuplicate){
distinctList[count--] = list[i];
}
}
int[] out = new int[list.length-count-1];
System.arraycopy(distinctList, count+1, out, 0, list.length-count-1);
return out;
}
}
int[] arrayRemoveDuplicates= Arrays.stream("Array").distinct().toArray();
// print the unique array
for (int i = 0; i < arrayRemoveDuplicates.length; i++) {
System.out.println(arrayRemoveDuplicates[i]);
}
Java.util.streamapi introduit dans Java 8
public class Test
static int[] array = {4, 3, 3, 4, 5, 2, 4};
static HashSet list = new HashSet();
public static void main(String ar[])
{
for(int i=0;i<array.length;i++)
{
list.add(array[i]);
}
System.out.println(list);
}}
La sortie est: [2, 3, 4, 5]
Vous pouvez faire quelque chose comme ça
public class MyClass {
public static void main(String args[]) {
int[] man = {4,56,98,89,78,45,78, 79, 56};
for (int i = 0; i < man.length; i++)
{
for (int j = i+1; j < man.length; j++)
{
//check if it is equal
if (man[i] == man[j])
{
man[j] = man[j] -1;
//Decrementing size
j--;
}
}
}
//Array without duplicates
for(int k=0; k<man.length; k++)
{
System.out.print(" " + man[k]);
}
}
}
Cela a fonctionné pour moi:
import Java.util.Arrays;
import Java.util.HashSet;
public class Util {
public static int[] removeDups(final int[] intArrayWithDups) {
final int[] intArrayDupsRemoved = new int[intArrayWithDups.length];
final HashSet<Integer> alreadyAdded = new HashSet<>();
int innerCounter = 0;
for (int integer : intArrayWithDups) {
if (!alreadyAdded.contains(integer)) {
intArrayDupsRemoved[innerCounter] = integer;
alreadyAdded.add(intArrayDupsRemoved[innerCounter]);
innerCounter++;
}
}
return Arrays.copyOf(intArrayDupsRemoved, innerCounter);
}
}
Vous pouvez utiliser HashSet qui n'autorise pas les éléments en double
public static void deleteDups(int a []) {
HashSet<Integer> numbers = new HashSet<Integer>();
for(int n : a)
{
numbers.add(n);
}
for(int k : numbers)
{
System.out.println(k);
}
System.out.println(numbers);
}
public static void main(String[] args) {
int a[]={2,3,3,4,4,5,6};
RemoveDuplicate.deleteDups(a);
}
}
o/p is 2
3
4
5
6
[2, 3, 4, 5, 6]