去重

最新推荐文章于 2021-07-29 20:03:57 发布
最新推荐文章于 2021-07-29 20:03:57 发布
阅读量345 收藏 1
点赞数
分类专栏： c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianzhijiaozi19/article/details/52253545
版权

http://blog.csdn.net/zitong_ccnu/article/details/11820511  

http://blog.sina.com.cn/s/blog_69146f5101016tv6.html

http://blog.csdn.net/ww1473345713/article/details/50987316

http://blog.csdn.net/lanjiangzhou/article/details/8993282

http://www.cnblogs.com/fish7/p/4391035.html




http://www.xuebuyuan.com/1394443.html 去重 模板

#include <iostream>
#include <string>
using namespace std;


int main()
{
string b;
getline(cin, b);
int count = 0;
for (int i = 0; i <= 127; i++)
if (b.find(i) != string::npos)//如果没有找到返回npos
count++;
cout << count;
}




/*编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计*/
//输入描述：输入N个字符，字符在ACSII码范围内(0~127)
//输出描述：输出字符的个数 #include<iostream>


using namespace std;


int main(){
char ch;
int arr[128] = { 0 };
int count = 0;
while (cin >> ch){
if (ch >= 0 && ch <= 127){
arr[ch]++;
}
}
for (int i = 0; i<128; i++){
if (arr[i]>0)
count++;
}
cout << count << endl;
return 0;
}


/*C++
输入字符，ascii值在[0,127]时插入集合set中，输出set中的元素个数。*/
#include<iostream>
#include<set>
using namespace std;
int main()
{
char c;
set<char> s;//set不允许添加重复的元素
while (cin >> c){
if (c >= 0 && c <= 127){
s.insert(c);
}
}
cout << s.size() << endl;
}




 去重函数：



//逆序去重
#include<iostream>
#include<string>
using namespace std;
int main()
{
string a;
int i, j,n=0;
cin >> a;
int len=a.length();






cout << a[len - 1];


for (int i = len - 2; i >= 0; i--)
{
int n = 0;
for (int j = i + 1; j<len; j++)


if (a[i]!= a[j])
{
n++;
if (n == (len - i - 1))
cout<<a[i];
}


}




/*for (i = 0; i < len; i++)
{    
for (j = 0;  j<i; j++)
{
if (a[i] != a[j])
{
n++;
if (n==i)
{
cout << a[i];
a[++k] = a[i];
n = 0;


}



}
}




}*/
//for (i = 0; i < k; i++)
//{
// cout << a[i];
//}
return 0;
}






//正序去重
#include<iostream>
#include<string>
using namespace std;
//int n;
int main()
{
string a;
int i, j, n = 0;
cin >> a;
int len = a.length();
cout << a[0];


for (i = 1; i < len; i++)//直接从1开始
{
n = 0;
for (j = 0;  j<i; j++)

if (a[i] != a[j])
{
n++;
if (n==i)
{
cout << a[i];
//n = 0;
int p = n;
}






}





}
//for (i = 0; i < k; i++)
//{
// cout << a[i];
//}
return 0;
}


正序去重2：

//去重 数组
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
int a[] = {1,2,3,3,3,4,4,4,4,5,6,7,6,8,6,9,1,11,10};//数组没有/0
int j=0;
//cout << sizeof(a) << endl;
cout << a[0];


for (int i = 1; i < sizeof(a)/sizeof(a[0]); i++)
{
j = 0;
for (int k = 0; k < i; k++)
if (a[k] == a[i])
j++;
if (j == 0)
cout << a[i]<<" ";


}


return 0;
}

//正序去重存储另一个空间

//去重 数组
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
int a[] = {1,2,3,3,3,4,4,4,4,5,6,7,6,8,6,9,1,11,10};//数组没有/0
int b[sizeof(a) / sizeof(a[0])];
int j=0,t=0;
//cout << sizeof(a) << endl;
//cout << a[0]<<" ";
b[t++] = a[0];

for (int i = 1; i < sizeof(a)/sizeof(a[0]); i++)
{
j = 0;
for (int k = 0; k < i; k++)
if (a[k] == a[i])
j++;
if (j == 0)
//cout << a[i]<<" ";
b[t++] = a[i];


}
for (int i = 0; i < t; i++)
{
cout << b[i] << " ";
}
cout << endl;
return 0;
}


