Как найти количество уникальных элементов в массиве

Раздел:
Задачи /
Простейшие /

Основы программирования
Каждый профессионал когда-то был чайником. Наверняка вам знакомо состояние, когда “не знаешь как начать думать, чтобы до такого додуматься”. Наверняка вы сталкивались с ситуацией, когда вы просто не знаете, с чего начать.
Эта книга ориентирована как раз на таких людей, кто хотел бы стать программистом, но совершенно не знает, как начать этот путь.
Подробнее…

Условие задачи 2.99

Задача 2.99
Дан одномерный массив А неупорядоченных целых чисел. Вывести на экран количество уникальных элементов в массиве.

Это не такая простая задача, как может показаться на первый взгляд. Даже мне пришлось немного поломать голову — с наскока сделать не удалось.

Но в этом и смысл задач — учиться искать решения.

Итак, я нашёл, может и не самое лучшее, но рабочее решение, для которого я использовал два одинаковых массива — один с числами, а другой — для индексов.

То есть массив А содержит числа, а в массив В я буду записывать индексы массива А совпадающих (не уникальных) элементов. Для уникальных элементов индексы в массиве В будут равны нулю. Таким образом, после поиска совпадений, у меня получится массив В такой же размерности, как и исходный массив. Но элементы с нулевым значением в массиве В будут соответствовать уникальным элементам в массиве А. И, подсчитав нулевые элементы в массиве В, мы сможем определить количество уникальных элементов в массиве А.

Сложновато? Ну да, не очень красиво. Но это первое решение, которое пришло в голову. Обычно программы так и пишутся:

Сначала быстро создаётся версия, которая будет хоть как-то работать, чтобы можно было побыстрее начать её использовать.
А потом выпускаются новые версии с доработками. И так до бесконечности…

ПРИМЕЧАНИЕ
В примерах я использую глобальные массивы, хотя это и не очень приветствуется.
Обычно стараются в таких случаях передавать массивы в функцию в качестве
параметра. Однако в этом случае новички могут столкнуться с трудностями,
преодоление которых описано здесь.

Подробно описывать решение не буду — см. комментарии в исходных кодах и видео выше.

Примеры программ на Паскале и
С++.

Решение задачи 2.99 на Паскале

program mytask;

uses CRT;     //!!! Подключить этот модуль

//****************************************************************
// КОНСТАНТЫ
//****************************************************************
const
  MAX_A = 16;

//****************************************************************
// ТИПЫ ДАННЫХ
//****************************************************************
type TMas = array[1..MAX_A] of byte;

//****************************************************************
// ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
//****************************************************************
var
  i         : byte;        //Индекс
  UniqueNum : byte = 0;    //Количество уникальных элементов
  A         : TMas;        //Массив чисел
  B         : TMas;        //Массив индексов

//****************************************************************
// ФУНКЦИИ И ПРОЦЕДУРЫ
//****************************************************************

//****************************************************************
// Определяет количество уникальных элементов в массиве
// ВХОД:  В - глобальный массив индексов
// ВЫХОД: UniqueNum - глобальная переменная - количество
// уникальных элементов
//****************************************************************
procedure GetUnique;
var i : byte;
begin
  UniqueNum := 0;
  for i := 1 to MAX_A do
    if B[i] = 0 then Inc(UniqueNum);
end;

//****************************************************************
// Проверяет уникальность элемента в массиве
// ВХОД:  А и В - глобальные массивы
//        N - значение элемента
//        Ind - индекс элемента
//****************************************************************
procedure CheckUnique(N, Ind : byte);
var i   : byte;
begin
  for i := 1 to MAX_A do
    //Если найдено совпадение
    if (A[i] = N) and (i <> Ind) then B[i] := i;
end;

