int maxRotateFunction(vector<int>& A) { int len = A.size(); if(len < 2) return 0; int sum = 0; for(int i = 0; i < len; ++ i) sum += A[i]; vector<int> nums(len); for(int i = 0; i < len; ++ i) nums[i] = sum - A[i]; int last = 0; for(int i = 0; i < len; ++ i) last += i * A[i]; int res = last; for(int i = 1; i < len; ++ i) { int f = last + nums[len - i] - (len - 1) * A[len - i]; res = std::max(f, res); last = f; } return res; }
int main() { Solution s; vector<int> nums({1, 3, 5, 5}); cout << s.containsDuplicate(nums) << endl; return 0; }
int main(){ int arr[] = {3,2,1,5,4,2}; vector<int> nums(arr, arr + sizeof(arr) / sizeof(int)); bubble_sort(nums); print_int(nums); return 0; }
vector<TreeNode*> generateTrees(int n) { vector<int> nums(n); for (int i=0; i<n; ++i) { nums[i] = i + 1; } return generateTrees(nums, 0, n); }
int testCase0() { int a[] = {1,0,2,1,0,2}; vector<int> nums(a, a + sizeof a / sizeof a[0]); sortColors(nums ); return 0; }
int main() { int n; cin >> n; vector<int> nums(n); for (int i = 0; i < n; ++i) { int a; cin >> a; nums[i] = a; } Solution s; vector<vector<int> > result = s.subsets(nums); for (int i = 0; i < result.size(); ++i) { for (int j = 0; j < result[0].size(); ++j) { cout << result[i][j] << " "; } cout << endl; } system("pause"); return 0; }
// s1: sort (same thought as others ) // o(1) SPACE, o(nlogn) time vector<int> twoSum_1(vector<int> &numbers, int target){ vector<int> res; if (nums.empty()) { return res; } int N = nums.size(); if (N < 2) { return res; } vector<pair<int, int>> nums(N); // initialize with size n for(int i = 0; i < N; i++){ nums[i] = make_pair(numbers[i], i+1); } sort(nums.begin(), nums.end(), compare); int l = 0, r = N - 1; while(l < r){ int sum = nums[l].first + nums[r].first; if(sum < target) l++; else if(sum > target) r--; else { res.push_back(min(nums[l].second, nums[r].second)); // min !!! res.push_back(max(nums[l].second, nums[r].second)); // max break; } } return res; }
void AtomContainer::calculateGrainProperties() { AtomID id; std::vector<std::vector<double>> grainProperties(grains->getNumGrains()); std::vector<int > nums (grains->getNumGrains(),0); //initialize with zeroes for (long iG = 0; iG < grains->getNumGrains(); iG++){ grainProperties[iG].resize(atomPropertyList.getNumProperties(),0.0); } AtomBox * box; gID grainId; int iP; //for each grain sum up all values for each corresponding atom for (id.iB = 0; id.iB < nBoxes; id.iB++){ box = boxes + id.iB; for (id.iA = 0; id.iA < box->getNumAtoms(); id.iA++){ grainId = box->getAtom(id.iA)->getGrainId(); if (grainId >= 0) { for (iP = 0; iP < atomPropertyList.getNumProperties(); iP++){ grainProperties[grainId][iP] += getAtomsProperty(iP,id); } } } } //calculate the average value Grain * grain; for (long iG = 0; iG < grains->getNumGrains(); iG++){ grain = grains->getGrain(iG); for (iP = 0; iP < atomPropertyList.getNumProperties(); iP++){ grainProperties[iG][iP] /= grain->getNumberOfAtoms(); } grain->setProperties(grainProperties[iG]); } }
int main(){ int arr[] = {3,2,1,5,4,2,1,2}; vector<int> nums(arr, arr + sizeof(arr) / sizeof(int)); quicksort(nums, 0, nums.size()-1); print_int(nums); return 0; }
int sumNumbers(TreeNode *root) { int sum = 0; int cur = 0; if (root != NULL) { nums(root, cur, sum); } return sum; }
int main(){ int arr[] = {3,2,1,5,6,4}; vector<int> nums(arr, arr + sizeof(arr) / sizeof(int)); for(int i=1; i<=nums.size(); i ++){ cout<<findKthLargest(nums, i)<<endl; } return 0; }
void FindDuplicate::TestClass() { int Array[7]={1,3,5,2,6,3,7}; vector<int> nums(Array,Array+7); //FastSort(Array,7,0,6); cout<<findDuplicate(nums)<<endl; }
vector<TreeNode*> generateTrees(int n) { if (n == 0) return vector<TreeNode*>(); vector<int> nums(n, 0); for (int i = 0; i < n; i++) { nums[i] = i + 1; } return helper(nums, 0, n - 1); }
int numTrees(int n){ vector<int> nums(n+1,0); nums[0]=nums[1]=1; for(int i=2;i<=n;i++) for(int j = 0;j<i;j++){ nums[i] += nums[j]*nums[i-j-1]; } return nums[n]; }
/* void nextPermutation(std::vector<int>& nums) { for(int i = 0; i < nums.size(); i++) { printf(""); } } */ int main(int argc, char **argv) { // printf("HEllo\n"); std::vector<int> nums(3); nums[0] = 1; nums[1] = 2; nums[2] = 3; permutation(nums); return(0); }
int main(void) { Solution s; Utils u; int iarr [] = {4, 5, 1, 2 ,3}; vector<int> nums(iarr, iarr + sizeof(iarr) / sizeof(iarr[0])); s.recoverRotatedSortedArray(nums); u.printIntVector(nums); return 0; };
int main(){ //int array[]={1,17,5,10,13,15,10,5,16,8}; //vector<int>nums(array,array+10); int array[]={5,3,3,2,5}; vector<int>nums(array,array+5); Solution*s=new Solution; cout<<s->wiggleMaxLength(nums)<<endl; return 0; }
int main() { int data[]{ 1,2,3 }; vector<int> nums(data, data + sizeof(data) / sizeof(int)); Solution test; test.permute(nums); return 0; }
int totalNQueens(int n) { std::vector<bool> d1(2 * n - 1, false); std::vector<bool> d2(2 * n - 1, false); std::vector<bool> nums(n, false); int result = 0; int size = 0; solve_n_queues_process(n, size, d1, d2, nums, result); return result; }
int main() { Solution solution; { int arr[] = {100, 4, 200, 1, 3, 2}; std::vector<int> nums(arr, arr + 6); std::cout << solution.longestConsecutive(nums) << std::endl; } return 0; }
int main(void) { Solution s; int iarr [] = {1, 2, 3, 3, 4, 5, 6, 7, 9, 10}; vector<int> nums(iarr, iarr + sizeof(iarr) / sizeof(iarr[0])); cout << s.binarySearch(nums, 3) << endl; cout << s.binarySearch(nums, 1) << endl; cout << s.binarySearch(nums, 10) << endl; cout << s.binarySearch(nums, 8) << endl; return 0; }
int candy(vector<int>& ratings) { int len = ratings.size(); vector<int> nums(len,0); for(int i = 1; i < len; ++i) if(ratings[i - 1] < ratings[i]) nums[i] = nums[i - 1] + 1; for(int i = len - 2; i >= 0; --i) if (ratings[i] > ratings[i + 1]) nums[i] = max(nums[i], nums[i + 1] + 1); return accumulate(nums.begin(), nums.end(), len); }
vector<TreeNode *> generateTrees(int n) { vector<TreeNode*> result; if (n == 0) return vector<TreeNode*> {nullptr}; vector<int> nums(n, 0); for (int i = 0; i < n; ++i) nums[i] = i + 1; buildTree(&nums[0], nums.size(), [&](TreeNode *node) { result.push_back(node); }); return result; }
void nums(TreeNode* root, int &cur, int& num) { if (root->left == NULL && root->right == NULL) { cur = cur*10 + root->val; num += cur; return; } else if (root->left != NULL && root->right == NULL) { cur = cur*10 + root->val; nums(root->left, cur, num); } else if (root->right != NULL && root->left == NULL) { cur = cur*10 + root->val; nums(root->right, cur, num); } else { cur = cur*10 + root->val; int tmp = cur; nums(root->left, cur, num); cur = tmp; nums(root->right, cur, num); } }
int main(int argc, const char * argv[]) { // vector<int> nums({0,1,3}); vector<int> nums({1}); Solution a; a.missingNumber(nums); return 0; }
int numTrees(int n) { if (n < 1) return 0; vector<int> cnts(n+1, -1); cnts[0] = 1; cnts[1] = 1; vector<int> nums(n); for (int i = 0; i < n; ++i) nums[i] = i; int result = count(nums, nums.begin(), nums.end()-1, cnts); return result; }
int nthUglyNumber(int n) { vector<int> nums(n, 0); nums[0] = 1; int index2 = 0, index3 = 0, index5 = 0; for(int i = 1; i < n; ++i){ nums[i] = min(min(nums[index2] * 2, nums[index3] * 3), nums[index5] * 5); if(nums[index2] * 2 == nums[i]) index2++; if(nums[index3] * 3 == nums[i]) index3++; if(nums[index5] * 5 == nums[i]) index5++; } return nums[n - 1]; }
int countNumbersWithUniqueDigits(int n) { vector<int> nums(n + 1, 0); nums[0] = 1; if (n >= 1) nums[1] = 9; for (int i = 2; i <= n; i++) { nums[i] = nums[i - 1] * max(0, 11 - i); } for (int i = 1; i <= n; i++) { nums[i] += nums[i - 1]; } return nums[n]; }
int main(){ int arr[] = {1,2,1,2}; vector<int> nums(arr, arr + sizeof(arr) / sizeof(int)); print_int(nums); merge_sort(nums); print_int(nums); // print_int(nums); // merge(nums, 0, nums.size()/2 , nums.size()-1); // print_int(nums); return 0; }
std::size_t BDDCalculator::findOptimalVar(const DisForm &df) { std::size_t conjSize = df.m_conjuncts[0].m_pos.size(); std::vector<std::size_t> nums(conjSize, 0); for(std::size_t i=0; i<df.m_conjuncts.size(); i++) { for(std::size_t j=0; j<conjSize; j++) if(df.m_conjuncts[i].m_pos.test(j) || df.m_conjuncts[i].m_neg.test(j)) nums[j]++; } std::size_t position = std::max_element(nums.begin(), nums.end()) - nums.begin(); return position; }