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;
}
