uuid string | repo_name string | relative_path string | content string | category string | algo_rel_score float64 | quality_score float64 |
|---|---|---|---|---|---|---|
d590e235-c10b-478e-82d4-77e88c96a664 | ESchulze88/WhiteRiver | Vrui-4.2-006/ExamplePrograms/EarthFunctions.cpp | #include <Math/Math.h>
#include <Math/Constants.h>
#include <Geometry/Geoid.h>
#include <GL/gl.h>
#include <GL/GLVertexArrayParts.h>
#define NONSTANDARD_GLVERTEX_TEMPLATES
#include <GL/GLVertex.h>
#include <GL/Extensions/GLARBVertexBufferObject.h>
/**********************************************************************... | ALGO | 0.995838 | 6.164785 |
f7c24088-acb5-4d51-bda3-e60294cb65de | vittorione94/ICP-Implementation | extern/libigl/igl/uniformly_sample_two_manifold.cpp | //////////////////////////////////////////////////////////////////////////////
// Helper functions
//////////////////////////////////////////////////////////////////////////////
IGL_INLINE void igl::uniformly_sample_two_manifold(
const Eigen::MatrixXd & W,
const Eigen::MatrixXi & F,
const int k,
const double p... | ALGO | 0.999314 | 5.74155 |
6e82fd21-64d3-4eb5-a787-fc6944ce5da2 | doviethung11192023/code_c_pluss_pluss_2 | buoi 9 bai 6 thuat toan mergesort.cpp | #include<bits/stdc++.h>
using namespace std;
void merge(int a[],int l,int m,int r)
{
vector<int>x(a+l,a+m+1);
vector<int>y(a+m+1,a+r+1);
int i=0;
int j=0;
while(i<x.size()&&j<y.size())
{
if(x[i]<=y[j])
{
a[l]=x[i];
l++;
i++;
}
else
{
a[l]=y[j];
l... | ALGO | 0.99996 | 4.035742 |
3b72843c-68a4-49f7-b109-7c652d75fe0a | hitarth-gg/CP | CodeForces/archive/1380B - Universal Solution.cpp | // clang-format off
#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace chrono;
using namespace __gnu_pbds;
/* ----------------------- int128 ----------------------- */
// typedef __int128 lll;
// istream &operator>>(istream &cin,... | ALGO | 0.999384 | 4.37331 |
f43c6c8b-6e01-4869-b1b7-d96173d53e07 | built1n/rockbox | rbutil/rbutilqt/base/system.cpp | #include "system.h"
#include <QtCore>
#include <QDebug>
#include <cstdlib>
#include <stdio.h>
// Windows Includes
#if defined(Q_OS_WIN32)
#if defined(UNICODE)
#define _UNICODE
#endif
#include <windows.h>
#include <tchar.h>
#include <lm.h>
#include <windows.h>
#include <setupapi.h>
#endif
// Linux and Mac includes
#... | TOOL | 0.870644 | 3.366847 |
10869558-a7f1-4b3e-a8db-3299022f9df3 | zhujoey/Coding | usaco/2024/December/Farmerjohnscheeseblock2.cpp | #include <iostream>
#include <vector>
int check(const int &x, const int &y, const int &z, const int &size, std::vector<std::vector<std::vector<bool>>> &cube, const int &n, int &ans)
{
cube[x][y][z] = false;
bool axis1, axis2, axis3 = true;
if (n < size)
{
std::cout << 0 << std::endl;
... | ALGO | 0.999966 | 4.979261 |
9fef8408-4236-4d66-895f-26a5f36d95ba | hjiang13/LLMs-in-IR | POJ-104/103/1001.cpp | #include <iostream>
using namespace std;
int main()
{
char str[1000];
cin>>str;
char flag;
int count=0;
for(int i=0; str[i]!='\0'; i++)
{
if(str[i]>='a')
str[i]-='a'-'A';
}
flag=str[0];
for(int i=0; str[i]!='\0'; i++)
{
if(str[i]!=flag)
{
cout << "(%c,%d)",flag,count);
flag=str[i];
count=1;
}
else
count++;
}
cout << "(... | ALGO | 0.998714 | 3.053778 |
04e52dc8-bff2-4561-9c94-5c85eddef969 | Zclarkwilliams/agile_robotics_controller | code/include/device_control.cpp | /**
* DeviceControl.cpp
* This is the device functions and math functions to run the neuromorphic model.
*
*/
// Standard libraries
#include <algorithm>
#include <iostream>
// Non-Standard Libraries
#include "config_data.hpp"
//#include <cuda.h>
//#include <cuda_runtime_api.h>
/*
* Membrane Capacitance Equation
*... | TOOL | 0.957417 | 3.039889 |
8e821342-f5e6-408d-81b6-295458de123f | yerass11/PP1-FALL-2022 | labka/10th lab/K (1).cpp | #include <bits/stdc++.h>
using namespace std;
typedef string str;
typedef vector<int> vi;
typedef vector<bool> vb;
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fr(i, n) for(int i = 0; i < n; i++)
#define rall(x) (x).rbegin(), (x).rend()
bool isPrime(int x){
if(x < 0) x *= -1;
if(x == 2 ||... | ALGO | 0.999813 | 4.418702 |
44151250-cc46-4053-811a-4f57e60bb619 | mccoinface-project/mccoinface | src/addrman.cpp | #include <addrman.h>
#include <hash.h>
#include <logging.h>
#include <serialize.h>
int CAddrInfo::GetTriedBucket(const uint256& nKey, const std::vector<bool> &asmap) const
{
uint64_t hash1 = (CHashWriter(SER_GETHASH, 0) << nKey << GetKey()).GetCheapHash();
uint64_t hash2 = (CHashWriter(SER_GETHASH, 0) << nKey... | TOOL | 0.916115 | 6.701082 |
545d32b1-3346-47db-ba97-4a7e9b2177e1 | KimmiGYH/LeetCode_Notes_Public | Solutions_1001-2000/1818_Minimum Absolute Sum Difference_绝对差值和/cpp_2_手写二分_v2.cpp | class Solution {
const int MOD = 1e9 + 7;
public:
int minAbsoluteSumDiff(vector<int>& nums1, vector<int>& nums2) {
int res = 0, n = nums1.size(), sum = 0, diff = 0, mx = 0;
vector<int> rec(nums1);
sort(rec.begin(), rec.end());
for (int i = 0; i < n; i++) {
int x = num... | ALGO | 0.999985 | 5.860905 |
7fa22567-ab8f-4547-a840-401ec51ab9a0 | maruf-rahad/codechef | CHEFRECP.cpp | #include<bits/stdc++.h>
using namespace std;
map<int,int>mp;
map<int,int>mp2;
map<int,int> :: iterator it;
int main()
{
int t,n,m,a,b,i,j,x,y;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
int sum = 0;
x = -1;
mp.clear();
mp2.clear();
for(i=1;i<=n;i++)
... | ALGO | 0.999793 | 3.52444 |
3a002491-7f6e-4941-b28c-68df701d646b | devhasibulislam/CodeForces-online-judge | ...rest/1417A-CopyPaste.cpp | #include <cstdio>
#include <vector>
int main(){
long t; scanf("%ld", &t);
while(t--){
long n, k; scanf("%ld %ld", &n, &k);
std::vector<long> a(n);
long idx(0);
for(long p = 0; p < n; p++){
scanf("%ld", &a[p]);
if(a[p] < a[idx]){idx = p;}
}
... | ALGO | 0.999561 | 3.272021 |
79f4d435-7769-4d13-96d5-9d3bc2a6232f | deliciousqoo/CodingStudy | Coding_Study/Coding_Study/bj_1100.cpp | /*
* 1032
* ڿ
* 20240519
*/
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<string> chess;
chess.resize(8);
for (int i = 0; i < 8; i++)
{
cin >> chess[i];
}
int count = 0;
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if ((i % 2 == 0 && j % 2 == 0) || ... | ALGO | 0.999548 | 4.704509 |
ee6fb92a-c209-43b7-af02-75b5af907955 | loma5464/RigoLomas-CSCI20-Fall2016 | lab13/lab13.cpp | //Rigo Lomas-Velazco
//Lab 13
//Looping
#include <iostream>
#include <string>
using namespace std;
int main()
{
int hour = 1;
int minute = 0;
int userStartHour = 0;
int userStartMinute = 0;
int userEndHour = 0;
int userEndMinute = 0;
string AmPm1;
string AmPm2;
char colon;
... | ALGO | 0.940828 | 3.43378 |
7be770a9-2e76-41d7-b75f-363bdca00ce3 | TasiChicken/LeetCode | cpps/1000/100/50/49.cpp | #include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;
class Solution {
public:
vector<vector<string>> groupAnagrams(vector<string>& strs) {
unordered_map<string, int> mp;
vector<vector<string>> ans;
for(string str : strs){
auto... | ALGO | 0.999899 | 6.130016 |
c6c2e15b-594f-4dc3-a495-c0d3019a59a5 | AzertP/VNOI_SPOJ | LQDDIV.cpp | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int N = 40;
const int MAX = 1e6 + 6;
int n, iDex, currentSum, maxS, maxT, zero;
int a[N], x[MAX], y[MAX], numS[MAX], numT[MAX];
int choice[2] = {1, -1};
vector <int> s, t;
//Choose i-th number from start to r?
void choose(int i, int end, int... | ALGO | 0.999918 | 3.859441 |
16b92ac7-ad93-4b3e-a0f7-677dd56c40aa | uubk/mt-llvm-mirror | clang-tools-extra/clang-reorder-fields/ReorderFieldsAction.cpp | #include "ReorderFieldsAction.h"
#include "clang/AST/AST.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h"
#include "clang/Tooling/Refactoring.h"
#inclu... | TOOL | 0.885365 | 7.779284 |
3e54f765-53f7-4f3d-84c3-f75237ff1e8d | Struna1292/LeetCode | 0137-single-number-ii/0137-single-number-ii.cpp | class Solution {
public:
int singleNumber(vector<int>& nums) {
sort(begin(nums), end(nums));
int counter = 1;
int prev = nums[0];
for (int i = 1; i < nums.size(); i++)
{
if (nums[i] != prev)
{
if (counter == 1)
{
... | ALGO | 0.999959 | 5.459483 |
4cf62588-b92e-4b4b-a57a-9c06a8cbd443 | jelasus/IPOO-4 | stack.cpp | #include "stack.h"
#include <iostream>
#include <vector>
using namespace std;
template<class T>
bool Stack<T>::Empty(){
if (this->STACK.size()==0)
return true;
else
return false;
}
template<class T>
void Stack<T>::push(const T& item){
this->STACK.push_back(item);
}
template<class T>
T& Stack<T>::top(){
... | TOOL | 0.941483 | 4.132096 |
2a36ea1c-2a67-4958-8c79-d6640e035574 | tarnhold/hector | src/ARFIMA.cpp | //=============================================================================
#include "ARFIMA.h"
#include <gsl/gsl_poly.h>
#include <cmath>
#include <math.h>
#include <iostream>
#include <ostream>
#include <cstdlib>
#include <cstring>
#define TINY 1.0e-7
// #define DEBUG
//======================... | ALGO | 0.99889 | 5.806517 |
d8425d44-2e33-43f4-83db-5abd314bcd54 | ajinkya-hatalage/Datastructure_key | 1_implimenting-stack_using-array.cpp | /* ---------(Stack)---------
1] It is a linear data structure
2] items can be addedto or removed
from the list only at one end.
3] LIFO (Last In First Out) mechanism;
ex: lift , pile of coins , tennis ball packet;
--operation--
i) push(x) := to insert element in stack
ii) pop() := topmost element removed
iii) ... | ALGO | 0.998787 | 4.880395 |
7d389140-fc0f-49e2-a24b-1ebd0a90bab7 | zep1994/OpenCV | opencv-4.7.0/opencv-4.7.0/3rdparty/carotene/src/laplacian.cpp | #include "common.hpp"
#include "saturate_cast.hpp"
#include <vector>
namespace CAROTENE_NS {
bool isLaplacian3x3Supported(const Size2D &size, BORDER_MODE border)
{
return isSupportedConfiguration() && size.width >= 8 &&
(border == BORDER_MODE_CONSTANT ||
border == BORDER_MODE_REPLICATE);
}
v... | ALGO | 0.990727 | 3.302226 |
32c0d08a-677e-49b3-9cfa-b56f8b79abf2 | Hangalik/advent-of-code | 2019/day-02/2/main.cpp | #include <iostream>
#include <vector>
std::vector<long long> readVector() {
std::vector<long long> intCode;
long long next;
while (std::cin >> next) {
intCode.emplace_back(next);
}
return intCode;
}
long long compute(std::vector<long long>& intCode) {
int i{ 0 };
while (true) {
if (intCode.at(i) == 99) {
... | ALGO | 0.999437 | 5.383036 |
068463b2-6fa7-449d-a05f-1591615269a0 | ihewro/leetcode | 114.cpp | #include "Util.hpp"
/**
* 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, TreeNod... | ALGO | 0.99974 | 6.44022 |
ac692b0f-435c-49f1-b140-0039ba8e5a4f | GlaucoMasi/CompetitiveProgramming | Olinfo/iiot_tourdetree.cpp | #include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> g;
vector<long long> dist;
void dfs(int i){
for(auto j : g[i]){
if(dist[j.first] == -1){
dist[j.first] = dist[i]+j.second;
dfs(j.first);
}
}
}
int main() {
int n, k;
cin >> n >> k;
long long tot = 0;
g.resize... | ALGO | 0.999885 | 4.081523 |
e0d09ec0-18dc-4625-a081-b161f43edd9d | FFMG/myoddweb.piger | myodd/boost/libs/hana/example/cppcon_2014/det.cpp | #include <boost/hana/assert.hpp>
#include "matrix/det.hpp"
namespace hana = boost::hana;
using namespace cppcon;
int main() {
// det
{
BOOST_HANA_CONSTEXPR_CHECK(det(matrix(row(1))) == 1);
BOOST_HANA_CONSTEXPR_CHECK(det(matrix(row(2))) == 2);
BOOST_HANA_CONSTEXPR_CHECK(det(matrix(row(... | TEST | 0.945855 | 6.401243 |
8a8efb48-bc35-4486-a956-b85b11e2a515 | yellowHatpro/Codes-Practice | Trees/Binary Trees/ZigZagTraversal.cpp | #include <bits/stdc++.h>
using namespace std;
template <typename T> class TreeNode {
public:
T val;
TreeNode<T> *left;
TreeNode<T> *right;
TreeNode(T val) {
this->val = val;
left = NULL;
right = NULL;
}
};
vector<vector<int>> zigZagTraversal(TreeNode<int> *root) {
vector<vector<int>> res;
i... | ALGO | 0.999999 | 5.028825 |
d456638a-5206-4183-8afb-92dfe6ae9f32 | MJSoto123/notebook-2023 | Codes/Graphs/2SAT.cpp | struct SATSolver {
// Assumes that nodes are 0-indexed
int n;
int m;
vector<bool> vis;
vector<int> comp;
vector<int> order;
vector<int> component;
vector<vector<int>> G;
vector<vector<int>> Gt;
SATSolver(int n, int m) : n(n), m(m) {
// X_i = 2i
// ~X_i = 2i + 1
comp.resize(2 * n);
vis.resize(2 * n, ... | ALGO | 0.99996 | 5.440342 |
5ec5ca51-3dbb-4d46-b306-ff533d9ae946 | exponentialcherub/VisualSSS | libigl-master/include/igl/knn.cpp | #include "knn.h"
#include "parallel_for.h"
#include <cmath>
#include <queue>
namespace igl {
template <typename DerivedP, typename KType, typename IndexType,
typename DerivedCH, typename DerivedCN, typename DerivedW,
typename DerivedI>
IGL_INLINE void knn(const Eigen::MatrixBase<DerivedP>& P,
... | ALGO | 0.99995 | 6.47752 |
16005959-96db-4983-9864-d21a9b6d4841 | mhanus/hermes2d | examples/crack/main.cpp | #define H2D_REPORT_WARN
#define H2D_REPORT_INFO
#define H2D_REPORT_VERBOSE
#define H2D_REPORT_FILE "application.log"
#include "hermes2d.h"
using namespace RefinementSelectors;
// This example uses adaptive multimesh hp-FEM to solve a simple problem
// of linear elasticity. Note that since both displacement components... | ALGO | 0.999701 | 5.710451 |
382b4398-d1cc-4872-88ec-fc241a91e171 | Biank23/Competitive-Programming | CSES/Advanced Techniques/Apples and Bananas.cpp | #include <bits/stdc++.h>
using namespace std;
#define sz(x) int(x.size())
#define all(x) begin(x), end(x)
using cd = complex<double>;
const double PI = acos(-1);
int reverse(int num, int log) {
int res = 0;
for (int i = 0; i < log; i++) {
if (num >> i & 1) res |= 1 << (log - 1 - i);
}
return... | ALGO | 0.999953 | 3.209349 |
78624e06-54ca-45e9-bb15-9f9a635ea88f | youlive789/AlgorithmStudy | euler/first/4.cpp | #include <iostream>
#include <string>
using namespace std;
bool palindrome(int num) {
string target = to_string(num);
int targetSize = target.size();
string front, back;
if (targetSize % 2 == 0) {
front = target.substr(0, targetSize / 2);
back = target.substr(targetSize / 2, targetSi... | ALGO | 0.999956 | 5.745904 |
31f1bd3a-467c-42d6-854c-f8bda683dab2 | muskanmahajan37/uva | 11805_bafana_bafana.cpp | //Status : Accepted
#include <bits/stdc++.h>
using namespace std;
int main(){
int kase ;
cin>>kase ;
for(int i = 0; i<kase ; ++i){
int n , k , p ;
cin>>n>>k>>p;
if((k+p)%n==0)
cout<<"Case "<<i+1<<": "<<n<<endl;
else
cout<<"Case "<<i+1<<": "<<(k+p)%n<<endl;
}
return 0 ;
} | ALGO | 0.999531 | 3.267788 |
99ae2bf6-57c4-441c-bf76-7e2b9c079ffd | AaronMParish/LeetCode-Solutions | 20. Valid Parentheses/validParentheses.cpp | #include <stack>
#include <string>
using namespace std;
class Solution {
public:
bool isValid(string s) {
stack<char> open;
for ( auto c : s ) {
switch( c ) {
case '(':
open.push(c);
break;
case '[':
... | ALGO | 0.998939 | 6.467497 |
8e4d879c-10e8-4793-b2c5-688c97194907 | keshish-kumar/CPP | 0402-remove-k-digits/0402-remove-k-digits.cpp | class Solution {
public:
string removeKdigits(string num, int k) {
stack<char> st;
for(int i=0;i<num.size();i++){
int n = num[i];
while(!st.empty() && k>0 && st.top()>n){
st.pop();
k--;
}
st.push(n);
}
wh... | ALGO | 0.999995 | 6.540349 |
385c6b89-a5f0-4969-b951-0d31dc5c6db6 | sreedavemuri/CSE-100 | lab01/linearsearch.cpp | #include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
// int search(int *arr, int a, int b){
// for(int i = 0; i < a; i++ ){
// if (arr[i] == b){
// return i;
// }
// }
// return -1;
// }
int main(){
int a;
cin >> a;
int b;
cin >> b;... | ALGO | 0.999736 | 4.986639 |
89a76fba-2f46-4081-8337-43d6488a21e6 | lbule/android_frameworks_av-cm-12.1-mtk | media/libstagefright/codecs/amrwb/src/isf_extrapolation.cpp | /*
------------------------------------------------------------------------------
Filename: isf_extrapolation.cpp
Date: 05/08/2007
------------------------------------------------------------------------------
REVISION HISTORY
Description:
-------------------------------------------------------------------... | ALGO | 0.999592 | 5.451385 |
4c5bfaa8-06b7-4589-94f3-51510703ed49 | mystic-01/LeetCode | 0079-word-search/0079-word-search.cpp | static const int offsets[4][2] = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
class Solution {
public:
bool recurse(int idx, int a, int b, vector<vector<char>>& board, string &word) {
if (idx == word.size()) {
return true;
};
for (int k = 0; k < 4; ++k) {
... | ALGO | 0.99973 | 6.19348 |
bdd076bc-d2dd-416a-8f94-595b7ba4c20a | Yejin-Moon/algorithm | C++/Baekjoon/Problem2628.cpp | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
vector<int> v1;
vector<int> v2;
int n,m;
cin>>n>>m;
int k;
cin>>k;
int tmp=0,maxv=0;
for(int i=0; i<k; i++)
{
int a,b;
cin>>a>>b;
if(a==0) v1.push_back(b);
el... | ALGO | 0.999899 | 3.184743 |
7dcc2c7d-c06e-4dee-a59e-4d3c1ab3a85d | PacktPublishing/Hands-On-Game-Animation-Programming | Chapter08/Sample00/Code/quat.cpp | #include "quat.h"
#include <cmath>
#include <iostream>
quat angleAxis(float angle, const vec3& axis) {
vec3 norm = normalized(axis);
float s = sinf(angle * 0.5f);
return quat(
norm.x * s,
norm.y * s,
norm.z * s,
cosf(angle * 0.5f)
);
}
quat fromTo(const vec3& from, const vec3& to) {
vec3 f = normalized(... | ALGO | 0.980214 | 5.239915 |
cdbdf99b-69fa-4222-a6fb-06a058d05492 | NingruiWei/Library | test_empty_forking.4.cpp | #include <iostream>
#include <unistd.h>
#include "vm_app.h"
#include <cstring>
#include <algorithm>
#include <functional>
#include <array>
#include <iostream>
using namespace std;
void printing(char* passed) {
cout << passed << endl;
}
void sorting(char* arr) {
size_t arraySize = sizeof(arr)/sizeof(*arr);
... | ALGO | 0.998914 | 3.268644 |
65318669-a6a0-4d38-afd3-66dae421b55f | twelvedeng/PAT-Leetcode | PAT_Basic/1004 成绩排名.cpp | #include <iostream>
using namespace std;
int main()
{
int n, grade, max = -1, min = 101;
cin >> n;
string name, num, maxname, maxnum, miname, minum;
for(int i = 0; i < n; i++){
cin >> name >> num >> grade;
if(grade > max){
max = grade;
maxname = name;
maxnum = num;
}
if(grade < min){
min = grad... | ALGO | 0.99876 | 3.514786 |
191ebec8-0ab4-4d39-8273-8d861aca1f8b | Harshini038/cpp | pattern/pat1.cpp | /*
print this pattern
111
222
333
*/
#include <iostream>
using namespace std;
int main()
{
int n;
cin>>n;
int i=1;
while(i<=n){
int j=i;
while(j<=n){
cout<<i;
j=j+1;
}
cout<<endl;
i=i+1;
}
} | ALGO | 0.999963 | 3.887227 |
965fdcb4-6cb3-4abb-b72c-308da9a8f717 | AOSP-15-Dev/android_frameworks_native | libs/input/InputDevice.cpp | #define LOG_TAG "InputDevice"
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <android-base/properties.h>
#include <android-base/stringprintf.h>
#include <ftl/enum.h>
#include <input/InputDevice.h>
#include <input/InputEventLabels.h>
using android::base::GetProperty;
using android::base::StringPr... | TOOL | 0.913583 | 7.141391 |
47aa4d1e-5483-4f70-a47d-2f863b76b434 | viscrisn/mit-algo-cpp | CPP Projects/Practice_misc/dfs_adj_mat.cpp | #include<iostream>
#include<stack>
using namespace std;
int gr[10000][10000];
void printdfs(int n,int m)
{
stack<int> s;
bool visit[20]= {false};
int i=0;
int arr[20],k=0;
int top,flag;
visit[i]=true;
s.push(i);
while(s.empty()!=true)
{
flag = 0;
top = s.top();
... | ALGO | 0.999992 | 3.630445 |
f6f8ad9f-bcb8-4546-b350-dfddef215e93 | ayushbarthwal/oops | 8.cpp | #include <iostream>
using namespace std;
class Student{
private:
int score[5];
int TotalScore;
public:
void input(){
for (int i = 0; i<5; i++){
cin >> score[i];
}
}
int calculateTotalScore(){
TotalScore = 0;
... | ALGO | 0.999681 | 3.807116 |
bb643d1a-e82c-439a-b1ae-2644be1c23bf | ceazarr/Test-Engineeering | util/src/compare.cpp | #include "compare.h"
#include <cmath>
bool isFuzzyEqual(double value1, double value2, double epsilon)
{
return fabs(value1 - value2) < epsilon;
}
bool isFuzzyGreater(double value1, double value2, double epsilon)
{
return value1 + epsilon > value2;
}
bool isFuzzySmaller(double value1, double value2, double e... | TOOL | 0.988533 | 5.698376 |
71e9bbaf-c8d9-40b7-b7f9-d24e2dd11921 | SanchitTaliyan/Codes | Graph/validPath.cpp | string Solution::solve(int A, int B, int C, int D, vector<int> &E, vector<int> &F) {
int map[A][B] = {0};
for(int i =0; i<A; i++){
for(int j = 0; j<B; j++){
for(int k = 0; k<C; k++){
int R = sqrt(pow(E[k]-i,2) + pow(F[k]-j, 2));
if(R<=D)
ma... | ALGO | 0.999966 | 4.133361 |
80cdc385-f164-4af4-a8e7-01d45cb89ac2 | 2017029570/Computer-Algorithm | project2-1/project2-1.cpp | #include <stdio.h>
#include <cstring>
#include <stdlib.h>
int col=0;
typedef struct Node {
unsigned int key;
unsigned int value;
bool status = false;
}Node;
typedef struct HashTable {
int MaxTableSize;
Node* Table;
}Hash;
int find(unsigned int k, Hash HashTable) {
if(HashTable.Table[k%HashTable.MaxTableSi... | ALGO | 0.972749 | 3.589533 |
d6433c51-b620-409e-849b-02fd2bb8887f | Anshul407/LeetCode | 2362-minimum-rounds-to-complete-all-tasks/2362-minimum-rounds-to-complete-all-tasks.cpp | class Solution {
public:
//prioriy queue kyu use kia hai?
//mereko ab pta chl gya ki utna jarrori nahi tha pehle 3 pairs ko remove krna
//hata du tera kuch code??
//tikh hain
int minimumRounds(vector<int>& tasks) {
unordered_map<int,int> mp;
for(auto it:tasks)
{
... | ALGO | 0.999807 | 5.560074 |
e8b6a533-ceca-4a41-b598-e1439af91f43 | VijayNegi/LeetCodeProblems | solutions/725. Split Linked List in Parts.cpp | /**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
vector<ListNode*> spl... | ALGO | 0.999792 | 5.679539 |
ba7a1c11-5476-445a-ac16-4304a440ee00 | Srushti-Bhosale-31/Srushti-s-Factorial | binary_search.cpp | #include <iostream>
using namespace std;
// Function to perform binary search
int binarySearch(int arr[], int size, int target) {
int left = 0;
int right = size - 1;
while (left <= right) {
int mid = left + (right - left) / 2; // Calculate mid index
// Check if target is present at mid
... | ALGO | 0.999974 | 6.923023 |
b764bfb4-f613-4125-ba0c-35eea1fed6fd | TilStack/FlutterProjects | navigator_bar_works/windows/runner/utils.cpp | #include "utils.h"
#include <flutter_windows.h>
#include <io.h>
#include <stdio.h>
#include <windows.h>
#include <iostream>
void CreateAndAttachConsole() {
if (::AllocConsole()) {
FILE *unused;
if (freopen_s(&unused, "CONOUT$", "w", stdout)) {
_dup2(_fileno(stdout), 1);
}
if (freopen_s(&unuse... | TOOL | 0.998514 | 6.76073 |
060143e1-5757-48ee-bf81-300b3b2a1f7c | armandix23/C-Prog | 2DAM/RepasoExamen/08_shared_object/libray/logica.cpp | #include "logica.h"
int AND(int op1, int op2) { return op1 & op2; }
int OR (int op1, int op2) { return op1 | op2; }
int XOR(int op1, int op2) { return op1 ^ op2; }
| TOOL | 0.995418 | 4.016566 |
db66f282-0e57-4627-9baf-ddd0eba1567c | ParthJohri/LeetCodePractice | 0994-rotting-oranges/0994-rotting-oranges.cpp | class Solution {
public:
int dr[4]={1,0,-1,0};
int dc[4]={0,1,0,-1};
bool check(int x,int y,int m,int n){
return x>=0 and y>=0 and x<m and y<n;
}
int orangesRotting(vector<vector<int>>& grid) {
int mnAns=0,cnt=0,count=0;
int m=grid.size(),n=grid[0].size();
int vis[m][... | ALGO | 0.999978 | 6.167622 |
7dfa8f1e-4dc0-4250-90b0-779dc5042779 | Dsxv/competitveProgramming | cses/1085.cpp | #include <bits/stdc++.h>
using namespace std ;
#define int long long
bool check(int x , int* a , int n , int k){
int sum = 0 ;
int reg = 1 ;
for(int i = 0 ; i < n ; i++){
if(sum + a[i] > x){ // this is break point // not region
sum = 0 ;
reg++ ;
}
sum += a[i] ;
}
return reg <= k;
}
int32_t main(){
... | ALGO | 0.999979 | 4.577384 |
4c6dc1fc-4434-46c7-b9e0-a7dcf7608f81 | satabios/megamap | projects/dist_estimate/Jive.cpp | /*!
* ============================================================================
*
* @addtogroup jive
* @{
*
* @file jive.cpp
* @version 1.0
* @date 12/14/2015
*
* @note Hand tracking class
*
* Copyright(c) 2007-2012 Texas Instruments Corporation, All Rights Reserved.
* TI makes NO WARRANTY as to ... | ALGO | 0.881381 | 3.010828 |
49e8341a-756e-4578-875b-39002fddddc0 | Aastha1Nagpal/gfg-dsa | Difficulty: Easy/Factorials Less than or Equal to n/factorials-less-than-or-equal-to-n.cpp | //{ Driver Code Starts
#include <bits/stdc++.h>
using namespace std;
// } Driver Code Ends
// User function Template for C++
class Solution {
public:
vector<long long> factorialNumbers(long long n) {
// Write Your Code here
vector<long long> ans;
long long fact = 1;
for (long long i = 1; ... | ALGO | 0.998082 | 6.401895 |
7d8cde17-94ae-41d8-85f0-b90026c51deb | Dplex/ACMICPC | Acm/1718.cpp | #include <stdio.h>
#include <string.h>
char x[30001];
char y[30001];
int main()
{
gets_s(x);
scanf("%s", y);
int len = strlen(y);
for (int i = 0; x[i]; i++) {
if (x[i] == ' ')
printf(" ");
else
printf("%c", (x[i] - 'a' - (y[i%len] - 'a') + 'z' - 'a') % 26 + 'a');
}
} | ALGO | 0.999962 | 3.213536 |
9487ae7c-eeb3-47bc-ba1d-655a8d8759e8 | Nirvan-Aggarwal/SEM-2-2023-24 | Data-Structures-using-CPP/Practice/string manupulation.cpp | #include<iostream>
#include<string>
using namespace std;
int main()
{
string name1="Nirvan1",name2="Nirvan12",name3="Nirvan",name4="replaced";
cout<<name1.compare(name1)<<endl;
cout<<name1.compare(name2)<<endl;
cout<<name1.compare(name3)<<endl;
cout<<name1.append(name2)<<endl;
cout<<name3.... | TOOL | 0.949118 | 3.132642 |
2edaf309-7a47-4ac5-b204-d7d0b88be35e | sipXtapi/sipXtapi-svn-mirror | sipXportLib/src/os/OsUtil.cpp | // SYSTEM INCLUDES
#include "os/OsIntTypes.h"
#include <assert.h>
#include <ctype.h>
#include <stdlib.h>
#include <time.h>
#ifdef __pingtel_on_posix__
#include <netdb.h>
#endif
#ifdef _VXWORKS
#include <resolvLib.h>
#endif
// APPLICATION INCLUDES
#include "os/OsExcept.h"
#include "os/OsNameDb.h"
#include "os/OsUtil.... | TOOL | 0.95885 | 6.989861 |
1c6f04fd-88e4-4bd8-85a6-1332d83c3b1e | Zioba/tiitDeliveryLab1 | 021703/Poplauski-Eldar/TIITLabworkQuadtree/quadtree.cpp | #include <iostream>
#include <string>
#include <vector>
#include <cmath>
#define uns unsigned
#define clout system("cls");
#define clin rewind(stdin);
#define pause system("pause");
#include "quadtree.h"
uns stringToUns(std::string str)
{
uns ans = 0;
for (uns i = 0; i < str.size(); i++)
{
ans *= 10;
if (str... | ALGO | 0.997647 | 3.267163 |
86682af6-d2ad-41cc-a527-8ac7830afffe | CodeTrans-Research/RefuTra | result/translate/chatgpt/java2cpp/c++_eval/DIVISIBILITY_9_USING_BITWISE_OPERATORS.cpp | #include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include <fstream>
#include <iomanip>
#include <bits/stdc++.h>
using namespace std;
bool f_gold ( int n ) {
if ( n == 0 || n == 9 ) return true;
if ( n < 9 ) return false;
return f_gold ( ( int ) ( n >> 3 ) - ( int ) ( n & 7 ) );
}
bool f... | TEST | 0.997261 | 6.062431 |
4deaaba0-5155-488f-93f1-431a2bca0eba | TarekkMA/FEE-First-Data-Structure-Algorithms | sheets17/sheet10/reverseArr.cpp | #include <iostream>
using namespace std;
void reverseArray(int a[],int n){
int i = 0;
int j = n-1;
while(i<j){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
i++;
j--;
}
}
int main(){
int a[] = {1,2,3,4,5,6,7,8,9... | ALGO | 0.998721 | 4.503508 |
6ee59df1-809e-4810-8557-3ec382ea5034 | Shubham4359/BinaryTree | DSU.cpp | #include <bits/stdc++.h>
using namespace std;
class DSU{
public:
vector<int>par;
vector<int>rank;
DSU(int n){
par.resize(n+1);
rank.resize(n+1);
for(int i=1;i<=n;i++){
par[i]=i;
rank[i]=1;
}
}
int get_leader(int u){
if(par[u]==u){
return u;
}
else{
... | ALGO | 0.999956 | 4.344893 |
49d53c06-e048-4034-8647-b10ab44e1596 | Shreyaspatil2310/GFG | Difficulty: Medium/Add Number Linked Lists/add-number-linked-lists.cpp | //{ Driver Code Starts
// driver
#include <bits/stdc++.h>
using namespace std;
/* Linked list Node */
struct Node {
int data;
struct Node* next;
Node(int x) {
data = x;
next = NULL;
}
};
struct Node* buildList(int size)
{
int val;
cin>> val;
Node* head = new Node(val)... | ALGO | 0.999848 | 6.240724 |
88afe118-8f90-4410-a2b8-b67cbda231f2 | mozilla/spiderweb | gfx/skia/skia/src/animator/SkParseSVGPath.cpp | #include <ctype.h>
#include "SkDrawPath.h"
#include "SkParse.h"
#include "SkPoint.h"
#include "SkUtils.h"
#define QUADRATIC_APPROXIMATION 1
#if QUADRATIC_APPROXIMATION
////////////////////////////////////////////////////////////////////////////////////
//functions to approximate a cubic using two quadratics
// m... | TOOL | 0.919175 | 4.303792 |
b5b66532-46c1-490b-83d3-a2f27ee09016 | sijaykr/code | squof natural.cpp | #include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cout<<"please ente the value of n :: ";
cin>>n;
for(int i=1;i<n;i++){
cout<<i*i<<endl;
}
} | ALGO | 0.996433 | 3.599331 |
15d70280-6ac1-42b9-a505-90d9935da06b | lovmoon3k/ICPC-PTIT-2024 | Contest-5/F.cpp | #include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
struct P {
double x, y;
};
double dist(P a, P b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
P circum(P a, P b, P c) {
double D = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
double x =... | ALGO | 0.999985 | 5.070519 |
5d960057-2e3f-4755-ab15-804d25f5a37e | hisyatokaku/AOJ | ALDS/6_C_quick_sort.cpp | #include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <climits>
#include <cstring>
#include <unordered_map>
#define rep(i, begin, end) for (__typeof(end) i = (begin) - (... | ALGO | 0.999947 | 3.750242 |
737cab78-3779-4f41-958b-db352baa2d10 | ada-zqz/leetcode | LCP06_拿硬币.cpp | class Solution {
public:
int minCount(vector<int>& coins) {
int ans = 0;
for(auto i: coins) ans += i + 1 >> 1;
return ans;
}
};
| ALGO | 0.999528 | 5.580424 |
31a4c61a-0c9b-4bbb-b58d-c515a9b109b0 | igorkamski/Algorithms-and-data-structures | Priority queue - list.cpp | // Kolejka priorytetowa za pomocą listy
#include <iostream>
#include <iomanip>
#include <ctime>
#include <cstdlib>
using namespace std;
const int MIN = 2147483647;
struct listEl
{
listEl * next;
int priority, data;
};
class priorityqueue
{
private:
listEl * head;
listEl * tail;
public:
priorit... | ALGO | 0.999734 | 4.19066 |
a456c687-1907-4fb6-aad3-cc1ff7c931be | DigitalNoteXDN/OLD-digitalnote | tests/CoreTests/ChainSplit1.cpp | #include "ChainSplit1.h"
using namespace std;
using namespace CryptoNote;
gen_simple_chain_split_1::gen_simple_chain_split_1()
{
REGISTER_CALLBACK("check_split_not_switched", gen_simple_chain_split_1::check_split_not_switched);
REGISTER_CALLBACK("check_split_not_switched2", gen_simple_chain_split_1::check_split_n... | TEST | 0.879186 | 3.652712 |
2a5c958d-2715-41e1-bbf7-fc7c7b2de36e | dilip43/DSA--CODE | 9.Tree/Node_With_Largest_data.cpp | #include<bits/stdc++.h>
#include<climits>
#include"TreeNode.h"
using namespace std;
TreeNode<int>* takeInputLevelWise() {
cout << "Enter root Data :";
int rootData; cin >> rootData;
TreeNode<int>* root = new TreeNode<int>(rootData);
queue<TreeNode<int>*>pendingNodes;
pendingNodes.push(root);
while (pendingNodes... | ALGO | 0.999377 | 4.419858 |
66167849-f051-483a-a2bd-5f092a02f0d9 | Pradep290/Operatingsystem | os11.cpp | #include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define NUM_THREADS 5
// Function to be executed by each thread
void *threadFunction(void *arg) {
int thread_id = *(int *)arg;
printf("Thread %d is running\n", thread_id);
return NULL;
}
int main() {
pthread_t threads[NUM_THREADS];
int t... | ALGO | 0.94834 | 5.464677 |
41053cff-57b1-464b-abc2-36f0530154d8 | Haroon-64/VS-Code | cpp/macr.cpp | //macros
#include <iostream>
using namespace std;
#define PI 3.14159
#define NEWLINE '\n'
#define wait cin.get()
#define print(x) cout << x << endl
/*
#if debug == 1 // debug to be defined in compiler
#define print(x) cout << x << endl
#else
#define print(x)
remove logging in release mode
*/
int main()
{
doubl... | ALGO | 0.996634 | 4.300929 |
d03fab1b-595e-46ce-955a-19d6884b857c | igshrey01/PlacewitRevisionCode | 18-07-2023/Unique Path Recursion Memo.cpp | class Solution {
vector<vector<int>> dp;
public:
int countWays(int m, int n){
if(m==1 and n==1)
return 1;
if(m==0 or n==0)
return 0;
if(dp[m][n]!=-1)
return dp[m][n];
int up = countWays(m-1,n);
... | ALGO | 0.999989 | 6.423152 |
d565d3a1-b1fa-488e-a923-55344bcdc9ed | jakubstachowicz/duzy-skrypt | example_gallery/2_files/solution.cpp | #include <cstdlib>
#include <ctime>
#include <iostream>
int main() {
int a, b;
std::cin >> a >> b;
std::srand(std::time(nullptr));
std::cout << a + b + rand() % 2 << "\n";
}
| TOOL | 0.999017 | 4.351956 |
b0d81a23-8a68-4db2-8689-c89bb88ba05a | Mugglen/LeeCode | LeeCode/94_二叉树的先序遍历.cpp | #include <iostream>
#include <sstream>
#include <vector>
#include <queue>
#include <string>
// 二叉树节点结构体
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
// 解析输入字符串为 vector<string>
std::vector<std::string> parseInput(const std::st... | ALGO | 0.999969 | 5.889143 |
407f1a8d-d476-409d-ab15-27609528f669 | arthurmartinsc1/Neps | zerosum.cpp | #include <iostream>
#include <vector>
using namespace std;
int contador(int n,int vector1[]){
int a = 0;
for (int i = 0; i < n-2; i++)
{
if (vector1[i] == 1 && vector1[i+1]==0 && vector1[i+2] == 0)
{
a++;
}
... | ALGO | 0.999966 | 4.766928 |
65e3adff-834e-4de3-9042-5eb1733c2275 | jahidem/learn_algo-data | USACO_solve/Section 2.1/castle.cpp | /*
ID: jahid.h1
TASK: castle
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<vector<int>> ls,vis;
int cur,n,m,mx=0;
map<int,int> mp;
void df(int u,int v){
if(u<0||u>=n||v<0||v>=m||vis[u][v])
return;
vis[u][v]=cur,mp[cur]++;
mx=max(mx,mp[cur]);
if(!(ls[u][v]&... | ALGO | 0.999886 | 3.443587 |
d97332d4-9483-483c-a40d-32abb0c104b9 | animikhaich/NeRF-Editing-GP | TetWild/extern/libigl/include/igl/copyleft/cgal/peel_winding_number_layers.cpp | #include "peel_winding_number_layers.h"
#include <cassert>
#include "propagate_winding_numbers.h"
template<
typename DerivedV,
typename DerivedF,
typename DerivedW >
IGL_INLINE size_t igl::copyleft::cgal::peel_winding_number_layers(
const Eigen::PlainObjectBase<DerivedV > & V,
const Eigen::PlainObjec... | ALGO | 0.996749 | 5.931994 |
941ffbb4-92d9-4b0f-9231-405c0335152a | spacefarers/cp | problems/USACO/2018-jan/b-1.cpp | #include <iostream>
#include <fstream>
#include <string>
#include <cstring>
#include <queue>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef vector<pi> vpi;
typedef vector<vi> vvi;
#define trav(a,x) for (auto& a: x)
#define p... | ALGO | 0.998979 | 3.871122 |
d66d2590-e8e4-443e-a6ce-9a3b26d85c04 | StOriJimmy/TreeMaker | Source/tmModel/tmOptimizers/tmScaleOptimizer.cpp | #include "tmScaleOptimizer.h"
#include "tmModel.h"
using namespace std;
/**********
class tmScaleOptimizer
An optimizer for the overall scale of a tree.
**********/
/*****
Constructor
*****/
tmScaleOptimizer::tmScaleOptimizer(tmTree* aTree, tmNLCO* aNLCO)
: tmOptimizer(aTree, aNLCO)
{
}
/*****
Initialize the calc... | ALGO | 0.980763 | 5.587708 |
a54731b5-e299-41b7-bc2a-c5fdbc0f6bfd | Jonsen-Brad/wincode | C_doc/tmp.cpp | #include<iostream>
using namespace std;
int main(){
int a = 3,b = 5;
int * pa = &a;
int * pb = &b;
swap(pa,pb);
cout << *pa << "," <<*pb;
return 0;
}
| ALGO | 0.999358 | 3.469528 |
66414026-2371-410f-9477-3eb39e3410f8 | A-AboElnaga/CP-Solutions | CodeForces/GNU C++20 (64)/1777B | Emordnilap/189994736.cpp | <algorithm>
<cmath>
<deque>
<functional>
<iomanip>
<iostream>
<map>
<numeric>
<queue>
<set>
<stack>
<string>
<unordered_set>
<utility>
<valarray>
<vector>
<sstream>
<bitset>
namespace std;
file \
"out.txt", "w", stdout); \
"in.txt", "r", stdin)
inf unsigned long long32_MAX
FIn \
0); \
(0);... | ALGO | 0.999895 | 5.237554 |
181d7c0b-77ac-49d3-b890-fb3b00e022c2 | Mr-Phoebe/ACM-ICPC | OJ/Leetcode/Algorithm/1444. Number of Ways of Cutting a Pizza.cpp | class Solution {
int N, M;
const long mod=1e9+7;
int dp[55][55][12];
int sum[55][55];
vector<vector<int>> a;
int subSum(int i, int j, int x, int y)
{
return (sum[x][y]-sum[x][j-1]-sum[i-1][y]+sum[i-1][j-1]);
}
int solve(int i, int j, int k) {
if (k == 1) {
... | ALGO | 0.999651 | 5.620083 |
65992d8a-9641-416c-aff3-a52e399a86b6 | guptaishika128/My-Leetcode-GFG-Solutions | 145-binary-tree-postorder-traversal/145-binary-tree-postorder-traversal.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.999857 | 5.732256 |
417d9b58-db43-4aae-85d6-9817f93dcd39 | Aadil-777/GreenBin | windows/runner/utils.cpp | #include "utils.h"
#include <flutter_windows.h>
#include <io.h>
#include <stdio.h>
#include <windows.h>
#include <iostream>
void CreateAndAttachConsole() {
if (::AllocConsole()) {
FILE *unused;
if (freopen_s(&unused, "CONOUT$", "w", stdout)) {
_dup2(_fileno(stdout), 1);
}
if (freopen_s(&unuse... | TOOL | 0.998733 | 6.76775 |
6c9e2e14-a4af-4db9-835e-e52d2f97ef1b | AndroidRul3z/android_frameworks_av | media/libstagefright/codecs/amrwb/src/homing_amr_wb_dec.cpp | /*
------------------------------------------------------------------------------
Filename: homing_amr_wb_dec.cpp
Date: 4/25/2007
------------------------------------------------------------------------------
REVISION HISTORY
Description:
--------------------------------------------------------------------... | ALGO | 0.998583 | 5.770949 |
0f2afcb8-bd54-4d9b-9cec-00166bbf8ce6 | Apolref/LeetcodeTraining | 5602-1546-1071-greatest-common-divisor-of-strings/5602-1546-1071-greatest-common-divisor-of-strings.cpp | class Solution {
public:
std::string gcdOfStrings(std::string str1, std::string str2) {
// Função auxiliar para calcular o MDC (Máximo Divisor Comum)
auto gcd = [](int a, int b) {
while (b != 0) {
int temp = b;
b = a % b;
a = temp;
... | ALGO | 0.999922 | 6.687655 |
91aeadbc-58df-478a-8ce1-e42f7885bf24 | Yashvanthk05/Yashvanth-C-C-- | PAT/area.cpp | #include<iostream>
using namespace std;
class shape{
public:
virtual void calculateArea(){
cout<<"Base Class Intialisation"<<endl;
}
virtual void calculatePerimeter(){
cout<<"Base Class Initialisation"<<endl;
}
};
class rectangle:public shape{
public:
float length,breadth;
... | ALGO | 0.94717 | 3.597514 |
952434e8-8af8-4c0b-a0a2-5f09c979b2da | aboutwonjun/Solution | Solution/0423_반복문/practice2_1부터N까지합.cpp | //1부터 n까지의 합 구하기
#include <iostream>
// int main()
// {
// std::cout << "1부터 n까지의 합 구하기";
// "숫자(양의 정수)를 입력하세오 :";
// int num;
// std::cin >> num;
// int res;
// for (1; 1 <= num; num++);
// {
// }
int main()
{
std::cout << "1부터 n까지의 합 구하기" << std::endl;
std::cout ... | ALGO | 0.985145 | 5.190972 |
31b98fad-4b61-4332-a17e-bf22575d7238 | FrankCCCCC/2021_computer_programming_2 | past_oj/程式設計2/期末考/Vector Dot.cpp | #include <string>
#include <iostream>
class Vector {
private:
int v_size;
int *v;
public:
Vector() {
v_size = 0;
v = NULL;
}
Vector(int n) {
v_size = n;
v = new int[n];
}
~Vector() {
delete [] v;
}
void read() {
for (int i = 0; i < v_s... | ALGO | 0.999247 | 4.991601 |
8d163e46-fbd9-4ca1-a63f-a149d74b7563 | figurekim317/BOJ | cpp/BOJ_1171.cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef vector<vpii> vvpii;
typedef vector<vpll> vvpl... | ALGO | 0.999981 | 3.418051 |
7bc2013c-d7df-45f6-a97a-85651aa4763e | klaymen1n/portal-sdk-2013 | src/utils/common/cmdlib.cpp | #if defined( MPI )
#include "vmpi.h"
#include "vmpi_tools_shared.h"
#endif
#if defined( _WIN32 ) || defined( WIN32 )
#include <direct.h>
#endif
#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#endif
// set these before calling CheckParm
int myargc;
char **myargv;
char com_token[1024];
qboolean archive... | TOOL | 0.898152 | 4.720727 |
9028b27d-0649-418e-89ef-fad55d22eccf | axuy312/Parallel-Programming-HW3 | HW3/part2/tools/graphTools.cpp |
#include <algorithm>
#include <climits>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
#include "../common/graph.h"
#define CMD_TEXT2BIN "text2bin"
#define CMD_INFO "info"
#define CMD_PRINT "print"
#define CMD_NOOUTEDGES "noout"
#define CMD_NOINEDGES "noin"
#define CMD_... | ALGO | 0.97424 | 5.960331 |
9b4ff3ad-8a5b-4cac-8639-bbd7d2645912 | tjgolubi/boost | libs/numeric/ublas/doc/samples/assignment_examples.cpp | #include <boost/numeric/ublas/assignment.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/vector_proxy.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/vector_sparse.hpp>
#include <boost/numeric/ublas/matrix_sparse.hpp>
#include <boost/numeric/ublas/io.hpp>
... | TOOL | 0.917662 | 3.670881 |
5fca5aba-73ab-4955-826c-8a2bc3ca7fe1 | Rafa350/EOS | v2/Source/System/Graphics/eosGraphics_Polygon.cpp | #include "eos.h"
#include "eosAssert.h"
#include "System/Collections/eosVector.h"
#include "System/Graphics/eosGraphics.h"
#include <vector>
#include <algorithm>
using namespace eos;
#define MAX_POINTS 15
struct Edge {
int16_t yMin;
int16_t yMax;
int16_t xVal;
int16_t dx;
int16_t dy;
int16_... | ALGO | 0.98429 | 4.707275 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.