akhauriyash/Code-Regression huggingface dataset:
#include<iostream>
#include<string>
#include<algorithm>	
#include<cmath>
using namespace std;
int main() {
	long long n, m, a, b, ans = 0; cin >> n >> m;
	int aa[101][101] = { 0 }; int bb[101] = { 0 }; 
	for (int h = 1; h <= n; h++) {
		for (int i = 1; i <= m; i++) {
			cin >> a;
			aa[h][i] = a;
		}
	}
	for (int h = 1; h <= m; h++) {
		cin >> b;
		bb[h] = b;
	}
	for (int h = 1; h <= n; h++) {
		for (int i = 1; i <= m; i++) {
			ans += aa[h][i] * bb[i];
		}
		cout << ans << endl;
		ans = 0;
	}
	cin >> n;
}


Measured memory_bytes: 3152
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> 
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

#define ordered_set tree<long long, null_type,less<long long>, rb_tree_tag,tree_order_statistics_node_update>
//s.find_by_order(index) returns iterator to the index-th element
//in O(logn) time.



typedef unsigned long long ull;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<int> vii;
typedef vector<string> vss;
typedef vector<pair<ll, ll> > vpll;
typedef unordered_map<ll ,ll> mpll;
typedef unordered_map<int ,int> mpii;
typedef unordered_map<char ,ll> mpcl;
typedef pair<ll , ll> pll;
typedef complex<double> cd;
typedef vector< complex<double> > vcd;


#define fore(i,n) for(i=0;i<n;i++)
#define forz(i,s,f) for(i=s;i<f;i++)
#define forer(i,n) for(i=n-1;i>=0;i--)
#define forzr(i,s,f) for(i=s;i>=f;i--)
#define mkp make_pair
#define pb push_back
#define eb emplace_back
#define ub upper_bound
#define lb lower_bound
#define ff first
#define ss second
#define pvec(i,vec) fore(i,vec.size())cout<<vec[i]<<" ";cout<<"\n";

const ll mod=1e9+7;
const ll modulo=998244353;
const double pi = 3.14159265358979323846;


ll power(ll x,ll y,ll m)//gives (x^y)%m
{
    ll ans=1;
    while (y>0)
    {
        if(y & 1)
        {
            ans=(ans*x)%m;
        }
        y=y/2;
        x=(x*x)%m;
    }
    return ans;
}

bool sortbysec(pll &a,pll &b)
{
    return(a.ss<b.ss);
}

ll gcd(ll a,ll b)
{
	if(a==0)
		return b;
	else
		return(gcd(b%a,a));
}

ll lcm(ll a,ll b)
{
	ll ans=(a*b)/gcd(a,b);
	return ans;
}

long double logn(long double a,long double n)
{
	return(log(n)/log(a));
}

int main(int argc, char const *argv[])
{
	ios_base::sync_with_stdio(false);cin.tie(NULL);
    
	ll te=1,test,i,j,n,m,flag,k,p,temp;
	//cin>>te;
	for(test=1;test<=te;test++)
	{
		cin>>n;

		vss a(n);
		map<string,ll> mp;
		fore(i,n)
		{
			cin>>a[i];
			mp[a[i]]++;
		}

		cout<<"AC x "<<mp["AC"]<<"\n";
		cout<<"WA x "<<mp["WA"]<<"\n";
		cout<<"TLE x "<<mp["TLE"]<<"\n";
		cout<<"RE x "<<mp["RE"]<<"\n";
		//cout<<"hello\n";
		//cout<<"Case #"<<test<<": ";
	}

	return 0;
}

Measured memory_bytes: 6380
use std::io::*;
use std::str::FromStr;
use std::cmp;


macro_rules! input { (source = $s:expr, $($r:tt)*) => { let mut iter = $s.split_whitespace(); let mut next = || { iter.next().unwrap() }; input_inner!{next, $($r)*} }; ($($r:tt)*) => { let stdin = std::io::stdin(); let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock())); let mut next = move || -> String{ bytes.by_ref().map(|r|r.unwrap() as char).skip_while(|c|c.is_whitespace()).take_while(|c|!c.is_whitespace()).collect() }; input_inner!{next, $($r)*} }; }
macro_rules! input_inner { ($next:expr) => {}; ($next:expr, ) => {}; ($next:expr, $var:ident : $t:tt $($r:tt)*) => { let $var = read_value!($next, $t); input_inner!{$next $($r)*} }; ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => { let mut $var = read_value!($next, $t); input_inner!{$next $($r)*} }; }
macro_rules! read_value { ($next:expr, ( $($t:tt),* )) => { ( $(read_value!($next, $t)),* ) }; ($next:expr, [ $t:tt ; $len:expr ]) => { (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>() }; ($next:expr, [ $t:tt ]) => { { let len = read_value!($next, usize); (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>() } }; ($next:expr, chars) => { read_value!($next, String).chars().collect::<Vec<char>>() }; ($next:expr, bytes) => { read_value!($next, String).into_bytes() }; ($next:expr, usize1) => { read_value!($next, usize) - 1 }; ($next:expr, $t:ty) => { $next().parse::<$t>().expect("Parse error") }; }
 
 

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}


fn main() {
	let N: u32 = read();
    let mut a: Vec<u32> = (0..N).map(|_| read()).collect();
    a.sort_by(|x, y| x.cmp(y).reverse());
   	let mut alice = 0;
    let mut bob = 0;
    
    for (i,&ai) in a.iter().enumerate(){
    	if i%2==0{
			alice += ai;
        }else{
        	bob += ai;
        }
    }
    println!("{}",alice-bob)

    
}


Measured memory_bytes: 4352
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<cmath>

using namespace std;

int main(void) {
	string a;
	cin >> a;
	if (a[0] == a[1] && a[1] == a[2]) {
		cout << "Yes";
		return 0;
	}
	if (a[1] == a[2] && a[2] == a[3]) {
		cout << "Yes";
		return 0;
	}
	cout << "No";
	return 0;
}

Measured memory_bytes: 256
import java.util.*;
import java.lang.*;
public class Main{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);

		int N = sc.nextInt();
		long[] X = new long[N+1];
		long[] xx = new long[N+1];
		for( int i=1; i<=N; i++ ){
			X[i] = sc.nextLong();
			xx[i] = X[i];
		}
		Arrays.sort(xx);
		long med1 = xx[N/2];
		long med2 = xx[N/2+1];
		for( int i=1; i<=N; i++ ){
			if( X[i]<=med1 ){
				System.out.println(med2);
			}else{
				System.out.println(med1);
			}
		}
	}
}


Measured memory_bytes: 93368
// https://atcoder.jp/contests/arc081/tasks/arc081_a
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>
#include <map>
#include <unordered_map>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <bitset>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define REP(i, n) for(size_t i = 0; i < (n); ++i)

