akhauriyash/Code-Regression huggingface dataset:
import java.util.*;
public class Main {
	//1210 start
	
	private void doit(){
		Scanner sc = new Scanner(System.in);
		while(true){
			int m = sc.nextInt();
			int n = sc.nextInt();
			if((m|n) == 0)break;
			String []data = new String[n+1];
			for(int i = 1 ; i <= n; i++){
				data[i] = sc.next();
			}
			LinkedList<Integer> list = new LinkedList<Integer>();
			for(int i = 1; i <= m; i++){
				list.add(i);
			}
			
			int now = 0;
			for(int i = 1; i <= n; i++){
				String s = data[i];
				boolean flg = false;
				if(i % 3 ==0 && i % 5 == 0){
					if(s.equals("FizzBuzz")){
						
					}
					else{
						flg = true;
					}
				}
				else if(i % 3 == 0){
					if(s.equals("Fizz")){
						
					}
					else{
						flg = true;
					}
				}
				else if(i % 5 == 0){
					if(s.equals("Buzz")){
						
					}
					else{
						flg = true;
					}
				}
				else{
					if(s.equals(i + "")){
						
					}
					else{
						flg = true;
					}
				}
				if(flg){
					//System.out.println("now = " + now + " i= " + i);
					list.remove(now);
					if(list.size() == 1) break;
					now = now % list.size();
				}
				else{
					now = (now + 1) % list.size();
				}
			}
			for(int i = 0 ; i < list.size()-1; i++){
				System.out.print(list.get(i) + " ");
			}
			System.out.println(list.removeLast());
		}
	}

	public static void main(String[] args) {
		Main obj = new Main();
		obj.doit();
	}
}

Measured memory_bytes: 16000
#include<bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;

int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};

int main(){
  int n, k; cin >> n >> k;
  cout << n - k + 1 << endl;

  return 0;
}

// EOF


Measured memory_bytes: 256
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
  ll n,x,sum=0,c=1;
  cin>>n>>x;
  ll l[n];
  for(ll i=1;i<=n;i++)
  {
    cin>>l[i];
  }
  for(ll i=1;i<=n;i++)
  {
    sum+=l[i];
    if(sum<=x)
    {
      c++;
    }
  }
  cout<<c;
}


Measured memory_bytes: 256
#include <iostream>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;

int main(){
    int n,h,w;
    int ans =0;
    long A[10000],B[10000];
    cin >> n>> h >> w;
    
    for(int i = 0; i < n; i++)
    {
        cin >> A[i] >> B[i];
    }
    
    for(int i = 0; i < n; i++)
    {
        
        if (A[i]>=h && B[i]>=w) {
            ans++;
        }
        
    }
    cout << ans <<endl;
    
    
}

Measured memory_bytes: 256
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) FOR(i,0,n)
#define FOR(i,a,b) for(ll i=a;i<b;i++)
#define PB push_back
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef pair<ll,ll> pii;
typedef vector<pii> vpii;
typedef pii point;
using namespace std;

struct UnionFind {
  ll size,*par,*rk;
  UnionFind(ll sz){
    size=sz;
    par=new ll[size]; REP(i,size) par[i]=i;
    rk=new ll[size]; REP(i,size) rk[i]=0;
  }
  ll find(ll x){
    if(par[x]==x) return x;
    else return par[x]=find(par[x]);
  }
  void unite(ll x,ll y){
    x=find(x); y=find(y);
    if(rk[x]>rk[y]) par[y]=x;
    else if(rk[x]<rk[y]) par[x]=y;
    else {par[x]=y;rk[y]++;}
  }
  bool same(ll x,ll y) {
    return find(x)==find(y);
  }
};

int main(){
  ll n,q; cin>>n>>q;
  UnionFind uf(n);
  REP(i,q) {
    ll com,x,y; cin>>com>>x>>y;
    if(com==0) uf.unite(x,y);
    else cout<<(uf.same(x,y)?1:0)<<endl;
  }
}



Measured memory_bytes: 3252
#include <bits/stdc++.h>

using namespace std;

int N, pw, vw[100000], pf[100000], vf[100000], th[100000];

