840 矩阵中的幻方1295.统计位数为偶数的数字1304 和为零的N个唯一整数1002查找常用字符1252 奇数值单元格的数目1313 解压缩编码列表1170. 比较字符串最小字母出现频次

840. 矩阵中的幻方
     3 x 3 的幻方是一个填充有从 1 到 9 的不同数字的 3 x 3 矩阵，其中每行，每列以及两条对角线上的各数之和都相等.
     给定一个由整数组成的 grid，其中有多少个 3 × 3 的 “幻方” 子矩阵？（每个子矩阵都是连续的）.

int numMagicSquaresInside(vector<vector<int>>& grid) {              
int res = 0 , temp = 1*2*3*4*5*6*7*8*9;        
for(int i = 1 ; i < grid.size()-1 ; i++)            
for(int j = 1 ; j < grid[0].size()-1 ; j++)            
{                
	if(grid[i][j]==5)                
	{                    
	if(grid[i-1][j-1]+grid[i-1][j]+grid[i-1][j+1]==15&&                        
	grid[i][j-1]+grid[i][j]+grid[i][j+1]==15&&                        
	grid[i+1][j-1]+grid[i+1][j]+grid[i+1][j+1]==15&& // 行                        
	grid[i-1][j-1]+grid[i][j-1]+grid[i+1][j-1]==15&&                          
	grid[i-1][j]+grid[i][j]+grid[i+1][j]==15&&                        
	grid[i-1][j+1]+grid[i][j+1]+grid[i+1][j+1]==15&&                        
	grid[i-1][j-1]+grid[i-1][j]+grid[i-1][j+1]==15&& // 列                        
	grid[i-1][j-1]+grid[i][j]+grid[i+1][j+1]==15&&                        
	grid[i+1][j-1]+grid[i][j]+grid[i-1][j+1]==15&&                        
	grid[i-1][j-1]*grid[i-1][j]*grid[i-1][j+1]*grid[i][j-1]*grid[i][j]*grid[i][j+1]*grid[i+1][j-1]*grid[i+1][j]*grid[i+1][j+1]==temp)                         
	{                                                      
		res++;                        
	}                
}            
}        
	return res;   
}

1295. 统计位数为偶数的数字
      给你一个整数数组 nums，请你返回其中位数为 偶数 的数字的个数

int findNumbers(vector<int>& nums) {        
int cnt = 0 , res = 0 , e = 0 ;        
for(int i = 0 ; i < nums.size() ; i++)        
	{            
		res = 1;            
		e = nums[i];            
		while(e/10)            
		{                
		e /= 10;                
		res++;            
		}            
		if(res%2==0) cnt++;                    
	}        
	return cnt;            
}

1304. 和为零的N个唯一整数
      给你一个整数 n，请你返回 任意 一个由 n 个 各不相同 的整数组成的数组，并且这 n 个数相加和为 0。

 vector<int> sumZero(int n) {        
 vector<int> res;        
 int cnt = 1;        
 if(n%2==0)        
	 {            
 		n = n/2;            
 		while(n)            
 		{                
 			res.push_back(cnt);                
			 res.push_back(-cnt);                
			 cnt++;                
			 n--;            
		}        
 	}        
 else        
 	{            
			 n = (n-1)/2;             
			 while(n)            
			 {               
			  res.push_back(cnt);               
			   res.push_back(-cnt);                
 			  cnt++;                 
 			  n--;            
  			 }            
 		  res.push_back(0);        
       }        
  		 return res;    
   }

1002. 查找常用字符
      给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。你可以按任意顺序返回答案。

 vector<string> commonChars(vector<string>& A) {        
 //建立二维数组        
	 vector<string> res;        
	 int cnt[100][26] = {0};        
 	for(int i = 0 ; i < A.size() ; i++)            
 		for(int j = 0 ; j < A[i].size() ; j++)                
 			cnt[i][A[i][j]-'a']++;
  	for(int i = 0 ; i < 26 ; i++)   //调换顺序            
 		 for(int j = 0 ; j < A.size() ; j++)                
  			cnt[0][i] = min(cnt[0][i] , cnt[j][i]);                 
  	for(int i = 0 ; i < 26 ; i++)        
 	 {            
 		 if(cnt[0][i]!=0)            
  			{                
  			while(cnt[0][i]--)                
  				{                    
 				 string temp;                
 				 temp.push_back((char)(i+'a'));                
  				res.push_back(temp);                
  				temp.clear();                
 				 }                            
			  }        
	  }        
  return res;            
  }

1252. 奇数值单元格的数目
      给你一个 n 行 m 列的矩阵，最开始的时候，每个单元格中的值都是 0。
      另有一个索引数组 indices，indices[i] = [ri, ci] 中的 ri 和 ci 分别表示指定的行和列（从 0 开始编号）。
      你需要将每对 [ri, ci] 指定的行和列上的所有单元格的值加 1。
      请你在执行完所有 indices 指定的增量操作后，返回矩阵中 「奇数值单元格」 的数目。