int main()
{
    int N;
    scanf("%d", &N);
    vector<ll> A(N);
    REP(i, N) scanf("%lld", &A[i]);
    sort(A.begin(), A.end(), greater<ll>());
    ll ans = -1;
    int i = 0;
    while (i < N)
    {
        if (i < N - 3 && A[i] == A[i + 1] && A[i] == A[i + 2] && A[i] == A[i + 3])
        {
            if (-1 == ans)
                ans = A[i] * A[i];
            else
                ans *= A[i];
            printf("%lld\n", ans);
            return 0;
        }
        else if (i < N - 2 && A[i] == A[i + 1] && A[i] == A[i + 2])
        {
            if (-1 == ans)
            {
                ans = A[i];
                i += 3;
                continue;
            }
            else
            {
                ans *= A[i];
                printf("%lld\n", ans);
                return 0;
            }
        }
        else if (i < N - 1 && A[i] == A[i + 1])
        {
            if (-1 == ans)
            {
                ans = A[i];
                i += 2;
                continue;
            }
            else
            {
                ans *= A[i];
                printf("%lld\n", ans);
                return 0;
            }
            
        }
        else
        {
            ++i;
            continue;
        }
        

    }
    printf("0\n");
    return 0;
}


Measured memory_bytes: 4048
#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <numeric>
#include <string>
#include <map>
#include <set>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define INF 1145141919
typedef long long int ll;
using namespace std;

template <typename T>
istream &operator>>(istream &is, vector<T> &vec)
{
    for (T &x : vec)
        is >> x;
    return is;
}

int main(){
    int n;
    ll x;
    cin >> n >> x;

    vector<ll> a(n);
    cin >> a;

    sort(a.begin(), a.end());

    ll ans=0;

    for(ll i=0; i<n-1; ++i){
        if(x>=a[i]){
            ++ans;
            x-=a[i];
        }
    }

    if(x==a[n-1]){
        ++ans;
    }

    cout << ans << endl;

    return 0;
}

Measured memory_bytes: 256
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <set>
#include <cmath>
#include <map>
#include <stack>
#include <queue>
#include <iomanip>
#define MOD(x) (x + 1000000007) % (1000000007)

using namespace std;

template <class t>
using vec = vector<t>;
using ll = long long;

const int MAX = numeric_limits<int>::max();

template <class t>
ostream &operator<<(ostream &out, vec<t> &v)
{
    for (auto &e : v)
        out << e << " ";
    out << "\n";
    return out;
}

template <class t>
istream &operator>>(istream &in, vec<t> &v)
{
    for (auto &e : v)
        in >> e;
    return in;
}

int main()
{
    int n;
    cin >> n;
    string cmp;
    cin >> cmp;
    vec<ll> dpt(n + 1), dp(n + 1);
    dp[1] = 1;
    for (int i = 2; i <= n; i++, swap(dpt, dp))
        for (int j = 1; j <= i; dpt[j] = MOD(dpt[j] + dpt[j - 1]), j++)
            if (cmp[i - 2] == '<')
                dpt[j] = MOD(dp[j - 1] - dp[0]);
            else
                dpt[j] = MOD(dp[i - 1] - dp[j - 1]);
    cout << dp[n];
    return 0;
}

Measured memory_bytes: 3656
N, M=list(map(int,input().split()))
A=list(map(int,input().split()))
BC=[]
for i in range(M):
    b, c=list(map(int,input().split()))
    BC.append([c,b])

A.sort()
BC=sorted(BC,key=lambda x: x[0])
BC.reverse()

nx=BC[0][0]
nx_i=0
nx_id=0

for i in range(N):
    if (A[i] < nx):
        A[i] = nx
        nx_id+=1
        if nx_id == BC[nx_i][1]:
            nx_id=0
            nx_i+=1
            if nx_i >= M: break
            nx=BC[nx_i][0]
    else:
        break

print(sum(A))

Measured memory_bytes: 26316
#include <iostream>
#include <vector>
using namespace std;

int main() {
  int N;
  cin >> N;
  vector<int> vec(N);
  for(int i = 0; i < N; i++){
    cin >> vec.at(i);
  }
  
  int count = 0;
  bool odd_exist = false;
  while(odd_exist == false){
    for(int i = 0; i < N; i++){
      if(vec.at(i) % 2 == 1){
        odd_exist = true;
        break;
      }
      else{
        vec.at(i) /= 2;
      }
    }
    if(odd_exist == true){
      break;
    }
    count++;
  }
  cout << count << endl;
}


Measured memory_bytes: 256
from collections import deque


H, W, K = map(int, input().split())
x1, y1, x2, y2 = map(lambda x: int(x) - 1, input().split())
grid = [input() for _ in range(H)]

INF = float('inf')
path = [[[(INF, INF)] * 4 for _ in range(W)] for _ in range(H)]

q = deque()
for d in range(4):
    path[x1][y1][d] = (1, 0)
    q.append((x1, y1, d, 1, 0))

D = [(-1, 0), (0, 1), (1, 0), (0, -1)]
while q:
    x, y, d, s, k = q.popleft()
    for nd in range(4):
        if nd == d:
            dx, dy = D[nd]
            nk = 1 if k == K else k + 1
            ns = s + 1 if k == K else s
        else:
            dx, dy = 0, 0
            nk = 0
            ns = s + 1
        nx = x + dx; ny = y + dy
        if 0 <= nx < H and 0 <= ny < W and grid[nx][ny] == '.' and path[nx][ny][nd] > (ns, nk):
            path[nx][ny][nd] = (ns, nk)
            if ns == s:
                q.appendleft((nx, ny, nd, ns, nk))
            else:
                q.append((nx, ny, nd, ns, nk))

ans = INF
for d in range(4):
    ans = min(ans, path[x2][y2][d][0])
ans = -1 if ans == INF else ans
print(ans)


Measured memory_bytes: 400560
#include<bits/stdc++.h>
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define mp make_pair 
#define F first
#define S second
#define ll long long
#define vi vector<ll>
#define vvi vector<vi>
#define BITLE(n) (1LL<<((ll)n))
#define SHIFT_LEFT(n) (1LL<<((ll)n))
#define SUBS(s,f,t) ((s).substr((f),(t)-(f)))
#define ALL(a) (a).begin(),(a).end()
using namespace std;
class BIT{
  //0-indexed
public:
  static const ll MAX_N=520000;
  ll bit[MAX_N+10]={},n;
  BIT(ll num){
    n=num+10;
  }
  void add(ll i,ll value){
    i++;
    while(i<=n){
      bit[i]+=value;
      i += i&-i;
    }
  }
  ll sum(ll i){
    ll ret=0;
    i++;
    while(i>0){
      ret += bit[i];
      i -= i & -i;
    }
    return ret;
  }
};