//****************************************************************
// ОСНОВНАЯ ПРОГРАММА
//****************************************************************
begin
  Randomize;                //Запустить генератор случайных чисел

  //Создать массив и вывести на экран
  for i := 1 to MAX_A do
    begin
      A[i] := Random(50);
      B[i] := 0;
      Write(A[i], ' ');
    end;

  //Найти одинаковые элементы
  for i := 1 to MAX_A do
    CheckUnique(A[i], i);

  WriteLn;
  GetUnique;  //Определить число уникальных элементов

  //Вывести массив с обнаруженными совпадениями
  for i := 1 to MAX_A do
    begin
      if B[i] > 0 then TextColor(Yellow)
      else TextColor(LightGray);
      Write(A[i], ' ');
    end;

  TextColor(LightGray);

  //Вывести решение на экран
  WriteLn(#10#13'Problem solution:');
  WriteLn('  Elements in the array: ', MAX_A);
  WriteLn('  Of them unique:        ', UniqueNum);

  WriteLn('The end. Press ENTER...');
  ReadLn;
end.

Решение задачи 2.99 на С++

#include <cstdlib>
#include <iostream>
#include <ctime>      //!!! Подключить, если будет ругаться на srand

//****************************************************************
// КОНСТАНТЫ
//****************************************************************
const int MAX_A = 16; 

//****************************************************************
// ТИПЫ ДАННЫХ
//****************************************************************
typedef short int TMas[MAX_A]; 

using namespace std;

//****************************************************************
// ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
//****************************************************************
short int i;             //Индекс
short int UniqueNum = 0; //Количество уникальных элементов
TMas A;                  //Массив 
TMas B;                  //Массив 

//****************************************************************
// ФУНКЦИИ И ПРОЦЕДУРЫ
//****************************************************************

//****************************************************************
// Определяет количество уникальных элементов в массиве
// ВХОД:  В - глобальный массив индексов
// ВЫХОД: UniqueNum - глобальная переменная - количество 
// уникальных элементов
//****************************************************************
void GetUnique()
{
short int i;
  UniqueNum = 0;
  for (i = 0; i < MAX_A; i++)
    if (-1 == B[i]) UniqueNum++;
}

//****************************************************************
// Проверяет уникальность элемента в массиве
// ВХОД:  А и В - глобальные массивы
//        N - значение элемента
//        Ind - индекс элемента
//****************************************************************
void CheckUnique(short int N, short int Ind)
{
short int i;
  for (i = 0; i < MAX_A; i++)
    //Если найдено совпадение
    if ((A[i] == N) && (i != Ind)) B[i] = i;
}

//****************************************************************
// ОСНОВНАЯ ПРОГРАММА
//****************************************************************
int main(int argc, char *argv[])
{
  srand(time(0));         //Запустить генератор случайных чисел

  //Создать массив и вывести на экран
  for(i = 0; i < MAX_A; i++)
  {
    A[i] = (rand() % 50);
    B[i] = -1;
    cout << int(A[i]) << " ";
  }

  //Найти одинаковые элементы
  for(i = 0; i < MAX_A; i++)
    CheckUnique(A[i], i);

  cout << endl;
  GetUnique();  //Определить число уникальных элементов
  
  //Вывести массив с обнаруженными совпадениями
  for(i = 0; i < MAX_A; i++)
  {
    if (B[i] > -1) cout << "*";
    cout << A[i] << " ";
  }

  //Вывести решение на экран
  cout << endl << "Problem solution:" << endl;
  cout << "  Elements in the array: " << MAX_A << endl;
  cout << "  Of them unique:        " << UniqueNum << endl;
  
  system("PAUSE");
  return EXIT_SUCCESS;
}

ПРИМЕЧАНИЕ
Программа на С++ несколько отличается от программы на Паскале. Во-первых,
вместо выделения цветом я использовал знак * для обозначения одинаковых
чисел (потому как в С++ использовать цвет сложнее, чем в Паскале,
если хотите знать как — читайте мою книгу “Основы С++”).
Во-вторых, в С++ индексация массивов начинается с нуля,
поэтому мы не можем использовать ноль в массиве В, и применяем -1.
Есть и другие особенности, но о них я уже говорить не буду.

ВНИМАНИЕ!
Если вам что-то осталось непонятно, то советую почитать книги
“Основы программирования” и
“Основы С++”.

Как стать программистом 2.0

Эта книга для тех, кто хочет стать программистом. На самом деле хочет, а не просто мечтает. И хочет именно стать программистом с большой буквы, а не просто научиться кулебякать какие-то примитивные программки…
Подробнее…

Помощь в технических вопросах

Помощь студентам. Курсовые, дипломы, чертежи (КОМПАС), задачи по программированию: Pascal/Delphi/Lazarus; С/С++; Ассемблер; языки программирования ПЛК; JavaScript; VBScript; Fortran; Python и др. Разработка (доработка) ПО ПЛК (предпочтение — ОВЕН, CoDeSys 2 и 3), а также программирование панелей оператора, программируемых реле и других приборов систем автоматизации.
Подробнее…

Источник

Given a sorted array arr[] of size N, the task is to find the number of unique elements in this array.

Note: The array is very large, and unique numbers are significantly less. i.e., (unique elements <<size of the array).

Examples:

Input: arr[] = {1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 5, 5, 7, 7, 8, 8, 9, 9, 10, 11, 12}
Output: 10
Explanation: 10 unique elements are: 1, 2, 3, 5, 7, 8, 9, 10, 11, 12

Input: arr[] = {1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5, 9, 9, 9, 10, 10, 10}
Output: 7
Explanation: 7 unique elements are: 1, 2, 3, 4, 5, 9, 10

Naive Approach: As the given array is sorted, one of the simple approaches will be traversing through all over the element and comparing them with the previous ones. If it is different, then count that element.

Time Complexity: O(N)
Auxiliary Space: O(1).

Approach based on Binary Search: The idea is the use Binary search because the array is sorted. Follow the steps mentioned below:

Take the first number, then find its last occurrence or upper bound using binary search.
Then count it as one unique element.
Place pointer to next different element and repeat the same step.

Note: This algorithm is only effective when very few unique elements.

Below is the implementation of the above approach.

C++

#include <bits/stdc++.h>

using namespace std;

int nextIndex(int arr[], int N, int l,

int target)

{

int result = -1;

int r = N - 1;

while (l <= r) {

int mid = l + (r - l) / 2;

if (arr[mid] == target) {

result = mid;

l = mid + 1;

}

else if (arr[mid] > target)

r = mid - 1;

else

l = mid + 1;

}

return result + 1;

}

int unique(int arr[], int N)

{

int i = 0;

int count = 0;

while (i < N) {

i = nextIndex(arr, N, i, arr[i]);

count++;

}

return count;

}

int main()

{

int arr[] = { 1, 1, 1, 1, 1, 1, 2, 2, 2,

2, 3, 5, 5, 7, 7, 8, 8, 9,

9, 10, 11, 12 };

int N = sizeof(arr) / sizeof(arr[0]);

cout << unique(arr, N);

return 0;

}

Java

class GFG {

static int nextIndex(int arr[], int N, int l, int target) {

int result = -1;

int r = N - 1;

while (l <= r) {

int mid = l + (r - l) / 2;

if (arr[mid] == target) {

result = mid;

l = mid + 1;

} else if (arr[mid] > target)

r = mid - 1;

else

l = mid + 1;

}

return result + 1;

}

static int unique(int arr[], int N) {

int i = 0;

int count = 0;

while (i < N) {

i = nextIndex(arr, N, i, arr[i]);

count++;

}

return count;

}

public static void main(String args[]) {

int arr[] = { 1, 1, 1, 1, 1, 1, 2, 2, 2,

2, 3, 5, 5, 7, 7, 8, 8, 9,

9, 10, 11, 12 };

int N = arr.length;

System.out.println(unique(arr, N));

}

Python3

def nextIndex(arr, N, l, target):

result = -1

r = N - 1

while (l <= r):

mid = l + (r - l) // 2

if (arr[mid] == target):

result = mid

l = mid + 1

elif (arr[mid] > target):

r = mid - 1

else:

l = mid + 1

return result + 1

def unique(arr, N):

i = 0

count = 0

while (i < N):

i = nextIndex(arr, N, i, arr[i])

count += 1

return count

arr = [1, 1, 1, 1, 1, 1, 2, 2, 2,

2, 3, 5, 5, 7, 7, 8, 8, 9,

9, 10, 11, 12]

N = len(arr)

print(unique(arr, N))

C#

using System;

using System.Collections.Generic;

public class GFG

{

static int nextIndex(int[] arr, int N, int l, int target) {

int result = -1;

int r = N - 1;

while (l <= r) {

int mid = l + (r - l) / 2;

if (arr[mid] == target) {

result = mid;

l = mid + 1;

} else if (arr[mid] > target)

r = mid - 1;

else

l = mid + 1;

}

return result + 1;

}

static int unique(int[] arr, int N) {

int i = 0;

int count = 0;

while (i < N) {

i = nextIndex(arr, N, i, arr[i]);

count++;

}

return count;

}

static public void Main (){

int[] arr = { 1, 1, 1, 1, 1, 1, 2, 2, 2,

2, 3, 5, 5, 7, 7, 8, 8, 9,

9, 10, 11, 12 };

int N = arr.Length;

Console.WriteLine(unique(arr, N));

}

Javascript

<script>

function nextIndex(arr, N, l,

target) {

let result = -1;

let r = N - 1;

while (l <= r) {

let mid = l + Math.floor((r - l) / 2);

if (arr[mid] == target) {

result = mid;

l = mid + 1;

}

else if (arr[mid] > target)

r = mid - 1;

else

l = mid + 1;

}

return result + 1;

}

function unique(arr, N) {

let i = 0;

let count = 0;

while (i < N) {

i = nextIndex(arr, N, i, arr[i]);

count++;

}

return count;

}

let arr = [1, 1, 1, 1, 1, 1, 2, 2, 2,

2, 3, 5, 5, 7, 7, 8, 8, 9,

9, 10, 11, 12];

let N = arr.length;

document.write(unique(arr, N));

</script>

Time Complexity: K * logO(N). where K = no. of unique elements.
Auxiliary Space: O(1).

Approach based on Divide and Conquer: This problem can be solved using divide and conquer. Idea is:

As duplicate elements are large, look at the first and last elements of this sorted array.
- If both are equal, it means only this element is present in the entire array, and it will be counted as one.
- If they are different, divide the array into two halves and repeat the above step for each array.
The final count is the number of unique elements.

Below is the implementation of the above approach:

C++

#include <bits/stdc++.h>

using namespace std;

int cnt = 0;

void UniqueElements(int arr[], int s,

int e, bool isDuplicate)

{

if (arr[s] == arr[e]) {

if (isDuplicate == false) {

cnt++;

}

else {

int mid = s + (e - s) / 2;

UniqueElements(arr, s, mid, isDuplicate);

UniqueElements(arr, mid + 1, e,

arr[mid] == arr[mid + 1]);

}

int unique(int arr[], int N)

{

UniqueElements(arr, 0, N - 1, 0);

return cnt;

}

int main()

{

int arr[] = { 1, 1, 1, 1, 1, 1, 2, 2, 2,

2, 3, 5, 5, 7, 7, 8, 8, 9,

9, 10, 11, 12 };

int N = sizeof(arr) / sizeof(arr[0]);

cout << unique(arr, N);

return 0;

}

Java

import java.util.*;

class GFG{

static int cnt = 0;

static void UniqueElements(int arr[], int s,

int e, boolean isDuplicate)

{

if (arr[s] == arr[e]) {

if (isDuplicate == false) {

cnt++;

}

else {

int mid = s + (e - s) / 2;

UniqueElements(arr, s, mid, isDuplicate);

UniqueElements(arr, mid + 1, e,

arr[mid] == arr[mid + 1]);

}

static int unique(int arr[], int N)

{

UniqueElements(arr, 0, N - 1, false);

return cnt;

}

public static void main(String[] args)

{

int arr[] = { 1, 1, 1, 1, 1, 1, 2, 2, 2,

2, 3, 5, 5, 7, 7, 8, 8, 9,

9, 10, 11, 12 };

int N = arr.length;

System.out.print(unique(arr, N));

}

Python3

cnt = 0;

def UniqueElements(arr, s, e, isDuplicate):

global cnt

if (arr[s] == arr[e]):

if (isDuplicate == False):

cnt += 1;

else:

mid = s + (e - s) // 2;

UniqueElements(arr, s, mid, isDuplicate);

UniqueElements(arr, mid + 1, e, arr[mid] == arr[mid + 1]);

def unique(arr, N):

UniqueElements(arr, 0, N - 1, False);

return cnt;

if __name__ == '__main__':

arr = [ 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 5, 5, 7, 7, 8, 8, 9, 9, 10, 11, 12 ];

N = len(arr);

print(unique(arr, N));

C#

using System;

public class GFG{

static int cnt = 0;

static void UniqueElements(int []arr, int s,

int e, bool isDuplicate)

{

if (arr[s] == arr[e]) {

if (isDuplicate == false) {

cnt++;

}

else {

int mid = s + (e - s) / 2;

UniqueElements(arr, s, mid, isDuplicate);

UniqueElements(arr, mid + 1, e,

arr[mid] == arr[mid + 1]);

}

static int unique(int []arr, int N)

{

UniqueElements(arr, 0, N - 1, false);

return cnt;

}

public static void Main(String[] args)

{

int []arr = { 1, 1, 1, 1, 1, 1, 2, 2, 2,

2, 3, 5, 5, 7, 7, 8, 8, 9,

9, 10, 11, 12 };

int N = arr.Length;

Console.Write(unique(arr, N));

}

Javascript

<script>

var cnt = 0;

function UniqueElements(arr , s,e, isDuplicate)

{

if (arr[s] == arr[e]) {

if (isDuplicate == false) {

cnt++;

}

else {

var mid = s + parseInt((e - s) / 2);

UniqueElements(arr, s, mid, isDuplicate);

UniqueElements(arr, mid + 1, e,

arr[mid] == arr[mid + 1]);

}

function unique(arr , N)

{

UniqueElements(arr, 0, N - 1, false);

return cnt;

}

var arr = [ 1, 1, 1, 1, 1, 1, 2, 2, 2,

2, 3, 5, 5, 7, 7, 8, 8, 9,

9, 10, 11, 12 ];

var N = arr.length;

document.write(unique(arr, N));

</script>

Time Complexity: O(log(N)) for the average case.The worst case will be O(N).
Auxiliary Space: O(1)

Last Updated :
28 Feb, 2022

Like Article

Save Article

Источник

Корректное решение требует определённых усилий. Первое что нужно — функция которая умеет считать длину генератора. Так как мы оптимизируем решение по памяти, то len(list(...)) не подходит. Вот одно из из самых простых и ясных решений:

def count(a):
    return max(enumerate(a, 1), default=(0, None))[0]

Сосчитаем одинаковые соседние элементы в списке. На этот раз нам не нужно экономить память так как на входе у нас список (или кортеж, или строка — решение достаточно универсальное):

def n_duplicates(a):
    return count(None for a, b in zip(a[:-1], a[1:]) if a == b)

К сожалению, исходный список может иметь несоседние одинаковые элементы. Очевидно, их можно сделать соседними с помощью перестановки. Хотя мы не знаем какая именно перестановка нам нужна, мы точно знаем что это перестановка. Переберём перестановки, нам нужна та где количество дубликатов самое большое. Этот максимум вычтем из длины исходного массива:

def n_uniques(a):
    return len(a) - max(n_duplicates(b) for b in itertools.permutations(a))

Решение достаточно изящно и отлично работает:

@>>> print(n_uniques([0, 1, 1, 3, -1, 3]))
4

Источник

numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None, *, equal_nan=True)[source]#

Find the unique elements of an array.

Returns the sorted unique elements of an array. There are three optional
outputs in addition to the unique elements:

the indices of the input array that give the unique values
the indices of the unique array that reconstruct the input array
the number of times each unique value comes up in the input array

Parameters:

ararray_like

Input array. Unless axis is specified, this will be flattened if it
is not already 1-D.

return_indexbool, optional

If True, also return the indices of ar (along the specified axis,
if provided, or in the flattened array) that result in the unique array.

return_inversebool, optional

If True, also return the indices of the unique array (for the specified
axis, if provided) that can be used to reconstruct ar.

return_countsbool, optional

If True, also return the number of times each unique item appears
in ar.

axisint or None, optional

The axis to operate on. If None, ar will be flattened. If an integer,
the subarrays indexed by the given axis will be flattened and treated
as the elements of a 1-D array with the dimension of the given axis,
see the notes for more details. Object arrays or structured arrays
that contain objects are not supported if the axis kwarg is used. The
default is None.

New in version 1.13.0.

equal_nanbool, optional

If True, collapses multiple NaN values in the return array into one.

New in version 1.24.

Returns:

uniquendarray

The sorted unique values.

unique_indicesndarray, optional

The indices of the first occurrences of the unique values in the
original array. Only provided if return_index is True.

unique_inversendarray, optional

The indices to reconstruct the original array from the
unique array. Only provided if return_inverse is True.

unique_countsndarray, optional

The number of times each of the unique values comes up in the
original array. Only provided if return_counts is True.

New in version 1.9.0.

Вступление

В Python у нас есть дубликаты элементов, присутствующих в списке. Иногда мы сталкиваемся с ситуацией, когда нам нужно подсчитать уникальные значения в списке в Python. Поэтому мы будем обсуждать различные способы поиска уникальных значений в массиве или списке. А также выведите количество уникальных элементов, присутствующих в списке.

Уникальные элементы-это элементы, которые появляются только один раз в списке .

Предположим, у нас есть список = [1, 2, 3, 2, 3, 5, 1, 6, 1]. Здесь мы видим, что 1 приходит 3 раза, 2 приходит 2 раза, 3 приходит 2 раза, 5 и 6 приходят один раз. Если мы посчитаем уникальные элементы в списке, то их будет всего 5.[1, 2, 3, 5, 6].

Различные методы подсчета уникальных значений

Давайте разберемся во всех различных методах, с помощью которых мы можем вычислить количество уникальных элементов в списке или массиве с помощью примеров:

1. Python Подсчитывает уникальные значения в списке обычным методом грубой силы

Мы называем этот метод подходом грубой силы . Этот метод не так эффективен, так как в нем больше времени и больше пространства. Этот подход будет принимать пустой список и переменную count, которая будет установлена в 0. мы пройдем от начала до конца и проверим, нет ли этого значения в пустом списке. Затем мы добавим его и увеличим переменную count на 1. Если его нет в пустом списке, то мы не будем его считать, не будем добавлять в пустой список.

# take an input list as lst 
lst = [1, 2, 3, 5, 1, 2, 6, 7] 
print("Input list : ",lst)

#Empty list 
lst1 = [] 

count = 0

# traverse the array 
for i in lst: 
	if i not in lst1: 
		count = count + 1
		lst1.append(i) 

# printing the output 
print("Output list : ",lst1)
print("No. of unique items are:", count)

Выход:

Input list :  [1, 2, 3, 5, 1, 2, 6, 7]
Output list :  [1, 2, 3, 5, 6, 7]
No. of unique items are: 6

Объяснение:

Здесь, во-первых, мы взяли входной список и напечатали входной список. Во-вторых, мы взяли пустой список и переменную count, которая установлена в 0. В-третьих, мы прошли список с самого начала и проверили, нет ли значения в пустом списке или нет. Если значение отсутствует в пустом списке, мы увеличиваем значение счетчика на 1 и добавляем это значение в пустой список. Если мы обнаруживаем, что элементы присутствуют в списке, мы не добавляем их в пустой список и не увеличиваем значение счетчика на 1. Наконец, мы напечатали пустой список, который теперь содержит уникальные значения и количество списка. Таким образом, мы можем видеть все уникальные элементы в списке.

2. С помощью счетчика

В этом методе мы будем использовать функцию счетчика из библиотеки коллекций. В этом случае мы будем создавать словарь с помощью функции counter (). Ключи будут уникальными элементами, а значения-числом этого уникального элемента. Взяв ключи из словаря, мы создадим список и напечатаем длину списка.

#import Counter from collections
from collections import Counter

#input of list
lst = [1, 2, 3, 1, 2, 5, 3, 4, 3, 6]
print("Input list : ",lst)

lst1 = Counter(lst).keys() 
print("output list : ",lst1)
print("No of unique elements in the list are:", len(lst1))

Выход:

Input list :  [1, 2, 3, 1, 2, 5, 3, 4, 3, 6]
output list :  dict_keys([1, 2, 3, 5, 4, 6])
No of unique elements in the list are: 6

Объяснение:

Здесь, во-первых, мы импортировали функцию Counter() из библиотеки коллекций. Во-вторых, мы взяли входной список и напечатали входной список. В-третьих, мы применили счетчик(), неупорядоченную коллекцию, где элементы хранятся как ключи словаря, а их подсчеты хранятся как значения словаря. Из входного списка мы создали новый список, в котором хранятся только те элементы, ключевые значения которых присутствуют один раз. Все эти элементы различны в списке. Наконец, мы напечатали пустой список, который теперь содержит уникальные значения и количество списка. Таким образом, мы можем видеть все уникальные элементы в списке.

3. Python Подсчитывает Уникальные Значения В Списке С помощью набора

В этом методе мы будем использовать встроенный тип данных python, называемый Set. Мы возьмем входные данные в виде списка, а затем преобразуем их в набор. Как мы все знаем, набор не содержит в себе никаких повторяющихся элементов. Он будет содержать только уникальные элементы, и мы выведем длину списка с помощью функции length ().

# Take input list
lst = [2, 3, 5, 2, 4, 3, 1, 5, 2, 1]
print("Input list : ", lst)

lst1 = set(lst)
print("Output list : ",lst1)
print("No of unique elements in the list are:", len(lst1))

Выход:

Input list :  [2, 3, 5, 2, 4, 3, 1, 5, 2, 1]
Output list :  {1, 2, 3, 4, 5}
No of unique elements in the list are: 5

Объяснение:

Здесь, во-первых, мы взяли входной список и напечатали входной список. Во-вторых, мы преобразовали входной список в набор. Set, который является встроенным типом данных в python, содержит только уникальные элементы в нем. В-третьих, мы сохранили все значения в другом списке. Наконец, мы напечатали пустой список, который теперь содержит уникальные значения и количество списка. Таким образом, мы можем видеть все уникальные элементы в списке.

4. С помощью numpy.unique

В этом методе мы импортируем библиотеку numpy с ее псевдонимом np. В библиотеке numpy мы будем использовать функцию numpy.unique (), которая возвращает уникальное значение входного списка. Мы также можем вернуть количество каждого уникального значения, если параметр return count имеет значение True.

#import numpy module
import numpy as np

#input list
lst = [1,2,3,4,2,5,1,2,6,3]
print("Input list : ",lst)

lst1 = np.unique(lst)
print("Output list : ", lst1)
print("No of unique elements in the list are:", len(lst1))

Выход:

Input list :  [1, 2, 3, 4, 2, 5, 1, 2, 6, 3]
Output list :  [1 2 3 4 5 6]
No of unique elements in the list are: 6

Объяснение:

Здесь, во-первых, мы импортировали модуль numpy в качестве псевдонима np. Во-вторых, мы взяли входной список и напечатали входной список. В-третьих, мы применили numpy. unique (), который сохранит только уникальные значения списка и сохранит их в другом списке. Наконец, мы напечатали пустой список, который теперь содержит уникальные значения и количество списка. Таким образом, мы можем видеть все уникальные элементы в списке.

5. Python Подсчитывает Уникальные Значения В Списке С Помощью Функции pandas dict + zip

В этом методе мы будем использовать словарь с комбинацией функций zip для поиска уникальных значений строки путем преобразования их в список.

#input as a string

str="latracalsolutions"
unique = dict(zip(list(str),[list(str).count(i) for i in list(str)]))
print("Dictionary : ",unique)
print("count : ",len(unique))

Выход:

Dictionary :  {'l': 3, 'a': 3, 't': 2, 'r': 1, 'c': 1, 's': 2, 'o': 2, 'u': 1, 'i': 1, 'n': 1}
count :  10

Объяснение:

Здесь во-первых, мы взяли строку как. Во-вторых, мы применили функцию dict внутри того, что мы применили функцию zip, и внутри нее мы преобразовали строку в список и подсчитали ключи и значения, пройдя по списку. В-третьих, мы взяли переменную unique, в которой мы хранили ключи и значения словаря. Наконец, мы напечатали длину словаря с помощью функции length в python.

6. Использование фрейма данных pandas.

В этом методе мы будем импортировать панд в качестве псевдонима pd. мы будем принимать входные данные в кадре данных панд.

import pandas as pd 

df = pd.DataFrame({ 
'Marks' : [65, 65, 64, 
			58, 67, 60, 
			58, 65]}, 
	

Names = ['sid', 'sam', 'Nia', 
			'Jenny', 'virat', 'Lucifer', 
			'Ramu', 'Nikita']) 
 
n = len(pd.unique(df['Marks'])) 

print("No.of.unique values :",n)

Выход:

Объяснение:

Здесь, во-первых, мы импортировали модуль панд с псевдонимом pd. Во – вторых, мы создали фрейм данных с вводом меток и имен. В-третьих, мы создали переменную n, в которой будем хранить значение. Мы применили уникальную функцию в метках в панд, а затем вычислили ее длину с помощью функции длины и сохранили ее в переменной n. Наконец-то мы напечатали результат.

Кроме того, Читайте

Numpy Count | Практическое объяснение поиска вхождений
4 Надежных Способа Подсчета Слов в строке в Python
5 Лучших способов найти длину строки Python
Использование панд в CSV() с совершенством
Сложение матриц в Python | Сложение двух матриц

Вывод

В этом уроке мы увидели, что представляют собой уникальные элементы в списке. Кроме того, мы видели различные методы, с помощью которых мы можем найти уникальные элементы в списке. Мы также подсчитали уникальные элементы в списке и напечатали их количество. Все методы подробно объясняются с помощью примеров. Все примеры также объясняются, что даст вам лучшее понимание методов. Вы можете использовать любую из программ, чтобы найти количество уникальных элементов в списке в соответствии с вашими потребностями и выбором.

Источник