vector去重函数unique

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
      vector<int> ps;
        if(pHead==NULL)
            return NULL;//必须加
        while(pHead!=NULL)
            {
            ps.push_back(pHead->val);
            pHead= pHead->next;
        }
          unique(ps.begin(),ps.end()); 
          ListNode* pt=new ListNode(ps[0]) ;
           ListNode*  p=pt;
         ListNode*  node=NULL;
            for(int i=1;i<ps.size();i++)
              {
               // p->next=node;
                
                //p->next.val=ps[i];
               // p= p->next;
               node = new ListNode(ps[i]);
            //   *node=sum % 10;
        
           p->next = node;
           // p =node;
           p= p->next ;
         
        
                
          }
           
        return  pt;
    }
  
};

//正向去重真的输入数组中

#include<iostream>
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
using namespace std;
int* qc(int* a,int n)
{
int b[500];
int j = 0, t = 0;
b[0] = a[0];


for (int i = 1; i <= n; i++)
{
j = 0;
for (int k = 0; k < i; k++)
if (a[k] == a[i])
j++;
if (j == 0)
b[++t] = a[i];
}
int* c = (int*)malloc(t*sizeof(int));
for (int i = 0; i < t; i++)
{
c[i] = b[i];
}
return c;
}
int main()
{
int a[] = { 99,23,99,78,87,78, 10,13,10,19 };//数组没有/0
int * c;
c = qc(a, sizeof(a) / sizeof(a[0]));
//
//cout << sizeMalloc(c);
for (int i = 0; i < *(c - 4) / sizeof(c); i++)
//for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
{
cout << c[i] << " ";
}
cout << endl;
return 0;
}


测试用例:
{1,2,3,3,4,4,5}

对应输出应该为:

{1,2,5}

你的输出为:

{1,2,3,4,5,4,5}//没彻底删除


//java正向去重和彻底删除

 package lianbiao;

import java.util.Scanner;

public class Main4 {

public static void main(String[] args)
{
Scanner sc=new Scanner( System.in);
while(sc.hasNext())
{
int n=sc.nextInt();
int[] a=new int[n];
for(int i=0;i<n;i++)
{
a[i]=sc.nextInt(); 
}
/*System.out.print(a[0]);

for(int i=1;i<n;i++) //正向去重
{
    int s=0;
for(int j=0;j<i;j++)
{
if(a[i]!=a[j])
s++;
}
if(s==i)
System.out.print(a[i]);*/  

int[] b=new int[n];
int value=0;
for(int i=0;i<n;i++)
{
    int s=0;
for(int j=0;j<n;j++)
{
if(a[i]==a[j])
s++;
}
if(s==1)//彻底删除
{
System.out.print(a[i]);
b[value]=a[i];
value++;
}
}

System.out.println();
for(int i=0;i<value;i++)
{
System.out.print(b[i]);
}


}
}
}





/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
      vector<int> ps;
        if(pHead==NULL)
            return NULL;//必须加 不然栈溢出
        while(pHead!=NULL)
            {
              //if(pHead->val==pHead->next->val)
              // {
              //  pHead=pHead->next->next;
             //   continue;
         //   }
            
            ps.push_back(pHead->val);
            pHead= pHead->next;
          
        }
        /*
           for(int i=0;i<ps.size();i++)
               {
                 if(ps[i]==ps[i+1])
                     t=p[i];
           }
           */
             
         // unique(ps.begin(),ps.end()); 
          ListNode* pt=new ListNode(ps[0]) ;
           ListNode*  p=pt;
         ListNode*  node=NULL;
        vector<int>::iterator iter = unique(ps.begin(),ps.end());
         // ps.erase(iter,ps.end());
         ps.erase(iter,ps.end());
            for(int i=1;i<ps.size();i++)
              {
               // p->next=node;
                
                //p->next.val=ps[i];
               // p= p->next;
               node = new ListNode(ps[i]);
            //   *node=sum % 10;
        
           p->next = node;
           // p =node;
           p= p->next ;
         
        
                
          }
           
        return  pt;
    }
  
};


//去重和擦除实现真正的去重

您的代码已保存
答案错误:您提交的程序没有通过所有的测试用例

case通过率为0.00%
测试用例:
{1,2,3,3,4,4,5}

对应输出应该为:

{1,2,5}

你的输出为:

{1,2,3,4,5}
http://blog.sina.com.cn/s/blog_69146f5101016tv6.html  排序去重 unique vector

http://blog.csdn.net/wangyadong/article/details/4239209

http://blog.csdn.net/a601025382s/article/details/8277609







题目：

题目描述

编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。


输入描述:
输入N个字符，字符在ACSII码范围内(0~127)。


输出描述:
输出字符的个数。

输入例子:
abc

输出例子:
3
 
 
 
 
 
 
#include<iostream>
#include<string>
using namespace std;
    int main()
   {
        int n=0;
        string a;
        cin>>a;
        int m=a.size();
        cout<<a[m-1];
        for(int i=m-2;i>=0;i--)
            {n=0;
            for(int j=i+1;j<m;j++)           
//for(int j=m-1;j>i;j--) //也可以
                if (a[i]!= a[j])                { n++;                if(n==m-1-i)                    cout<<a[i];             }                       }    }
 
 
题目描述

  
  

   
   
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。


   
   
输入描述:

   
   
输入一个int型整数

   
   

   
   

   
   
输出描述:

   
   
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数

  
  
 
 
 

 


                

        

        

    

  


    

      

        

            

              
                
                  乐学勤思
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
逆序去重（Python实现）

				
			

			

				

					qq_42433311的博客
				

				

					11-13
					
					457
					
				

			

		

		

			
				
# 输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。 保证输入的整数最后一位不是0。
# 输入描述： 输入一个int型整数
# 输出描述： 按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
# 示例1 输入： 30010733 输出： 3701
num = input("请输入一个int型整数：")
res =''
st = set()
for i in num[::-1]:
    if i not in st:
        res+=i
        st.a.

			
		

	



                

            
              



	

		

			

				
					
华为机试—整数逆序并去重

				
			

			

				

					小地盘的诺克萨斯
				

				

					01-09
					
					2449
					
				

			

		

		

			
				
输入一个整数，如12336544，或1750，然后从最后一位开始倒过来输出，最后如果是0，则不输出，输出的数字是不带重复数字的，所以上面的输出是456321和571。如果是负数，比如输入-175，输出-571。
#include 
#include 
using namespace std;