int main(){
  cin.tie(0);
  ios::sync_with_stdio(false);
  ll n;cin>>n;
  string s;cin>>s;
  BIT bit[27]={n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,
               n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1,n+1  };

  for(int i=0;i<n;i++){
    bit[s[i]-'a'].add(i,1);
  }
  ll q;cin>>q;
  while(q--){
    ll ty;cin>>ty;
    if(ty == 1){
      ll po;char c;cin>>po>>c;
      bit[s[po-1]-'a'].add(po-1,-1);
      bit[c-'a'].add(po-1,1);
      s[po-1] = c;
    }else{
      ll cnt = 0;
      ll l,r;cin>>l>>r;l--;r--;
      for(int i=0;i<26;i++){
       ll minus = 0;
        if(l>0)minus = bit[i].sum(l-1);
		if(bit[i].sum(r)-minus > 0){
          cnt++;
       //   cout<<i<<"!"<<endl;
        }
      }
      cout<<cnt<<endl;
    }
  }
  return 0;
}


Measured memory_bytes: 110620
#include <bits/stdc++.h>
using namespace std;

#define rep(i, n) for(int i = 0; i < (n); i++)
#define repp(i, l, r) for(int i = (l); i < (r); i++)
#define per(i, n) for(int i = ((n)-1); i >= 0; i--)
#define perr(i, l, r) for(int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(),(x).end()
#define MOD 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP <<" "<<
#define CYES cout<<"Yes"<<endl
#define CNO cout<<"No"<<endl
#define CFS cin.tie(0);ios::sync_with_stdio(false)

typedef long long LL;
typedef long double LD;

int main(){
  int n;
  cin >> n;
  if(n==0) cout << 1 << endl;
  else if(n==1) cout << 2 << endl;
  else if(n==2) cout << 1 << endl;
  else{
    cout << 0 <<endl;
  }
  return 0;
}



Measured memory_bytes: 3096
import std.stdio;
import std.conv;
import std.string;
import std.typecons;
import std.algorithm;
import std.array;

alias Tuple!(double, "x", double, "y") Point;

void main()
{
  double[] input;
  while ((input = readln().split().map!(to!double)().array()).length != 0) {
    Point[3] p;
    foreach (i, j; [0, 2, 4]) {
      p[i].x = input[j];
      p[i].y = input[j + 1];
    }

    Point pp;
    pp.x = input[6];
    pp.y = input[7];

    if (cross(p[0], p[1], pp, p[2]) | 
        cross(p[1], p[2], pp, p[0]) | 
        cross(p[0], p[2], pp, p[1])) {
      writeln("NO");
    } else {
      writeln("YES");
    }
  }
}

bool cross(Point p1, Point p2, Point p3, Point p4)
{
  auto value = ((p1.x - p2.x) * (p3.y - p1.y) + (p1.y - p2.y) * (p1.x - p3.x)) *
               ((p1.x - p2.x) * (p4.y - p1.y) + (p1.y - p2.y) * (p1.x - p4.x));
  return (value < 0);
}

Measured memory_bytes: 1072
#include <bits/stdc++.h>
using namespace std;

#define TRACE(x) x
#define WATCH(x) TRACE(cout << #x" = " << x << endl)
#define WATCHR(a, b) TRACE(for (auto it=a; it!=b;) cout << *(it++) << " "; cout << endl)
#define WATCHC(V) TRACE({cout << #V" = "; WATCHR(V.begin(), V.end());})

#define all(x) (x).begin(), (x).end()

using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int N;
    string A, B, C;
    cin >> N >> A >> B >> C;

    int ans = 0;
    for (int i = 0; i < N; i++) {
        ans += B[i] != A[i];
        ans += C[i] != A[i] && C[i] != B[i];
    }
    cout << ans << endl;

    return 0;
}



Measured memory_bytes: 256
#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/range/adaptor/reversed.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
typedef long long int ll;

#define PI (acos(-1))
#define REP(i,n) for(ll (i)=0;(i)<(n);(i)++)

#define dump(x)  cerr << #x << " = " << (x) << endl;
#define dumparr(x) cerr << #x ; for(auto elem: x){cerr << " " << elem;} cerr << endl;
#define dumppairs(x) cerr << #x ; for(auto elem: x){cerr << "(" << elem.first << " " << elem.second << ") ";} cerr << endl;
#define dumpline cerr << "**********************" << endl;
#define dumpwline(x) cerr << "******** " << #x << "=" << (x) << " ********" << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#define ARRAY_LENGTH(array) (sizeof(array) / sizeof(array[0]))

int main(void){
    ll n; cin >> n;
    vector <ll> hs;
    REP(i, n){
        ll h; cin >> h;
        hs.push_back(h);
    }
    vector <ll> dp(n, 1e18);
    dp[0] = 0;
    dp[1] = abs(hs[0] - hs[1]);
    for(int i=2; i<n; i++){
        dp[i] = min(
                abs(hs[i] - hs[i-1]) + dp[i-1],
                abs(hs[i] - hs[i-2]) + dp[i-2]
        );
    }
    cout << dp[n-1] << endl;
    return 0;
}

Measured memory_bytes: 1908
#include <iostream>
using namespace std;
#define N 100
#define INF 9999999
int M[N][N];
int mincost[N];
bool used[N];
int n;
int prim(){
  for(int i=0;i<n;i++){
    used[i]=false;
    mincost[i]=INF;
  }
  mincost[0]=0;
  int res=0;

  while(true){
    int v=-1;
    for(int i=0;i<n;i++){
      if(!used[i] && (v==-1||mincost[i]<mincost[v])){
        v=i;
      }
    }
    if(v==-1) break;
    used[v]=true;
    res+=mincost[v];

    for(int i=0;i<n;i++){
      mincost[i]=min(mincost[i], M[v][i]);
    }
  }
  return res;
}
int main(){
  cin>>n;
  for(int i=0;i<n;i++){
    for(int j=0;j<n;j++){
      int e; cin>>e;
      M[i][j]=(e==-1)?INF:e;
    }
  }
  cout<<prim()<<"\n";

}



Measured memory_bytes: 3108
import collections

# nC2を足す理由は、同一文字列からアナグラムとなっている2つの文字列を見つけないといけないから
N = int(input())
s = ["".join(sorted(input())) for _ in range(N)]
# ソートした時にそれぞれの文字がリストに分割されるからjoinで文字列に直す
c = collections.Counter(s)
ans = 0
for i in set(s):
    n = c[i]
    ans += n * (n - 1) // 2
print(ans)

# set(s)によって、同じ文字列は消去される。そしてcによって、何回その文字が出ているかを数えれる。


Measured memory_bytes: 23436
#include <bits/stdc++.h>
using namespace std;

