uuid string | repo_name string | relative_path string | content string | category string | algo_rel_score float64 | quality_score float64 |
|---|---|---|---|---|---|---|
7aa22173-7de2-4606-b20f-11ab170bf877 | ssohyunKim/TIL | PROGRAMMERS/폰켓몬.cpp | #include <vector>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
bool check[200001];
int solution(vector<int> nums)
{
int answer = 0;
int size = nums.size();
for(int i=0; i<size; i++){
if(check[nums[i]] == false){
check[nums[i]] = tru... | ALGO | 0.999728 | 4.942657 |
a7d891fa-e4e1-4b0e-a728-2f47dd3b0800 | paulrahul/algo | hackerrank/billboards2.cpp | #include <iostream>
using namespace std;
int main(int argc, char** argv) {
int n, k;
int arr[100001];
int sums[100001];
int l[100001];
int lpos[100000][2];
cin >> n >> k;
cin >> arr[0];
sums[0] = l[0] = arr[0];
lpos[0][0] = lpos[0][1] = 0;
int tmp = 0;
for (int i = 1; i < n; ++i) {
cin >> arr[i];
... | ALGO | 0.999924 | 3.562542 |
d377b1a1-1aad-4c54-947b-b91fd903b12e | lydrainbowcat/tedukuri | 配套光盘/习题/0x18 基本数据结构 总结与练习/Sliding Window/POJ2823 Sliding Window.cpp | //Author:XuHt
//C++ AC only
#include <cstdio>
#include <iostream>
using namespace std;
const int N = 1000006, INF = 0x3f3f3f3f;
int maxa[N], maxt[N], maxl = 0, maxr = 1, ansmax[N];
int mina[N], mint[N], minl = 0, minr = 1, ansmin[N];
int main() {
int n, k;
cin >> n >> k;
maxa[0] = INF;
mina[0] = -INF;
for (int i ... | ALGO | 0.999989 | 3.035658 |
9490780b-aea0-4acc-8fc7-a20a9e958c60 | Subhadip7/Snake_game | main.cpp | #include <iostream>
#include <cstdlib>
#include <conio.h>
#include<ctime>
#include "Snake.h"
#include "Food.h"
#include <windows.h>
#define WIDTH 50
#define HEIGHT 25
using namespace std;
Snake snake({ WIDTH / 2, HEIGHT / 2 }, 1);
Food food;
int score;
void board() {
COORD snake_pos = snake.get_pos();
COOR... | TOOL | 0.920403 | 4.737226 |
0279fefa-426d-4d1d-b383-f8fe132b8af2 | nikhilsourav/Data-Structures-and-Algorithms | 19. Graph/11. Diameter/ques.cpp | /*
Question: https://www.spoj.com/problems/PT07Z/
*/
#include <bits/stdc++.h>
using namespace std;
// fast io
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL);
// vectors
#define vi vector<int>
#define vvi vector<vector<int>>
#define vs vector<string>
#define vvs vector<vector<string>>
#define pb pu... | ALGO | 0.98908 | 4.663988 |
c505c960-c38a-463c-9ce3-29227a81a37d | chl-123/Algorithm | Shortest_path.cpp | #include "Shortest_path.h"
#include<iostream>
using namespace std;
void creat_Graph( bool direct)
{
int i, j, inf = 99999999, num;
cin >> n ;
for (i = 1; i <= n; i++)
{
for (j = 1; j <= n; j++)
{
if (i==j)
{
graph[i][j] = 0;
}
else
graph[i][j] = inf;
}
}
for (int k = 1; k <= n; k++)
{
... | ALGO | 0.999957 | 4.093872 |
8747a896-055e-417f-81a4-325ba30ab347 | zaychenko-sergei/cpp_intro | 05_strings/day_of_week.cpp | #include <stdio.h>
const char* dayOfWeek ( int _day )
{
static const char* s_DayNames [] =
{
"Illegal day",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday"
};
return ( _day >= 1 && _day <= 7 ) ? s_DayNames[ _day ] : s_DayNames[ 0 ];... | TOOL | 0.989461 | 3.752044 |
0b957381-0171-4c18-9b71-dfd9ef95fb65 | nikhilmole/CPP-Programs-3 | Program231.cpp | #include<iostream>
using namespace std;
int DigonalAdd(int **Arr,int iRow, int iCol)
{
int i =0;
int j = 0;
int Digo1 = 0;
int Digo2 = 0;
for(i = 0; i < iRow; i++)
{
for(j = 0; j < iCol; j++)
{
if(i == j)
{
if(Digo1 < Arr[i][j])
... | ALGO | 0.999737 | 3.635453 |
c8397d30-a4ca-4c6e-900f-bf610d950e1a | fmoeran/CP | premades/mod.cpp | struct mod {
const long long M = 1e9+7;
long long val;
mod() {val = 0;}
mod(const mod& other) {val = other.val;}
mod operator=(mod other) {val = other.val; return val;}
template<typename T> mod(T other) {val = other%M;}
template<typename T> operator=(T other) {val = (long long)other;}
... | ALGO | 0.999734 | 4.341807 |
b1fa8d81-a0b0-4686-b755-5556638a1dbb | tienvuiet/tienvuviet_C_session16 | kha5.cpp | #include <stdio.h>
void capNhatPhanTu(int *mang, int kichThuoc, int giaTriMoi, int viTri) {
if (viTri >= 0 && viTri < kichThuoc) {
*(mang + viTri) = giaTriMoi;
} else {
printf("Vi tri can cap nhat khong hop le!\n");
}
}
int main() {
int mang[] = {10, 20, 30, 40, 50};
int kichThuoc = ... | ALGO | 0.999614 | 5.024759 |
6f6f8373-e38c-4394-a635-54b13a442083 | jatinmangla26/LeetCode | 901.cpp | #include <bits/stdc++.h>
using namespace std;
stack<pair<int, int>> st;
int next(int price)
{
int span = 1;
while (!st.empty() && price >= st.top().first)
{
span += st.top().second;
st.pop();
}
pair<int, int> p;
p.first = price;
p.second = span;
st.push(p);
return st.... | ALGO | 0.998774 | 3.505424 |
35875e98-9e35-4c28-9e43-f1affaf0921e | libigl/libigl-legacy | tutorial/602_Matlab/main.cpp | #include <igl/jet.h>
#include <igl/readOFF.h>
#include <igl/cotmatrix.h>
#include <igl/matlab/matlabinterface.h>
#include <igl/opengl/glfw/Viewer.h>
#include <iostream>
#include "tutorial_shared_path.h"
// Base mesh
Eigen::MatrixXd V;
Eigen::MatrixXi F;
// Matlab instance
Engine* engine;
// Eigenvectors of the lapl... | ALGO | 0.991762 | 5.073436 |
998e648d-f587-4d39-a05c-44f7f851de73 | qpwoeirut/competitive-programming | ojuz/ioi/2020/Day1/supertrees_sol/sandbox/supertrees.cpp | #include <bits/stdc++.h>
#include "supertrees.h"
using namespace std;
int construct(vector<vector<int>> p) {
int n = p.size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (p[i][j] == 3) return 0;
}
}
vector<vector<int>> answer;
for (int i = 0; i < n; ... | ALGO | 0.999925 | 4.156165 |
2c7291b6-6450-4f33-9e11-95c58dfd2dfe | Atha2445/My_DSA | stack.cpp | #include<bits/stdc++.h>
using namespace std;
int main(){
stack<int> s;
int n,ele;
cin>>n;
for(int i=0;i<n;i++){
cin>>ele;
s.push(ele);
}
while(!s.empty()){
cout<<s.top()<<" ";
s.pop();
}
return 0;
}
| ALGO | 0.999899 | 4.384488 |
c9663e66-c2ad-4b41-83f9-41cd86fc96d3 | Suryansh-23/CodeForces | Global Round 24/A. Doremy's Paint.cpp | #include <iostream>
using namespace std;
int main()
{
int t, a, b;
cin >> t;
while (t--)
{
cin >> a >> b;
}
}
| ALGO | 0.99903 | 4.059712 |
6b21be5b-7c70-4fe0-9b66-18e2f37f323a | hackerpranavpandey/LeetCode | 0050-powx-n/0050-powx-n.cpp | class Solution {
public:
double myPow(double x, int n) {
// if 2,4 then (2*2)*(2*2) works like 4*4 instead of 2 four times
// this saves time
// just need to take care for odd number cases
// like n=3 and all
// to handle case of INT_MIN used exp variable since -(-2^31) > INT... | ALGO | 0.99966 | 5.949291 |
672b16d7-2615-4ab7-95b6-31ebf754b5c0 | vikasgola/leetcode | 1236.n-th-tribonacci-number.cpp | class Solution {
public:
int _tribonacci(int n, int* dp){
if(dp[n] != -1) return dp[n];
dp[n-3] = _tribonacci(n-3, dp);
dp[n-2] = _tribonacci(n-2, dp);
dp[n-1] = _tribonacci(n-1, dp);
return dp[n-1]+dp[n-2]+dp[n-3];
}
int tribonacci(int n) {
int dp[38] = {-1};... | ALGO | 0.999968 | 5.77394 |
f491b941-4d40-4967-812f-eabf3641c0ed | Dawid-Paleczny/Sprawdzian-z-liczb-zespolonych | WyrazenieZesp.cpp | #include "WyrazenieZesp.hh"
#include "LZespolona.hh"
using namespace std;
/*!
* Realizuje wyświetlanie operatora.
*/
ostream & operator << (ostream &StrmWyj, Operator Op)
{
const char oper [] = {'+', '-', '*', '/'}; //Zamiast mechanizmu switch/case zastosowałem metode przedstawioną na wykładzie
StrmWyj << oper[... | TOOL | 0.939152 | 4.111773 |
47848802-3cb8-4573-a5d9-8b7ba52bb63e | rvp-group/mad-ba | modules/srrg/srrg2_solver/srrg2_solver/app/sfm/sfm2essential.cpp | #include <srrg_system_utils/parse_command_line.h>
#include "srrg_solver/solver_core/factor_graph.h"
#include "srrg_solver/variables_and_factors/types_3d/variable_se3_ad.h"
#include "srrg_solver/variables_and_factors/types_3d/variable_point3_ad.h"
#include "srrg_solver/variables_and_factors/types_projective/se3_pose_poi... | ALGO | 0.998748 | 6.400152 |
69544ee5-c8d8-4647-88eb-494d0df1ff49 | protectors/ACM | HDUOJ/HDU2110-Crisis_of_HDU.cpp | #include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int n[150],v[150];
int a[1000010],b[1000010];
int main(){
int N;
while(cin>>N&&N){
int sum=0;
for(int i=0;i<N;i++){
cin>>v[i]>>n[i];
sum+=v[i]*n[i];
}
if(sum%3!=0){
cout<<"sorry"<<endl;
continue;
}
sum/=3;
mem... | ALGO | 0.999656 | 3.229757 |
c7bbeb27-d869-40b1-8a51-2eb639bc7ab1 | enotvtapke/itmo | ЭВМ/hw5/MatrixDeterminant/MatrixDeterminant.cpp | #include <iostream>
#include <random>
#include <cmath>
#include <ctime>
#include <omp.h>
#include <fstream>
using namespace std;
int LUPDecompose(double** a, int n, double tol);
int LUPDecomposeParallel(double** a, int n, double tol);
double LUPDeterminant(double** a, int p, int n);
void fillMatrix(double** a, int n,... | ALGO | 0.999362 | 4.646172 |
19df2d25-8403-4226-8516-579bfcb0edb3 | dhchung/me491_ros | src/readmarker/src/readmarker.cpp | //Reading AruCo markers
//Author : Dongha Chung
//Reference : https://docs.opencv.org/3.3.0/d5/dae/tutorial_aruco_detection.html
#include <ros/ros.h>
#include <image_transport/image_transport.h>
#include <cv_bridge/cv_bridge.h>
#include <sensor_msgs/image_encodings.h>
#include <opencv2/opencv.hpp>
#include <opencv2/im... | TOOL | 0.979064 | 4.97328 |
49f335d3-57cf-4101-8f35-e8ccad8509f5 | yzheng51/leetcode-practice | problems/implement_strstr/main.cpp | #include <iostream>
#include "solution.hpp"
int main(int argc, char const *argv[]) {
std::string haystack = "abcdabcdabde";
std::string needle = "abcdabd";
Solution sln;
auto res = sln.strStr(haystack, needle);
std::cout << res << std::endl;
return 0;
}
| ALGO | 0.999513 | 5.577755 |
040c6af2-c92a-4a66-84cc-8cb0f5aecd21 | trailofbits/llvm-wedlock | clang/lib/Tooling/Refactoring/ASTSelection.cpp | #include "clang/Tooling/Refactoring/ASTSelection.h"
#include "clang/AST/LexicallyOrderedRecursiveASTVisitor.h"
#include "clang/Lex/Lexer.h"
#include "llvm/Support/SaveAndRestore.h"
using namespace clang;
using namespace tooling;
using ast_type_traits::DynTypedNode;
namespace {
CharSourceRange getLexicalDeclRange(Dec... | TOOL | 0.922264 | 7.903986 |
8112a91f-d58c-453d-af7f-72e66e3833de | raincross7/code-similarity | codes/train_code/problem280/problem280_208.cpp | #include <iostream>
using namespace std;
int main(void)
{
int yeardays[3]= {200, 195, 195};
int monthdays[2]= {0, 20};
int num;
cin>>num;
for(int i= 0; i < num; i++)
{
int year, month, day;
cin>>year>>month>>day;
long long int sum= 1;
for(int j= year; j < 1000; j++)
sum+= yeardays[j%3];
if(year ... | ALGO | 0.99959 | 3.824986 |
ab4ce600-fa7a-4981-a866-65833573cd15 | prateek-dhanker/LeetCodeDaily | 20April2025.cpp | // 781. Rabbits in Forest
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
int numRabbits(vector<int>& answers) {
unordered_map<int,int> freq;
for(int ans : answers)
freq[ans]++;
int res = 0;
for(au... | ALGO | 0.99996 | 6.020407 |
2142324d-839b-47a3-9a99-7f41710b3dc2 | akarshan2602/codeforces-solutions | Code_A/A_Team.cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, solved=0;
cin>>n;
for (int i = 0; i < n; i++)
{
int a,b,c; cin>>a>>b>>c;
solved+= (a+b+c >=2);
}
cout<<solved;
} | ALGO | 0.99961 | 4.272197 |
ef7fbd4e-5cc8-4ac0-8477-453415c53855 | wangaaron78739/Contests | Codeforces/CF722/c.cpp | #include <algorithm>
#include <array>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <vector>
using namespace std;
template <typename A, ty... | ALGO | 0.999552 | 5.541152 |
f3a025ac-dd56-4d40-bbb4-21874edc8d95 | kolmar7777/data_for_test_plagiarism | solutions_real_db_out/test/1463/2.cpp | #include<bits/stdc++.h>
using namespace std;
#pragma region Debugger
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(fl... | ALGO | 0.999764 | 3.389153 |
bb02e04a-437f-4b20-be56-6faab4440d62 | xueyajiang/Fu_qingtao | lesson_7/BubbleSort.cpp | #include <iostream>
using namespace std;
void swapInt(int *a, int *b)
{
cout << "swapInt" << endl;
int temp = *a;
(*a > *b) ? (*a = *b, *b = temp) : (*a, *b);
}
void bubbleSort(int *num, int length)
{
int i, j;
cout << "bubbleSort:" << length <<endl;
for (i = length - 1; i > 0; i--)
{
for (j = 0; j < i; j++)
... | ALGO | 0.999886 | 4.090379 |
8b5a3bb8-5856-4187-bb3b-2f966393bf40 | lalalayong/Data-Structure | chapter03/P66/p66_5.cpp | /*
ջ
*/
#include <bits/stdc++.h>
using namespace std;
#define Maxsize 50
typedef struct
{
int data[Maxsize];
int top[2];
} stack1;
stack1 s;
int push(int i, int x)
{ //ջiʾջţսɹ1-1xΪջԪ
if (i < 0 || i > 1)
{
cout << "ջ" << endl;
return -1;
}
if (s.top[1] - s.top[0] == 1... | ALGO | 0.999823 | 3.609401 |
9b7ab9fe-adda-4db9-9545-837a7e082fa0 | pratham0203/450_DSA | tripletsumarray.cpp | #include<bits/stdc++.h>
using namespace std;
int main(){
int arr[]={1,4,45,6,10,8};
int n=6;
int X=13;
int sum=0;
int ans =0;
sort(arr,arr+n);
for(int i = 0;i < n;i++){
sum = X - arr[i];
int low = i+1;
int high = n-1;
while(low<high){
if(arr[low]+... | ALGO | 0.999919 | 3.759357 |
f5930e66-bc96-41da-bc6e-4b5b0b521d67 | pratyush220498/Data_Structure-CPP | data_structure/sorting/funcount.cpp | #include<iostream>
using namespace std;
void countsort(int[],int[],int[],int,int);
int main()
{
int i,flag,temp,size,j,k,range;
cout<<"enter size ="<<endl;
cin>>size;
int ip[size];
cout<<"enter elements :-"<<endl;
for(i=0;i<=size-1;i++)
cin>>ip[i];
int max=0;
for(i=1;i<=size-1;i++)
{
if(ip[i]>ip[max])
max... | ALGO | 0.999972 | 3.894567 |
3bc89818-1097-4578-a609-d9c3496c115d | answer19831020/beagle-lib | examples/fourtaxon/fourtaxon.cpp | #include <iostream>
#include <iomanip>
#include <fstream>
#include <numeric> // needed for accumulate algorithm
#include <cmath>
#include <cstdlib>
#include "fourtaxon.h"
/*-----------------------------------------------------------------------------
| Allocates a two-dimensional array of doubles as one contiguous bl... | ALGO | 0.990162 | 3.622664 |
32d165f8-3863-420b-b1a7-1f01d1486184 | SirjanSingh/CP-CF | cpp/B_Maximum_Multiple_Sum.cpp | #include<bits/stdc++.h>
using namespace std;
#define f(i, x, y) for (int i = x; i < y; i++)
#define int long long
#define yes cout << "YES\n"
#define no cout << "NO\n"
#define all(vector) vector.begin(),vector.end()
#define nl cout << "\n"
#define x first
#define y second
#define mapii map<int,int>
#define mapci map<c... | ALGO | 0.999835 | 3.510997 |
d5916567-2097-49d8-9a60-25e6763e100d | LeoS9/ELVcoin | src/pbkdf2.cpp | #include <string.h>
#include "pbkdf2.h"
static inline uint32_t
be32dec(const void *pp)
{
const uint8_t *p = (uint8_t const *)pp;
return ((uint32_t)(p[3]) + ((uint32_t)(p[2]) << 8) +
((uint32_t)(p[1]) << 16) + ((uint32_t)(p[0]) << 24));
}
static inline void
be32enc(void *pp, uint32_t x)
{
uint8_t ... | ALGO | 0.997248 | 6.905365 |
0661a3f4-41e5-4250-bcb0-a8258fddef4e | koosaga/olympiad | ICPC/NAIPC/nac23_f.cpp | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pi = array<int, 2>;
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
using ll = long long;
using pll = pair<ll, ll>;
bool Do(pll A, pll B, pll C, pll D) {
if (A.fi == B.fi + C.fi + D.fi &... | ALGO | 0.999986 | 3.757607 |
e679b4e2-6e74-4a36-93ff-e33d13523a20 | hzfsls/leetcode-supercrawl | data/1822.sign-of-the-product-of-an-array/code_snippets/sol.cpp | class Solution {
public:
int arraySign(vector<int>& nums) {
}
}; | ALGO | 0.999976 | 5.256941 |
50bcdb55-815d-40fd-971f-61695948d27b | azizmhamdi/cpp_problems | invertednum.cpp |
#include <iostream>
using namespace std;
int ReadPositiveNumber(string Message) {
int Number = 0;
do {
cout << Message << endl;
cin >> Number;
} while (Number <= 0);
return Number;
}
void printInverted(int number) {
for (int i = 1; i <= number ; i++) {
for (int j = 1; j... | ALGO | 0.999183 | 5.223258 |
d1b752d8-95b8-43e7-821f-1bd08c6fcdcb | gabrielss2406/Algoritmos-Inatel | Algoritmos 3 - C204/C204-L/arvores4-ordenacao.cpp | #include <iostream>
using namespace std;
struct treenode
{
int info;
treenode *esq;
treenode *dir;
};
typedef treenode* treenodeptr;
// Typedef = onde tiver * substritui por treenodeptr
// Função que insere termos na arvore
void tInsere(treenodeptr &p, int x){
if(p==NULL){ // insere na raiz
p = new treenode;
... | ALGO | 0.999851 | 4.735171 |
d03fe432-4f72-4882-8b3e-3700a37fcd15 | GauravYadavAtWork/cses-solutions | Introductory/cses_Chessboard_and_Queens.cpp | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
class Solution {
public:
int solveNQueens(int n, vector<string>&grid) {
int solutions = 0;
vector<vector<int>> board (n,vector<int>(n,0));
find(n,0,board,solutions, grid);
return solutions;
... | ALGO | 0.999962 | 5.871154 |
df905e59-5ab7-4144-a184-c97b2c6ecc28 | manu05X/Leetcode | 0013-roman-to-integer/0013-roman-to-integer.cpp | class Solution {
public:
int romanToInt(string s) {
unordered_map<char, int> m;
m['I'] = 1;
m['V'] = 5;
m['X'] = 10;
m['L'] = 50;
m['C'] = 100;
m['D'] = 500;
m['M'] = 1000;
int result = 0;
for (int i = 0; i < s.length(); i ++)... | ALGO | 0.999854 | 6.764181 |
db353272-04b5-474a-bd6f-5c9f0912e56e | SeNSE-lab/whiskitphysics | code/bulletlib/src/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.cpp | #include "btHeightfieldTerrainShape.h"
#include "LinearMath/btTransformUtil.h"
btHeightfieldTerrainShape::btHeightfieldTerrainShape
(
int heightStickWidth, int heightStickLength, const void* heightfieldData,
btScalar heightScale, btScalar minHeight, btScalar maxHeight,int upAxis,
PHY_ScalarType hdt, bool flipQuadEdge... | TOOL | 0.896565 | 7.232734 |
6e7138d0-b0b8-4562-8e4c-a68c88832440 | wpdudH/Baekjoon-study | Sorting/MergeSort.cpp | #include <iostream>
// Linked List Node class
template<typename T>
class Node
{
public:
int data;
T raw;
Node* next;
Node(T x, int d)
{
data = d;
raw = x;
next = nullptr;
}
};
template<typename T>
Node<T>* split(Node<T>* head)
{
Node<T>* first = head;
Node<T>* second = head;
while (first->next != null... | ALGO | 0.999953 | 5.047495 |
16d2c4e2-21fd-469f-a723-9fbdff6d0f5e | tofuuuuuuu/templates | segment_tree.cpp | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int, int>
const int MAXN = 100005;
struct Segtree{
ll a[MAXN];
ll seg[4*MAXN];
void pushup(int cur) {
seg[cur] = (seg[2*cur] + seg[2*cur+1]);
}
void construct(int cur, int l, int r) {
if(l == r) {
... | ALGO | 0.99678 | 3.701822 |
ad46056e-47a1-4c67-9711-9a9b2e496ca5 | cassiesu/algorithms_lab | exercise/defence_bgl.cpp | #include <climits>
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <queue>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/push_relabel_max_flow.hpp>
using namespace std;
using namespace boost;
typedef adjacency_list_traits<vecS, vecS, directedS>::edge_descriptor Edge;
typedef adjac... | ALGO | 0.999594 | 3.971831 |
afa8a87c-09c6-483b-861e-3bc20c105d67 | FracturedPlane/CharacterAnimation | bullet3/src/BulletCollision/CollisionShapes/btConvexHullShape.cpp | #if defined (_WIN32) || defined (__i386__)
#define BT_USE_SSE_IN_API
#endif
#include "btConvexHullShape.h"
#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
#include "LinearMath/btQuaternion.h"
#include "LinearMath/btSerializer.h"
btConvexHullShape ::btConvexHullShape (const btScalar* points,int numPoin... | ALGO | 0.9906 | 7.238117 |
b3b2b449-690b-459a-9211-db7f03ad2aba | sfischme/truetime | examples/RUNES_demo/node/return_distance.cpp | double return_distance(int seg, void* data) {
AODVrcv_Data *d = (AODVrcv_Data *) data;
switch (seg) {
case 1:
// Wait period depending on nodeID
ttSleep(((double)(d->nodeID % 6))*0.025);
return 0.0001;
case 2:
// Broadcast message with distance
GenericNwkMsg *msg = new GenericNwkMsg... | TOOL | 0.9347 | 5.139977 |
493379b0-403f-4fa9-a92d-aa0d47b9d2f9 | Moonshile/AlgorithmCandy | leetcode/114.cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
private:
void downtoLeaf(TreeNode* root, stack<TreeNode*> &s) {
while (root) {
if (... | ALGO | 0.999965 | 6.149925 |
2843fe8e-b832-4b0e-8a70-4db718fcc711 | sarvex/leetcode-boo | solution/1300-1399/1332.Remove Palindromic Subsequences/Solution.cpp | class Solution {
public:
int removePalindromeSub(string s) {
if (s.empty())
return 0;
string t = s;
reverse(s.begin(), s.end());
if (s == t)
return 1;
return 2;
}
}; | ALGO | 0.999895 | 6.590424 |
9f45f799-b6fa-459c-a474-66fd1a5367ee | dineshj888/object-oriented-programming-with-c- | program8.cpp | #include<iostream>
using namespace std;
class num
{
public: char a[10];
int o;
};
class hexa:public num
{
public:int val;
hexa()
{
val=0;
}
void read()
{
cout<<"Enter hexa no"<<endl;
cin>>a;
}
void hextodec()
{
int t,i,j=1,n=0;
for(i=0;a[i]!='\0';i++)
{
n++;
}
for(i=n-1;i... | ALGO | 0.97343 | 3.092087 |
877caf3f-23da-42b0-a4f5-610d493eec4a | khalidmesbah/ps | problem-solving/cpp/snippets/wth_for_loop.cpp | #include <iostream>
using namespace std;
int main()
{
int t = 4;
for (; t++; t++)
{
if (t % 2 == 0)
continue;
break;
}
cout << t;
return 0;
}
| ALGO | 0.978103 | 3.240547 |
205d47cd-ca78-4d01-9f82-1cd9142df7e0 | jayeshpatel8/Coding-Practise-using-Leetcode-Coding-Platform | 2375-minimum-obstacle-removal-to-reach-corner/solution.cpp | class Solution {
public:
int minimumObstacles(vector<vector<int>>& grid) {
int M =grid.size(), N = grid[0].size();
vector<vector<int>> dist(M+1,vector<int>(N+1, N+M-3));
priority_queue<array<int,3>,vector<array<int,3>>,greater<>> pq;
pq.push({0,0,0});
dist[0][0]=0;
... | ALGO | 0.999994 | 5.762812 |
f2ec18f6-2a0c-4a96-8b6f-9f306b4c6f0b | yusheng-ma/GomokuAI | main_human.cpp | #include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <array>
#include <vector>
#include <cassert>
#define TIMEOUT 10
struct Point {
int x, y;
Point() : Point(0, 0) {}
Point(float x, float y) : x(x), y(y) {}
bool operator==(const Point& rhs) const {
return x == rhs.x && y == rh... | ALGO | 0.977947 | 5.111535 |
d540d873-bf8b-4a40-9dbf-c596552fc201 | SaadNoor555/cp-practice | A_MarkScheme.cpp | /*
---. `
:dmms /dho`
ymmmo ymmh`.///`
... | ALGO | 0.999871 | 3.614533 |
981ae0df-cd3b-495f-accf-c15c2654c9c5 | ohgnakrap9290/CodeTree | 250716/별표 출력하기 4/print-star-4.cpp |
#include <iostream>
using namespace std;
int main() {
// Please write your code here.
int n;
cin>>n;
for(int i=n;i>1;i--){
for(int j=0;j<i;j++){
cout<<'*'<<' ';
}
cout<<endl;
}
for(int i=1;i<=n;i++){
for(int j=0;j<i;j++){
cout<<'*'<<' ';... | ALGO | 0.999892 | 3.74076 |
5fba8030-f70d-4363-b18b-3ec4aac5fc10 | ManojKumarPatnaik/Sr.SoftwareEngineerInterviewPrep | 3]. 450 DSA by Love Babbar/C++/13]. Trie/_03)_Word_Break_Problem_(Trie solution).cpp | /*
GFG problem link:- https://practice.geeksforgeeks.org/problems/d857113143f69fab217cf5dab978535542f3cbb1/1/
*/
/*
Input:
12 ilikesamsung
i
like
same
sung
samsung
mobile
ice
cream
icecream
man
go
mango
... | ALGO | 0.999936 | 5.048831 |
4e39e81b-48db-483a-b2fa-5400f70e2a10 | thegamer1907/Code_Analysis | Codes/AC/1432.cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n,S;
scanf("%d%d",&n,&S);
vector<int> a(n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
int lo=0,hi=n;
while(lo<hi){
int mid=lo+hi+1>>1;
ll c=0;
vector<ll> v;
for(int i=0;i<n;i++){
v.push_back(a[i]+1ll*(i+1)*mid);
... | ALGO | 0.999967 | 3.581786 |
edaa442a-7b66-47f5-b508-364eb97aea5c | flamit/opencloth | OpenCloth_SemiImplicit/OpenCloth_SemiImplicit/main.cpp | #include <GL/glew.h>
#include <GL/wglew.h>
#include <GL/freeglut.h>
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp> //for matrices
#include <glm/gtc/type_ptr.hpp>
#pragma comment(lib, "glew32.lib")
using namespace std;
const int width = 1024, height = 1024;
LARGE_INTEGER frequency;... | ALGO | 0.918312 | 4.00684 |
9006d5d1-4b3a-4fbc-8a43-d7c6811f9b9b | olegshnitko/libboost | libs/graph/test/bellman-test.cpp | // From Louis Lavery <<EMAIL>>
/*Expected Output:-
A: 0 A
B: 11 A
Actual Output:-
A: 0 A
B: 2147483647 B
*/
#include <iostream>
#include <iomanip>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/bellman_ford_shortest_paths.hpp>
#include <boost/cstdlib.hpp>
#include <boost/test/minimal.hpp>
int t... | ALGO | 0.999204 | 5.678792 |
780a4787-24b6-47fb-bba7-f53d67f43cc0 | Aditya01jain/100dayscode | 1036-rotting-oranges/rotting-oranges.cpp | class Solution {
public:
int orangesRotting(vector<vector<int>>& grid) {
int n = grid.size();
int m = grid[0].size(); // Number of columns
queue<pair<int, int>> q;
int freshOranges = 0;
// Add all initially rotten oranges to the queue
for (int i = 0; i < n; i++) {
... | ALGO | 0.999987 | 7.012831 |
72d95f12-3765-4dd6-9bbf-e7d452308716 | arnafi/Codeforces-problems-solve | 339A Helpful Maths.cpp | #include<bits/stdc++.h>
using namespace std;
int main()
{
string arry;
cin>>arry;
int n=arry.size();
for(int i=0;i<n;i+=2){
for(int j=0;j<n-1-i;j+=2){
if (arry[j]>arry[j+2]){
swap(arry[j],arry[j+2]);
}
}
}
cout<<arry<<endl;
return 0;
}
| ALGO | 0.999972 | 4.007658 |
f39a4e9e-2bf4-4d54-8505-8426a109b234 | Muzahid037/Online-Judge-Problems | CodeForces/A. Common Prefixes.cpp | ///"--------------------Bismillahir Rahmanir Rahim"-----------------------///
#include<bits/stdc++.h>
using namespace std;
///_____________________________FAST I/O__________________________________///
#define Boost() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
///---------------------------------------------... | ALGO | 0.999829 | 3.09896 |
67498a0c-450a-4442-95b3-53c83824d9f4 | TechGuard/advent_of_code | 2017/22 Sporifica Virus/22B.cpp | #include <iostream>
#include <sstream>
#include <map>
namespace
{
using i64 = std::int64_t;
struct Coordinate
{
i64 x = 0;
i64 y = 0;
bool operator<(const Coordinate& other) const
{
if (x != other.x)
return x < other.x;
return y < other.y;
}
};
enum State
{
Clean,
Weakened,
Infecte... | ALGO | 0.999773 | 4.780821 |
8c94f596-0684-423d-a1cc-35cbf0df1f95 | Hironobu-okubo/AtCoder | AlgorithmDataStructure/ch04/ALDS1_3_A-Stack.cpp | #include <bits/stdc++.h>
using namespace std;
/* alias */
using ull = unsigned long long;
using ll = long long;
using vi = vector<int>;
using vl = vector<long>;
using vll = vector<long long>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using vvll = vector<vll>;
using vs = vector<string>;
using vc = vector<char>;
us... | ALGO | 0.999899 | 3.981055 |
8f7b87ce-22e9-42ac-965d-2a544cd72948 | alexsteve647/Comparison-of-Programming-Language-Performance | SkaitluGeneresanaUnApstrade/c++/c++.cpp | #include <iostream>
#include <vector>
#include <chrono>
#include <windows.h>
#include <psapi.h>
#include <cstdlib>
using namespace std;
using namespace std::chrono;
int main() {
// Start memory measurement
PROCESS_MEMORY_COUNTERS memCounter;
GetProcessMemoryInfo(GetCurrentProcess(), &memCounter, sizeof(me... | ALGO | 0.974279 | 5.468207 |
acd4aba4-4450-438a-9c5d-7543c360e568 | dungnguyen2112/DSA_PTIT | DSA04008.cpp | #include <bits/stdc++.h>
#include <sstream>
#include <vector>
#include <algorithm>
#include <string>
#define faster() \
std::ios_base::sync_with_stdio(false); \
std::cin.tie(NULL); \
std::cout.tie(NULL);
using namespace std;
using std::string;
const int mod = 1e... | ALGO | 0.99997 | 4.153706 |
9756da8a-431b-4569-9bb1-b808c0725199 | Prajjawal-Vaishya/Leetcode | C++/231.cpp | #include <iostream>
using namespace std;
bool checkpoweroftwo(int n, int v) {
if (n == v) {
return true;
}
else if (n < v) {
return false;
}
checkpoweroftwo(n, v*2);
}
bool isPowerOfTwo(int n, int pow = 2) {
if (n == 1) {
return true;
}
if (n == pow) {
... | ALGO | 0.998309 | 5.888511 |
009ce1cb-1a3f-4082-8dec-7a75f46d41e1 | kiwibang/kattis-uva | uva01585.cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum, consec;
string line;
cin >> n;
while (n--) {
cin >> line;
consec = 0;
sum = 0;
for (int i = 0; i < line.size(); ++i) {
if (line[i] == 'X') {
consec = 0;
} else ... | ALGO | 0.999492 | 4.179554 |
b0bcbb88-9d2d-443f-97c0-e3cdbdd68cc6 | qf-offical/Frame | Frame/Source/Assignment/Assignment7/Scene.cpp | //
// Created by Göksu Güvendiren on 2019-05-14.
//
#include "Scene.hpp"
void Scene::buildBVH() {
printf(" - Generating BVH...\n\n");
this->bvh = new BVHAccel(objects, 1, BVHAccel::SplitMethod::NAIVE);
}
Intersection Scene::intersect(const Ray &ray) const
{
return this->bvh->Intersect(ray);
}
void Scene... | ALGO | 0.910395 | 4.978103 |
8ede7487-7281-4af1-82fa-5634a4bfaa48 | clay-arras/leetcode-submissions | binary-tree-right-side-view/Accepted/5-6-2024, 4:20:18 PM/Solution.cpp | // https://leetcode.com/problems/binary-tree-right-side-view
/**
* 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) {}
* ... | ALGO | 0.999812 | 6.652722 |
db632523-824b-414d-8f37-1862e7e9edfe | xodn0802/codetree-TILs | 240211/문자열 놀이/play-with-string.cpp | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
int q;
cin >> s >> q;
for(int i = 0; i < q; i++){
int n, a, b;
cin >> n;
if(n == 1){
cin >> a >> b;
int cnt;
cnt = s[a - 1];
s[a - 1] = s[b - 1];
... | ALGO | 0.999958 | 4.870667 |
15e17986-84e4-48ca-8ca1-c81428e85d8a | kDushyanth/Graph-Algos | dijikstra.cpp | #include<iostream>
#include<cstdlib>
using namespace std;
typedef struct no{
int v;
int key;
}no;
typedef struct node{
int data;
int w;
struct node *next;
}node;
void print(node *adj[],int n)
{
for(int i=0;i<n;i++)
{
cout<<i+1<<"->";
node *temp=adj[i];
while(temp!=NULL)
{
... | ALGO | 0.999996 | 3.515974 |
f3d8f284-a82e-45f7-a04b-28f93bafe07e | altmanWang/leetcode_c-_solution | 47. Permutations II/src/Solution.cpp | #include<iostream>
#include<vector>
#include<algorithm>
#include<set>
using std::set;
using std::sort;
using std::vector;
class Solution {
public:
vector<vector<int>> permuteUnique(vector<int>& nums) {
sort(nums.begin(), nums.end());
vector<vector<int>> res;
vector<int> path;
bool... | ALGO | 0.999987 | 5.372524 |
a6eace92-4e1c-4124-8c83-171fd0045211 | chuang0221/leetcode | Binary Tree/173. Binary Search Tree Iterator/main.cpp | #include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <stack>
using namespace std;
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(i... | ALGO | 0.9999 | 5.721456 |
358d9cb5-6e5c-4934-8c58-103fd3be74eb | NeetuSarkar/Striver-A-to-Z | Learn the Basics/01_Basic Maths/03_ArrayPalindrome.cpp | #include <bits/stdc++.h>
using namespace std;
bool isPalindrome(int arr[])
{
int j = arr.size();
int i = 0;
while (i < j)
{
if (arr[i] != arr[j])
return false;
}
return true;
}
int main()
{
int n;
cin >> n; // size of the array
int arr[n];
// Take input for the array
for (int i = 0... | ALGO | 0.998545 | 5.099162 |
06f85679-2002-4c72-9e71-0fd41832180f | vedhkreddy/CompetitiveProgramming | Silver/Recursive Dragon/CF797Div3/d.cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef double db;
typedef string str;
// change ld to db if neccesary
typedef pair<int,int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pld;
typedef set<int> si;
typedef set<ll> sl;
typedef set<ld> sld;
typedef set<str>... | ALGO | 0.99924 | 4.108548 |
a49b40d3-a836-49be-9313-d837788be049 | instr3/BZOJ-solution-legacy | A1034/1034泡泡堂BNB.cpp | #include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
int d1[100001],d2[100001];
int main()
{
int n;
scanf("%d",&n);
for(int i=1;i<=n;++i)
{
scanf("%d",&d1[i]);
}
sort(d1+1,d1+n+1);
for(int i=1;i<=n;++i... | ALGO | 0.999962 | 3.715464 |
ef3a76ed-a941-4777-8c06-39bd299b852a | ishandutta2007/codeforces | okwedook/normal/1540/B.cpp | #pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("sse4.2")
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <bitset>
#include <sstream>
#include <deque>
... | ALGO | 0.999706 | 4.607223 |
1c108a99-27a6-4eac-ae70-5e4598d5ea7d | iwanlothbrok/Students_Exercises | Еxercises/C++/MathExercise/DigitFour/DigitFour.cpp | #include <iostream>
bool hasDigitFour(int n) {
while (n != 0) {
int digit = n % 10;
if (digit == 4) {
return true;
}
n /= 10;
}
return false;
}
int main() {
int a, b;
std::cin >> a >> b;
bool found = false;
for (int i = a; i <= b; i++) {
... | ALGO | 0.999931 | 4.690707 |
03aadd4a-875b-4365-b8f1-ce5bb245e740 | Harshitkukreja31/-CrackYourInternship_HKukreja | 0273-integer-to-english-words/0273-integer-to-english-words.cpp | class Solution {
public:
vector<string> belowTen={"","One","Two","Three","Four","Five","Six","Seven","Eight","Nine"};
vector<string> belowTwenty={"Ten","Eleven","Twelve","Thirteen","Fourteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen"};
vector<string> belowHundred={"","Ten","Twenty","Thirty","For... | ALGO | 0.993733 | 6.626386 |
a54b026a-46ce-4534-bb45-77aa5979dc2d | phumipatc/C_Competitive_Programming | Website/APIO/2017/Travelling_Merchant.cpp | /*
Task : Travelling_Merchant
Author : Phumipat C. [MAGCARI]
Language: C++
Created : 18 May 2021 [15:03]
Algo :
Status :
*/
#include<bits/stdc++.h>
#define rep(i, a, b) for(int i = a; i <= (b); ++i)
#define repr(i, a, b) for(int i = a; i >= (b); --i)
#define all(x) begin(x),end(x)
#define allst(x,y) (x).begin()... | ALGO | 0.999963 | 4.015178 |
441458d6-a01d-41d3-b637-662e161e5ea8 | adityanjr/code-DS-ALGO | Data Structures/Graph/LCA.cpp | struct node {
node *p, *jmp[20];
int depth;
node(node *_p = NULL) : p(_p) {
depth = p ? 1 + p->depth : 0;
memset(jmp, 0, sizeof(jmp));
jmp[0] = p;
for (int i = 1; (1<<i) <= depth; i++)
jmp[i] = jmp[i-1]->jmp[i-1]; } };
node* st[100000];
node* lca(node *a, node *b) {
if (!a || !b) return NU... | ALGO | 0.999907 | 3.471691 |
f6d57e53-cf92-4c1e-9ed2-364e799a784a | ishandutta2007/codeforces | timsei/normal/1545/D.cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int t, m, k, A[N][N];
long long sm1[N], sm2[N];
long long solve(int x) {
// x - 1, x, x + 1
return (sm2[x + 1] + sm2[x - 1] - 2 * sm2[x]);
}
int main() {
cin >> m >> k;
for(int i = 1; i <= k; ++ i) {
for(int j = 1; j <= m; ++ j) scanf("%d... | ALGO | 0.999988 | 3.362626 |
0890de05-6ccd-4caa-b255-64d76a022f4b | HEltim7/cpcode | CF/Round/847/G_Tokens_on_Graph.cpp | #include <queue>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
#define endl '\n'
using LL=long long;
constexpr int N=2e5+10;
vector<int> adj[N];
bool ist[N],isb[N],vis[N];
int dis[N],fa[N],sz[N];
int findfa(int x) {
if(fa[x]==x) return x;
return fa[x]=findfa(fa[x]);
}
void s... | ALGO | 0.999956 | 4.972683 |
fe437282-d05b-49e0-8b3c-22484b86fdaf | luisfcofv/competitive-programming-book | ch2/ch2_04_stack_queue.cpp | #include <cstdio>
#include <stack>
#include <queue>
using namespace std;
int main() {
stack<char> s;
queue<char> q;
deque<char> d;
printf("%d\n", s.empty()); // currently s is empty, true (1)
printf("==================\n");
s.push('a');
s.push('b');
s.push('c');
// stack is LIFO, t... | TEST | 0.970387 | 4.612847 |
31f26874-20a9-47df-b2d0-7e82afc201ba | mahmudul35/data-structure | Problem/Anton.cpp | #include<bits/stdc++.h>
using namespace std;
int main()
{
int c=0;
string s;
getline(cin,s);
sort(s.begin(),s.end());
for(int i=0;i<s.size();i++){
if(s[i]=='{' ||s[i]=='}' || s[i]==',' || s[i]==' ')
{
continue;
}
else
{
... | ALGO | 0.998419 | 3.543063 |
54de50b9-3b2b-442e-87e6-bdeb77ce6f32 | 113bommy/deepmind_codecontests_refine | cpp_gold_filter_file/cpp_train_8787_1.cpp | #include <bits/stdc++.h>
using namespace std;
const int maxn = 52;
static char S[maxn][maxn];
static int dis[maxn][maxn], n, m;
static int h[maxn * maxn * 10][2], lh;
static bool vis[maxn][maxn];
void update(int x, int y, int d, char ch) {
if (x <= 0 || y <= 0 || x > n || y > m) return;
if (ch != S[x][y]) d++;
if... | ALGO | 0.999548 | 3.860429 |
2f3ba6ce-820c-4728-9146-6598210cf095 | Mohammad-Sufyan-Azam/CN-Product-Companies-Interview-Prep | 0 Patterns/Number Pattern 2.cpp | /*
Print the following pattern for n number of rows.
Note: each line consist of equal number of characters + spaces.
Suppose you are printing xth line for N=n. You need to print 1..x followed by (n-x) spaces,
again (n-x) spaces followed by x..1
For eg. N = 5
1 1
12 21
123 321
1234 4321
1234554321
*/
... | ALGO | 0.999941 | 4.723195 |
f4e8666d-16fe-489b-a5e6-77091ff5edf4 | eliyaAharon/Rational_Number | main.cpp | #include <iostream>
#include "Rational.h"
using namespace std;
void printMinFraction(Rational *rational);
void printMaxFraction(Rational *rational);
int main() {
//יצרתי כאן 5 אובייקטים בשביל לנסות את פונקציית המינימום כמו שביקשת
Rational rationals[5];
for (int i = 0; i < 5; ++i) {
rationals[i]... | ALGO | 0.950265 | 4.594182 |
8c3510bd-9fbe-47e9-8e7e-d593657f5337 | hiranoo/atcoder | contests/abc132/c.cpp | #include <bits/stdc++.h>
// #include <atcoder/segtree>
#include <time.h>
#define rep(i, s, t) for(int i = (s); i <= (t); i++)
#define repd(i, s, t) for(int i = (s); i >= (t); i--)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
typedef pair<int, int> pii;
typ... | ALGO | 0.999938 | 4.21694 |
d86909b3-edad-4315-9426-7b9cf8cecf57 | mykey700/1st-year-project | session 5/pi/pi/opencv/samples/cpp/tutorial_code/ImgTrans/houghcircles.cpp | /**
* @file houghcircles.cpp
* @brief This program demonstrates circle finding with the Hough transform
*/
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.hpp"
using namespace cv;
using namespace std;
int main(int argc, char** argv)
{
//![load]
const char* filename... | ALGO | 0.99442 | 6.179154 |
8407b102-d939-4cfe-832b-f7f74e94e64a | yashwardhan-gautam/cp | 1282B2.cpp | #include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define mii map<int,int>
#... | ALGO | 0.999956 | 3.666076 |
12c9d575-2ab3-44f6-8b45-dde1b8c18a13 | Exr0nProjects/learn_cpp | problems/cses/tree/x_subordinates/x_main_subordinates.cpp | /*
* Problem subordinates (cses/tree/subordinates)
* Create time: Thu 03 Dec 2020 @ 18:40 (PST)
* Accept time: Thu 03 Dec 2020 @ 18:45 (PST)
*
*/
#include <set>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <utility>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long lon... | ALGO | 0.999494 | 4.114356 |
43159b19-9995-4d23-bb30-5a2f2c9aa25a | scdeng/cxxlib | src/mst.cpp | /*
* =====================================================================================
*
* Filename: mst.cpp
*
* Description: minimum spanning tree implementation
* 1. lazy Prim's algorithm
* 2. instant Prim's algorithm
* 3. Kruskal's algorithm
*
* Version: 1.0
* ... | ALGO | 0.999899 | 5.489069 |
a04d358d-023b-4095-9153-24e0d0783dc5 | amisha-singh12/-CrackYourPlacement | 0416-partition-equal-subset-sum/0416-partition-equal-subset-sum.cpp | class Solution {
public:
bool canPartition(vector<int>& nums) {
int sum = accumulate(nums.begin(), nums.end(), 0);
if (sum % 2 != 0) return false;
int target = sum / 2;
vector<bool> dp(target + 1, false);
dp[0] = true; // Base case
for (int num : nums) {
... | ALGO | 0.999852 | 6.358734 |
ac34b52c-1bb4-438d-b4c0-079614c74197 | Moozzaart23/DSA-Labs | DSA Lab-3/P2.cpp | #include<stdio.h>
int main()
{
char a[100005];
gets(a);
int t;
scanf("%d",&t);
while(t--)
{
int f,r,k;
scanf("%d %d %d",&f,&r,&k);
f=f-1;
r=r-1;
for(int j=0;j<k;j++)
{
char temp=a[r];
for(int i=r;i>=(f+1);i--)
{
char t=a[i];
a[i]=a[i-1];
}
a[f]=temp;
}
}
puts(a);
}
| ALGO | 0.999343 | 3.418038 |
9a23ad7b-a92e-44f3-b01b-f5d2780d58fc | SinghJi2002/C-Cpp-Programing | 2_BinarySearch/Questions/Q3_MountainArray_PeakElement.cpp | #include<iostream>
using namespace std;
int peak_element_left(int arr[],int size,int max){
//Thora discuss krte hai ki logic kya lgayenge. Dekho yha 2 progression dekhne mila, ek starting mai ascending or fir decending.
int start=0;
int end=size-1;
//Yha mid ka role bhut important hai. Dhyan se nikalo
... | ALGO | 0.999983 | 4.06355 |
1332887b-b734-4539-8550-1dcb109ffb94 | JosephMillsAtWork/yacl | libs/7zip/win/CPP/7zip/UI/Common/UpdatePair.cpp | // UpdatePair.cpp
#include "StdAfx.h"
#include <time.h>
#include "../../../Common/Wildcard.h"
#include "../../../Windows/TimeUtils.h"
#include "SortUtils.h"
#include "UpdatePair.h"
using namespace NWindows;
using namespace NTime;
static int MyCompareTime(NFileTimeType::EEnum fileTimeType, const FILETIME &time1, ... | TOOL | 0.926544 | 6.307382 |
c1d41ca6-39ad-4cce-a784-311743ca1c11 | ultraUnicorn74/Striver-SDE-Sheet | 09]. Recursion/05]. Palindrome Partitioning.cpp | bool isPalindrome(string str, int low, int high) {
while(low < high) {
if(str[low] != str[high]) return false;
low++;
high--;
}
return true;
}
void find(int ind, string str, vector<string>&ds, vector<vector<string>>& ans) {
if(ind == str.size()) {
ans.push_back(ds);
... | ALGO | 0.999937 | 6.072638 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.