API tools faq
paste
Advertisement
Rofyda_Elghadban1

Untitled

Rofyda_Elghadban1
Mar 9th, 2024
788
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 8.17 KB | None | 0 0
raw download clone embed print report
  1.  #include <bits/stdc++.h>
  2.  #define ll long long
  3.  #define ull unsigned long long
  4.  #define pi 3.141592654
  5.  #define NUM 1e18
  6.  #define Mod  1'000'000'007
  7.  #define fixed(n) fixed<<setprecision(n)
  8.  #define cin(v) for(auto &i:v) cin >> i ;
  9.  #define cout(v) for(auto &i:v) cout << i  <<" ";
  10.  #define vowel(x) (x=='e'||x=='a'||x=='i'||x=='o'||x=='u')
  11.  #define small(x) (x>=97&&x<=122)
  12.  #define capital(x) (x>=65&&x<=90)
  13.  #define Tolower(s) transform(s.begin(),s.end(),s.begin(),::tolower);
  14.  #define Toupper(s) transform(s.begin(),s.end(),s.begin(),::toupper);
  15.  #define sz(x) (int)(x.size())
  16.  #define all(v) ((v).begin()), ((v).end())
  17.  #define allr(v) ((v).rbegin()), ((v).rend())
  18.  #define updmax(a,b) a=max(a,b)
  19.  #define updmin(a,b) a=min(a,b)
  20.  #define ceil(a,b) ((a/b)+(a%b?1:0))
  21.  /* asc -> 1 2 3 ,des -> 3 2 1 */
  22.  /******************************************************************************/
  23.  using namespace std;
  24.  void Rofyda_Elghadban(){
  25.   #ifndef ONLINE_JUDGE  
  26.     freopen("input.txt", "r", stdin), freopen("output.txt", "w", stdout);
  27.    #endif
  28.     ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
  29.  }
  30.  /******************************************************************************/
  31.  /*Monotonic Stack "Next Greater Element" Zero base*/
  32.  vector<int>monotonic_stack(int n,vector<int>&v){
  33.   int sz=v.size();
  34.   vector<int>ans(sz);
  35.   for(int i=0;i<ans.size();i++){
  36.     ans[i]=-1;
  37.   }
  38.   stack<int>s;
  39.   s.push(0);
  40.   int i=1;
  41.   while(i<v.size()){
  42.     while(s.size()!=0&&v[s.top()]<v[i]){
  43.       ans[s.top()]=i;
  44.       s.pop();
  45.     }
  46.     s.push(i);
  47.     i++;
  48.   }
  49.   return ans;
  50.  }
  51.  /******************************************************************************/
  52.  /*Monotonic Stack "Next Smaller Element" Zero base*/
  53.  vector<int>monotonic_stack(int n,vector<int>&v){
  54.   int sz=v.size();
  55.   vector<int>ans(sz);
  56.   for(int i=0;i<ans.size();i++){
  57.     ans[i]=-1;
  58.   }
  59.   stack<int>s;
  60.   s.push(0);
  61.   int i=1;
  62.   while(i<v.size()){
  63.     while(s.size()!=0&&v[s.top()]>v[i]){
  64.       ans[s.top()]=i;
  65.       s.pop();
  66.     }
  67.     s.push(i);
  68.     i++;
  69.   }
  70.   return ans;
  71.  }
  72.  /******************************************************************************/
  73.  /*Monotonic Stack "Previous Smaller Element" Zero base*/
  74.  vector<int>monotonic_stack(int n,vector<int>&v){
  75.   int sz=v.size();
  76.   vector<int>ans(sz);
  77.   for(int i=0;i<ans.size();i++){
  78.     ans[i]=-1;
  79.   }
  80.   stack<int>s;
  81.   s.push(v.size()-1);
  82.   int i=v.size()-1;
  83.   while(i>=1){
  84.     while(s.size()!=0&&v[s.top()]>v[i]){
  85.       ans[s.top()]=i;
  86.       s.pop();
  87.     }
  88.     s.push(i);
  89.     i--;
  90.   }
  91.   return ans;
  92.  }
  93.  /******************************************************************************/
  94.  /*Monotonic Stack "Previous Greater Element" Zero base*/
  95.  vector<int>monotonic_stack(int n,vector<int>&v){
  96.   int sz=v.size();
  97.   vector<int>ans(sz);
  98.   for(int i=0;i<ans.size();i++){
  99.     ans[i]=-1;
  100.   }
  101.   stack<int>s;
  102.   s.push(v.size()-1);
  103.   int i=v.size()-1;
  104.   while(i>=1){
  105.     while(s.size()!=0&&v[s.top()]<v[i]){
  106.       ans[s.top()]=i;
  107.       s.pop();
  108.     }
  109.     s.push(i);
  110.     i--;
  111.   }
  112.   return ans;
  113.  }
  114.  /******************************************************************************/
  115.  ll gcd(ll num1,ll num2){
  116.   while(num2!=0){
  117.     ll temp=num1;
  118.     num1=num2;
  119.     num2=temp%num1;
  120.   }
  121.   return num1;
  122.  }
  123.  /******************************************************************************/
  124.  ll lcm(ll num1,ll num2){
  125.   return(num1/gcd(num1,num2))*num2;
  126.  }
  127.  /******************************************************************************/
  128.  bool prime(ll n){
  129.   if(n<2){
  130.     return false;
  131.   }for(ll i=2;i<=n/i;i++){
  132.     if(n%i==0){
  133.       return false;
  134.     }
  135.   }
  136.   return true;
  137.  }
  138.  /******************************************************************************/
  139.  vector<int>factors(int n){
  140.   vector<int>v;
  141.   for(int i=1;i<=n/i;i++){
  142.     if(n%i==0){
  143.       v.push_back(i);
  144.       if(i!=n/i){
  145.         v.push_back(n/i);
  146.       }
  147.     }
  148.   }
  149.   return v;
  150.  }
  151.  /******************************************************************************/
  152.  vector<int>prime_factors(int n){
  153.   vector<int>v;
  154.   for(int i=2;i<=n/i;i++){
  155.     while(n%i==0){
  156.       n/=i;
  157.       v.push_back(i);
  158.     }
  159.   }
  160.   if(n!=1){
  161.     v.push_back(n);
  162.   }
  163.   return v;
  164.  }
  165.  /******************************************************************************/
  166.  void binary(ll n){
  167.   ll x=n;
  168.   string s="";
  169.   while(n>0){
  170.     if(n%2==0){
  171.       s+=to_string(0);
  172.     }else{
  173.       s+=to_string(1);
  174.     }
  175.     n/=2;
  176.   }
  177.   ll sum=0;
  178.   for(int i=0;i<s.size();i++){
  179.     sum+=s[i]-'0';
  180.   }
  181.   if(x%sum==0){
  182.     cout<<"YES"<<endl;
  183.   }else{
  184.     cout<<"NO"<<endl;
  185.   }
  186.  }
  187.  /******************************************************************************/
  188.  /*Print num data type(__int 128)*/
  189.  void print(__int 128 x){
  190.   string num;
  191.   while(x){
  192.     num.push_back(x%10+'0');
  193.     x/=10;
  194.   }
  195.   reverse(all(num));
  196.   cout<<num<<"\n";
  197.  }
  198.  /******************************************************************************/
  199.  ll add(ll a,ll b,ll m){
  200.   return ((a%m)+(b%m))%m;
  201.  }
  202.  /******************************************************************************/
  203.  ll sub(ll a,ll b,ll m){
  204.   return ((a%m)-(b%m)+m)%m;
  205.  }
  206.  /******************************************************************************/
  207.  ll mul(ll a,ll b,ll m){
  208.   return ((a%m)*(b%m))%m;
  209.  }
  210.  /******************************************************************************/
  211.  /*MEX: is the smallest whole number that is not present in the array.*/
  212.  int mex(int n,vector<int>&v){
  213.   sort(v.begin(),v.end());
  214.   int mex=0;
  215.   for(int i=0;i<n;i++){
  216.     if(v[i]==mex){
  217.       mex++;
  218.     }
  219.   }
  220.   return mex;
  221.  }
  222.  /******************************************************************************/
  223.  /*Next_Permutation*/
  224.  vector<vector<int>>nextpermutation(int n,vector<int>&v){
  225.   ll size=1;
  226.   for(int i=1;i<=n;i++){
  227.     size*=i;
  228.   }
  229.   vector<vector<int>>ans(size);
  230.   int counter=0;
  231.   sort(v.begin(),v.end());
  232.   do{
  233.     for(int i=0;i<n;i++){
  234.       ans[counter].push_back(v[i]);
  235.     }
  236.     counter++;
  237.   }while(next_permutation(v.begin(),v.end()));
  238.   return ans;
  239.  }
  240.  /******************************************************************************/
  241.  /*Prev_Permutation*/
  242.  vector<vector<int>>prevpermutation(int n,vector<int>&v){
  243.   ll size=1;
  244.   for(int i=1;i<=n;i++){
  245.     size*=i;
  246.   }
  247.   vector<vector<int>>ans(size);
  248.   int counter=0;
  249.   sort(v.begin(),v.end());
  250.   reverse(v.begin(),v.end());
  251.   do{
  252.     for(int i=0;i<n;i++){
  253.       ans[counter].push_back(v[i]);
  254.     }
  255.     counter++;
  256.   }while(prev_permutation(v.begin(),v.end()));
  257.   return ans;
  258.  }
  259.  /******************************************************************************/
  260.  /*Kadane max sum of contiguous subarray*/
  261.  ll kadane_max_sum(int n,vector<int>&v){
  262.   ll sum=0,ans=LLONG_MIN;
  263.   for(int i=0;i<n;i++){
  264.     sum+=v[i];
  265.     ans=max(ans,sum);
  266.     sum=max(sum,0ll);
  267.   }
  268.   return ans;
  269.  }
  270.  /******************************************************************************/
  271.  /*Kadane min sum of contiguous subarray*/
  272.  ll kadane_min_sum(int n,vector<int>&v){
  273.   ll sum=0,ans=LLONG_MAX;
  274.   for(int i=0;i<n;i++){
  275.     sum+=v[i];
  276.     ans=min(ans,sum);
  277.     sum=min(sum,0ll);
  278.   }
  279.   return ans;
  280.  }
  281.  /******************************************************************************/
  282.  /*Seive of eratosthenes*/
  283.  bool composite[n+1];
  284.  void sieve(){
  285.   composite[0]=composite[1]=1;
  286.   for(ll i=2;i<=n/i;i++){
  287.     if(composite[i]!=1){
  288.       for(int j=i*i;j<=n;j+=i){
  289.         composite[j]=1;
  290.       }
  291.     }
  292.   }
  293.  }
  294.  /******************************************************************************/
  295.  /*n->number, x->power*/
  296.  int bin_exp(int n,int x){
  297.   int res=1;
  298.   while(x>0){
  299.     if(x%2==1){
  300.       res*=x;
  301.     }
  302.     n*=n;
  303.     x/=2;
  304.   }
  305.   return res;
  306.  }
  307.  /******************************************************************************/
  308.  /* (n*n)->long long,int "%m" */
  309.  int modular_exp(int n,int x,int m){
  310.   int res=1;
  311.   while(x>0){
  312.     if(x%2==1){
  313.       res=(res*n)%m;
  314.     }
  315.     n=(n%m*n%m)%m;
  316.     x/=2;
  317.   }
  318.   return res;
  319.  }
  320.  /******************************************************************************/
  321.  void solve(){
  322.  
  323.  }
  324.  
  325.  int main(){
  326.   Rofyda_Elghadban();
  327.   int t=1;  
  328.   // cin>>t;
  329.   while(t--){
  330.     solve();
  331.   }
  332.   return 0;
  333.  }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!