long long int n, k;
long long int M = 1e+9 + 7;
int main()
{
    cin >> n >> k;
    long long int ans = 1, s1 = 0, s2 = 0;
    for (long long int i = n; i > n - k; i--)
        s2 += i;
    for (long long int i = 0; i < k; i++)
        s1 += i;
    for (long long int i = k; i <= n; i++)
    {
        // cout<<s1<<" "<<s2;
        ans = ((ans + (s2 - s1+1) % M) % M + M) % M;
        s2 += n - i;
        s1 += i;
    }
    cout<<ans;
}

Measured memory_bytes: 3636
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class Main {
     public static void main(String[] args) {
         FastScanner fs=new FastScanner();
         int T=1;
         for (int tt=0; tt<T; tt++) {
                long a = fs.nextLong(),b = fs.nextLong(),c = fs.nextLong(),d = fs.nextLong();
                long ans;
                ans =       a*c;
                long ans1 = a*d;
                long ans2 = b*c;
                long ans3 = b*d;
                System.out.println(Math.max(ans,Math.max(ans1, Math.max(ans2, ans3))));     

}
}
 
 static class FastScanner {
     BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
     StringTokenizer st=new StringTokenizer("");
     String next() {
     while (!st.hasMoreTokens())
         try {
             st=new StringTokenizer(br.readLine());
         } catch (IOException e) {
             e.printStackTrace();
         }
         return st.nextToken();
     }
     
     int nextInt() {
         return Integer.parseInt(next());
     }
     int[] readArray(int n) {
         int[] a=new int[n];
         for (int i=0; i<n; i++) a[i]=nextInt();
         return a;
     }
     long nextLong() {
         return Long.parseLong(next());
     }
 }

 
}


Measured memory_bytes: 32740
/* -------------------------------- Template -------------------------------- */

#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <locale>
#include <iostream>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define ALL(x) (x).begin(),(x).end()

using ll = long long;
using ld = long double;

template <typename T> T &chmin(T &a, const T &b) { return a = std::min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = std::max(a, b); }
template <typename T> int len(const T &x) { return x.size(); }

// template<typename T> constexpr T inf = [](){ assert(false); };
// template<> constexpr int inf<int> = 1e9;
// template<> constexpr ll inf<ll> = 1e18;
// template<> constexpr ld inf<ld> = 1e30;

struct yes_no : std::numpunct<char> {
  string_type do_truename()  const { return "Yes"; }
  string_type do_falsename() const { return "No"; }
};

void solve();

int main() {
  std::locale loc(std::locale(), new yes_no);
  std::cout << std::boolalpha << std::setprecision(12) << std::fixed;
  std::cout.imbue(loc);
  solve();
  return 0;
}

using namespace std;

/* -------------------------------- Library -------------------------------- */

/* ---------------------------------- Main ---------------------------------- */

void solve() {
  string s;
  cin >> s;
  string t = s;
  reverse(ALL(s));
  for (char &c: s) {
    if (c == 'b') c = 'd';
    else if (c == 'd') c = 'b';
    else if (c == 'p') c = 'q';
    else if (c == 'q') c = 'p';
  }
  cout << (s == t) << endl;
  return;
}


Measured memory_bytes: 512
N,M,C=map(int, input().split())
*B,=map(int, input().split())
A= [
  list(map(int, input().split()))
  for _ in range(N)
]

ans =0
for pa in A:
  x = sum(a*b for a,b in zip(pa, B)) + C
  ans += x > 0
print(ans)

Measured memory_bytes: 3060
n,m = map(int,input().split())
ans = []
li = []

for i in range(m):
    s,c = map(int,input().split())
    li.append([s,c])

if n == 1:
    for i in range(10):
        buf = str(i)
        flag = True
        for j in range(len(li)):
            if buf[li[j][0]-1] != str(li[j][1]):
                flag = False
        if flag:
            ans.append(buf)
            flag = True
else:
    for i in range(10**(n-1),10**n):
        buf = str(i)
        flag = True
        for j in range(len(li)):
            if buf[li[j][0]-1] != str(li[j][1]):
                flag = False
        if flag:
            ans.append(buf)
            flag = True

ans.sort()
if ans:
    print(ans[0])
else:
    print(-1)


Measured memory_bytes: 3064
from itertools import permutations as per
n = int(input())
x = [0]*n
y = [0]*n
for i in range(n): x[i],y[i] = map(int,input().split())

s = 0
for p in per(range(n)):
    for i in range(1,n):
        a,b = p[i],p[i-1]
        s += ((x[a]-x[b])**2+(y[a]-y[b])**2)**0.5

fac = 1
for i in range(1,n+1): fac *= i
print(s/fac)

Measured memory_bytes: 3064
#include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x)  cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000


int main(void)
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    int N, K;
    cin >> N >> K;
    double ans = 0.0;
    REP(i, 1, N) {
        int x = i;
        double p = 1.0;
        while(x < K) {
            x *= 2;
            p *= 0.5;
        }
        ans += 1.0/N * p;
    }
    cout << fixed << setprecision(12) << ans << endl;

    return 0;
}


Measured memory_bytes: 256
#
# 　　  ⋀_⋀　 
#　　  (･ω･)  
# .／ Ｕ ∽ Ｕ＼
#  │＊　合　＊│
#  │＊　格　＊│ 
#  │＊　祈　＊│ 
#  │＊　願　＊│ 
#  │＊　　　＊│ 
#      ￣
#
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,sqrt,factorial,hypot,log #log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint
def ceil(a,b): return (a+b-1)//b
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    N=I()
    A=set(LI())
    print(["NO","YES"][len(A)==N])

if __name__ == '__main__':
    main()

Measured memory_bytes: 28996
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

//少数を考えるときはdouble!!!intだけ使うと引っかかるぞ！！
//愚かなことにcin > a[n]としていて全然進まなかった、、、

int main(){
  int n,c,k,counter=0;
  cin >> n >> c >>k;
  int t[1000100];
  for(int i= 0;i<n;i++){
    cin >> t[i];
  }
  sort(t,t+n);
  for(int i=0;i<n;){
    int res = 1;
    for(;res<=c;res++){
      if(t[i+res]-t[i]>k||res==c){
        counter++;
      //  cout << "breakpoint : " << i+1 << endl;
        break;
      }
    }
    i+=res;
  }
  cout << counter <<endl;
}


Measured memory_bytes: 640
#include <bits/stdc++.h>
using namespace std;
using ll = long long ;
int main(){
ll a ,b ,c,sum=0 ;
cin >> a >> b >>c ;
sum=(a*c)-b ;
cout << sum<<endl;
for(int i=0 ; i<9 ;i++)
{
   sum=(sum*a)-b ;
   cout << sum <<endl ;

}
 return 0  ;
}


Measured memory_bytes: 256
n,k=gets.split.map(&:to_i)
highs=[]
n.times do
	highs << gets.to_i
