多多的求和计算

• JavaScript 版本

  function sum(num, param, arr) {
    let total = 0
    for (let i = 1; i <= num; i++) {
        for (let j = 0; j <= num-i; j++) {
            let temporaryArr = arr.slice(j, j+i)
            if (eval(temporaryArr.join('+')) % param === 0) total++
        }
    }
    return total
  }

#include <iostream>
#include <cstring>
using namespace std;
int main(){
    int n, m;
    cin>>n>>m;
    int arr[n];
    for (int i = 0; i < n; ++i){
        cin>>arr[i];
    }
    int map[m];//下标表示前缀和 % m后的值，map[i]表示取余后值为i的个数；
    memset(map, 0, sizeof(map));
    map[0] = 1;//需要设置这个初始值，看下面代码就懂了
    long sum = 0;
    long ans = 0;
    for (int i = 0; i < n; ++i){
        sum += arr[i];
        int index = sum % m;
        ans += map[index]++;
    }
    cout<<ans<<endl;
    return 0;
}

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

int main() {
    long long n, m; 
    cin >> n >> m;
    vector<long long> cnt(m, 0);  //前缀和余数出现的次数
    cnt[0] = 1;   // 数值未加入前，前缀和为0，统计起点为0的情况
    //前缀和sum[j] - sum[i]为区间[i, j]的总和
    //所以统计前缀和余数相同的数出现的次数，任意选两个可以组成一个和谐区间
    long long tree; 
    long long sum = 0;
    for(int i = 0; i < n; i ++){
        cin >> tree;
        tree = tree % m;
        sum = (sum + tree) % m;
        cnt[sum] ++;
    }
    long long ans = 0;
    for(int i = 0; i < m; i ++){
        ans += cnt[i] * (cnt[i] - 1)/2;
    }
    cout << ans << endl;
    return 0;
}

# 利用前缀和原理
n,m = list(map(int, input().strip().split(' '))) # 主要在意M就行，要能被M整除
ai=list(map(int,input().strip().split(' '))) # 每个数组的值
li={0:1} # li字典放所有的前缀和 除 m 得到的余数出现的次数，初始化我们需要 使出现 余数为 0 出现一次
sum=0
count = 0 # 用来统计
for i in ai:
    sum+= i # 前缀和
    yu=sum%m # 求前缀和的除m的余数
    if yu in li.keys():
        # 如果 已有存在的key（余数）说明到他这里我们必有可以除断的。（可以理解为余数一样的那么中间这一段必定可以除断）
        # 然后我们需要看几个余数一样的来判断可以组合几个
        count += li[yu]
    if yu not in li.keys(): # 将前缀和的余数存进字典
        li[yu]=1
    else:
        li[yu]+=1
print(count)

import java.util.*;
 
public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        int M = scanner.nextInt();
        int[] A = new int[N];
        for(int i = 0; i < N; i++){
            A[i] = scanner.nextInt();
        }
        int count = 0;
        int sum = 0;
        Map<Integer, Integer> record = new HashMap<>();
        //遍历数组nums之前，record提前放入 0:1 键值对，代表求第 0 项前缀和之前，前缀和 mod K 等于 0 这种情况出现了 1 次。
        record.put(0,1);
        for(int elem : A){
            sum+=elem;//前缀和
            int model = (sum % M + M) % M;//取余数
            //getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值0。
            record.put(model, record.getOrDefault(model, 0)+1);
        }
        //values() 方法返回映射中所有 value 组成的 Set 视图
        for(int n : record.values()){
            count+=n*(n-1)/2;
        }
        //for(Map.Entry<Integer, Integer> entry : record.entrySet()){
        //    count+=entry.getValue()*(entry.getValue()-1)/2;
        //}
        System.out.println(count);
    }
}

