uuid string | repo_name string | relative_path string | content string | category string | algo_rel_score float64 | quality_score float64 |
|---|---|---|---|---|---|---|
aed0b014-4934-450f-be0e-bc9cf02a0215 | roudramondal/Codeforces | Pangram.cpp | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
char s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
bool alpha[26] = {false};
for (int i = 0; i < n; i++) {
char ch = s[i];
if (ch >= 'A' && ch <= 'Z') {
ch = ch - 'A' + 'a... | ALGO | 0.999951 | 5.149333 |
0f8417e9-e935-4383-b9bc-71b83a8b3c40 | jicanta/Competitive-Programming | tesoro.cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long tint;
typedef long double ld;
#define forsn(i, s, n) for(int i=s;i<int(n);i++)
#define forn(i, n) forsn(i, 0, n)
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(), v.rend()
#define NACHO ios::sync_with_stdio(0); cin.tie(NULL);
#define dbg... | ALGO | 0.999964 | 3.96255 |
e22777c6-3eff-418f-83da-d5589363113c | sunqinxuan/rgbd_plane_slam | src/CameraPoseEstimation.cpp | /*==============================================
#
# Author: Sun Qinxuan
#
# Email: <EMAIL>
#
# Last modified: 2017-03-23 09:42
#
# Filename: CameraPoseEstimation.cpp
#
# Description:
#
===============================================*/
#include "CameraPoseEstimation.h"
namespace sun
{
CameraPoseEstimation::CameraPos... | ALGO | 0.997664 | 5.681943 |
1ef27533-cdc3-4ea5-9489-4bdd96be1901 | Stellarhold170NT/DSA-CodePTIT | DSA07011.cpp | #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <stack>
#include <cmath>
#include <iomanip>
#include <cstdlib>
#include <numeric>
#include <unordered_set>
using name... | ALGO | 0.999965 | 6.170858 |
39b4945d-d099-4f1c-b27f-0d49894c5713 | Ayushsinhahaha/Codes | 543-diameter-of-binary-tree/543-diameter-of-binary-tree.cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), l... | ALGO | 0.999919 | 6.544135 |
1923f2d1-ce38-471e-a3a0-5ac9477392d2 | hthuwal/competitive-programming | old/mixed/cpp/harish-and-his-rooks-puzzle.cpp | #include <cstdio>
int main()
{
int t;
char puz[10][10];
for(scanf("%d",&t);t--;)
{
for(int i=0;i<8;i++)
scanf("%s",puz[i]);
int row[8]={0};
int col[8]={0};
for(int i=0;i<8;i++)
for(int j=0;j<8;j++)
{
if(puz[i][j]=='R')
{
row[i]++;
col[j]++;
}
}
bool ans = false;
for... | ALGO | 0.9983 | 4.111081 |
5b6c73aa-b81c-4276-94e8-8d1456d70fd9 | infinity4471/Interview-Preparation-Kit | Warm-Up/counting-valleys.cpp | #include <bits/stdc++.h>
using namespace std;
// Complete the countingValleys function below.
int countingValleys(int n, string s) {
int sum = 0, prev = 0, valeys = 0;
for( char c : s ) {
if( c == 'U' ) sum++;
else sum--;
if( prev >= 0 && sum < 0 ) valeys++;
prev = sum;
}
... | ALGO | 0.999986 | 5.479942 |
ebc10810-9151-41c6-9659-baa403505795 | Subbuleo23/finding-nemo | UnacademyCourse/DPInterviewPrepMay2021/Lecture2/JumpOverBuilding.cpp | // Problem Link - https://www.codechef.com/UADPIP01/problems/BLJUMP
/* By Sanket Singh */
#include<bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
//#include<ext/pb_ds/tree_policy.hpp>
//#include <ext/pb_ds/trie_policy.hpp>
//using namespace __gnu_pbds;
using namespace std;
#define ll long long int
#define... | ALGO | 0.999976 | 4.372976 |
835f0d55-e423-4c1a-bff4-5a902a6d53a9 | ArinNigam/DSA-Grind | POTD/Sept2023/LC_21sept.cpp | // Median of Two Sorted Arrays
#include<bits/stdc++.h>
using namespace std;
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1,vector<int>&nums2){
int n1 = nums1.size();
int n2 = nums2.size();
if (n1>n2) return findMedianSortedArrays(nums2,nums1);
int low =0;
... | ALGO | 0.999997 | 5.597116 |
070cb5e0-f8c2-4a72-8abc-813e86ff0573 | thegamer1907/Code_Analysis | contest/1542591118.cpp | #include <bits/stdc++.h>
#define FOR(i, n) for(lli i = 0; i < (lli)(n); ++i)
#define ALL(x) (x).begin(), (x).end()
#define X(A) get<0>(A)
#define Y(A) get<1>(A)
#define Z(A) get<2>(A)
#define W(A) get<3>(A)
#define mt make_tuple
using namespace std;
using lli = long long int;
const lli INFTY = 1000*1000*1000;
usi... | ALGO | 0.999909 | 4.609751 |
7d7277c3-e5e0-4180-82ed-2da07459bbb0 | Kiran0207/DSA | findMissingNumber.cpp | class Solution {
public:
int missingNumber(vector<int>& nums) {
int n=nums.size();
n=(n*(n+1))/2;
for(int i=0;i<nums.size();i++){
n=n-nums[i];
}
return n;
}
}; | ALGO | 0.999886 | 5.572511 |
cb1a3192-ed84-44f9-83fe-0b59279e8cb4 | kushagra7589/codeforces-contests | round_435/B.cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define F first
#define S second
const int MAX_SIZE = 1e5 + 10;
vector<int> graph[MAX_SIZE];
bool visited[MAX_SIZE];
int color[MAX_SIZE];
ll cnt[2];
void bfs(int s, int n)
{
for(int i = 1; i <= n; i++)
{
color[i] = -1;
... | ALGO | 0.999867 | 4.761373 |
e606f47c-6122-4594-8409-86a3314690a6 | wavestoweather/PCViewer | PCViewer/eigen-3.3.7/unsupported/doc/examples/PolynomialSolver1.cpp | #include <unsupported/Eigen/Polynomials>
#include <vector>
#include <iostream>
using namespace Eigen;
using namespace std;
int main()
{
typedef Matrix<double,5,1> Vector5d;
Vector5d roots = Vector5d::Random();
cout << "Roots: " << roots.transpose() << endl;
Eigen::Matrix<double,6,1> polynomial;
roots_to_mo... | TEST | 0.998999 | 4.728547 |
b6bf6db6-1246-4b82-9e7a-d5427fb51f54 | kholostovamk/DataStructures-Algorithms-CPP | HW2 C++ Review2/HW2-1.cpp | /*Write a program that uses pointers to set ten elements in an array of ints to zero.*/
#include <iostream>
using namespace std;
int arr[10] = {1, 2,3,4,5,6,7,8,9,10};
int arrLength = sizeof(arr) / sizeof(int);
int *arrptr = arr;
int main () {
//change numbers in array for 0s
for (int i=0; i < arrLength; i... | ALGO | 0.981373 | 4.590556 |
97898857-feb8-4df3-b41b-01c62e7e83ab | MariaChrysafis/CompetitiveProgramming | LeetCode/1998.cpp | class Solution {
public:
const static int MAX = 1e5 + 10;
vector<int> oc[MAX];
int connectedComponent[MAX];
int comp;
vector<int> adj[MAX];
void dfs(int x){
connectedComponent[x] = comp;
for(int i: adj[x]){
if(!connectedComponent[i]){
dfs(i);
... | ALGO | 0.999979 | 5.418906 |
e024ed5b-651e-4d78-93d0-e4e059cb7046 | Priyankakatare0/CPU-Scheduling-Algorithms | SRTF (Shortest Remaining Time First) scheduling.cpp | #include<bits/stdc++.h>
using namespace std;
struct Process {
int pid;
int arrivalTime;
int burstTime;
int completionTime;
int turnaroundTime;
int waitingTime;
int remainingTime;
};
void calculateTimes(Process proc[], int n) {
int currentTime = 0;
int completedProcesses = 0;
... | ALGO | 0.999978 | 5.109019 |
ac0365ea-99e3-43b2-b8c4-e7effa4b06e6 | Abhishek-Sharma-1999/LeetCode-Solutions | 2176-count-equal-and-divisible-pairs-in-an-array/2176-count-equal-and-divisible-pairs-in-an-array.cpp | class Solution {
public:
int countPairs(vector<int>& nums, int k) {
unordered_map<int,vector<int>>mp;
int count=0;
for(int i=0;i<nums.size();i++)
{
if(mp.find(nums[i])!=mp.end()) //element map mein present hai
{
for(auto x:mp[nums[i]])
... | ALGO | 0.999832 | 5.714899 |
7b992898-8e68-46ca-a54e-e19d6b8b14e9 | Kawser-nerd/CLCDSA | Source Codes/AtCoder/abc024/B/4077070.cpp | #include <iostream>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
#include <string>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cmath>
#include <climits>
#include <bitset>
#include <array>
#include <deque>
#include <queue>
#include <map>
#d... | ALGO | 0.999966 | 4.223557 |
3a12f727-5856-4743-95d0-4c545f249bbe | ltangvald/mysql | storage/ndb/src/common/util/md5_hash.cpp | #include "md5_hash.hpp"
#ifdef WORDS_BIGENDIAN
#define HIGHFIRST 1
#endif
#ifndef HIGHFIRST
#define byteReverse(buf, len) /* Nothing */
#else
void byteReverse(unsigned char *buf, unsigned longs);
/*
* Note: this code is harmless on little-endian machines.
*/
void byteReverse(unsigned char *buf, unsigned longs)
{
... | ALGO | 0.999624 | 5.931593 |
c2a4a565-6d54-4d8c-81ee-7cefc188dc8f | selmanalpdundar/CompetitiveProgramming | LittleGirlAndMaximumSum.cpp | #include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;
int main(){
int size, numberOfQuery;
cin>>size>>numberOfQuery;
vector<int> inputs;
vector<int> queries;
inputs.reserve(size);
queries.reserve(numberOfQuery+1);
for(int i = 0; i<size; i++){
... | ALGO | 0.999873 | 3.945274 |
953e8cab-e760-4959-9c2c-e96d280bec64 | MENGJIANGTAO/FHR | cocos2d/cocos/math/Mat4.cpp | #include "math/Mat4.h"
#include "math/Quaternion.h"
#include "math/MathUtil.h"
#include "base/ccMacros.h"
NS_CC_MATH_BEGIN
Mat4::Mat4()
{
*this = IDENTITY;
}
Mat4::Mat4(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24,
float m31, float m32, float m33, float m3... | TOOL | 0.980455 | 7.258378 |
52e87cbf-7f50-4dbb-9c6b-6396bdad4148 | SamProkopchuk/coding-problems | hackerrank/hackerland-radio-transmitters/solution.cpp | #include <algorithm>
#include <iostream>
#include <vector>
typedef signed long long ll;
#define FOR(x, to) for (x = 0; x < (to); ++x)
#define FORR(x, arr) for (auto& x : arr)
using namespace std;
int main() {
int n, k, i;
cin >> n >> k;
vector<int> houses(n);
FOR(i, n) cin >> houses[i];
sort(houses.begin(... | ALGO | 0.999971 | 4.622869 |
0618d99f-650d-4d30-9b00-6e6f78497e0d | rkcraushan333/leetcode | 0496-next-greater-element-i/0496-next-greater-element-i.cpp | class Solution {
public:
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2)
{
unordered_map<int,int>m;
for(int i=0;i<nums2.size();i++)
{
m[nums2[i]] = i;
}
vector<int>ans;
for(int i=0;i<nums1.size();i++)
{
int j... | ALGO | 0.999757 | 5.869791 |
cd8f1833-5b6e-44e2-91d4-860f95a3a54d | MarcioAntusa/Beecrowd-Solutions | C++/1076.cpp | #include <iostream>
#include <vector>
using namespace std;
vector<int> *adj;
bool visited[50];
int t = 0;
void dfs(int u)
{
visited[u] = true;
for (vector<int>::iterator it = adj[u].begin(); it != adj[u].end(); ++it)
{
if (!visited[*it])
{
t++;
dfs(*it);
}... | ALGO | 0.999562 | 4.034572 |
67f40290-9f0a-4b87-8ef1-7f9718bcd409 | EpicIan60142/matlab-drive | ASEN1320/ASEN1320Code/demos/lab/Week7/Code2_Funct_By_Ref.cpp | #include <iostream>
using namespace std;
// Go through the swap example first to show simple call by reference
// DemoCode/Week6/lecture
// Example of void return
// Tell them you can have mix of reference and call by value.
void areaCalc(int r, double &area);
const double pi=3.1416; // Explain global variable a... | TOOL | 0.973847 | 5.704196 |
7a5e5ffb-06b8-47a3-b5fb-59294dd98b01 | charon1212/MyLibraryForCompProgramming | MyLibraryForCompProgramming/UnitTest/CumulativeSumTest.cpp | #include "pch.h"
#include "CppUnitTest.h"
#include "../MyLibraryForCompProgramming/CumulativeSum.cpp"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace CumulativeSumTest
{
TEST_CLASS(CumulativeSumTest)
{
public:
TEST_METHOD(CumulativeSumTestMethod_1D)
{
... | TEST | 0.960735 | 6.531962 |
30d705dc-fafb-496c-9041-4378a334a264 | ESHAN-tech/C-Pinnacle | Array/baasic.cpp | #include <iostream>
using namespace std;
//Here we will do static alloaction of the array
void print(int *arr , int n){
for(int i = 0 ; i < n ; i++)
{
cout<<arr[i]<<" ";
}
cout<<endl;
}
int main()
{
int n = 5;
int arr[5]={1,2,3,4,5};
cout<<"array number 1 = ";
print(arr, 10);
... | ALGO | 0.928965 | 3.550426 |
4d5977d8-84aa-42cc-a770-52abb51dea41 | varunjain4700/Competitive-Programming | 702(div-3)/A_Dense_Array.cpp | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define ub upper_bound
#define lb lower_bound
#define endl "\n"
#define mod 1000000007
#define rep(i,n) for(int i=0;i<n;i++)
#define repr(i,n) for(int i=n-1;i>=0;i--)
int main() {
ios_base::sync_with_stdio... | ALGO | 0.999181 | 3.698267 |
896ca567-318f-4193-a362-bd51c5a3628d | xiang123456778/Framwork8.1 | frameworks/av/media/libstagefright/codecs/mp3dec/src/pvmp3_huffman_parsing.cpp | /*
------------------------------------------------------------------------------
PacketVideo Corp.
MP3 Decoder Library
Filename: pvmp3_huffman_decoding.cpp
Funtions:
pvmp3_huffman_quad_decoding
pvmp3_huffman_pair_decoding
pvmp3_huffman_pair_decoding_linbits
Date: 09/21/2007
------------... | ALGO | 0.999632 | 5.370636 |
928168f0-92fe-45ad-9e47-4d69e9f487fe | EAirPeter/CODEVS | p3116.cpp | #include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
#define NOCHECK
class hint {
friend bool operator <(const hint &a, const hint &b);
public:
void NOCHECK trans(char *s) {
z = 0;
int i;
char t;
for (i = (int) strlen(s); i > 8; i -= 8) {
t = s[i];
s[i] = '\0';
d[z++] = ato... | ALGO | 0.999678 | 3.663386 |
67944b67-fb8b-4789-8675-60338be757c1 | ishandutta2007/codeforces | xuanyi/normal/518/D.cpp | #include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair <int, int> pii;
typedef vector <int> vi;
typedef vector <pii> vp;
template <typename T>
inline T max(const T &x, const T &y) { return x < y ? y : x; }
tem... | ALGO | 0.999846 | 3.709311 |
6a8061bb-0334-45cd-9c9b-dd256fb2cbdb | Rituresh143/Competitive-coding | Replace_character.cpp | #include <bits/stdc++.h>
using namespace std;
// Function to replace all occurrences
// of character c1 with character c2
void replaceCharacter(char input[],
char c1, char c2)
{
// Base Case
// If the string is empty
if (input[0] == '\0') {
return;
}
// If the charact... | ALGO | 0.999982 | 4.667938 |
3e67406f-adbf-4e5c-a855-fd7ea99461b6 | DarkJyn/SPOJ_PTIT | PTIT013B_Bài B - BONG DA.cpp | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MOD 1000000007;
int mark[5005];
struct team{
string name;
int score;
};
bool cmp(team a, team b){
if(a.score == b.score) return a.name < b.name;
return a.score > b.score;
}
int main(){
cin.tie(nullptr)->sync_with_stdio(false);
int t;cin ... | ALGO | 0.999803 | 3.702997 |
efd01761-b15b-4438-9d37-9d5315cc8dc6 | DhruvTotala/Leetcode | 3475-minimum-operations-to-make-binary-array-elements-equal-to-one-i/minimum-operations-to-make-binary-array-elements-equal-to-one-i.cpp | class Solution {
public:
int minOperations(vector<int>& nums) {
int count = 0;
int n = nums.size();
int i = 0;
while(i < n) {
if(nums[i] == 0){
if(i > n - 3) return -1;
nums[i] ^= 1;
nums[i + 1] ^= 1;
nums[i ... | ALGO | 0.999954 | 5.849212 |
286c6ced-304a-4d10-bbd9-6af052b56c79 | NescafeAlgeria/Subiecte-admitere | 3/main.cpp | #include <iostream>
#include <fstream>
using namespace std;
ofstream fout("palin.txt");
int ogl(int n){
int x=0;
while(n!=0){
x = x*10 + n%10;
n /= 10;
}
return x;
}
int main(){
int a,b;
cin>>a>>b;
for(int i=a;i<=b;i++){
if(i==ogl(i)) fout<<i<<' ';
}
return... | ALGO | 0.998877 | 3.923448 |
3e6b6a5a-4110-4899-b6c2-9498f843230c | KilTae/algorithm | heap/disk_controller.cpp | #include <string>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
struct cmp {
bool operator()(vector<int> a, vector<int> b) {
return a.at(1) > b.at(1);
}
};
int solution(vector<vector<int>> jobs) {
int answer = 0;
int time = 0;
int i = 0;
sort(jobs.begin(... | ALGO | 0.999952 | 5.270124 |
087f07f5-f40e-4cf4-a41c-59e926b9e7ad | Sherlock9256/LeetCode | 318.cpp | #include<vector>
#include<string>
using namespace std;
class Solution {
public:
int maxProduct(vector<string>& words) {
vector<int> rec;
for(auto& a:words){
int tmp = 0;
for(auto& chr:a){
int cnt = chr-'a';
int idx=1;
idx<<=cnt;... | ALGO | 0.999931 | 5.459626 |
ddbd5a58-84fa-4c64-8f84-4ae2a38995c6 | kmjp/procon | atcoder/arc101-150/arc104/c.cpp | #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define FORR2(x,y,arr) for(auto& [x,y]:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#def... | ALGO | 0.99998 | 3.245372 |
6e19ceb7-7d30-4d3c-acc4-f017b3125b43 | isha-24/Leetcode | Validate Stack Sequences.cpp | //https://leetcode.com/problems/validate-stack-sequences/
class Solution {
public:
bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
stack<int> st;
int n=pushed.size();
int c=0;
for(int i=0;i<n;i++){
if(pushed[i]==popped[c]){
c++;
... | ALGO | 0.999819 | 6.346383 |
87f6d6c7-82c0-4eb6-82b7-fd38bc5c3613 | eyhhhh/2rdWinterVacation | baekjoon/2_week2/1302 베스트셀러/1302 베스트셀러/1302.cpp | #include <iostream>
#include <map>
using namespace std;
int main() {
int N;
cin >> N;
map<string, int> books;
while (N--) {
string book;
cin >> book;
if (books.find(book) != books.end()) {
books[book]++;
}
else {
books[book] = 1;
}
}
string bestseller;
int compare = 0;
for (auto i : books) ... | ALGO | 0.999777 | 4.969079 |
1c402867-a48c-48c8-96ba-b6cf045c14c1 | ianhom/Cpp-Noob | Note_1/Class_OpOverload.cpp | #include <iostream>
using namespace std;
class box
{
public:
box (int a)
{
A = a;
}
int getB(void)
{
return B;
}
/* “+”运算重载，重新定义“+”操作的具体定义，实现两个对象的相加 */
box operator+(const box& b)
{
box c(1);
... | ALGO | 0.982051 | 4.367864 |
78a771dd-99f8-4ff1-8a3e-d88eaf674bc8 | flyingU-ai/IN203 | Projet/src/parametres.cpp | #include <cstdlib>
#include <cassert>
#include <ctime>
#include <iostream>
#include <random>
#include <chrono>
#include <omp.h>
#include "galaxie.hpp"
#include "parametres.hpp"
#define THREADS 16
#define CHUNK 100
expansion calcul_expansion(const parametres& c, std::uniform_real_distribution<double>& rd,
... | ALGO | 0.999567 | 3.555327 |
5c7d9d2a-9486-4997-b5d8-27ab73e9c4a7 | s1021430/LeetCode_CPP | TopInterView/_101SymmetricTree/SymmetricTree.cpp | //
// Created by fk035 on 2022/4/26.
//
#include "SymmetricTree.h"
bool SymmetricTree::isSymmetric(SymmetricTree::TreeNode *root) {
if(root == nullptr) return true;
return NodeCompare(root->left, root->right) && NodeCompare(root->right, root->left);
}
bool SymmetricTree::NodeCompare(SymmetricTree::TreeNode *... | ALGO | 0.999013 | 5.842438 |
8efe6a9c-98d0-4c31-94b6-ebf75e740be9 | sagarkumarpatel/Data-Structure-Using-C | Graph/level_order_Traversal.cpp | #include<iostream>
#include<queue>
using namespace std;
class Node{
public:
int data;
Node* left;
Node* right;
Node(int val){
data=val;
left=right=NULL;
}
};
Node* insert(Node* root, int value) {
if (root == NULL)
return new Node(value);
if (value < root->data)
root->left = insert(ro... | ALGO | 0.999996 | 5.748945 |
a6cf1014-7275-4c79-8e61-2a997b7b03a3 | Divyansh-Mehta/Coding-ninja-dsa | Data-Structures-in-C++/Lecture-9-Linked-List-2/Code/find-node-in-ll-recursive.cpp | /*
Find a node in LL (recursive)
Given a singly linked list of integers and an integer n, find and return the index for the first occurrence of 'n' in the linked list. -1 otherwise.
Follow a recursive approach to solve this.
Note :
Assume that the Indexing for the linked list always starts from 0.
Input format :
The f... | ALGO | 0.999911 | 5.782097 |
1b45173e-86d4-4cd4-8346-25ac7dd62bd1 | cdsama/LeetCode | src/0572.cpp | #include "LeetCode.hpp"
/*
572. Subtree of Another Tree
Easy
Given two non-empty binary trees s and t, check whether tree t has exactly the same structure and node values with a subtree of s. A subtree of s is a tree consists of a node in s and all of this node's descendants. The tree s could also be considered as a ... | ALGO | 0.999791 | 7.169245 |
9df43d75-dd29-4b10-8998-fb558cf5bca3 | MaicolGomez/ACM | spoj/2699.cpp | #include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
#include<cmath>
#include<algorithm>
#include<climits>
#include<set>
#include<deque>
#include<queue>
#include<map>
#include<climits>
#include<string>
#include<stack>
#include<sstream>
using namespace std;
#define pi (2.0*acos(0.0))
#define eps 1e-6
#... | ALGO | 0.999918 | 3.863557 |
d643e2f8-e204-401c-a43d-93a7865c9dd3 | kripken/ammo.js | bullet/src/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.cpp | #include "btGjkConvexCast.h"
#include "BulletCollision/CollisionShapes/btSphereShape.h"
#include "btGjkPairDetector.h"
#include "btPointCollector.h"
#include "LinearMath/btTransformUtil.h"
#ifdef BT_USE_DOUBLE_PRECISION
#define MAX_ITERATIONS 64
#else
#define MAX_ITERATIONS 32
#endif
btGjkConvexCast::btGjkConvexCast(... | ALGO | 0.997587 | 6.413063 |
32a1a1fe-dda9-400c-807a-b9b100e5d4d0 | Ras-hi/GFG-Problems | Basic/Binary number to decimal number/binary-number-to-decimal-number.cpp | //{ Driver Code Starts
#include <bits/stdc++.h>
using namespace std;
// } Driver Code Ends
class Solution {
public:
int binary_to_decimal(string str) {
// Code here.
string num = str;
int dec_value = 0;
// Initializing base value to 1, i.e 2^0
int base = 1;
... | ALGO | 0.999747 | 6.632402 |
8b2dc55b-7d82-4af9-8f99-98cd9239332f | sanjeetboora/Launchpad_29Dec2019 | Lecture09/linearSearch.cpp | #include <bits/stdc++.h>
using namespace std;
bool linearSearch(int* arr, int n, int key){
if(n == 0){
return false;
}
//recursive call -> linearSearch(arr+1, n-1, key)
if(arr[0] == key || linearSearch(arr+1, n-1, key)){
return true;
}
return false;
}
int main(int argc, char const *argv[])
{
int arr[10] = ... | ALGO | 0.999954 | 4.911482 |
5e354218-2b3e-4a5f-98df-3baf8eafed6a | weiwch/faiss_preassigned | tutorial/cpp/7-PQFastScan.cpp | #include <cassert>
#include <cstdio>
#include <cstdlib>
#include <random>
#include <faiss/IndexPQFastScan.h>
using idx_t = faiss::idx_t;
int main() {
int d = 64; // dimension
int nb = 100000; // database size
int nq = 10000; // nb of queries
std::mt19937 rng;
std::uniform_real_distribution... | TEST | 0.954725 | 5.504812 |
3b8dfce7-64ca-40ec-88d4-3bfe901d0d38 | BitBuddiesHub/BBH-C---Learning-Journey | assignment/3/inline.cpp | #include <iostream>
using namespace std;
inline bool func(char k)
{
if (k >= '0' && k <= '9')
{
return true;
}
else
{
return false;
}
}
int main()
{
char k;
k = cin.get();
cout << func(k);
} | ALGO | 0.851295 | 3.324809 |
0e72734d-29f6-4446-9546-1a151fde5f86 | sarvex/leetcode-pascal | solution/1200-1299/1235.Maximum Profit in Job Scheduling/Solution.cpp | class Solution {
public:
int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
int n = profit.size();
vector<tuple<int, int, int>> jobs(n);
for (int i = 0; i < n; ++i) jobs[i] = {endTime[i], startTime[i], profit[i]};
sort(jobs.begin(), jobs.end());
... | ALGO | 0.999993 | 6.070285 |
e9a78979-0f68-4b3b-bd10-4573024ff269 | DipanshuRaj2/Learning-C-plus-plus | basic _c++.cpp/array.cpp | /*
basic operation of array:-
1. searching
#include<iostream>
using namespace std;
int search(int arr[], int n , int x)
{
for(int i = 0; i < n; i++){
if(arr[i] == x)
return i;
}
return -1;
}
int main(){
int n;
cout << "Enter the size of the array ";
cin >> n;
int a... | ALGO | 0.999291 | 4.338024 |
1f39a62a-9230-4398-9237-9be0c8b2ece5 | salah-sorour-dev/Algorithms-Problem-Solving-Level-2 | problem 8.cpp | // problem 5.cpp : This file contains the 'main' function. Program execution begins and ends there.
//
#include <iostream>
#include <string>
using namespace std;
int ReadPositiveNumber(string Message)
{
int Number = 0;
do
{
cout << Message;
cin >> Number;
} while (Number <= 0);
return Number;
}
int CountDig... | ALGO | 0.996503 | 5.537979 |
7f03f592-b34d-44c7-bf1c-b7a54434bfc1 | jamesroutley/Flower-Classification | servers/cnn_matlab/src/bits/normalize.cpp | /** @file normalize.cpp
** @brief Normalization block
** @author Andrea Vedaldi
**/
#include "normalize.hpp"
#include <algorithm>
#include <cmath>
#include <blas.h>
#include <string.h>
#include <x86intrin.h>
/* ---------------------------------------------------------------- */
/* ... | DATA | 0.998849 | 5.29742 |
36dd92d1-5b98-4ddb-8574-f3c7be90e377 | kumudh-ranasinghe/DSA | LAB 9/hashtable1.cpp | #include <iostream>
#include "linkedlist.cpp"
using namespace std;
struct HashTable{
int MAX_LENGTH = 4;
int MAX_CHAIN_LENGTH = 2;
LinkedList * password = new LinkedList[MAX_LENGTH];
bool isFull(){
bool full = true;
int count = 0;
for (int i = 0; i < MAX_LENGTH; i++){
... | ALGO | 0.984513 | 4.016196 |
32dd5759-98ef-4357-9da0-d5912d94c3f7 | tudelft3d/3D_Urban_Mesh_Annotator | CGAL/examples/Polygon/Example.cpp |
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Polygon_2.h>
#include <list>
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef CGAL::Point_2<K> Point;
typedef CGAL::Polygon_2<K> Polygon_2;
typedef Polygon_2::Vertex_iterator VertexIterator;
typedef Polygon_2::Edge_c... | ALGO | 0.999049 | 6.798208 |
52540e99-b071-4570-bf2a-9a8514e394a7 | sigus/solutions | timus/volume 6/1581.cpp | #include <cstdio>
int main() {
int n, b, c = 0, cur_number = 0;
scanf(" %d", &n);
for (int i = 0; i < n; i++) {
scanf(" %d", &b);
if (b == cur_number)
c++;
else {
if (cur_number)
printf("%d %d ", c, cur_number);
c = 1;
... | ALGO | 0.999224 | 3.166091 |
9eabee52-a56f-404f-903d-b954ee1ea4d6 | K1Sula/ADS24-25 | Endterm/L11.cpp/dfs.cpp | #include <iostream>
#include <vector>
#include <climits>
using namespace std;
int graph_size; // Размер графа
vector<int> color;
vector<int> discovery;
vector<int> finish;
vector<int> predecessor;
int dfs_time;
void dfs_visit(int u, const vector<vector<int>>& adj) {
color[u] = 1; // Серый цвет
discovery[u] =... | ALGO | 0.99955 | 6.009907 |
039fec06-96d2-4882-a393-f8f39ce65703 | AshHyun/BOJ | 1834.cpp | #include <algorithm>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <queue>
#include <set>
#include <tuple>
#include <utility>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef tuple<int, int, int>... | ALGO | 0.99979 | 3.930417 |
1d612401-1a40-4ea0-9a18-e7cb0cb74ffe | sarvex/leetcode-skip | solution/1800-1899/1822.Sign of the Product of an Array/Solution.cpp | class Solution {
public:
int arraySign(vector<int>& nums) {
int ans = 1;
for (int v : nums) {
if (!v) return 0;
if (v < 0) ans *= -1;
}
return ans;
}
}; | ALGO | 0.999996 | 5.59998 |
830d5c74-e6ff-4dea-8273-f8bd823c727c | Am10aN16/webD_projects_beginners_Hacktoberfest22 | String/Count_Prefixes_of_a_Given_String.cpp | /*
You are given a string array words and a string s, where words[i] and s comprise only of lowercase English letters.
Return the number of strings in words that are a prefix of s.
A prefix of a string is a substring that occurs at the beginning of the string. A substring is a contiguous sequence of characters within... | ALGO | 0.999851 | 6.457502 |
d4656f11-aae6-48f1-a991-3035883d063b | yashsiwach/GeekForGeeks-CPP | Easy/Palindrome String/palindrome-string.cpp | //{ Driver Code Starts
#include <bits/stdc++.h>
using namespace std;
// } Driver Code Ends
//User function template for C++
class Solution{
public:
int solve(string& j,int s,int e)
{
int ans=1;
if(s>=e)
{
return ans;
}
if(j[s]!=j[e])
{
... | ALGO | 0.999794 | 5.626296 |
0c16f34f-d306-4b80-a014-23f388497105 | iamishansharma/Placement-Preparation | DSA/Interview Bit/Greedy/Bulbs.cpp | int Solution::bulbs(vector<int> &A)
{
int ans = 0, i;
int n = A.size();
if (A.size() != 0)
{
if (A[i] == 0)
ans = 1;
for (i = 1; i < n; i++)
{
if (A[i] != A[i - 1])
ans++;
}
}
return ans;
}
| ALGO | 0.999431 | 5.231867 |
46e9b1d3-56a0-4e31-86f2-213472c5c709 | nponce16/eda | STL data structures/Casino/P40902.cpp | #include <iostream>
#include <map>
using namespace std;
int main() {
map<string,int> profits; //mapa<nombre, dinero ganado>
string op;
string name;
while(cin >> name >> op) {
if (op == "enters") {
//si la persona ya está en el casino
if (profits.find(name) != profits.e... | ALGO | 0.977263 | 4.006076 |
a9b0c754-c489-444d-97e4-c3a091ac1661 | miguelsndc/competitive-programming-lib | Solutions/Seletiva-2025/H7/E.cpp | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define MOD 1000000007
#define vi vector<int>
#define fi first
#define se second
#define sz(x) int(x.size())
#define all(a) (a).begin(), (a).end()
#define INF 1000000009
bool prime(ll a) { if (a==1) return 0; for (int i=2;i<=round(sqrt(a));++i) if ... | ALGO | 0.999995 | 4.762287 |
b263b81d-e74c-4d8d-ac6e-a93134b5972e | RichieSams/lantern | third_party/embree/kernels/bvh/bvh_builder_sah.cpp | #include "bvh.h"
#include "bvh_builder.h"
#include "../builders/primrefgen.h"
#include "../builders/splitter.h"
#include "../geometry/linei.h"
#include "../geometry/triangle.h"
#include "../geometry/trianglev.h"
#include "../geometry/trianglev_mb.h"
#include "../geometry/trianglei.h"
#include "../geometry/quadv.h"
#in... | ALGO | 0.997907 | 6.978913 |
21729a2c-467d-4ac6-b5a3-d0e120531e94 | pari-1920/godot.py | thirdparty/rvo2/rvo2_2d/Agent2d.cpp | #include "Agent2d.h"
#include "KdTree2d.h"
#include "Obstacle2d.h"
namespace RVO2D {
Agent2D::Agent2D() : maxNeighbors_(0), maxSpeed_(0.0f), neighborDist_(0.0f), radius_(0.0f), timeHorizon_(0.0f), timeHorizonObst_(0.0f), id_(0) { }
void Agent2D::computeNeighbors(RVOSimulator2D *sim_)
{
obstacleNeighbors_.clear(... | ALGO | 0.999694 | 4.949144 |
c7390b38-607e-4108-955b-0114d5cb2548 | Hadeer-Elsaeed/C-Plus-Plus | others/happy_number.cpp | /**
* @file
* @brief A happy number is a number whose sum of digits is calculated until the
* sum is a single digit, and this sum turns out to be 1
*/
#include <iostream>
/**
* Checks if a decimal number is a happy number
* \returns true if happy else false
*/
template <typename T>
bool is_happy(T n) {
T s... | ALGO | 0.996332 | 6.161031 |
67ca6177-003b-4d34-a7b2-02c2907bd854 | MostafaAshraf98/Problem-Solving | Greedy/Leetcode/179. Largest Number.cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
#define sf(n) scanf("%d", &n)
#define sff(n, m) scanf("%d%d", &n, &m)
#define sfl(n) scanf("%I64d", &n)
#define sffl(n, m) scanf("%I64d%I64d", &n, &m)
#define sfs(s) scanf("%... | ALGO | 0.999978 | 6.021071 |
fc1b75cc-1b81-4a99-8faf-e62a63d54176 | nashiong/cantera | cantera/branches/2.0/src/oneD/StFlow.cpp | /**
* @file StFlow.cpp
*/
#include <stdlib.h>
#include <time.h>
#include "cantera/oneD/StFlow.h"
#include "cantera/base/ctml.h"
#include "cantera/oneD/MultiJac.h"
#include <cstdio>
using namespace ctml;
using namespace std;
namespace Cantera
{
//------------------- importSolution ------------------------
/**
... | ALGO | 0.97443 | 3.249026 |
aa3b56dc-dd8d-4bd4-864e-38a29fd045fc | Bungmint/competitiveprogramming | contest/codeforces/1220/E.cpp | using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
using vpi = vector<pii>;
using pll = pair<ll, ll>;
using vl = vector<ll>;
using vpl = vector<pll>;
using ld = long double;
template <typename T, size_t SZ>
using ar = array<T, SZ>;
template <typename T>
using pqg = priority_... | ALGO | 0.999916 | 4.235639 |
acf66d4e-9d77-4992-a849-aa12e76d0dcc | soonkwan1/beakjoon | bj15685.cpp | #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <deque>
#include <queue>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#define endl "\n"
#define ll long long
#define fastio cin.tie(NULL), cout.tie(NULL), ios_base::sync_with_stdio(f... | ALGO | 0.999707 | 4.771339 |
bb3a4392-544f-4e5f-9af1-a78d83d00764 | pr7prashant/Leetcode | 268-missing-number/268-missing-number.cpp | class Solution {
public:
int missingNumber(vector<int>& nums) {
int x1 = 0, x2 = 0;
for (int n : nums) x1 ^= n;
for (int i = 0; i <= nums.size(); i++) x2 ^= i;
return x1 ^ x2;
}
};
| ALGO | 0.999963 | 5.694756 |
9b2cc3bd-955f-47c7-b5fe-81e6d7f4c8fc | northmachine/pat_test | a1030_SPFA.cpp | #include <bits/stdc++.h>
const int MAXV = 510;
const int INF = 0x3fffffff;
using namespace std;
struct node{
int v,dis,cost;
node(int _v,int _dis,int _cost): v(_v),dis(_dis),cost(_cost){}
};
vector<node> Adj[MAXV];
int N,M,S,D;
int d[MAXV],c[MAXV],num[MAXV];
bool inq[MAXV];
int pre[MAXV];
bool SPFA(int s){
memset(in... | ALGO | 0.999985 | 3.530442 |
efb792e3-9825-4a0b-9f49-b52a18b14b1e | absolutePi/Competitive_Programming | POSN/AtCoder/slimes.cpp | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 405;
int a[N],dp[N][N];
signed main(){
int n;
cin >> n;
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
dp[i][j]=LLONG_MAX;
}
}
for(int i=1;i<=n;i++){
cin >> a[i];
a[i]+=a[... | ALGO | 0.999912 | 3.595859 |
8d7f7045-ac75-4402-8b80-35452238765d | MenaPaul/Grupo-8---Mena---Chablay-4683- | DeberOperadores/main.cpp |
/* UNIVERSIDAD DE LAS FUERZAS ARMADAS (ESPE)
Nombre del programa: Sobrecarga de Operadores (& - &&)
Autor: Esteban Chablay & Paul Mena
Fecha de creacion: 16/05/2022
Fecha de modificacion: 16/05/2022
4683 ESTRUCTURA DE DATOS
*/
#include <iostream>
#include <bitset>
#include "Operadores.h"
using namespace std;
int ma... | ALGO | 0.993221 | 5.158983 |
b4d0e165-358f-4d95-bade-79d2daeb4211 | monda00/AntBook | cpp/chapter2/maze.cpp | /* 幅優先探索で最短手数を求める
* キューを使って実装
*/
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int INF = 100000000;
typedef pair<int, int> P;
vector<vector<char> > maze;
int n, m;
int start_x, start_y;
int goal_x, goal_y;
vector<vector<int> > d;
// 移動方向のベクトル
int dx[4] = {1, 0, -1, 0}, dy[4] ... | ALGO | 0.999732 | 4.138631 |
bc3ba699-660f-4f1c-981f-f6c47b4b5c6c | ulvenforst/Univalle | Programación OO/Lab4/main.cpp | /**
HISTORIA:
Estamos en el concurso de televisión ¿Quieres ser trillonario? Los ganadores están en fila para recibir el premio El premio, y también hay una fila de presentadores para entregarlos. Hay distintos tipos de presentadores:
• El presentador de ideas fijas: siempre da como premio 100 bitcoins.
• ... | ALGO | 0.945869 | 4.796138 |
a2cbafc4-8711-4942-a6b1-a4565e837f7c | ishandutta2007/codeforces | ekzhang/normal/723/B.cpp | #include <bits/stdc++.h>
using namespace std;
#define error(args...) { vector<string> _v = split(#args, ','); err(_v.begin(), args); }
vector<string> split(const string& s, char c) { vector<string> v; stringstream ss(s); string x; while (getline(ss, x, c)) v.push_back(move(x)); return v; }
void err(vector<string>::ite... | ALGO | 0.999667 | 4.581774 |
c7fe7465-5652-4be2-901b-081867e0b659 | ancabilloni/SDC-UnscentedKalmanFilter | src/tools.cpp | #include <iostream>
#include "tools.h"
using Eigen::VectorXd;
using Eigen::MatrixXd;
using std::vector;
Tools::Tools() {}
Tools::~Tools() {}
VectorXd Tools::CalculateRMSE(const vector<VectorXd> &estimations,
const vector<VectorXd> &ground_truth) {
/**
TODO:
* Calculate the RMSE... | ALGO | 0.974152 | 5.977083 |
f9520099-66ad-4add-a3af-b221c3fe02a0 | xdandroid/frameworks_base | media/libstagefright/codecs/amrnb/enc/src/ton_stab.cpp | /*
------------------------------------------------------------------------------
Pathname: ./audio/gsm-amr/c/src/ton_stab.c
Funtions:
Date: 02/06/2002
------------------------------------------------------------------------------
REVISION HISTORY
Description: For check_lsp()
1. Eliminated u... | TOOL | 0.879591 | 7.670895 |
1e5e2981-0170-46fa-981f-7c473b5696ea | yasinenis/happy-codings-examples-c | examples-01-04-01/main.cpp | // Program to Search an element in Array
#include <stdio.h>
int main()
{
int a[30], ele, j, x;
printf("\nEnter no of elements :");
scanf_s("%d", &j);
printf("\nEnter the values :");
for (x = 0;x < j;x++)
{
scanf_s("%d", &a[x]);
}
// Read the element to be searched
printf("\nEnter the elements to be searc... | ALGO | 0.998784 | 4.330229 |
7f8b36b9-b4eb-4c7d-9c26-eaabaec6eeda | 113bommy/deepmind_codecontests_refine | cpp_gold_filter_file/cpp_train_4142_65.cpp | #include<iostream>
using namespace std;
int main()
{
long int a,b;
cin>>a>>b;
cout<<a*b;
return 0;
} | ALGO | 0.975914 | 3.216476 |
bab9f805-a0ee-48f0-81d2-5ec6e5fb7231 | CDPS/Competitive-Programming | LightOJ/Beginners/1354 - IP Checking.cpp | #include <bits/stdc++.h>
using namespace std;
string tostring(int n){
stringstream st;
st << n;
return st.str();
}
int main() {
int t,caseno=1;
scanf("%d",&t);
while(t--){
string a,b;
cin >> a;
cin >> b;
a+='.';
string res= "";
for(int i=0;... | ALGO | 0.999465 | 3.876968 |
1b3c1259-9dd4-4be0-a228-8b908e5dffca | roman-ojha/cpp | Notes/Threading/06_std_promise_and_std_future.cpp | /*
*) std::promise & std::future in C++ threading
-> std::promise is used to pass a value from one thread to another
EX:
-> let's say that we have a main function 'main()'
-> an you have a function 'Func()' that act as a thread thread 'T'
-> main(){
... | TOOL | 0.929872 | 4.931753 |
54a96f9d-9ccb-4f08-b5b4-48d4386b6b40 | dvt32/code-journey | C++/Uni-Ruse/1. Intro to Programming/04.01.2015.12.55.cpp | /* Димитър Валериев Трифонов, КН, 50Б, 146518 */
/* 1) Да се намери броят на нулевите елементи в масива u с m елементи. */
#include "stdafx.h"
using namespace std;
#include <iostream>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
void main(){
system("chcp 1251");
int brNulevi = 0;
int u[1337];
int m;... | ALGO | 0.999658 | 3.795768 |
307c2679-8d26-41c6-ac34-701061870642 | qazimsajjad/Programming-Fundamentals-With-CPP | Week 9/Lec 15 Codes/4_Find_Max_in_Array.cpp | #include <iostream>
using namespace std;
// Function declaration
void findMax(int arr[], int size);
int main() {
int numbers[] = {5, 2, 9, 12, 7};
int size = sizeof(numbers) / sizeof(numbers[0]); // Calculate the size of the array
findMax(numbers, size); // Passing array and its size as arguments
re... | ALGO | 0.999695 | 5.745155 |
4423c55c-1876-4cfc-b6bc-d6575f10a850 | dmkz/competitive-programming | e-olymp.com/7269 - Probable diagnosis.cpp | /*
Problem: 7269 - Probable diagnosis
Solution: probability theory, O(n*m*k)
Author: Dmitry Kozyrev, github: dmkz, e-mail: <EMAIL>
*/
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <cassert>
#include <valarray>
using ld = long double;
using vd = std::vecto... | ALGO | 0.995911 | 3.806758 |
9c7b6120-5787-4980-8aa3-ec0283bb4006 | qq910876301/Android-Android_5_0_2 | frameworks/av/media/libstagefright/codecs/amrnb/dec/src/bgnscd.cpp | /*
------------------------------------------------------------------------------
Pathname: ./audio/gsm-amr/c/src/bgnscd.c
Functions:
Bgn_scd_reset
Bgn_scd
------------------------------------------------------------------------------
MODULE DESCRIPTION
Background noise source characteristi... | ALGO | 0.967685 | 6.9677 |
246e693f-d2ed-47dc-9c7a-c337c7f06977 | devdrx/cp-submissions | B_Rock_and_Lever.cpp | #include "bits/stdc++.h"
#define int long long
#define uint unsigned long long
#define vi vector<int>
#define vvi vector<vi >
#define vb vector<bool>
#define vvb vector<vb >
#define fr(i,n) for(int i=0; i<(n); i++)
#define rep(i,a,n) for(int i=(a); i<=(n); i++)
#define nl cout<<"\n"
#define dbg(var) cout<<#var<<"="<<va... | ALGO | 0.999854 | 5.226927 |
e8a1e956-cc26-4266-aa51-fbd94368f229 | DathaRishyanth/Acads | Acads/CS2810/Labs/LAB3/main.cpp | #include <vector>
#include <iostream>
#include <algorithm>
#include <queue>
#include <string>
using namespace std;
class Graph
{
private:
vector<vector<int>> adj;
public:
friend istream &operator>>(istream &stream, Graph &g);
friend ostream &operator<<(ostream &stream, Graph &g);
// overloading + op... | ALGO | 0.987442 | 5.596619 |
33b1c160-b0f2-4f37-92f5-ecf835c3694d | FRIDAYFREEBIE/Algorithm | BaekJoon/No_2056.cpp | #include <iostream>
#include <vector>
#include <queue>
using namespace std;
int n;
vector<vector<int>> v;
vector<int> indegree, timeVector, dp;
queue<int> q;
// 동시작업 가능 위상정렬
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
v.resize(n + 1);
indegree.resize(n + 1);
time... | ALGO | 0.999931 | 4.422106 |
263e81d1-2de4-41ee-b1ed-e14946298cc9 | gangriming/Algorithm_Solve | VS_Solution/AlgorithmSolve/PGS_plus2.cpp | #include <string>
#include <vector>
#include <set>
using namespace std;
vector<int> solution(vector<int> numbers) {
set<int> a;
for (int i = 0; i < numbers.size(); ++i)
{
for (int j = i + 1; j < numbers.size(); ++j)
a.insert(numbers[i] + numbers[j]);
}
vector<int> answer(a.beg... | ALGO | 0.999798 | 5.476297 |
914d4bd9-7713-4106-9d7d-828b765683f3 | ishandutta2007/codeforces | sunset/normal/1054/A.cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
#ifdef wxh010910
freopen("input.txt", "r", stdin);
#endif
int x, y, z, t1, t2, t3;
cin >> x >> y >> z >> t1 >> t2 >> t3;
int stairs = abs(x - y) * t1;
int elevator = (abs(x - y) + abs(x - z)) * t2 + 3 * t3;
puts(elevator <= stairs ? "YES" : "NO");... | ALGO | 0.999773 | 3.785267 |
316241ed-6bc2-42ab-834f-91a224ce9d4f | Sharafabdullah/CompetitiveProgramming | seeLater/B_Parking.cpp | #include <bits/stdc++.h>
using namespace std;
#define all(v) ((v).begin()), ((v).end())
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define pb push_back
#define ppb pop_back
#define F ... | ALGO | 0.999868 | 3.687089 |
77ea6ac2-8c2e-4b89-b9f1-d2c52efa6cfb | pdlotko/paht_signatures_of_graphs | test_signatures_of_graphs.cpp | #include "signatures_of_graphs.h"
int main()
{
/*
// 1-----2
// | / \
// | / \
// 3--------4-----0
std::vector< std::vector<unsigned short int> > incidence_list(5);
std::vector<unsigned short int> neighs_0 = {4};
std::vector<unsigned short int> neighs_1 = {2,3};
std::vector<unsigned short int> neighs_2... | ALGO | 0.997928 | 3.576003 |
8701e0a9-dba3-4270-807c-11dbedb1bc48 | PriyankaRoy1012/Computer_Vision | opencv/modules/core/src/matrix_operations.cpp | #include "precomp.hpp"
#include "opencv2/core/mat.hpp"
#include "opencv2/core/types_c.h"
#include "opencl_kernels_core.hpp"
#undef HAVE_IPP
#undef CV_IPP_RUN_FAST
#define CV_IPP_RUN_FAST(f, ...)
#undef CV_IPP_RUN
#define CV_IPP_RUN(c, f, ...)
/**************************************************************************... | ALGO | 0.989054 | 6.212432 |
58a637ef-bc73-4281-92de-9eb98313bc51 | pacha2880/competitive_programming_codes | B. Whos Opposite.cpp | #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/rope>
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)a.size()
#define eq(a, b) (fabs(a - b) < EPS)
#define md(a, b) ((a) % b +... | ALGO | 0.99994 | 4.22103 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.