end
highs.sort!
difference=10**9
i=0
while i < n-k+1 do
	difference = highs[i+k-1] - highs[i] if difference > highs[i+k-1] - highs[i]
	i+=1
end
puts difference

Measured memory_bytes: 4016
#include <cstdio>
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

int a, b, c, k;

int solve()
{
	if (k <= a)
	{
		return k;
	}

	if (k <= a + b)
	{
		return a;
	}

	int rest = k - (a + b);
	return a - rest;
}

int main()
{
	cin >> a >> b >> c >> k;
	cout << solve() << endl;
}

Measured memory_bytes: 3184
N = (int(input()))
A = [0]+[int(input()) for T in range(0,N)]
Now = 1
Count = 0
Flag  = False
for T in range(0,N):
    Next = A[Now]
    Count += 1
    if Next==2:
        Flag = True
        break
    else:
        Now = Next
if Flag:
    print(Count)
else:
    print(-1)

Measured memory_bytes: 13740
#include <stdio.h>

int main(void){  

  int a, b;

  scanf("%d %d", &a, &b);

  while(a<-1000 || a>1000 || b<-1000 || b>1000){
    printf("??????????????\??????????????????\n");
    scanf("%d %d", &a, &b);
  }

  if(a<b){
    printf("a < b\n");
  }else if(a>b){
    printf("a > b\n");
  }else if(a==b){
    printf("a == b\n");
  }

  return 0;
}

Measured memory_bytes: 580
#include "bits/stdc++.h"
#include<assert.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define int long long
#define MRE assert(0);
const int inf = 1e17;
const int mod = 924844033;
typedef pair<int, int> P;
typedef pair<int, P> PP;
vector<int>NG[2005], G[2005];
int dp[2005][2005][2];
int used[2005];
int C[2005];
int kj[2010], kji[2010];


int modpow(int a, int x) {
	int res = 1;
	while (x) {
		if (x & 1)res = res*a%mod;
		a = a*a%mod;
		x >>= 1;
	}
	return res;
}

void setkj(int n) {
	kj[0] = 1;
	rep(i, n)kj[i + 1] = kj[i] * (i + 1) % mod;
	rep(i, n + 1)kji[i] = modpow(kj[i], mod - 2);
}

signed main() {
	int n, k; cin >> n >> k;
	setkj(n + 1);
	rep(i, n - k) {
		NG[i + k].push_back(i);
		NG[n - 1 - i - k].push_back(n - i - 1);
		C[i]++; C[n - i - 1]++;
	}
	rep(i, n) {
		sort(NG[i].begin(), NG[i].end());
		if (NG[i].size() > 1) {
			G[NG[i][0]].push_back(NG[i][1]);
			G[NG[i][1]].push_back(NG[i][0]);
		}
	}

	dp[0][0][0] = 1;
	int cnt = 0;
	int now = 0, fs = 0;
	while (cnt != n) {
		int nxt = -1;
		for (int e : G[now]) {
			if (!used[e])nxt = e;
		}

		rep(i, n) {
			dp[cnt + 1][i][0] += dp[cnt][i][0] + dp[cnt][i][1];
			if (C[now]) {
				if (nxt == -1) {
					if (C[now] == 1)dp[cnt + 1][i + 1][0] += dp[cnt][i][0];
					else dp[cnt + 1][i + 1][0] += 2 * dp[cnt][i][0] + dp[cnt][i][1];
				}
				else {
					if (C[now] == 1)dp[cnt + 1][i + 1][1] += dp[cnt][i][0];
					else {
						dp[cnt + 1][i + 1][0] += dp[cnt][i][0];
						dp[cnt + 1][i + 1][1] += dp[cnt][i][0] + dp[cnt][i][1];
					}
				}
			}
			rep(p, 2)rep(q, 2)dp[cnt + 1][i + p][q] %= mod;
		}
		used[now]++; cnt++;

		if (nxt == -1) {
			rep(i, n) {
				if (!used[i]) {
					now = i; break;
				}
			}
			fs = 0;
		}
		else {
			now = nxt; fs = 1;
		}
	}

	int ans = 0;
	for (int i = n; i >= 0; i--) {
		int X = dp[n][i][0] + dp[n][i][1];
		if (i & 1)ans -= X*kj[n - i] % mod;
		else ans += X*kj[n - i] % mod;
		ans = (ans + mod) % mod;
	}
	cout << ans << endl;
}


Measured memory_bytes: 63232
#[allow(non_snake_case)]
use proconio::{
    input,
};

fn main() {
    input! {
        n: u64,
        a: [u64; n],
    }

    let mut s:u64 = a.iter().sum();
    let mut ans:u64 = 0;
    let MOD = 1_000_000_007;

    for i in a {
        s -= i;
        ans += ((s % MOD) * (i % MOD)) % MOD;
        ans %= MOD
    }
    println!("{}", ans)
}


Measured memory_bytes: 5640
#include "bits/stdc++.h"
using namespace std;
#define INF 1e9
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, l, r) for (int i = (l); i < (r); i++)
#define ALL(x) (x).begin(), (x).end()     //昇順
#define RALL(x) (x).rbegin(), (x).rend()  // 降順
#define FOR(i, c) \
  \ for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
const long long mod = 1e9 + 7;
typedef long long ll;  // ll とdoubleは違う
typedef priority_queue<int> PQ;
typedef vector<long long> VL;
typedef vector<bool> VB;
typedef vector<int> VI;  // VI a(n);
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<char> VC;
typedef vector<VS> VSS;
typedef vector<VC> VCC;
typedef vector<VI> VII;  // VII a(n,vector<int>(m)) n * m
typedef vector<VL> VLL;
typedef vector<VB> VBB;
typedef pair<int, int> PII;
typedef map<int, int> MP;  // MP a;
typedef vector<pair<ll, ll>> PS;

