scanf не будет потреблять\n, поэтому он будет приниматься с помощью gets, следующего за scanf. запустите поток ввода после scanf, как это.
#include <stdlib.h>
#include <string.h>
int main(void) {
int a;
char b[20];
printf("Input your ID: ");
scanf("%d", &a);
fflush(stdin);
printf("Input your name: ");
gets(b);
printf("---------");
printf("Name: %s", b);
system("pause");
return 0;
}
Вы можете отсортировать массив, а затем просмотреть его и посмотреть, совпадает ли следующий (или предыдущий) индекс с текущим. Если у вас хороший алгоритм сортировки, он должен быть меньше O (n 2 ):
var arr = [9, 9, 111, 2, 3, 4, 4, 5, 7]; вар sorted_arr = arr.slice (). sort (); // Здесь вы можете определить функцию сравнения. // JS по умолчанию использует дерьмовое сравнение строк. // (мы используем срез для клонирования массива, чтобы // исходный массив не изменялся) var results = []; for (var i = 0; i
На тот случай, если вы должны вернуть как функцию для дубликатов. Это для случая аналогичного типа.
Вот небольшой простой фрагмент, чтобы найти уникальные и повторяющиеся значения без сортировки и двух циклов.
var _unique = function (arr) {
var h = [], t = [];
arr.forEach(function (n) {
if (h.indexOf(n) == -1)
h.push(n);
else t.push(n);
});
return [h, t];
}
var result = _unique(["test",1,4,2,34,6,21,3,4,"test","prince","th",34]);
console.log("Has duplicate values : " + (result[1].length > 0)) //and you can check count of duplicate values
console.log(result[0]) //unique values
console.log(result[1]) //duplicate values
//find duplicates:
//sort, then reduce - concat values equal previous element, skip others
//input
var a = [1, 2, 3, 1, 2, 1, 2]
//short version:
var duplicates = a.sort().reduce((d, v, i, a) => i && v === a[i - 1] ? d.concat(v) : d, [])
console.log(duplicates); //[1, 1, 2, 2]
//readable version:
var duplicates = a.sort().reduce((output, element, index, input) => {
if ((index > 0) && (element === input[index - 1]))
return output.concat(element)
return output
}, [])
console.log(duplicates); //[1, 1, 2, 2]
Это одно из простых решений ES5, о которых я мог подумать -
function duplicates(arr) {
var duplicatesArr = [],
uniqueObj = {};
for (var i = 0; i < arr.length; i++) {
if( uniqueObj.hasOwnProperty(arr[i]) && duplicatesArr.indexOf( arr[i] ) === -1) {
duplicatesArr.push( arr[i] );
}
else {
uniqueObj[ arr[i] ] = true;
}
}
return duplicatesArr;
}
/* Input Arr: [1,1,2,2,2,1,3,4,5,3] */
/* OutPut Arr: [1,2,3] */
var a= [1, 2,2,3,3,4,4,4];
var m=[];
var n = [];
a.forEach(function(e) {
if(m.indexOf(e)=== -1) {
m.push(e);
}else if(n.indexOf(e)=== -1){
n.push(e);
}
});
Быстрый и элегантный способ с использованием деструктуризации и уменьшения объектов es6.
. Он работает в O (n) (1 итерация по массиву) и не повторяет значения, которые появляются более чем в 2 времена
const arr = ['hi', 'hi', 'hi', 'bye', 'bye', 'asd']
const {
dup
} = arr.reduce(
(acc, curr) => {
acc.items[curr] = acc.items[curr] ? acc.items[curr] += 1 : 1
if (acc.items[curr] === 2) acc.dup.push(curr)
return acc
}, {
items: {},
dup: []
},
)
console.log(dup)
// ['hi', 'bye']
var input = ['a', 'b', 'a', 'c', 'c'],
duplicates = [],
i, j;
for (i = 0, j = input.length; i < j; i++) {
if (duplicates.indexOf(input[i]) === -1 && input.indexOf(input[i], i+1) !== -1) {
duplicates.push(input[i]);
}
}
console.log(duplicates);
Следовать логике будет проще и быстрее
// @Param:data:Array that is the source
// @Return : Array that have the duplicate entries
findDuplicates(data: Array<any>): Array<any> {
return Array.from(new Set(data)).filter((value) => data.indexOf(value) !== data.lastIndexOf(value));
}
Преимущества:
Описание логики:
Примечание: методы map () и filter () эффективны и быстрее.
Использование «include» для проверки, если элемент уже существует.
var arr = [1, 1, 4, 5, 5], darr = [], duplicates = [];
for(var i = 0; i < arr.length; i++){
if(darr.includes(arr[i]) && !duplicates.includes(arr[i]))
duplicates.push(arr[i])
else
darr.push(arr[i]);
}
console.log(duplicates);
<h3>Array with duplicates</h3>
<p>[1, 1, 4, 5, 5]</p>
<h3>Array with distinct elements</h3>
<p>[1, 4, 5]</p>
<h3>duplicate values are</h3>
<p>[1, 5]</p>
Существует действительно простой способ решить это. Если Вы используете довольно новый 'Набор' команда JavaScript. Набор может взять массив в качестве ввода и вывода новый 'Набор', который только содержит уникальные значения. Тогда путем сравнения длины массива и свойства 'размера' набора Вы видите, отличаются ли они. Если они отличаются, это должно произойти из-за дублирующейся записи.
var array1 = ['value1','value2','value3','value1']; // contains duplicates
var array2 = ['value1','value2','value3','value4']; // unique values
console.log('array1 contains duplicates = ' + containsDuplicates(array1));
console.log('array2 contains duplicates = ' + containsDuplicates(array2));
function containsDuplicates(passedArray) {
let mySet = new Set(passedArray);
if (mySet.size !== passedArray.length) {
return true;
}
return false;
}
при выполнении вышеупомянутого отрывка, Вы получите этот вывод.
array1 содержит дубликаты = верный
, array2 содержит дубликаты = ложь
Вот простое решение, о котором я мог думать:
const arr = [-1, 2, 2, 2, 0, 0, 0, 500, -1, 'a', 'a', 'a']
const filtered = arr.filter((el, index) => arr.indexOf(el) !== index)
// => filtered = [ 2, 2, 0, 0, -1, 'a', 'a' ]
const duplicates = [...new Set(filtered)]
console.log(duplicates)
// => [ 2, 0, -1, 'a' ]
Вот именно.
Примечание:
Это работает с любыми числами включая 0
, строки и отрицательные числа, например, -1
- Связанный вопрос: Добираются, все уникальные значения в массиве JavaScript (удалите дубликаты)
, исходный массив arr
сохраняется (filter
возвраты новый массив вместо того, чтобы изменить оригинал)
Эти filtered
, массив содержит весь дубликаты; это может также содержать больше чем 1 то же значение (например, наш фильтрованный массив здесь [ 2, 2, 0, 0, -1, 'a', 'a' ]
)
, Если Вы хотите добраться только [1 126] значения, которые дублированы (Вы не хотите иметь несколько дубликатов с тем же значением), можно использовать [...new Set(filtered)]
(ES6 имеет объект Набор , который может сохранить только уникальные значения)
Hope, которой это помогает.
Этот ответ мог бы также быть полезным, он усиливает оператор/метод js reduce
для удаления дубликаты от массива.
const result = [1, 2, 2, 3, 3, 3, 3].reduce((x, y) => x.includes(y) ? x : [...x, y], []);
console.log(result);
Вы можете добавить эту функцию или настроить ее и добавить в прототип массива Javascript:
Array.prototype.unique = function () {
var r = new Array();
o:for(var i = 0, n = this.length; i < n; i++)
{
for(var x = 0, y = r.length; x < y; x++)
{
if(r[x]==this[i])
{
alert('this is a DUPE!');
continue o;
}
}
r[r.length] = this[i];
}
return r;
}
var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,9];
var unique = arr.unique();
alert(unique);
Если вы хотите удалить дубликаты, попробуйте этот отличный решение:
function eliminateDuplicates(arr) {
var i,
len = arr.length,
out = [],
obj = {};
for (i = 0; i < len; i++) {
obj[arr[i]] = 0;
}
for (i in obj) {
out.push(i);
}
return out;
}
Источник: http://dreaminginjavascript.wordpress.com/2008/08/22/eliminating-duplicates/
Следующая функция (вариант уже упомянутой функции excluDuplicates), похоже, помогает добиться цели, возвращая test2,1,7,5 для входных данных ["test", "test2", " test2 ", 1, 1, 1, 2, 3, 4, 5, 6, 7, 7, 10, 22, 43, 1, 5, 8]
Обратите внимание, что проблема в JavaScript более странная, чем в большинстве других языков, потому что массив JavaScript может содержать что угодно. Обратите внимание, что решениям, использующим сортировку, может потребоваться соответствующая функция сортировки - я еще не пробовал этот маршрут.
Эта конкретная реализация работает (по крайней мере) для строк и чисел.
function findDuplicates(arr) {
var i,
len=arr.length,
out=[],
obj={};
for (i=0;i<len;i++) {
if (obj[arr[i]] != null) {
if (!obj[arr[i]]) {
out.push(arr[i]);
obj[arr[i]] = 1;
}
} else {
obj[arr[i]] = 0;
}
}
return out;
}
Просто чтобы добавить немного теории к вышесказанному.
Поиск дубликатов имеет нижнюю границу O (n * log (n) в модели сравнения. Итак, теоретически вы не можете сделать ничего лучше, чем сначала отсортировать, а затем пройти через список, последовательно удаляя любые найденные дубли.
Если вы хотите найти дубликаты за линейное (O (n)) ожидаемое время, вы можете хешировать каждый элемент списка; если есть столкновение, удалите / пометьте его как дубликат, и продолжаем.
Это должно дать вам то, что вы хотите, только дубликаты.
function find_duplicates(arr) {
var len=arr.length,
out=[],
counts={};
for (var i=0;i<len;i++) {
var item = arr[i];
counts[item] = counts[item] >= 1 ? counts[item] + 1 : 1;
if (counts[item] === 2) {
out.push(item);
}
}
return out;
}
find_duplicates(['one',2,3,4,4,4,5,6,7,7,7,'pig','one']); // -> ['one',4,7] in no particular order.
Array.prototype.unique = function () {
var arr = this.sort(), i; // input must be sorted for this to work
for( i=arr.length; i--; )
arr[i] === arr[i-1] && arr.splice(i,1); // remove duplicate item
return arr;
}
var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,9],
arr2 = [1,2,511,12,50],
arr3 = [22],
unique = arr.concat(arr2, arr3).unique();
console.log(unique); // [22, 50, 12, 511, 2, 1, 9, 5, 8, 7, 3, 6, 4]
if (!Array.prototype.indexOf){
Array.prototype.indexOf = function(elt /*, from*/){
var len = this.length >>> 0;
var from = Number(arguments[1]) || 0;
from = (from < 0) ? Math.ceil(from) : Math.floor(from);
if (from < 0)
from += len;
for (; from < len; from++){
if (from in this && this[from] === elt)
return from;
}
return -1;
};
}
if( $.inArray(this[i], arr) == -1 )
var arr = [1,2,2,3,3,4,5,6,2,3,7,8,5,22], arr2 = [1,2,511,12,50], arr3 = [22], unique; // Combine all the arrays to a single one unique = arr.concat(arr2, arr3); // create a new (dirty) Array with only the unique items unique = unique.map((item,i) => unique.includes(item, i+1) ? item : '' ) // Cleanup - remove duplicate & empty items items unique = [...new Set(unique)].filter(n => n); console.log(unique);
instead of adding the 'Array.prototype.indexOf'
В библиотеке Prototype есть функция uniq , которая возвращает массив без дубликатов. Но это только половина работы.
/ * Метод indexOf объекта Array полезен для сравнения элементов массива. IE - единственный крупный браузер, который изначально не поддерживает его, но его легко реализовать: * /
Array.prototype.indexOf= Array.prototype.indexOf || function(what, i){
i= i || 0;
var L= this.length;
while(i<L){
if(this[i]=== what) return i;
++i;
}
return -1;
}
function getarrayduplicates(arg){
var itm, A= arg.slice(0, arg.length), dups= [];
while(A.length){
itm= A.shift();
if(A.indexOf(itm)!= -1 && dups.indexOf(itm)== -1){
dups[dups.length]= itm;
}
}
return dups;
}
var a1 = [1, 22, 3, 2, 2, 3, 3, 4, 1, 22, 7, 8, 9];
alert (getarrayduplicates (a1));
Для очень больших массивов может быть быстрее удалять дубликаты из массива по мере их обнаружения, чтобы они больше не просматривались:
function getarrayduplicates(arg){
var itm, A= arg.slice(0, arg.length), dups= [];
while(A.length){
itm= A.shift();
if(A.indexOf(itm)!= -1){
dups[dups.length]= itm;
while(A.indexOf(itm)!= -1){
A.splice(A.indexOf(itm), 1);
}
}
}
return dups;
}
var arr = ['a','b','c','a'];
arr.filter( (item , index ) => {
console.log(item , index , arr.indexOf(item) , arr.indexOf( item ) == index);
return index == arr.indexOf(item)
} );
Можно использовать sort
, filter
и sets
, чтобы сделать это.
var numbers = [1,2,3,4,5,6,7,8,1,2,3,4,5,3,3,4];
var numbersSorted = numbers.sort();
let result = numbers.filter((e, i) => numbers[i] == numbers[i+1]);
result = [...new Set(result)];
console.log(result);
Самый Короткий ванильный JS:
arr.filter((v,i,a) => a.indexOf(v) !== i) // [9, 4]
var array = ['a', 'b', 'c', 'a'];
function unique(array) {
var unique_arr = [];
array.forEach(function(i, e) {
if (unique_arr.indexOf(i)===-1) unique_arr.push(i);
});
return unique_arr;
}
console.log(unique(array));