Подходить:
1. Поместите все входные целые в ключ hashmap
2. Печать ключейУстановить за пределами цикла
Джава
import java.util.HashMap;
public class UniqueInArray2 {
public static void main(String args[])
{
int ar[] = { 10, 5, 3, 4, 3, 5, 6 };
HashMap<Integer,Integer> hm = new HashMap<Integer,Integer>();
for (int i = 0; i < ar.length; i++) {
hm.put(ar[i], i);
}
System.out.println(hm.keySet());
}
}
|
C #
using System;
using System.Collections.Generic;
public class UniqueInArray2
{
public static void Main(String []args)
{
int []ar = { 10, 5, 3, 4, 3, 5, 6 };
Dictionary<int,int> hm = new Dictionary<int,int>();
for (int i = 0; i < ar.Length; i++)
{
if(hm.ContainsKey(ar[i]))
hm.Remove(ar[i]);
hm.Add(ar[i], i);
}
var v = hm.Keys;
foreach(int a in v)
Console.Write(a+" ");
}
}
|
Для целочисленного массива выведите все отдельные элементы массива. Данный массив может содержать дубликаты, и выходные данные должны печатать каждый элемент только один раз. Данный массив не отсортирован.
Примеры:
Input: arr[] = {12, 10, 9, 45, 2, 10, 10, 45}
Output: 12, 10, 9, 45, 2
Input: arr[] = {1, 2, 3, 4, 5}
Output: 1, 2, 3, 4, 5
Input: arr[] = {1, 1, 1, 1, 1}
Output: 1 Простое решение состоит в том, чтобы использовать два вложенных цикла. Внешний цикл выбирает элемент один за другим, начиная с самого левого элемента. Внутренний цикл проверяет наличие элемента слева от него. Если присутствует, то игнорирует элемент, иначе печатает элемент. Ниже приводится реализация простого алгоритма.
C ++
#include <iostream>
#include <algorithm>
using namespace std;
void printDistinct(int arr[], int n)
{
for (int i=0; i<n; i++)
{
int j;
for (j=0; j<i; j++)
if (arr[i] == arr[j])
break;
if (i == j)
cout << arr[i] << " ";
}
}
int main()
{
int arr[] = {6, 10, 5, 4, 9, 120, 4, 6, 10};
int n = sizeof(arr)/sizeof(arr[0]);
printDistinct(arr, n);
return 0;
}
|
Джава
import java.io.*;
class GFG {
static void printDistinct(int arr[], int n)
{
for (int i = 0; i < n; i++)
{
int j;
for (j = 0; j < i; j++)
if (arr[i] == arr[j])
break;
if (i == j)
System.out.print( arr[i] + " ");
}
}
public static void main (String[] args)
{
int arr[] = {6, 10, 5, 4, 9, 120, 4, 6, 10};
int n = arr.length;
printDistinct(arr, n);
}
}
|
python3
def printDistinct(arr, n):
for i in range(0, n):
d = 0
for j in range(0, i):
if (arr[i] == arr[j]):
d = 1
break
if (d == 0):
print(arr[i])
arr = [6, 10, 5, 4, 9, 120, 4, 6, 10]
n = len(arr)
printDistinct(arr, n)
|
C #
using System;
class GFG {
static void printDistinct(int []arr, int n)
{
for (int i = 0; i < n; i++)
{
int j;
for (j = 0; j < i; j++)
if (arr[i] == arr[j])
break;
if (i == j)
Console.Write(arr[i] + " ");
}
}
public static void Main ()
{
int []arr = {6, 10, 5, 4, 9, 120,
4, 6, 10};
int n = arr.Length;
printDistinct(arr, n);
}
}
|
PHP
<?php
function printDistinct($arr, $n)
{
for($i = 0; $i < $n; $i++)
{
$j;
for($j = 0; $j < $i; $j++)
if ($arr[$i] == $arr[$j])
break;
if ($i == $j)
echo $arr[$i] , " ";
}
}
$arr = array(6, 10, 5, 4, 9, 120, 4, 6, 10);
$n = sizeof($arr);
printDistinct($arr, $n);
?>
|
Выход:
6 10 5 4 9 120
Сложность времени вышеупомянутого решения составляет O (n 2 ). Мы можем использовать сортировку, чтобы решить проблему за O (nLogn) время. Идея проста, сначала отсортируйте массив так, чтобы все вхождения каждого элемента стали последовательными. Как только вхождения становятся последовательными, мы можем обойти отсортированный массив и распечатать отдельные элементы за O (n) времени. Ниже приводится реализация идеи.
C ++
#include <iostream>
#include <algorithm>
using namespace std;
void printDistinct(int arr[], int n)
{
sort(arr, arr + n);
for (int i=0; i<n; i++)
{
while (i < n-1 && arr[i] == arr[i+1])
i++;
cout << arr[i] << " ";
}
}
int main()
{
int arr[] = {6, 10, 5, 4, 9, 120, 4, 6, 10};
int n = sizeof(arr)/sizeof(arr[0]);
printDistinct(arr, n);
return 0;
}
|
Джава
import java.io.*;
import java .util.*;
class GFG
{
static void printDistinct(int arr[], int n)
{
Arrays.sort(arr);
for (int i = 0; i < n; i++)
{
while (i < n - 1 && arr[i] == arr[i + 1])
i++;
System.out.print(arr[i] +" ");
}
}
public static void main (String[] args)
{
int arr[] = {6, 10, 5, 4, 9, 120, 4, 6, 10};
int n = arr.length;
printDistinct(arr, n);
}
}
|
python3
def printDistinct(arr, n):
arr.sort();
for i in range(n):
if(i < n-1 and arr[i] == arr[i+1]):
while (i < n-1 and (arr[i] == arr[i+1])):
i+=1;
else:
print(arr[i], end=" ");
arr = [6, 10, 5, 4, 9, 120, 4, 6, 10];
n = len(arr);
printDistinct(arr, n);
|
C #
using System;
class GFG {
static void printDistinct(int []arr, int n)
{
Array.Sort(arr);
for (int i = 0; i < n; i++)
{
while (i < n - 1 && arr[i] == arr[i + 1])
i++;
Console.Write(arr[i] + " ");
}
}
public static void Main ()
{
int []arr = {6, 10, 5, 4, 9, 120, 4, 6, 10};
int n = arr.Length;
printDistinct(arr, n);
}
}
|
PHP
<?php
function printDistinct( $arr, $n)
{
sort($arr);
for ($i = 0; $i < $n; $i++)
{
while ($i < $n - 1 and
$arr[$i] == $arr[$i + 1])
$i++;
echo $arr[$i] , " ";
}
}
$arr = array(6, 10, 5, 4, 9, 120, 4, 6, 10);
$n = count($arr);
printDistinct($arr, $n);
?>
|
Выход:
4 5 6 9 10 120
Мы можем использовать хеширование, чтобы решить это в среднем за O (n) раз. Идея состоит в том, чтобы обойти заданный массив слева направо и отслеживать посещенные элементы в хеш-таблице. Ниже приводится реализация идеи.
C ++
#include<bits/stdc++.h>
using namespace std;
void printDistinct(int arr[],int n)
{
unordered_set<int> s;
for (int i=0; i<n; i++)
{
if (s.find(arr[i])==s.end())
{
s.insert(arr[i]);
cout << arr[i] << " ";
}
}
}
int main ()
{
int arr[] = {10, 5, 3, 4, 3, 5, 6};
int n=7;
printDistinct(arr,n);
return 0;
}
|
Джава
import java.util.*;
class Main
{
static void printDistinct(int arr[])
{
HashSet<Integer> set = new HashSet<>();
for (int i=0; i<arr.length; i++)
{
if (!set.contains(arr[i]))
{
set.add(arr[i]);
System.out.print(arr[i] + " ");
}
}
}
public static void main (String[] args)
{
int arr[] = {10, 5, 3, 4, 3, 5, 6};
printDistinct(arr);
}
}
|
python3
def printDistinct(arr, n):
s = dict();
for i in range(n):
if (arr[i] not in s.keys()):
s[arr[i]] = arr[i];
print(arr[i], end = " ");
arr = [10, 5, 3, 4, 3, 5, 6];
n = 7;
printDistinct(arr, n);
|
C #
using System;
using System.Collections.Generic;
class GFG
{
public static void printDistinct(int[] arr)
{
HashSet<int> set = new HashSet<int>();
for (int i = 0; i < arr.Length; i++)
{
if (!set.Contains(arr[i]))
{
set.Add(arr[i]);
Console.Write(arr[i] + " ");
}
}
}
public static void Main(string[] args)
{
int[] arr = new int[] {10, 5, 3, 4, 3, 5, 6};
printDistinct(arr);
}
}
|
Выход:
10 5 3 4 6
Еще одно преимущество хеширования перед сортировкой состоит в том, что элементы печатаются в том же порядке, что и во входном массиве.
Пожалуйста, пишите комментарии, если вы обнаружите что-то неправильное или вы хотите поделиться дополнительной информацией по обсуждаемой выше теме.
Рекомендуемые посты:
- Печать отсортированных отдельных элементов массива
- Выделить соседние элементы в массиве
- Подсчет отдельных элементов в массиве
- Проверьте, все ли элементы массива различны
- Произведение неповторяющихся (различных) элементов в массиве
- Отдельные смежные элементы в двоичном массиве
- Третий по величине элемент в массиве отдельных элементов
- Найти сумму неповторяющихся (различных) элементов в массиве
- Найти сингл в массиве из 2n + 1 целых элементов
- Найти минимальные изменения, необходимые в массиве, чтобы он содержал k различных элементов
- Подсчет подмассивов, имеющих общее количество элементов, таких же, как у исходного массива
- Различение элементов в отсортированном массиве с минимальными приращениями
- Количество способов выбрать целое число, чтобы в данном массиве было ровно K элементов больше, чем оно
- Построить отдельный массив элементов с заданным размером, суммой и верхней границей элемента
- Печатать элементы массива в соответствии с порядком, определенным другим массивом | набор 2
Распечатать все отдельные элементы заданного целочисленного массива
0.00 (0%) 0 votes