template <class T, class U>  // chmax(max, a);
bool chmax(T &a, U b) {
  if (a <= b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T, class U>  // chmin(min,a)
bool chmin(T &a, U b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
template <typename T>  // operator << (cout,a);
ostream &operator<<(ostream &os, vector<T> &v) {
  os << "{";
  rep(i, (int)v.size()) { os << v[i] << (i < v.size() - 1 ? ", " : ""); }
  os << "}";
  return os;
}

// g++ -std=c++11 prac.cpp

int main() {
  ll x=0,y=0,k,n,m,h,w,sum=0,ans=0,Max=1,Min=1e9+1;
  string s,t,u;
  bool ok = false;
  VII a(3, VI (3));
  rep(i,3) rep(j,3) cin >> a[i][j];
  cin >> n;
  VI b(n);
  rep(i,n) cin >> b[i];
  VBB c(3, VB(3));
  rep(i,3) rep(j,3) c[i][j] = false;

  rep(i,9){
    rep(j,3)
    {
      rep(k,3){
        if(b[i]==a[j][k])
          c[j][k] = true;
      }
    }
  }
  
  rep(j,3){
    rep(i,3){
      if(c[j][i]==true){
        sum++;
      }
    }
    if(sum==3){
      ok = true;
    }
    sum = 0;
  }

  rep(j,3){
    rep(i,3){
      if(c[i][j]==true){
        sum++;
      }
    }
    if(sum==3){
      ok = true;
    }
    sum = 0;
  }

  if(c[0][0] == true && c[1][1] == true && c[2][2] == true )
    ok=true;
  
  if(c[0][2] == true && c[1][1] == true && c[2][0] == true)
    ok = true;

  
  
  if(ok)
    cout << "Yes" << endl;
  else
    cout << "No" << endl;

  return 0;
}

Measured memory_bytes: 256
# include <bits/stdc++.h>
# define rep(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
# define reps(i, n) for(int i=1, i##_len=(n); i<=i##_len; ++i)
# define rrep(i, n) for(int i=((int)(n)-1); i>=0; --i)
# define rreps(i, n) for(int i=((int)(n)); i>0; --i)
# define ALL(x) (x).begin(), (x).end()
# define SZ(x) ((int)(x).size())
# define pb push_back
# define optimize_cin() cin.tie(0); ios::sync_with_stdio(false)
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const long long INF = 1LL << 60;

int main()
{
    double a,b;
    cin >> a >> b;

    int ans = -1;

    reps(i,1000){
        int x = i * 8/100;
        int y = i * 1/10;
        if(x == a && y == b) {
            ans = i;
            break;
        }
    }

    cout << ans << endl;
    return 0;
}

Measured memory_bytes: 256
#include<algorithm>
#include<bitset>
#include<cassert>
#include<cfloat>
#include<climits>
#include<cmath>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>

using namespace std;

using lint = long long;
using P = pair<int, int>;
using LLP = pair<long long, long long>;

#define REP(i, x, n) for(int i = (x), i##_len = (int)(n) ; i < i##_len ; ++i)
#define rep(i, n) for(int i = 0, i##_len = (int)(n) ; i < i##_len ; ++i)
#define reps(i, n) for(int i = 1, i##_len = (int)(n) ; i <= i##_len ; ++i)
#define rrep(i, n) for(int i = (int)(n) - 1 ; i >= 0 ; --i)
#define rreps(i, n) for(int i = (int)(n) ; i > 0 ; --i)
#define SORT(x) sort((x).begin(), (x).end())
#define SORT_INV(x) sort((x).rbegin(), (x).rend())
#define REVERSE(x) reverse((x).begin(), (x).end())
#define TWINS(x) cout << ((x) ? "Yay!" : ":(") << '\n'
#define endl '\n'

constexpr int IINF = (1 << 30) - 1;
constexpr long long LLINF = 1LL << 61;
constexpr double EPS = 1e-10;

constexpr int dx4[] = {1, 0, -1, 0}, dy4[] = {0, 1, 0, -1};
constexpr int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};

template<typename T>
bool chmax(T& a, T b){
    if(a < b){
        a = b;
        return true;
    }
    return false;
}

template<typename T>
bool chmin(T& a, T b){
    if(b < a){
        a = b;
        return true;
    }
    return false;
}

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);

    int n, m;
    cin >> n >> m;

    vector< pair<bool, int> > v(n, make_pair(false, 0));
    rep(i, m){
        int p;
        string s;
        cin >> p >> s;
        --p;
        v[p].first |= s == "AC";
        if(!v[p].first){
            ++v[p].second;
        }
    }

    int ac = 0;
    int pena = 0;
    rep(i, n){
        ac += v[i].first;
        pena += v[i].first * v[i].second;
    }

    cout << ac << ' ' << pena << endl;

    cout << flush;

    return 0;
}

Measured memory_bytes: 1024
# AtCoder
import math
N = int(input())
mi = float("inf")


def F(x, y):
    return max(len(str(x)), len(str(y)))


sq = math.floor(math.sqrt(N)+1)

for A in range(1, sq):
    if N % A == 0:
        B = N // A
        mi = min(F(A, B), mi)
print(mi)


Measured memory_bytes: 3060
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<unordered_map>
#include<climits>
#include<cstdlib>
#include<cmath>
#include<string>
#include<iomanip>
#include<bitset>
#include<list>

/*
　　　　　　　　　　　　　　　　　　　　　__,.二ﾆ==-　　ﾆ．、_.　　　　　　　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　　　.,.．‐　⌒　　　　　　　　　　　　｀`'ァ-ﾆ、.　　　　　　　　　　　　　　　
　　　　　　　　　　　　　　ィ'´.　　　　　　　　　　　　　　　　　　　　　　´丶.、　　　　　　　　　　　　
　　　　　　　　　　　.,ィ'´　　　　　　　　　　　　　　　　　　　　　　　　　　　　`.ｘ、..　　　　　　　　　
　..　　　　　　　　／.　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　､＼.　　　　　　　　
　　　　　　　　.ﾝ′.　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　￢`""冖ｰミト．
　　　　　　　,ｒ′.　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　.ﾍ、　　　　`
　　　　　　ﾂ　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　`、....　　　
　　　　　./´　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ﾍ　　　　
　.....　　/.　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　.〉.　　　
　　　´/..　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　.ｌ　　　
　　　ｨ　　　　　　　　　　　　　　　　　　　　　　　　　．　　　　　　　　　　　　　　　　　　　　　ｆ..　　
　..　.ｆ　,d.　　　　　　　　　　　　　　　　　l　　　′　」　　,.　　　　　　　　　　　　　ﾄ　　　　　！　　
　.　〕../.ｆ..　　　　　　　　　　　　　　　　　′　．.　　|　　.｝　　　　　　　　　　　　　|　　　　　　|.　　
　　.!./..f..　　　　　　　　　　　　　　　　　/　　!－　ナ丶п冖т　　　　ﾉｰ-　．　〕　　　　　　|.　　
　　|ﾒ　|　　　　　　　　　　　　　　　｜　j　　　　　　,　　┌．　|〈.　　　л`.　　　/|..　　　　　┤,..　
　...「...｜.　　　　　　|　　´　　　　　　l.　|　　j.Ｌ......ｭ.Ｌ＿└ヽ_｜Y.　　ﾒムｗ　ょ　|　　j.:　　　|　￣
　.　　｜.　　　　　　　　　　　　　　　т〕＜.ィ冖T冖..　г‐　`､　`,　/┴￢..г￣|..　.′　　｜　　
　...　　|　　　　　　　　．..　　　　　　　),|..　｀　　ﾘ　「_ﾉ.||　　　　`　V　　|!｛,｢ll　´.」.　　　　　卜　　
　.　　｜.」　　　　　　′　　　　　　　　ヽ　　　　└++〃..　　　　　　　　ﾙｗｆ　　ｶz′.　　　｜.　　
　　　　|..〕　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　｢　　　　　．|　　　
　　　　.ｌ.|.　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　′.　　　　　|　　　
　.　　　.〕..　　　　　　　　　　　　　　　`!　　　　　　　　_...．.ｰ：''　　　　　　　　　｣　´　　　　λ.　　
　　　　_｢.　　　　,　　　　　　　　　　　　┐_,、｀~‐''"´　　　　　　　　　　　　　　　　ィ　　　.､　ﾍ、　
　　　　ｆ　　　　　　:_＿..,二ュ．-i―'''^~´　　　　　　　　　　　　　　　　　　　　　　　､＼イ　ヘ．`ｘ
　.　　/　　　　　　｛　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　j　　　　.~^
　　､/　　　　　　　'ｔ..　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　丿..　　　　　
　.../.　　　　　　　,x┐..　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　∠∫　　　　　
　:^.　　　　　　　/　　￣冖ー=zzｭ┌ｰ―--　　　∟,二...＿.　　　　　　　_,､．-ｰ.'l+~.　.l｀．　　　　
　.　　　　　　　У.　　　　　　　　　⌒冖‐-=．_..　l｢.｢　　　　　　´￣｣了　　.,､-''＾　　　〉　ヽ_　　　
　　　　　　　_/.　　　　　　　　　　　　　　　　　　￣~'.ー-=．、＿,..usｧ.ｰ''"　　　　　　｛　　　＼´　
　　　　　　_ヰl'￢―-　､_　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　（　　　　.＼
*/