//逆序
char * revs(char *s){
	int j = strlen(s)-1;
  

			
		

	



              


  
              

                


	

		

			

				
					
java  jsonarray 踢重  去重操作

				
			

			

				

					11-17
				

			

		

		

			
				
在Java中处理JSON数据时，经常需要对JSON数组进行各种操作，其中去重是一个常见的需求。本文将详细介绍如何使用Java对`JSONArray`进行去重操作，并深入探讨背后的原理和技术细节。  ### JSON与Java  JSON...

			
		

	





	

		

			

				
					
python图片批量去重脚本.zip

					
最新发布

				
			

			

				

					11-04
				

			

		

		

			
				
Python图片批量去重脚本是利用计算机视觉库OpenCV实现的一种高效、智能的图像处理解决方案。这个脚本旨在帮助用户在大量图片库中检测并去除重复或高度相似的图片，从而节省存储空间并优化管理。在图像处理领域，特别...

			
		

	



		

			
		



	

		

			

				
					
Java中对List去重 Stream去重的解决方法

				
			

			

				

					08-27
				

			

		

		

			
				
Java中List去重和Stream去重的解决方法  List去重是Java中的一种常见操作，对于List中的重复元素进行去重，从而使得List中的元素变得独一无二。 Java中提供了多种方法来实现List去重，下面我们将对其中的一些方法...

			
		

	





	

		

			

				
					
基于python与哈希算法实现图像去重

				
			

			

				

					06-25
				

			

		

		

			
				
当我们需要对大量图片进行管理和分类时，图像去重成为一个关键问题。本文将深入探讨如何利用Python编程语言和哈希算法来有效地实现图像去重。  首先，我们要理解哈希算法的基本原理。哈希（Hash）算法是一种将任意...

			
		

	





	

		

			

				
					
Java中List集合对象去重及按属性去重的8种方法

				
			

			

				

					09-08
				

			

		

		

			
				
【Java中List集合对象去重及按属性去重的8种方法】  在Java编程中，当我们处理包含重复元素的List时，有时需要去除其中的重复项。以下文章将详细介绍8种针对List集合对象去重的方法，包括基于对象整体以及按特定属性...

			
		

	





	

		

			

				
					
倒序 升序 去重

				
			

			

				

					浅夏博客
				

				

					03-29
					
					207
					
				

			

		

		

			
				
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>排序</titl...

			
		

	





	

		

			

				
					
将整数倒序输出，剔除重复数据

				
			

			

				

					Dylan_min
				

				

					07-08
					
					904
					
				

			

		

		

			
				
输入一个整数，如12336544，或1750，然后从最后一位开始倒过来输出，最后如果是0，则不输出，输出的数字是不带重复数字的，所以上面的输出是456321和571。如果是负数，比如输入-175，输出-571。

			
		

	





	

		

			

				
					
js数组去重

				
			

			

				

					weixin_45519474的博客
				

				

					10-28
					
					2361
					
				

			

		

		

			
				
1、利用ES6中 Set去重
ES6提供了新的数据结构Set，Set函数可以接受一个数组（或类数组对象）作为参数来初始化。
Array.from方法可以将Set结构转换为数组结果，而Set结果是不重复的数据集，因此能够去重。

2、利用ES6中 Set 和解构赋值去重
…扩展运算符        （…可用来转换为数组对象）

问题：因为js是判断对象地址是否相同，而不是对象内容，所以每个空对象都是...

			
		

	





	

		

			

				
					
实现去重的五种方法

				
			

			

				

					qq_45570358的博客
				

				

					07-29
					
					3088
					
				

			

		

		

			
				
实现去重的五种方法
1.使用LinkedHashSet删除arraylist中的重复数据
LinkedHashSet是在一个ArrayList删除重复数据的最佳方法。LinkedHashSet在内部完成两件事：
删除重复数据
保持添加到其中的数据的顺序
Java示例使用LinkedHashSet删除arraylist中的重复项。在给定的示例中，numbersList是包含整数的arraylist，其中一些是重复的数字，例如1,3和5.我们将列表添加到LinkedHashSet，然后将内容返回到列表中。结果a

			
		

	





	

		

			

				
					
distinct合并结果集---以及SQL中distinct的用法

				
			

			

				

					c_molione的博客
				

				

					10-21
					
					2585
					
				

			

		

		

			
				
转自 ：https://www.cnblogs.com/rainman/archive/2013/05/03/3058451.html#m1

1.作用于单列
	2.作用于多列
	3.COUNT统计
	4.distinct必须放在开头
	5.其他
在表中，可能会包含重复值。这并不成问题，不过，有时您也许希望仅仅列出不同（distinct）的值。关键词 distinct用于返回唯一不同的值。

表A：



表B:



1.作用于单列


select distinct name from A

执行后结果

			
		

	





	

		

			

				
					
深度学习之原生数组去重

				
			

			

				

					测试0901-1
				

				

					07-19
					
					209
					
				

			

		

		

			
				
 //使用一次循环来完成我们的数组去重    //思想:    //var obj={};    //把数组中的每一项都当做一个对象的属性名和属性值进行存储 -&gt;    //{1:1}    //{1:1,2:2}    //{1:1,2:2,3:3}    //接下来需要存储的是2,看原来的对象中是否存在这一项,不存在继续存储,存在的话说明数组中的这一项在之前出现过(这一项重复了),我们把...

			
		

	





	

		

			

				
					
去重是distinct还是group by？

					
热门推荐

				
			

			

				

					梁吉林的博客
				

				

					04-24
					
					10万+
					
				

			

		

		

			
				
distinct简单来说就是用来去重的，而group by的设计目的则是用来聚合统计的，两者在能够实现的功能上有些相同之处，但应该仔细区分，因为用错场景的话，效率相差可以倍计。单纯的去重操作使用distinct，速度是快于group by的。distinctdistinct支持单列、多列的去重方式。 
单列去重的方式简明易懂，即相同值只保留1个。 
多列的去重则是根据指定的去重的列信息来进行，即只有

			
		

	





	

		

			

				
					
JavaScript对象数组去重与删除方法

				
			

			

				

					
				

			

		

		

			
				
本文主要讨论了在JavaScript中如何处理数组，特别是当数组中存储的对象时，如何进行去重和删除特定属性的操作。提供了四种不同的方法，包括使用jQuery的`$.unique`函数、`$.grep`函数，以及两种自定义的JavaScript...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值