double f(double v)
{
  double ret = v * pw;
  for(int i = 0; i < N; i++) {
    ret += max(0.0, double(th[i] - vw[i] * v) / vf[i]) * pf[i];
  }
  return (ret);
}

int main()
{
  while(scanf("%d", &N), N) {
    scanf("%d", &pw);
    for(int i = 0; i < N; i++) {
      scanf("%d %d %d %d", vw + i, pf + i, vf + i, th + i);
    }
    double low = 0, high = 100;
    for(int i = 0; i < 100; i++) {
      double left = (low * 2 + high) / 3;
      double right = (low + high * 2) / 3;
      if(f(left) < f(right)) high = right;
      else low = left;
    }
    printf("%.10lf\n", f(low));
  }
}

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

#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for (int i = x; i < n; i++)
#define OP(m) cout << m << endl
typedef long long ll;
typedef unsigned long long ull;

int main()
{
    int n;
    cin >> n;
    string s[n];
    vector<int> maxv(26, 100);
    rep(i, n)
    {
        cin >> s[i];
        rep(j, 26)
        {
            int m = count(ALL(s[i]), (char)('a' + j));
            maxv[j] = min(maxv[j], m);
        }
    }
    string ans = "";
    rep(i, 26)
    {
        if (maxv[i] == 100)
            continue;
        rep(j, maxv[i])
        {
            ans += (char)('a' + i);
        }
    }

    OP(ans);

    return 0;
}

Measured memory_bytes: 256
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <string>
#include <cmath>
#include <algorithm>

using namespace std;

#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define BIT(X, i) ((X>>i)&1)
#define REP(i, a, b) for(int i = (a); i < (b); ++i)
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define r_all(a) (a).rbegin(), (a).rend()

typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<ll, ll> pii;
typedef vector<pii> vii;
typedef priority_queue<ll> pq;

const int MOD = 1e9+7;
const int INF = (1<<30);
const ll INFL = (1L<<62);

int main() {
  int N; cin >> N;
  int M = 2, sum = 1;
  bool ok = false;
  while (sum <= N) {
    if (sum == N) {
      ok = true;
      break;
    }
    sum += M++;
  }
  if (!ok) {
    cout << "No" << endl;
    return 0;
  }

  cout << "Yes" << endl;
  vvi ans(M);
  int ini = 1;
  rep(i, M) {
    rep(j, M-1-i) {
      ans[i].pb(ini+j);
      ans[i+1+j].pb(ini+j);
    }
    ini += M-1-i;
  }

  cout << M << endl;
  rep(i, M) {
    cout << M-1;
    rep(j, M-1) {
      printf(" %ld", ans[i][j]);
    }
    cout << endl;
  }
  return 0;
}


Measured memory_bytes: 2304
#include<bits/stdc++.h>
using namespace std;
#define ll long long 
#define pb push_back
#define mp make_pair
#define M 1000000007
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
const int N = 1e2 + 1 , V = 1e5 + 1;
int n , w;
ll  dp[V] , mx;
int main(){
	for (int j = 0; j < V; ++j)dp[j] = 2e9;
	scanf("%d%d",&n,&w);
	dp[0] = 0;
	for (int i = 1,x,val; i <= n; ++i){
		scanf("%d%d",&x,&val);
		for (int j = V-1; j >= val; --j)
			dp[j] = min(dp[j] ,dp[j-val] + x );
	}
	int ans = 0;
	for (int i = 1; i < V; ++i)
		if(dp[i] <= w)ans = i;
		
	cout << ans <<endl;



}	

Measured memory_bytes: 4412
#include<iostream>
#include<algorithm>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<iomanip>

using namespace std;
using ll = long long;
using P = pair<int, int>;

const int MOD = 1e9 + 7;
const int MAX = 1e9;
const ll LLMAX = 1e18;
const int INF = numeric_limits<int>::max();
const ll LLINF = numeric_limits<ll>::max();
const double PI = acos(-1.0);

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, a, n) for (int i = a; i <= (n); ++i)

int main() {
    int A, B; cin >> A >> B;
    cout << (A + B) % 24 <<endl;
    return 0;
}