using namespace std;

using ll = long long int;
using ull = unsigned long long int;

ll const MOD = 1000000007;
ll const INF = (long long int)1 << 61;

ll mypow(ll x,ll n,ll mod = MOD){
    ll ret = 1;
    while(n > 0){
        if(n&1){
            ret = (ret*x)%mod;
        }
        x = (x*x)%mod;
        n >>= 1;
    }
    return ret;
}

ll mygcd(ll a,ll b){
    if(b == 0)return a;
    return mygcd(b,a%b);
}

ll twoPow(ll shiftNum){
    return (1LL << (shiftNum - 1));
}

int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
 
    ll n;
    cin >> n;

    vector<ll> a(n);
    vector<ll> count(200001,0);
    for(auto &x: a){
        cin >> x;
        count[x]++;
    }

    ll totalans = 0;
    for(const auto x: count){
        totalans += (x*(x-1))/2;
    }

    for(const auto x: a){
        cout << totalans - (count[x]*(count[x]-1))/2 + ((count[x]-1)*(count[x]-2)/2) << endl;
    }

    return 0;
}

Measured memory_bytes: 5760
#include <iostream>
#include <vector>
#include <cstdio>
#include <complex>
#include <cmath>

using namespace std;

typedef complex<double> Point;

int main() {
    int cnt = 1;
    while(true) {
        int N;
        cin >> N;
        if(!N) break;

        vector<Point> points;
        for(int i = 0; i < N; ++i) {
            Point p;
            cin >> p.real() >> p.imag();
            points.push_back(p);
        }

        double area = 0;
        for(int i = 0; i < N; ++i) {
            int next = (i+1) % N;
            area += points[i].real()*points[next].imag()-points[i].imag()*points[next].real();
        }
        printf("%d %.1f\n", cnt++, abs(area/2));
    }
    return 0;
}

Measured memory_bytes: 0
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<set>
#include<map>
using namespace std ;

#define MOD 998244353

long long n ;
string a ;

long long f[ 8 ] ;


void input ( ) {
    cin >> n ;
    cin >> a ;
}

void solve ( ) {
    long long ans = 1 ;
    for ( int i = 0 ; i < 3 * n ; ++ i ) {
        int x = ( a[ i ] == 'B' ) + ( a[ i ] == 'G' ) * 2 ;
        int lft = ( 7 - (1<<x) ) ;
        if ( f[ lft ] > 0 ) {
            ans *= f[ lft ] -- , ans %= MOD ;
        }
        else {
            int j ;
            for ( j = 0 ; j < 3 ; ++ j ) {
                if ( j == x )  { continue ; }
                if ( f[ (1<<j) ] > 0 ) {
                    ans = ( ans * f[ (1<<j) ] -- ) % MOD ;
                    ++ f[ (1<<j) + (1<<x) ] ;
                    break ;
                }
            }
            if ( j >= 3 ) {
                ++ f[ (1<<x) ] ;
            }
        }
    }
    for ( int i = 1 ; i <= n ; ++ i ) {
        ans = ( ans * i ) % MOD ;
    }
    printf ( "%lld\n" , ans ) ;
}

int main ( ) {
    ios_base :: sync_with_stdio ( false ) ;
    cin.tie ( NULL ) ;
    input ( ) ;
    solve ( ) ;
    return 0 ;
}


Measured memory_bytes: 720
#define y1 askjdkasldjlkasd
#include <bits/stdc++.h>
#undef y1

using namespace std;

#define pb push_back
#define mp make_pair
#define fi(a, b) for(int i=a; i<=b; i++)
#define fj(a, b) for(int j=a; j<=b; j++)
#define fo(a, b) for(int o=a; o<=b; o++)
#define fdi(a, b) for(int i=a; i>=b; i--)
#define fdj(a, b) for(int j=a; j>=b; j--)
#define fdo(a, b) for(int o=a; o>=b; o--)
#define sz(x) (int)x.size()

typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef vector<ll> vl;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<ll> vll;

#ifdef _DEBUG
#define LOCAL
#endif

#ifdef LOCAL
#define err(...) fprintf(stderr, __VA_ARGS__)
#else
#define err(...) while (0)
#endif

double START_TIME;

void exit() {
#ifdef LOCAL	
	cerr << "TIME: " << setprecision(5) << fixed << (clock() - START_TIME) / CLOCKS_PER_SEC << endl;
#endif	
	exit(0);
}

template<typename A, typename B>
ostream& operator<<(ostream& os, pair<A, B> p) {
	os << "(" << p.first << ", " << p.second << ")";
	return os;
}

template<typename T>
ostream& operator<<(ostream& os, vector<T> v) {
	fi(0, sz(v) - 1) {
		os << v[i] << " ";
	}
	return os;
}

template<typename T>
ostream& operator<<(ostream& os, set<T> t) {
	for (auto z : t) {
		os << z << " ";
	}
	return os;
}

template<typename T1, typename T2>
ostream& operator<<(ostream& os, map<T1, T2> t) {
	cerr << endl;
	for (auto z : t) {
		os << "\t" << z.first << " -> " << z.second << endl;
	}
	return os;
}

