uuid string | repo_name string | relative_path string | content string | category string | algo_rel_score float64 | quality_score float64 |
|---|---|---|---|---|---|---|
455a00ae-5443-44e8-ba12-b9383dfcad88 | zakki/openhsp | package/win32/iOS/hspproj_gp/hspproj/hsp3dish/extlib/src/BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.cpp | #include "BulletCollision/CollisionShapes/btConvexShape.h"
#include "btGjkEpaPenetrationDepthSolver.h"
#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h"
bool btGjkEpaPenetrationDepthSolver::calcPenDepth( btSimplexSolverInterface& simplexSolver,
const btConvexShape* pConvexA, const btConvexShape... | ALGO | 0.99937 | 5.976816 |
bfb87008-45b6-4595-a093-5a5a32063289 | Priya-C-016/CppSolutions | Cycle.cpp | bool hasCycle(ListNode *head) {
ListNode* fast=head;
ListNode* slow=head;
while(fast!=nullptr && fast->next!=nullptr){
fast=fast->next->next;
slow=slow->next;
if(slow==fast){
return true;
}
}
return false;
| ALGO | 0.999377 | 4.414647 |
1d6721e2-fb0c-40b1-ace8-9cb6c6bd73b6 | Raghuveer22/striverSDEsheet | Day-6LinkedList2/firstNodeinCycle.cpp | /****************************************************************
Following is the class structure of the Node class:
class Node
{
public:
int data;
Node *next;
Node()
{
this->data = 0;
next = NULL;
... | ALGO | 0.999955 | 4.411048 |
d849a338-14fc-404d-8aaf-46639d7c9a48 | hRJ06/DSA | GFG/Check if frequencies can be equal.cpp | class Solution{
private:
bool f(vector<int> &v) {
int n = -1;
for(auto &i : v) {
if(i > 0) {
if(n == -1) n = i;
else if(n != i) return false;
}
}
return true;
}
public:
bool sameFreq(string s)
{
// code here
ve... | ALGO | 0.99997 | 5.474679 |
b4d4e06d-8dc9-407d-89e4-4718aeec6b1b | incenger/dsa_practice | codeforces/750C.cpp | #include <iostream>
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const* argv[]) {
int n;
cin >> n;
int INF = (int) 1e9;
int low = -INF;
int high = INF;
int del = 0;
for (int i = 0; i < n; i++) {
int c, d;
cin >> c>> d;
if (d == 1) low = ma... | ALGO | 0.999239 | 3.638067 |
c9f5f2cb-8e39-469a-b922-ebd979b1284e | coldwallet2020/billiecoin | src/spork.cpp | #include "spork.h"
#include "base58.h"
#include "chainparams.h"
#include "validation.h"
#include "messagesigner.h"
#include "net_processing.h"
#include "netmessagemaker.h"
#include <boost/lexical_cast.hpp>
CSporkManager sporkManager;
std::map<uint256, CSporkMessage> mapSporks;
std::map<int, int64_t> mapSporkDefault... | TOOL | 0.90788 | 6.012873 |
ab841f0f-459b-4bea-8e62-77f4471de718 | flamingfox/--Gamagora--Library | modele/si/si_primitive.cpp | #include "si_primitive.h"
SI_Primitive::SI_Primitive()
{
}
SI_Primitive::SI_Primitive(float e, float R):
e(e), R(R)
{
}
bool SI_Primitive::inOut(const Vector3D &p) const
{
return potentiel(p) >= 0.5f;
}
// Smooth falloff function
// r : small radius
// R : Large radius
float SI_Primitive::falloff( float r, ... | ALGO | 0.994532 | 4.486608 |
5f4beff6-e7be-4888-a729-556f67aad5c5 | MarcalAmaral/webserv | src/master/parser/utils.cpp | #include <iostream>
#include "utils.hpp"
#include "utils/utils.hpp"
#include <cctype>
#include <algorithm>
namespace common_utils = utils;
std::string master::parser::utils::remove_comments_spaces(const std::string &line) {
size_t foundComment = line.find('#');
if (foundComment != std::string::npos)
return (comm... | TOOL | 0.967391 | 3.531487 |
56130341-bfa2-4a99-8279-cefebf69d393 | hasueng/IntervalSimpp | src/systemc/tests/systemc/misc/v1.0/dash3/speed.cpp | /*****************************************************************************
speed.cpp -- Definition of the speedometer.
Original Author: Ali Dasdan, Synopsys, Inc.
*****************************************************************************/
/*************************************************************... | ALGO | 0.887009 | 6.06311 |
5ca2feaa-beba-4dd1-9e35-4729c499fde9 | GonzaloHer97/TAIS | Voraz/Prob60_Oferta3x2/Prob36_Oferta3x2/Source.cpp |
// Gonzalo Hernndz Hernndez
// TAIS39
// Comentario general sobre la solucin,
// explicando cmo se resuelve el problema
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
// resuelve un caso de prueba, leyendo de la entrada la
// configuracin, y esc... | ALGO | 0.99981 | 3.849602 |
5e05b51c-e9d9-423c-a08d-d74e28b104f7 | qpwoeirut/competitive-programming | Topcoder/Marathons/MM161/v1/HordeChess.cpp | #pragma GCC optimize("O3,unroll-loops")
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cassert>
#include <unordered_map>
#include "board.cpp"
#include "pieces.h"
using namespace std;
const int Q_CUTOFF = 9000;
const int TIME_LIMIT = 9900;
const int MAX_WHITE_MOVES = 10 * 8;
const int MAX_BLACK_... | ALGO | 0.998661 | 4.86053 |
fbec00f4-ccc4-4af7-9884-6efb1a880367 | Barala/c-code | codechef/JanChaleenge/prob4.cpp | #include <bits/stdc++.h>
using namespace std;
int main()
{
int t,p,q;
cin>>t;
while(t--)
{
int n=0,count=0;
scanf("%d",&n);
map<int, int> range;
int r1=0,r2=0;
int rr1=-1000000,rr2=-1000000;
while(n--)
{
scanf("%d %d",&p,&q);
range.insert(pair<int, int>(p,q));
}
for(map<int, int>::itera... | ALGO | 0.999897 | 3.827781 |
33771125-00ec-47a1-a3e3-0eea4b446915 | OLR-xray/XRay-NEW | XRay/xr_3da/xrGame/patrol_path_manager.cpp | ////////////////////////////////////////////////////////////////////////////
// Module : patrol_path_manager.cpp
// Created : 03.12.2003
// Modified : 03.12.2003
// Author : Dmitriy Iassenev
// Description : Patrol path manager
////////////////////////////////////////////////////////////////////////////
#include... | TOOL | 0.899012 | 3.48444 |
33a43327-bc72-46b6-83d7-b9451f68f19d | AKD-01/DSA-LeetCode | 3439-reschedule-meetings-for-maximum-free-time-i/3439-reschedule-meetings-for-maximum-free-time-i.cpp | class Solution {
public:
int maxFreeTime(int eventTime, int k, vector<int>& startTime,
vector<int>& endTime) {
int n = startTime.size(), res = 0;
vector<int> sum(n + 1);
for (int i = 0; i < n; i++) {
sum[i + 1] = sum[i] + endTime[i] - startTime[i];
}
... | ALGO | 0.999878 | 5.756396 |
a5892ff0-a49f-4f9e-af64-60a3e0f36a88 | windcry1/My-ACM-ICPC | OpenJudge/58.木材加工.cpp | #include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<fstream>
#include<iosfwd>
#include<sstream>
#include<fstream>
#include<cwchar>
#include<iomanip>
#include<ostream>
#include<vector>
#include<cstdlib>
#include<queue>
#include<set>
#include<ctime>
#include<algorithm>
#include<complex>
#inclu... | ALGO | 0.999923 | 3.262676 |
2aa2a61d-c9e7-46a7-bb23-be4c693acb6b | justangel/Lets_Make_a_Deal-Monty_Hall- | MontyHall.cpp | #include <iostream>
#include <cmath>
using namespace std;
double round(double num, int precision);
int main()
{
const int DOORS_COUNT = 3;
int win1Count = 0, win2Count = 0;
int gamesCount = 10000000;
for (int i = 0; i < gamesCount; i++)
{
bool autom[DOORS_COUNT] = { false };
autom[rand() % DOORS_COUNT] = ... | ALGO | 0.999132 | 4.373102 |
eb2fe2df-c45a-4319-b147-8b4536fdb6f1 | IvanRenison/ProgrammingProblems | ICPC contests/TAP Argentinian Subregional 2018/H.cpp | // https://codeforces.com/group/YjFmW2O15Q/contest/101919
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<ull> vu;
typedef vector<ll> vi;
typedef pair<ull, ull> uu;
typedef tuple<ull, ull, ull, ull> uuuu;
typedef tuple<ull, ull, ull, ull, ull> uuuuu;... | ALGO | 0.999697 | 4.766186 |
7038affc-25eb-4bd2-a30f-b0ddd34fb125 | freefcw/leetcode | cpp/min-cost-climbing-stairs.cpp | #include <cstdio>
#include <vector>
#include <map>
#include <iostream>
using namespace std;
class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
int total = cost.size();
if (total < 2) {
return 0;
}
vector<int> solutions(total);
solutions[0] =... | ALGO | 0.99989 | 5.317539 |
887691e9-6005-4fc1-8a51-4b77f118b18a | carlosngo/CompetitiveProgramming | Kattis/savinguniverse.cpp | #include <bits/stdc++.h>
using namespace std;
// READING INPUT
#define SCD(t) fscanf(stdin, "%d",&t)
#define SCLD(t) fscanf(stdin, "%ld",&t)
#define SCLLD(t) fscanf(stdin, "%lld",&t)
#define SCC(t) fscanf(stdin, "%c",&t)
#define SCS(t) fscanf(stdin, "%s",t)
#define SCF(t) fscanf(stdin, "%f",&t)
#define SCLF(t) fscanf... | ALGO | 0.999783 | 4.072496 |
9f3e6d13-dd6c-47ac-be3c-dd03f619a85e | sarvex/leetcode-checked-c | solution/0100-0199/0145.Binary Tree Postorder Traversal/Solution.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.999993 | 6.245906 |
d341adb3-a5b2-4cef-a054-6fdd9cf0323e | SriramAkula/CompetetiveCoding | Arr_binary_search.cpp | #include <iostream>
using namespace std;
int bin_search(int arr[],int n,int k){
int l=0;
int r=n;
// int mid=l+r/2;
while(l<=r){
int mid=(l+r)/2;
if(arr[mid]==k) return mid;
else if(arr[mid]>k){
r=mid-1;
}
else if(arr[mid]<k){
l=mid+1;
... | ALGO | 0.99993 | 4.650969 |
ec164637-22f9-46e2-8bfe-8b5ea0787a46 | z-a-f/HackerRank | Arrays and Sorting/Sherlock and MiniMax/solution.cpp | // #include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <iostream>
using namespace std;
int n;
int arr[109];
int A, B;
int answer;
//returns the value to be maximised if M=x
int check( int x )
{
int ret = INT_MAX;
for( int i = 0; i < n; ++i )
ret =min(ret, abs( x- arr[i] ));
ret... | ALGO | 0.99997 | 4.324266 |
aa37e969-ab7d-4cc3-8460-2f907816a79d | towhid1zaman/atcoder-solve | Atcoder Boot camp/abc170_d.cpp |
// </> : towhid1zaman
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair< int, int > pii;
typedef pair< pii, int > ppi;
#define fill(a,b) memset(a,b,sizeof(a))
#define all(v) (v).begin(),(v).end()
#define sp(k) cout<<setprecision(k)<<fixed;... | ALGO | 0.99989 | 3.705685 |
62496bc0-cdb0-4719-a075-30da4b2dcc21 | Dark-Basic-Software-Limited/GameGuruMAX | GameGuru Core/Guru-WickedMAX/GGTerrain/BC7Compress/Bc7PcaEigen.cpp |
#include "pch.h"
#include "Bc7Pca.h"
#if defined(OPTION_PCA)
#include "SnippetHorizontalSum4.h"
#define EIGEN_DONT_VECTORIZE
#define EIGEN_FAST_MATH 1
#include "Eigen/SVD" // Eigen 3.3.7 is required
static ALWAYS_INLINED __m128 FMS_ps(__m128 a, __m128 b, __m128 c)
{
#if defined(OPTION_FMA)
return _mm_fmsub_ps(a, ... | ALGO | 0.988582 | 5.944411 |
49d1cfc8-087c-4119-a56a-4bfa255f5fee | Dartpixel/Competitive-Coding | CODECHEF/PRIZEPOOL.cpp | #include <iostream>
using namespace std;
int main()
{
int testcase, x, y;
cin >> testcase;
while (testcase--)
{
cin >> x >> y;
cout << (x * 10) + (y * 90) << endl;
}
return 0;
}
| ALGO | 0.996019 | 4.038725 |
05c7e5f1-0825-41fe-b19f-5ee05588db8a | nakatamaho/mplapack | mplapack/test/eig/common/Rdrvst2stg.cpp | #include <mpblas.h>
#include <mplapack.h>
#include <fem.hpp> // Fortran EMulation library of fable module
using namespace fem::major_types;
using fem::common;
#include <mplapack_matgen.h>
#include <mplapack_eig.h>
#include <mplapack_debug.h>
void Rdrvst2stg(INTEGER const nsizes, INTEGER *nn, INTEGER const ntypes, b... | ALGO | 0.875875 | 4.252666 |
eebe2a6f-ac76-47a7-8b1d-5e5949ce1250 | Ashishmaley/LeetCode | 19-remove-nth-node-from-end-of-list/remove-nth-node-from-end-of-list.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:
ListNode* removeNthFr... | ALGO | 0.999969 | 5.973399 |
b1f34170-9ae9-4c3f-bb0d-c7fd08645139 | the0cp/leetcode | src/684.Redundant-Connection.cpp | class Solution {
public:
vector<int> findRedundantConnection(vector<vector<int>>& edges) {
int m=edges.size();
vector<int>root(m+1);
iota(root.begin(), root.end(), 0);
auto find = [&root](int n) -> int {
while(root[n] != n) n = root[n];
return n;
};... | ALGO | 0.999738 | 5.719914 |
0758fcf4-d238-42eb-8334-1efa5b50f4f3 | MEDUSA2O/leetcode-questions | 3194-find-words-containing-character/find-words-containing-character.cpp | class Solution {
public:
vector<int> findWordsContaining(vector<string>& words, char x) {
vector<int>a;
for(int i = 0 ; i < words.size() ; i++){
for(int j = 0 ; j < words[i].size() ; j++){
if(words[i][j] == x){
a.push_back(i);
break... | ALGO | 0.99981 | 5.732237 |
33e505b4-46e0-4e41-ad6b-5f711b6a2788 | Daen-cpu/Binary-arifm-NC_rk1-informatics | 3задача.cpp | #include <iostream>
#include <string>
#include <sstream>
using namespace std;
bool is_hex(const string& hex) {
for (char c : hex) {
if (!(c <= '9' or (c >= 'A' and c <= 'F') or (c >= 'a' and c <= 'f'))) return 0;
}
return 1;
}
int hex_to_dec(const string& hex) {
int decimal = 0;
stringstr... | ALGO | 0.99873 | 5.194067 |
169bb3b1-c415-4ad2-8472-5786e11e281e | ishandutta2007/codeforces | yuma_/normal/689/C.cpp | #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-9;
//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Downloa... | ALGO | 0.999955 | 4.291763 |
4eab0e81-5451-4f68-ac93-554d7645609c | nickchen111/Leetcode | Binary_Tree/1372. Longest ZigZag Path in a Binary Tree.cpp | /*
1372. Longest ZigZag Path in a Binary Tree
*/
// 4/9
class Solution {
int res = 0;
public:
int longestZigZag(TreeNode* root) {
DFS(root, 0, -1);
return res;
}
// 0 -> left, 1 -> right
void DFS(TreeNode* root, int count, int dir){
if(root == NULL) return;
res = ma... | ALGO | 0.999974 | 5.528493 |
15e729b7-f2be-4c08-b24a-17af3ae814dc | Souvik0901/SDE-Sheet | LinkedList/00.LinkedList.cpp | #include<bits/stdc++.h>
using namespace std;
// structure data structue
struct Node{
int data;
Node* next;
};
// function to create a node
Node *createNode(int value){
Node* newNode = new Node(); // initilize memory allocation
newNode->data = value;
newNode->next = nullptr;
return newNode;
}... | ALGO | 0.998865 | 4.747854 |
b1bad6bd-e17c-4707-87fa-b6fe90b004b5 | MaheshSharan/LeetCode_Automation | solutions/0200-0299/0215.Kth Largest Element in an Array/Solution3.cpp | class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
unordered_map<int, int> cnt;
int m = INT_MIN;
for (int x : nums) {
++cnt[x];
m = max(m, x);
}
for (int i = m;; --i) {
k -= cnt[i];
if (k <= 0) {
... | ALGO | 0.999912 | 5.657299 |
75bd80c9-a353-421d-9498-a10499127072 | mayankmishra0801/leetcode | 0101-symmetric-tree/0101-symmetric-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.999966 | 6.507883 |
cef30e5e-86ab-4a65-8ed5-d838ec34c951 | arrows-1011/CPro | AOJ/Volume12/1200.cpp | #include <iostream>
using namespace std;
#define MAX 50000
bool prime[MAX];
void is_prime(){
fill(prime,prime+MAX,true);
prime[0] = prime[1] = false;
for(int i = 2 ; i*i < MAX ; i++){
if(prime[i]){
for(int j = 2*i ; j < MAX ; j += i){
prime[j] = false;
}
}... | ALGO | 0.999837 | 4.353768 |
87fccbb1-41c9-4b5f-af3a-7cbdab6ba648 | gulatigaurav/Essential-Coding-Problems | Heaps - Interview Problems/MaxHeapImplementationScratch.cpp | #include <iostream>
#include <vector>
using namespace std;
class Heap
{
private:
int left(int parent);
int right(int parent);
int parent(int child);
void heapifyup(int root);
void heapifydown(int root);
void buildHeap(vector<int> arr, int n);
public:
Heap()
{
}
vector<int> heap... | ALGO | 0.999688 | 4.209906 |
8f8f8be5-7707-47ef-a30e-f5062237b938 | nkirov/nkirov.github.com | 2007/CSCB441/Volen/Non-repeating_Character.cpp | #include <iostream>
#include <string>
using namespace std;
int charCount[ 128 ];
int main()
{
for( int i = 0; i < 128; i++ ) charCount[ i ] = 0;
char ch;
string s;
while( cin >> ch )
{
charCount[ ch ]++;
s += ch;
}
for( int k = 0; k < s.size(); k++ )
... | ALGO | 0.999778 | 4.335731 |
29e30783-b95c-4e8d-bf79-99afe86fbeac | janParamo/GuiaDeEjercicios7 | Ejercicio3/empleados.cpp | #include <iostream>
#include "funciones.cpp";
using namespace std;
/*Se dispone de un archivo indexado (DNI National Identity Document en
orden ascendente) denominado empleados.dat, que contiene los datos de un conjunto
de empleados y cuya clave es el número DNI. Desarrollar un programa capaz de
categorizar los sal... | DATA | 0.882262 | 3.398062 |
a054d72c-741c-45c6-b97b-3179e1c76e2a | PiperBetle/MyCode | CF1442B Identify the Operations.cpp | #include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cassert>
#include<tuple>
#define siz(x) int((x).size())
#define cauto const auto
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
using std::cin;using std::cout;
using std::max;using std::min;
using std::tie;using ... | ALGO | 0.999974 | 4.775626 |
62f68e25-8920-46b5-93fd-09810654574e | Aheed-Siddiqui-Official/DSA | Lecture 21 Book Allocation or Allocate Books Problem DSA Series - Binary Search/code.cpp | #include <iostream>
#include <vector>
using namespace std;
bool isValid(vector<int> &arr,int n,int m, int maxAllowedPages) { //O(n)
int stu = 1, pages = 0;
for(int i = 0 ; i < n ; i++) {
if(arr[i] > maxAllowedPages) {
return false;
}
if(pages + arr[i] <= maxAllowedPages) {... | ALGO | 0.999983 | 5.703662 |
64484be6-1a8d-4ee2-b82c-0db6ddf1ebee | zxf-work/GraphProfile | boost_1_63_0/libs/graph/test/eccentricity.cpp | #include <iostream>
#include <boost/graph/undirected_graph.hpp>
#include <boost/graph/directed_graph.hpp>
#include <boost/graph/floyd_warshall_shortest.hpp>
#include <boost/graph/eccentricity.hpp>
#include <boost/graph/exterior_property.hpp>
#include <boost/graph/property_maps/constant_property_map.hpp>
using namespa... | ALGO | 0.998542 | 5.736807 |
6fdd301b-925b-4c58-af61-12ae1a8e919a | bhargavi290504/Leetcode | 1248-count-number-of-nice-subarrays/1248-count-number-of-nice-subarrays.cpp | class Solution {
public:
int numberOfSubarrays(vector<int>& nums, int k) {
int ans = 0;
int cnt = 0;
unordered_map<int, int>mp;
mp[0] = 1;
for (int num : nums) {
if (num % 2 != 0) {
cnt++;
}
if (mp.find(cnt - k) != mp.end())... | ALGO | 0.99999 | 5.904241 |
2af46da2-3a5c-419c-b99d-d7b5e4d58621 | NomanAli17/PF-Lab-Tasks | Lab 6/Question 5.cpp | #include<stdio.h>
int main(){
int prime = 0;
int n;
printf("Enter the number:"); scanf("%d",&n);
if(n == 0 || n == 1){
printf("Not prime");
}else if(n == 2){
printf("Prime");
}else if(n > 2){
for(int i = 2; i < n; i++){
if(n%i == 0){
prime = 0;
break;
}
else{
prime = 1;
}
}
if(... | ALGO | 0.999848 | 3.099697 |
b7115076-ca99-4471-9fb2-689e4b0f1834 | AlBovo/Olinfo-WriteUps | Olinfo/training/gator_classifica.cpp | // Punti: 100.0
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
int main()
{
ifstream fin("input.txt");
ofstream fout("output.txt");
int N, k; fin >> N;
int vittorie[N];
fill(vittorie, vittorie+N, 0);
k = (N*(N-1))/2;
for(int i=0; i<k; i++)
{
int ... | ALGO | 0.999969 | 3.894263 |
9746083f-8a6b-436d-9daf-a55eed853321 | ishandutta2007/codeforces | davoth/normal/1483/F.cpp | #include <bits/stdc++.h>
/*#pragma GCC optimize("Ofast,unroll-loops")
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma,tune=native")*/
/*#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2,fma")*/
using... | ALGO | 0.999916 | 4.420829 |
c0524de1-4c26-41b5-add4-6393ef67d474 | manishjhacse/cppcodes | patterns/pattern7.cpp | #include<iostream>
using namespace std;
int main()
{
int row=1,column,n;
int value;
cout<<"enter the value of n"<<endl;
cin>>n;
while(row<=n)
{
column=1;
value=row;
while(column<=row)
{
cout<<value<<" ";
value--;
column++;
... | ALGO | 0.999976 | 3.904896 |
a3afef7a-fd49-41ac-a7e0-84066ca06d8e | MUID-MARUF/Algorithms | palindrome_integer.cpp | #include <bits/stdc++.h>
using namespace std;
string check_palindrome()
{
int n, num, digit, rev = 0;
cin >> num;
n = num;
do
{
digit = num % 10;
rev = (rev * 10) + digit;
num = num / 10;
} while (num != 0);
if (n == rev)
{
return "Yes";
}
else
... | ALGO | 0.999941 | 4.530207 |
b91e7c21-e6a7-4d13-994b-6f6bd52f90d5 | Ayu1C/CrackYourInternship | 2233-maximum-product-after-k-increments/2233-maximum-product-after-k-increments.cpp | class Solution {
public:
int maximumProduct(vector<int>& nums, int k) {
priority_queue<int, vector<int>, greater<int>> pq(nums.begin(), nums.end());
while(k--) {
int mini = pq.top();
pq.pop();
pq.push(mini + 1);
}
lo... | ALGO | 0.999984 | 5.842302 |
4a8046d3-380e-411c-8bff-67afd89529ed | Feroz455/Fundamentals-Of-Computer-Algorithms | Chapter_03/Exercises_3.7/09.cpp | /*
Page 188
09. The kth quantiles of an n-element set are the k-1 elements from
the set that devide the sorted set into k equal-sized sets.Give an O(nlogn)
time algorithm to lsit the kth quantiles of a set.
*/
#include <iostream>
#include <algorithm>
#include <climits>
#include <cmath>
#include <ctime>
using namespace ... | ALGO | 0.99997 | 4.504868 |
9087e204-3da6-473b-b4f6-1d42b57ebd89 | lucic71/llvm-ub-free | llvm/lib/Transforms/Utils/FunctionComparator.cpp | #include "llvm/Transforms/Utils/FunctionComparator.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/... | TOOL | 0.955284 | 5.505927 |
f38206e8-d155-4ac6-97ae-a86e5ffd4c12 | harshit7962/LeetCode_Easy | PlusOne.cpp | class Solution {
public:
vector<int> plusOne(vector<int>& digits) {
int i=digits.size()-1;
while(i>=0 && digits[i]==9) {
digits[i--]=0;
}
if(i>-1) {
digits[i]=digits[i]+1;
return digits;
}
vector<int> x(digits.size()+1, 0);
... | ALGO | 0.999893 | 6.738304 |
079af2ba-8238-4a2c-92b3-02cc2818965b | aash553/leetcode-gfg | Difficulty: Medium/Tree Boundary Traversal/tree-boundary-traversal.cpp | /*
// Tree Node
class Node {
public:
int data;
Node* left;
Node* right;
// Constructor to initialize a new node
Node(int val) {
data = val;
left = NULL;
right = NULL;
}
};
*/
class Solution {
public:
bool isleaf(Node * root){
return (root->left == NULL &&... | ALGO | 0.99999 | 5.91608 |
70028feb-713b-46b6-baa5-18acb40d1507 | scs/leanXopencv | src/cvaux/cvspinimages.cpp | #include "_cvaux.h"
#include <algorithm>
#include <cmath>
#include <limits>
#include <set>
#include <fstream>
using namespace cv;
using namespace std;
/********************************* local utility *********************************/
namespace cv
{
using std::log;
using std::max;
using std::min;
usi... | ALGO | 0.999358 | 5.172482 |
ad6e3cc4-1e63-4ab1-bd8f-0e0af23079f3 | DongwookHong/codingtest | 3.19/소수찾기.cpp | #include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <cmath>
using namespace std;
void makenum(string numbers, string current, vector<bool>& used, set<int>& result) {
if (current.length() > 0) {
result.insert(stoi(current));
}
for (int i = 0; i < numbers.size(); i+... | ALGO | 0.999268 | 5.753623 |
8e21f753-fe51-4eaf-97f9-2d90d9a45565 | manpreetrathore/dsa | knapsack01.cpp | #include<bits/stdc++.h>
using namespace std;
int knapsack(int value[], int w[], int n, int W){
if(n==0 || W==0){
return 0;
}
if(w[n-1]>W){
return knapsack(value,w,n-1,W);
}
return max(knapsack(value,w,n-1,W-w[n-1])+value[n-1],knapsack(value,w,n-1,W));
}
int main(){
int w[] = {1... | ALGO | 0.999906 | 4.816348 |
5ba11c69-5c80-45d1-b7bc-def951fdda90 | ishandutta2007/codeforces | fdg/normal/77/A.cpp | #include <cstdio>
#include <map>
#include <algorithm>
#include <iostream>
#include <vector>
#include <string>
#define ll long long
using namespace std;
int main()
{
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
char mas[7][20]={"Dracul","Troll","Anka","Hexadecimal","Snowy","Cleo",... | ALGO | 0.9998 | 3.350341 |
fc800595-a301-4f67-bcec-8638e67229d0 | matsumoto2004/competitive_programming | archive/archive_practice/ARC137D.cpp | #include<bits/stdc++.h>
#include<cassert>
//#include<ext/pb_ds/assoc_container.hpp>
//#include<ext/pb_ds/tree_policy.hpp>
//#include<ext/pb_ds/tag_and_trait.hpp>
#define overload4(_1, _2, _3, _4, name, ...) name
#define rep1(i, n) for (ll i = 0; i < ll(n); ++i)
#define rep2(i, s, n) for (ll i = ll(s); i < ll(n); ++i)
#... | ALGO | 0.999909 | 3.08774 |
d5a03d2f-6607-412d-81e2-a0b15e51a69f | ishandutta2007/codeforces | tsukiko_tsutsukakushi/normal/1279/B.cpp | #include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<deque>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<un... | ALGO | 0.999983 | 3.660246 |
09759e02-e2bb-4279-89be-cc16684d1449 | Sergi-0/first-repository-git | task17(1).cpp | #include <iostream>
#include <math.h>
#include <vector>
#include <string>
#include <Windows.h>
using namespace std;
double *arr;
void task1()
{
int N,a;
cout << "Введите количество элементов в массиве: ";
cin >> N;
arr = new double[N];
cout << "Введите элементы массива: ";
for (int i = 0; i < N; ++i) cin >> arr... | ALGO | 0.979414 | 3.159069 |
05c8cf68-0775-42db-994c-396e4621393e | maliksaad84/PoP-NDN-Vehicular-NDN- | applications/ndn-consumerO6.cpp | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#include "ns3/ptr.h"
#include "ns3/log.h"
#include "ns3/simulator.h"
#include "ns3/packet.h"
#include "ns3/callback.h"
#include "ns3/string.h"
#include "ns3/boolean.h"
#include "ns3/uinteger.h"
#include "ns3/integer.h"
#include "ns3/double.h"
#include ... | TOOL | 0.884934 | 6.510532 |
9cdc8edc-ebae-4112-940d-7adc7ac106ab | fardinzam/BS-Tree | main.cpp | #include <iostream>
#include <limits>
#include "BSTree.h"
using namespace std;
void printOrders(BSTree *tree) {
cout << "Preorder = ";
tree->preOrder();
cout << endl;
cout << "Inorder = ";
tree->inOrder();
cout << endl;
cout << "Postorder = ";
tree->postOrder();
cout << endl;
}
int menu() {
int c... | ALGO | 0.98811 | 5.041667 |
8f7d6457-6ca7-4fde-a1d9-3e9f3265b396 | nabaraj-malla/DSA-in-Cpp | BST/print-elements-in-range.cpp | // Problem statement
// Given a Binary Search Tree and two integers k1 and k2, find and print the elements which are in range k1 and k2 (both inclusive).
// Print the elements in increasing order.
#include <iostream>
#include <queue>
template <typename T>
class BinaryTreeNode
{
public:
T data;
BinaryTreeNode<... | ALGO | 0.999989 | 5.085536 |
7fdd6df2-f8bf-43c2-b945-1c451560ac72 | SHAIKARSHADA/DSA | if-else.cpp | //{ Driver Code Starts
#include <bits/stdc++.h>
using namespace std;
// } Driver Code Ends
//User function Template for C++
class Solution {
public:
string compareNM(int n, int m){
if (n > m) {
return "greater";
} else if( n < m ) {
return "lesser";
} else {
... | ALGO | 0.999974 | 5.564896 |
dbc2d7b3-0437-441e-91b2-b5d13074aae1 | JOhnBroker/Learn_DX12 | Extra_RayTracing/sphere.cpp | #include "sphere.h"
bool sphere::hit(const Ray& r, interval ray_t, hit_record& rec) const
{
bool res = false;
point3 cen = is_moving ? GetCenter(r.GetTime()) : center;
vec3 oc = r.GetOrigin() - cen;
// 射线与球体是否相交 可以 转化为射线到球心之间的距离
// (P(t)-C)·P(t)-C = r^2 ; P(t) = Ori + t*Dir
// 展开公式可得
// t^2... | ALGO | 0.967498 | 5.483653 |
a79a0e97-19f1-40c2-bac6-ca15b1922ac7 | IIITManjeet/Leetcode-solutions | 3195-separate-black-and-white-balls/separate-black-and-white-balls.cpp | class Solution {
public:
long long minimumSteps(string s) {
long long ans=0;
int n=s.size();
long long cnt=0;
for(int i=n-1;i>=0;i--){
if(s[i]=='1'){
ans+=cnt;
}
else{
cnt++;
}
}
return an... | ALGO | 0.999961 | 5.830064 |
03a7023a-6185-42cc-87d1-52dfff08552b | Azhar2786/Leetcode_DailyChallange_Sol | October_daily_question/Day2.cpp |
//! 2038. Remove Colored Pieces if Both Neighbors are the Same Color
class Solution {
public:
bool winnerOfGame(string colors) {
int n = colors.size();
int winner1 = 0,winner2=0;
for(int i = 1;i<n-1;i++)
{
if(colors[i]=='A' && colors[i-1]=='A' && colors[i+1]=='A')
... | ALGO | 0.998711 | 5.828009 |
c08225b0-0064-4182-86e2-087c08ec675a | zFerishttto/kutubu | 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 |
b5d2aa4e-7c46-453e-848e-7ac3ff587e54 | thegamer1907/Code_Analysis | contest/1542503667.cpp | #include<bits/stdc++.h>
using namespace std;
int main()
{
string s1,s2;
int n;
bool r1=false,r2=false;
cin>>s1>>n;
for(int i=0;i<n;i++)
{
cin>>s2;
if(s1==s2){r1=true;r2=true;}
if(s2[1]==s1[0]){r1=true;}
if(s2[0]==s1[1]){r2=true;}
}
if(r1==tr... | ALGO | 0.99998 | 3.436827 |
b5ada8fc-f929-4a9a-aec8-afd03ddd4ed4 | Aryan810/programming | learn/learn_cpp/codeforces/contest_1037_div3/C_I_Will_Definitely_Make_It.cpp | // #include<atcoder/modint>
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
// #pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
using namespace __gnu_pbds;
using uint = unsigned int;
using ull = unsigned long long;
using ll = long long;
// using namesp... | ALGO | 0.99993 | 4.380409 |
aef64138-2e90-48d8-a052-a0f0199f169d | alexandraback/datacollection | solutions_5686275109552128_0/C++/jeno5980515/2.cpp | #include <iostream>
#include <vector>
#include <sstream>
#include <map>
#include <fstream>
#include <cmath>
#include <limits.h>
using namespace std;
int main()
{
fstream fin("in.txt",ios::in);
fstream fout("out.txt",ios::out);
int n ;
fin >> n ;
for ( int n2 = 0 ; n2 < n ; n2 ++ ){
if ( n2... | ALGO | 0.999839 | 3.3666 |
0c5f82d4-0aae-4fe5-8908-95aa5cd32af8 | Chethan-L701/cpp-prog | src/prog38.cpp | //prog38.cpp
//Program to Swap Two Strings
#include <iostream>
#include <cstring>
using namespace std;
int main(){
char temp[50],str1[50],str2[50];
cout<<"Enter the string1:";
fgets(str1,50,stdin);
cout<<"Enter the string2:";
fgets(str2,50,stdin);
cout<<"Before Swapping : \n"<<"String1 = "<<str1<<"\nString2 = ... | ALGO | 0.97229 | 3.563159 |
f9b53780-13d4-4895-8a2f-b5ae67b97cee | SakshamSahgal/Competitive-Programming | Codeforces + Codechef/C. Interesting Sequence.cpp | #include<bits/stdc++.h>
#define lli long long int
#define ulli unsigned long long int
#define ld long double
#define GO_FAST ios_base::sync_with_stdio(0);ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
// basic debugging macros
lli __i__,__j__;
lli inf = 9e18;
#define line_printer(l) cout<<"\n"; for(__i__=0;__i__<l;__i... | ALGO | 0.999922 | 3.786931 |
6338ae1c-bbad-41e7-946a-f15fffe72214 | CodeBus69/High-School | Zadanie 3.27/main.cpp | #include <iostream>
#include <cstdlib>
#include <time.h>
using namespace std;
int main()
{
/////////////////////
double tablica[5][5];
srand(time(0));
/////////////////////
for (int i=0;i<5;i++)
for (int j=0;j<5;j++)
tablica[i][j]=rand()%109-20;
/////////////////////
f... | ALGO | 0.998183 | 3.267093 |
2a77092b-3132-4526-89d0-5575d483ea70 | wwt17/BZOJ | 1003 [ZJOI2006]物流运输trans.cpp | #include <cstdio>
#include <cstring>
#include <queue>
#define INF 0x00010000
inline bool mini(int &a,const int b){return a>b?(a=b,true):false;}
struct node;
struct edge{
node* ed; edge* next; int w;
edge(node* _ed,edge* _next,int _w):ed(_ed),next(_next),w(_w){}
};
struct node{
edge* son; bool inq,flag,f[101]; int di... | ALGO | 0.999823 | 3.908023 |
2d612741-e4b4-4aeb-bc20-5adac218b44e | Sudhanwaa/LeetCode-Solutions | 202-happy-number/202-happy-number.cpp | class Solution {
public:
bool isHappy(int n) {
// to store value each squares of digit
int value = 0;
// var to check index of the digit
int index;
// to store all the values of squares of digits
set<int>s;
while(1)
{
while(n)
... | ALGO | 0.999974 | 6.277301 |
981ac954-6932-4f0d-9457-b5359f54a97d | parthtyagii/DSA-Codes | primeSieve.cpp | #include <iostream>
using namespace std;
// All Prime numbers between 1 and N:
void primeSieve(int arr[])
{
arr[0] = arr[1] = 0;
arr[2] = 1;
//we want to check only odd numbers.
for (int i = 3; i < 1000; i += 2)
{
arr[i] = 1;
}
// Applying Sieve method: (consider taking i and j a... | ALGO | 0.999969 | 4.63985 |
778688b8-b195-4347-b98c-258a959fc1a1 | vishusharmaX/100DaysofCodeChallenge | Easy/Count the elements/count-the-elements.cpp | //{ Driver Code Starts
// Initial Template for C++
#include <bits/stdc++.h>
using namespace std;
// } Driver Code Ends
// User function Template for C++
class Solution {
public:
vector<int> countElements(vector<int> &a, vector<int> &b, int n, vector<int> &qu,
int q) {
// Y... | ALGO | 0.999854 | 5.886805 |
d7017c04-f2e3-4271-9ade-79727141fb0e | JoaoDanielRufino/Online-Judges | LeetCode/binary_search.cpp | class Solution {
public:
int search(vector<int>& nums, int target) {
int l = 0, r = nums.size() - 1;
while(l <= r) {
int mid = l + (r - l)/2;
if(nums[mid] == target)
return mid;
if(nums[mid] > target)
r = mid - 1;
else... | ALGO | 0.999919 | 6.319489 |
4e80d9f2-c5ec-470c-b800-eb9f6a97871c | MobClub/ShareSDK-Cocos2d-x-Demo-for-iOS | cocos2d/cocos/math/CCVertex.cpp | #include "math/CCVertex.h"
#include "base/ccMacros.h"
NS_CC_BEGIN
void ccVertexLineToPolygon(Vec2 *points, float stroke, Vec2 *vertices, unsigned int offset, unsigned int nuPoints)
{
nuPoints += offset;
if(nuPoints<=1) return;
stroke *= 0.5f;
unsigned int idx;
unsigned int nuPointsMinus = nuPoin... | ALGO | 0.992627 | 5.824827 |
1c4238b5-34ed-4dbb-8fcc-bb79cbb06199 | AlanGuzman04/flutter_act17maps_20220258 | flutter_maps_20220258/google_maps_in_flutter/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.997524 | 6.76073 |
2673eb73-7abf-4d11-b3dd-077cd1325a5a | facebookresearch/TransCoder | data/evaluation/geeks_for_geeks_successful_test_scripts/cpp/NUMBER_TRIANGLES_N_MOVES_1.cpp | #include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include <fstream>
#include <iomanip>
#include <bits/stdc++.h>
using namespace std;
int f_gold ( int n ) {
int ans = 2 * ( pow ( 3, n ) ) - 1;
return ans;
}
//TOFILL
int main() {
int n_success = 0;
vector<int> param0 {78,89,46,56,7... | ALGO | 0.972025 | 3.96682 |
ec82c8bb-9950-43ae-979e-82e5fb860ba5 | lip6/Louvain-BinaryBuild | louvain-generic/src/owzad.cpp | #include "owzad.h"
using namespace std;
OwZad::OwZad(Graph & gr, long double al, long double max_w):Quality(gr,"Owsinski-Zadrozny (with alpha=" + to_string(al) + ")"), alpha(al), max(max_w) {
n2c.resize(size);
in.resize(size);
w.resize(size);
// initialization
for (int i=0 ; i<size ; i++) {
n2c[i] =... | ALGO | 0.993745 | 4.509838 |
98746030-9381-4dac-bd56-81e76ecbef13 | DavidingPlus/algorithm | leetcode/1047.删除字符串中的所有相邻重复项.cpp | /*
* @lc app=leetcode.cn id=1047 lang=cpp
*
* [1047] 删除字符串中的所有相邻重复项
*/
// @lc code=start
#include <bits/stdc++.h>
class Solution
{
public:
std::string removeDuplicates(std::string s)
{
// 这个题目和使用栈处理括号匹配的那个题目没有任何区别，模拟一下过程即可
// 只不过这里就是用一个字符串模拟栈了，本质是一样的
std::string res;
re... | ALGO | 0.99985 | 6.647634 |
2a55f0bd-5799-469a-bc04-ea923c32cd5d | raincross7/code-similarity | codes/train_code/problem184/problem184_125.cpp | #include <iostream>
#include <sstream>
#include <stack>
#include <iomanip>
#include <string>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <queue>
#include <cmath>
#define BEGIN(x) x.begin()
#define END(x) x.end()
#define ALL(x... | ALGO | 0.999941 | 3.616451 |
aa0afbee-5405-476a-8b81-259d40c5fa98 | eduong100/CS31 | Project3/grocery.cpp | #include <string>
#include <cassert>
using namespace std;
//Get integer from string
int getIntFromString(size_t& pos, string str) {
int final_int = 0;
int current_number;
//Loop through string until it ends or we no longer read a number
for ( ; ; ) {
//read in string building final_int step by step
if (pos >... | ALGO | 0.934995 | 4.297891 |
e5463138-63cc-4164-90af-aa46421ebe3c | NatchSiri/DataStruct | 5.Priority_Queue/3.priority_queue_example.cpp | #include <iostream>
#include "priority_queue.h"
using namespace CP;
typedef bool(*CompFunc)(int, int);
bool myGreater(int a,int b) {
return a > b;
}
typedef struct cmp {
bool operator() (int a, int b) {
return a < b;
}
}cmp;
int main() {
priority_queue<int> pq1;
priority_queue< int, greater<... | TOOL | 0.927536 | 3.841469 |
86e906ef-63bc-4981-ae15-d61b2a7763b5 | abidh8820/LightOJ-Solutions | LOJ-1085 All Possible Increasing Subsequences.cpp | #include "bits/stdc++.h"
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
const int M = 1e9 + 7;
const int N = 1 << 18;
bool comp(pii a, pii b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
LL tree[N * 4], a[N], dp[N];
void update(int u, int l, int ... | ALGO | 0.999884 | 4.378273 |
980e1285-d985-4cd9-b1cd-80c23778ed13 | v2v3v4/xray-cop | engine/xrGame/ik/math3d.cpp | #include "StdAfx.h"
#include "math3d.h"
#ifndef JACK
Matrix idmat =
{
{1.0, 0.0, 0.0, 0.0},
{0.0, 1.0, 0.0, 0.0},
{0.0, 0.0, 1.0, 0.0},
{0.0, 0.0, 0.0, 1.0}
};
void
matmult(Matrix A,Matrix B,Matrix C)
/*
* Multiply 4x4 matrices:
*
* A = B * C
*
* Don't use this if the matrices are homogeneous:... | ALGO | 0.999759 | 4.448696 |
6834afa4-a633-4492-99bb-f176359cd47c | omkarauti11/30-Days-6-Companies-Challenge-2024 | Day6/1401_Circle_and_Rectangle_Overlapping.cpp | #include <bits/stdc++.h>
using namespace std;
// solution
class Solution
{
public:
bool checkOverlap(int radius, int xCenter, int yCenter, int x1, int y1, int x2, int y2)
{
int nearest_x = max(x1, min(x2, xCenter));
int nearest_y = max(y1, min(y2, yCenter));
int dist_x = nearest_x - x... | ALGO | 0.999673 | 4.941988 |
56a908b3-da31-43a3-8e23-dd1805ee1f1b | bandtank/Arb2PWL | AutoTrace.cpp | #include "AutoTrace.h"
// Custom
#include "MooreTracing.h"
#include "Helpers.h"
// ITK
#include "itkAndImageFilter.h"
#include "itkBinaryBallStructuringElement.h"
#include "itkBinaryDilateImageFilter.h"
#include "itkBinaryThinningImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkConnectedThreshol... | TOOL | 0.962488 | 6.304371 |
db3e89c5-d087-4be2-ab34-7f144d13d0a0 | Nishikawa5/Competitive-Programming | CP4 Exercises/Chapter2/LinearDataStructure/Problems/Stack.cpp | #include <stdio.h>
#include <stdlib.h>
#include <stack>
#include <iostream>
#include <vector>
using namespace std;
/*
wash plates the same order they come
only two piles of plates in table
not necessary to make the min number of moves?
*/
int main(void) {
int N;
bool firstRun = true;
while (cin >> N && N... | ALGO | 0.998707 | 4.430821 |
c63dc497-b634-4181-b870-22299d3068f5 | GSWlee/leetcode | 257.cpp | class Solution {
public:
void binaryTreePaths(TreeNode* root,vector<string> &ans,string temp){
if (!root){
return;
}
if (root->left==nullptr&&root->right==nullptr){
temp=temp+to_string(root->val);
ans.push_back(temp);
return;
}
... | ALGO | 0.999943 | 5.777251 |
d304112c-eae3-4c43-992c-bdcf465703ce | zoewilson/C-plus-plus | Wilson_HWK5_5.cpp | /*
* Zoe Wilson
* February 9, 2016
* Homework 5.5
*/
#include <iostream>
#include <vector>
#include <sstream>
const int MAX_SIZE = 20;
struct IntegerOverflow {
int size;
IntegerOverflow(int s) {
size = s;
}
};
struct Arrays {
std::string a;
std::string b;
};
// Get input from the us... | ALGO | 0.982575 | 5.233895 |
849e0462-79c9-4f95-8aac-489cd8434ee2 | geyan3566/mfem_dgd | fem/integ/bilininteg_curlcurl_pa.cpp | #include "../qfunction.hpp"
#include "bilininteg_hcurl_kernels.hpp"
namespace mfem
{
void CurlCurlIntegrator::AssemblePA(const FiniteElementSpace &fes)
{
// Assumes tensor-product elements
Mesh *mesh = fes.GetMesh();
const FiniteElement *fel = fes.GetFE(0);
const VectorTensorFiniteElement *el =
dyn... | ALGO | 0.980549 | 5.584367 |
e39f8365-8ee7-4065-823b-8d9e8c388bbc | Etsuya233/CodeSyncEtsuya | Luogu/8786_dp.cpp | #include <iostream>
#include <algorithm>
using namespace std;
int n, m;
int moda = 1000000007;
int dp[105][105][105];
int main(){
cin >> n >> m;
fill(dp[0][0], dp[0][0] + 105 * 105 * 105, 0); //memset
dp[0][0][2] = 1;
for(int i = 0; i <= n; i++){
for(int j = 0; j <= m; j++){
if(i == 0 && j == 0) continue;
... | ALGO | 0.999993 | 4.602011 |
0fed34b7-3796-481c-9b23-d6e8227d21ee | AugustoSan/todo-list-flutter | 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 |
e662bda7-003e-4a35-989e-d9f1b2306f3d | aaaschmitt/rpi_slam | lib/boost_1_63_0/libs/program_options/src/value_semantic.cpp | #define BOOST_PROGRAM_OPTIONS_SOURCE
#include <boost/program_options/config.hpp>
#include <boost/program_options/value_semantic.hpp>
#include <boost/program_options/detail/convert.hpp>
#include <boost/program_options/detail/cmdline.hpp>
#include <set>
#include <cctype>
namespace boost { namespace program_options {
... | TOOL | 0.97972 | 7.622782 |
ff7fe573-520c-4178-a677-bb553cedd53a | mohammedidhi0225/LeetCode | 0145-binary-tree-postorder-traversal/0145-binary-tree-postorder-traversal.cpp | class Solution {
public:
void dfs(TreeNode* root, vector<int> &ans){
if(!root)
return;
dfs(root->left,ans);
dfs(root->right,ans);
ans.push_back(root->val);
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> ans;
dfs(root,ans);
... | ALGO | 0.999969 | 6.069303 |
0c861793-7021-4940-b66d-469c1e82e31d | madhav-bits/Coding_Practice | leetArrWithElemNotEqAvgNeigh.cpp | /*
*
//*******************************************1968. Array With Elements Not Equal to Average of Neighbors.******************************************
https://leetcode.com/problems/array-with-elements-not-equal-to-average-of-neighbors/
*******************************************************************TEST CASES:**... | ALGO | 0.999991 | 5.670377 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.