Measured memory_bytes: 3604
import math
n = int(input())
s = math.ceil(math.sqrt(n))
h = 10**5
for i in range(1,s+1):
  if n%i==0:
    if h > max(len(str(i)),len(str(int(n/i)))):
      h = max(len(str(i)),len(str(int(n/i))))
print(h)

Measured memory_bytes: 65084
#include<iostream>
#include<string>
#include<cmath>
#include<iomanip>

#define rep(i,start,n) for(int i=start ; i<n ; i++)          //???????????????

using namespace std;

struct dice{                                     //dice??¨???????§????????????????
  int surface[6];
  void turn_n(){                                 //n??????????????¢???????????¨???
    int temp = surface[0];
    surface[0] = surface[1];
    surface[1] = surface[5];
    surface[5] = surface[4];
    surface[4] = temp;
  }
  void turn_e(){                                 //e??????????????¢???????????¨???
    int temp = surface[0];
    surface[0] = surface[3];
    surface[3] = surface[5];
    surface[5] = surface[2];
    surface[2] = temp;
  }
  void turn_s(){                                 //s??????????????¢???????????¨???
    rep(i,0,3) turn_n();
  }
  void turn_w(){                                 //w??????????????¢???????????¨???
    rep(i,0,3) turn_e();
  }
  void top_print(){                                 //????????????????????£???????????¨???
    cout << surface[0] << endl;
  }

};

int main(){

  dice d;

  rep(i,0,6){
    cin >> d.surface[i];                         //???????????????????????\???
  }

char order;

while(cin >> order){                              //?????¢??????????§??????\???

  if(order == 'N') d.turn_n();

  else if(order == 'E') d.turn_e();

  else if(order == 'S') d.turn_s();

  else if(order == 'W') d.turn_w();

}

d.top_print();                                  //????????????????????£???????????¨???

return 0;
}

Measured memory_bytes: 1164
#include <stdio.h>


int main(){
 
    int x,y,z;
    scanf("%d %d %d",&x,&y,&z);
    if(x+y == z || x+z == y || y +z ==x){
        printf("Yes");
    }
    else{
        printf("No");
    }
    
    return 0;
}


Measured memory_bytes: 256
#include "bits/stdc++.h"

// Begin {{{
#define all(x) x.begin(), x.end()
#define rep(i, n) for (i64 i = 0, i##_limit = (n); i < i##_limit; ++i)
#define reps(i, b, e) for (i64 i = (b), i##_limit = (e); i <= i##_limit; ++i)
#define repr(i, b, e) for (i64 i = (b), i##_limit = (e); i >= i##_limit; --i)

#ifndef DEBUG
#define dump(...)
#endif

using namespace std;
using i64 = int_fast64_t;
using pii = pair<i64, i64>;
template <class T> using MaxHeap = priority_queue<T>;
template <class T> using MinHeap = priority_queue<T, vector<T>, greater<>>;
template <class A, class B> inline bool chmax(A &a, const B &b) { return b > a && (a = b, true); }
template <class A, class B> inline bool chmin(A &a, const B &b) { return b < a && (a = b, true); }
inline i64 sigma(i64 n) { return n * (1 + n) >> 1; }
inline i64 updiv(i64 n, i64 d) { return (n + d - 1) / d; }

constexpr int INF = 0x3f3f3f3f;
constexpr i64 LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr int MOD = int(1e9) + 7;

template <class T>
inline vector<T> make_v(const T &initvalue, size_t sz) {
    return vector<T>(sz, initvalue);
}

template <class T, class... Args>
inline auto make_v(const T &initvalue, size_t sz, Args... args) {
    return vector<decltype(make_v<T>(initvalue, args...))>(sz, make_v<T>(initvalue, args...));
}
// }}} End

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    string s;
    cin >> s;
    int g = 0, p = 0;
    int res = 0;
    for (auto &e : s) {
        if (e == 'g') {
            if (p + 1 <= g) {
                p++; res++;
            } else {
                g++;
            }
        } else {
            if (p + 1 <= g) {
                p++;
            } else {
                g++; res--;
            }
        }
    }
    cout << res << "\n";
    return 0;
}


Measured memory_bytes: 512