#ifdef LOCAL
#define dbg(x) {cerr << __LINE__ << "\t" << #x << ": " << x << endl;}
#define dbg0(x, n) {cerr << __LINE__ << "\t" << #x << ": "; for (int ABC = 0; ABC < n; ABC++) cerr << x[ABC] << ' '; cerr << endl;}
#else
#define dbg(x) while(0){}
#define dbg0(x, n) while(0){}
#endif

#ifdef LOCAL
#define ass(x) if (!(x)) { cerr << __LINE__ << "\tassertion failed: " << #x << endl, abort(); }
#else
#define ass(x) assert(x)
#endif

///////////////////////////////////////////////////

const int MAX = 2e5 + 41;
const int MOD = 1e9 + 7;

int mul(int a, int b) {
	return (ll) a * b % MOD;
}

int add(int a, int b) {
	a += b;
	if (a >= MOD) a -= MOD;
	return a;
}

int a[MAX];
int p[MAX];
int d[MAX];
int nxt[MAX];

int n;

void solve() {
	memset(p, -1, sizeof(p));
	fdi(n - 1, 0) {
		nxt[i] = p[a[i]];
		p[a[i]] = i;
	}    
	d[n] = 1;
	fdi(n - 1, 0) {		
		d[i] = d[i + 1];
		if (nxt[i] != -1 && i + 1 != nxt[i]) {
			d[i] = add(d[i], d[nxt[i]]);
		}
	}
	printf("%d\n", d[0]);
}

int main() {
#ifdef LOCAL
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
	START_TIME = (double)clock();
#endif
	
	scanf("%d", &n);
	fi(0, n - 1) scanf("%d", &a[i]);
	solve();

	exit();
	return 0;
}





Measured memory_bytes: 3328
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define REP(i,x) for(int i=0;i<(int)(x);i++)
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();i++)
#define RFOR(i,c) for(__typeof((c).rbegin())i=(c).rbegin();i!=(c).rend();i++)
#define ALL(container) (container).begin(), (container).end()
#define RALL(container) (container).rbegin(), (container).rend()
#define SZ(container) ((int)container.size())
#define mp(a,b) make_pair(a, b)
#define pb push_back
#define eb emplace_back
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );

template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
template<class T> ostream& operator<<(ostream &os, const vector<T> &t) {
    os<<"["; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"]"; return os;
}
template<class T> ostream& operator<<(ostream &os, const set<T> &t) {
    os<<"{"; FOR(it,t) {if(it!=t.begin()) os<<","; os<<*it;} os<<"}"; return os;
}
template<class S, class T> ostream& operator<<(ostream &os, const pair<S,T> &t) { return os<<"("<<t.first<<","<<t.second<<")";}
template<class S, class T> pair<S,T> operator+(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first+t.first, s.second+t.second);}
template<class S, class T> pair<S,T> operator-(const pair<S,T> &s, const pair<S,T> &t){ return pair<S,T>(s.first-t.first, s.second-t.second);}

const int INF = 1<<28;
const double EPS = 1e-8;
const int MOD = 1000000007;

int T, n, m;

ll S(ll x) {
    ll res = 0;
    while(x) {
        res += x % 10;
        x /= 10;
    }
    return res;
}

bool check(ll x, ll y) {
    return x * S(y) >= y * S(x);
}

int main(int argc, char *argv[]){
    ios::sync_with_stdio(false);
    cin >> n;
    vector<ll> ans;
    ans.push_back(1ll);
    for(ll i=2;i <= 10000000000000000ll;) {
        while(!ans.empty()) {
            ll x = ans.back();
            if (x * S(i) > i * S(x)) ans.pop_back();
            else break;
        }
        ans.push_back((ll)i);

        ll mx = i + 1;
        for(ll j=1;j <= i * 10;j*=10) {
            if (check(mx, i+j)) {
                mx = i + j;
            }
        }
        i = mx;
    }
    REP(i, n) cout << ans[i] << endl;
    return 0;
}


Measured memory_bytes: 256
#include"bits/stdc++.h"
#include<iostream>
using namespace std;

int main(){
  int a,b,i;
  cin >> a >> b;
  i = a*b % 2;
  if(i == 0){
    cout << "Even" << endl;
  }else{
    cout << "Odd" <<endl;
  }
}


Measured memory_bytes: 256
t = list(input())

for i in range(len(t)):
    if t[i]=="?":
        t[i]="D"
count = 0
for i in range(len(t)-1):
    if t[i]=="P" and t[i+1]=="D":
        count +=1
    elif t[i]=="D":
        count +=1
print("".join(t))



Measured memory_bytes: 10848
# -*- coding: utf-8 -*-
n,m = list(map(int,input().split()))
d = [[i,tuple(map(int,input().split()))] for i,_ in enumerate(range(m))]
#print(d)

d.sort(key=lambda x:x[1][1])
p_cnt = [0] * (n+1)
ret_tuples = [0] * m #(市id,認識番号) のtupleのリスト

for i,v in enumerate(d):
    p = v[1][0]
    x = p_cnt[p]+1
    p_cnt[p]+=1
    ret_tuples[i] = (v[0],"{:0=6}{:0=6}".format(p,x))

ret_tuples.sort(key=lambda x:x[0])
for i in ret_tuples:
    print(i[1])

Measured memory_bytes: 46852
#include <iostream>
using namespace std;
int main()
{
    string str;
    cin >> str;
    for(int i = 0; i < str.length(); i++){
        if((i % 2 == 0 && str[i] == 'L')
                || (i % 2 == 1 && str[i] == 'R')){
            cout << "No";
            return 0;
        }
    }
    cout << "Yes";
    return 0;
}


Measured memory_bytes: 256
#include <iostream>
#include <math.h>
#include <queue>
#include <algorithm>
#include <map>

using namespace std;

typedef long long ll;
typedef pair<int, int> P;

vector<ll> prime_factor(ll n) {
    vector<ll> ret;
    ret.push_back(1);
    for(int64_t i = 2; i * i <= n; i++) {
        bool fir = true;
        while(n % i == 0) {
            if(fir) {
                ret.push_back(i);
                fir = false;
            }
            n /= i;
        }
    }
    if(n != 1) ret.push_back(n);
    return ret;
}

int main() {
    ll a, b;
    cin >> a >> b;

    vector<ll> pa = prime_factor(a);
    vector<ll> pb = prime_factor(b);

    int res = 0;
    int ia = 0, ib = 0;
    while(ia < pa.size() && ib < pb.size()){
        if(pa[ia] == pb[ib]){
            ia++;
            ib++;
            res++;
        }
        else if(pa[ia] < pb[ib]){
            ia++;
        }
        else{
            ib++;
        }
    }

    cout << res << endl;

    return 0;
}

Measured memory_bytes: 256