n,m = list(map(int, input().strip().split(' ')))
ai=list(map(int,input().strip().split(' ')))
li={}
sum=0 for i in ai:
    sum+=i
    yu=sum%m if yu not in li.keys():
        li[yu]=1  else:
        li[yu]+=1 hh=0 for i,j in li.items(): if i==0:
        hh+=j
    nn=j*(j-1)//2  hh+=nn print(hh)

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static long countHarmonySubarrays(long[] A, int M) {
        long count = 0;
        long[] P = new long[A.length + 1];
        Map<Long, Long> map = new HashMap<>();
        for (int i = 0; i < A.length; i++) {
            P[i + 1] = P[i] + A[i];
            if (P[i + 1] % M == 0) {
                count++;
            }
            if (map.containsKey(P[i + 1] % M)) {
                count += map.get(P[i + 1] % M);
            }
            if (!map.containsKey(P[i + 1] % M)) {
                map.put(P[i + 1] % M, 0L);
            }
            map.put(P[i + 1] % M, map.get(P[i + 1] % M) + 1);
        }
        return count;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        int M = scanner.nextInt();
        long[] A = new long[N];
        for (int i = 0; i < N; i++) {
            A[i] = scanner.nextLong();
        }
        System.out.println(countHarmonySubarrays(A, M));
    }
}

const rl = require("readline").createInterface({ input: process.stdin });
var iter = rl[Symbol.asyncIterator]();
const readline = async () => (await iter.next()).value;

// 相同余数的前缀区间任选两个所构成的中间区间一定和谐（因为大的那个前缀区间求和减去小的前缀区间求和，刚好把那个多出来的余数减掉了，因此中间区间求和一定能被m整除）
void async function () {
    // Write your code here
    var arr=[];
    while(line = await readline()){
        arr.push(line)
        
    }
    // console.log("arr:",arr)
    var firstline=arr[0].split(" ")
    // console.log("firstline:",firstline)
    var listlen=parseInt(firstline[0])
    var harmonum=parseInt(firstline[1])
    var list=arr[1].split(" ")
    var lista=list.map(item=>parseInt(item))
    // console.log('lista:',lista)
// //存放0-i位置的数组和的余数
    // var leftnum=[]
    var sumtmp=0
    var ans=0
// //存放某个余数的出现个数
    var map=new Map([[0,0]])
    for(var i=0;i<listlen;i++){
        sumtmp+=lista[i]
        if(sumtmp%harmonum==0){ans+=1}
        if(!map.has(sumtmp%harmonum)){
            map.set(sumtmp%harmonum,1)
        }else{
            ans+=map.get(sumtmp%harmonum)
            map.set(sumtmp%harmonum,map.get(sumtmp%harmonum)+1)
        }
    }
    console.log(ans)
}()

#include<bits/stdc++.h>
using namespace std;
int main(){
    long int n = 0, m = 0;
    cin>>n>>m;
    vector<long int> vec(n);
    for(auto &i : vec) cin>>i;
    vector<long int> arr(m, 0);
    long long int ans = 0;
    for(auto i : vec){
        vector<long int> old = arr;
        for(int j = 0;j < m;j++){
            arr[(i + j)%m] = old[j];
        }
        arr[i%m]++;
        ans += arr[0];
    }
    cout<<ans;
    return 0;
}

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


int main()
{
	int N, M;
	cin >> N >> M;
	vector <int> arr(N);
	for (int i = 0; i < N; i++)
	{
		cin >> arr[i];
	}
	vector <int> map(M,0);
	map[0] = 1;
	long sum = 0;
	long ans = 0;
	for(int i = 0; i < N; i++)
	{
		sum += arr[i];
		int index = sum % M;
		ans += map[index]++;
	}
	cout << ans << endl;
	system("pause");
	return 0;

}

前缀和技巧 + 同余

#include <iostream>
#include <algorithm>
#include <vector>
#include <unordered_map>
// #include <bits/stdc++.h>

using namespace std;
const int N = 1e5 + 5;
int w[N];
unordered_map<int, int> cnt;

void solve(){
    cnt[0] = 1;

    int n, m;
    cin >> n >> m;
    int s = 0;
    long long ans = 0;
    for (int i = 1; i <= n; i ++ ) {
        int x;
        cin >> x;
        s = (s + x) % m;
        ans += cnt[s];
        cnt[s] ++ ;
    }

    cout << ans << endl;
}

int main()
{   
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int t;
    // cin >> t;
    t = 1;
    while (t -- )
        solve();
    return 0;
}