int  row[n] = {0} , col[m] = {0};        
int res = 0;        
for(auto e : indices)       
 {            
 	row[e[0]]++;            
 	col[e[1]]++;        
 }        
 for(int i = 0 ; i < n ; i++)        
 	{            
 		for(int  j = 0 ; j < m ; j++)            
 		{                
		 if((row[i]+col[j])%2!=0)                    
 		 res++;            
 		}        
	 }        
 return res;

/*  ？？？？？？？？？？？？？？？ 不应该错啊 ？？？？？？？？？？？？？？        
int res[n][m] = {0};        
int cnt = 0;        
for(int i = 0 ; i < indices.size() ; i++)        
{            
for(int j = 0 ; j < m ; j++) // 行           
 {                
 int row = indices[i][0];                
 res[row][j]++;            
 }            
 for(int j = 0 ; j < n ; j++) // 行            
 {                
 int col = indices[i][1];                
 res[j][col]++;            
 }        
 }        f
 or(int i = 0 ; i < n ;i++)            
 for(int j = 0 ; j < m ; j++)            
 {                
 if(res[i][j]%2!=0)                    
 cnt++;            
 }        
 return cnt; */    
 }

1232. 缀点成线
      在一个 XY 坐标系中有一些点，我们用数组 coordinates 来分别记录它们的坐标，其中 coordinates[i] = [x, y] 表示横坐标为 x、纵坐标为 y 的点。
      请你来判断，这些点是否在该坐标系中属于同一条直线上，是则返回 true，否则请返回 false。

bool checkStraightLine(vector<vector<int>>& coordinates) {        
// 斜率公式         
for(int i = 1 ; i < coordinates.size() ; i++)        
	{            
	if((coordinates[1][1]-coordinates[0][1])*(coordinates[i][0]-coordinates[0][0])!=(coordinates[1][0]-coordinates[0][0])*(coordinates[i][1]-coordinates[0][1]))              
	return false;        
	}        
	return true;    
}

1313. 解压缩编码列表
      给你一个以行程长度编码压缩的整数列表 nums。
      考虑每相邻两个元素 [a, b] = [nums[2i], nums[2i+1]] （其中 i >= 0 ），每一对都表示解压后有 a 个值为 b 的元素。
      请你返回解压后的列表。

 vector<int> decompressRLElist(vector<int>& nums) {        
 vector<int> res;        
 for(int i = 0 ; i < nums.size() ;)        
	 {            
		 while(nums[i]--)           
  		{                
  		res.push_back(nums[i+1]);            
  		}            
  		i++;            
  		i++;       
  	 }        
   return res;
 }

1287. 有序数组中出现次数超过25%的元素
      给你一个非递减的 有序 整数数组，已知这个数组中恰好有一个整数，它的出现次数超过数组元素总数的 25%。请你找到并返回这个整数

 int findSpecialInteger(vector<int>& arr) {        
 int res ,cnt = 0 , num = arr.size();        
 for(int i = 0 ; i < num-1 ; i++)        
 {            
 	if(arr[i+1]==arr[i])                
 		cnt++;            
 	else                
	 	cnt = 0;            
	 if(cnt>num/4)               
 	{                   
 		res = arr[i];                   
 		break;               
 	}         
 }        
 return res;
}

1170. 比较字符串最小字母出现频次
      我们来定义一个函数 f(s)，其中传入参数 s 是一个非空字符串；该函数的功能是统计 s 中（按字典序比较）最小字母的出现频次。
      例如，若 s = “dcce”，那么 f(s) = 2，因为最小的字母是 “c”，它出现了 2 次。
      现在，给你两个字符串数组待查表 queries 和词汇表 words，请你返回一个整数数组 answer 作为答案，其中每个 answer[i]是满足 f(queries[i]) < f(W) 的词的数目，W 是词汇表 words 中的词。

 //  题目描述真扯淡        
 int quer[queries.size()] = {0} , wor[words.size()] = {0};        
 int cnt = 1 , num = 0;        
 for(auto querie : queries)  // queries        
 	{            
		 sort(querie.begin() , querie.end());            
 		cnt = 1;            
 		for(int i = 1 ; i < querie.size() ; i++)            
 		{                
		 if(querie[i-1]==querie[i])                    
 			cnt++;                
		 else                    
 			break;            
		}            
  		 quer[num] = cnt;            
  		 num++;        
     }       
 num = 0;         
for(auto word : words)  // words        
    {            
    	sort(word.begin() , word.end());            
    	cnt = 1;            
    for(int i = 1 ; i < word.size() ; i++)            
    {                
   	 if(word[i-1]==word[i])                    
    		cnt++;                
   	 else                    
   		 break;
    }            
      wor[num] = cnt;            
      num++;        
   }        
   sort(wor , wor+words.size());        
    vector<int> res;        
    num = words.size();        
    for(int i = 0 ; i < queries.size() ; i++)        
       {            
            for(int j = 0 ; j < num ; j++)            
            	{                
           		 if(wor[num-1]<=quer[i])  // 特殊情况                    
           		 {                        
            			res.push_back(0);                        
            			break;                    
            		 }                
            		if(wor[j]>quer[i])                   
           		 {                       
           			 res.push_back(num-j);                        
           			 break;                   
           		 } 
            	}        
       }             
 return res;
 }