fork download
copy 
  1. #pragma GCC optimize("Ofast")
  2. #pragma GCC optimize("unroll-loops")
  3. #pragma GCC optimize("inline")
  4. #include<bits/stdc++.h>
  5. using namespace std;
  6. #define MD (1000000007U)
  7. struct Modint{
  8.   unsigned val;
  9.   Modint(){
  10.     val=0;
  11.   }
  12.   Modint(int a){
  13.     val = ord(a);
  14.   }
  15.   Modint(unsigned a){
  16.     val = ord(a);
  17.   }
  18.   Modint(long long a){
  19.     val = ord(a);
  20.   }
  21.   Modint(unsigned long long a){
  22.     val = ord(a);
  23.   }
  24.   inline unsigned ord(unsigned a){
  25.     return a%MD;
  26.   }
  27.   inline unsigned ord(int a){
  28.     a %= (int)MD;
  29.     if(a < 0){
  30.       a += MD;
  31.     }
  32.     return a;
  33.   }
  34.   inline unsigned ord(unsigned long long a){
  35.     return a%MD;
  36.   }
  37.   inline unsigned ord(long long a){
  38.     a %= (int)MD;
  39.     if(a < 0){
  40.       a += MD;
  41.     }
  42.     return a;
  43.   }
  44.   inline unsigned get(){
  45.     return val;
  46.   }
  47.   inline Modint &operator++(){
  48.     val++;
  49.     if(val >= MD){
  50.       val -= MD;
  51.     }
  52.     return *this;
  53.   }
  54.   inline Modint &operator--(){
  55.     if(val == 0){
  56.       val = MD - 1;
  57.     }
  58.     else{
  59.       --val;
  60.     }
  61.     return *this;
  62.   }
  63.   inline Modint operator++(int a){
  64.     Modint res(*this);
  65.     val++;
  66.     if(val >= MD){
  67.       val -= MD;
  68.     }
  69.     return res;
  70.   }
  71.   inline Modint operator--(int a){
  72.     Modint res(*this);
  73.     if(val == 0){
  74.       val = MD - 1;
  75.     }
  76.     else{
  77.       --val;
  78.     }
  79.     return res;
  80.   }
  81.   inline Modint &operator+=(Modint a){
  82.     val += a.val;
  83.     if(val >= MD){
  84.       val -= MD;
  85.     }
  86.     return *this;
  87.   }
  88.   inline Modint &operator-=(Modint a){
  89.     if(val < a.val){
  90.       val = val + MD - a.val;
  91.     }
  92.     else{
  93.       val -= a.val;
  94.     }
  95.     return *this;
  96.   }
  97.   inline Modint &operator*=(Modint a){
  98.     val = ((unsigned long long)val*a.val)%MD;
  99.     return *this;
  100.   }
  101.   inline Modint &operator/=(Modint a){
  102.     return *this *= a.inverse();
  103.   }
  104.   inline Modint operator+(Modint a){
  105.     return Modint(*this)+=a;
  106.   }
  107.   inline Modint operator-(Modint a){
  108.     return Modint(*this)-=a;
  109.   }
  110.   inline Modint operator*(Modint a){
  111.     return Modint(*this)*=a;
  112.   }
  113.   inline Modint operator/(Modint a){
  114.     return Modint(*this)/=a;
  115.   }
  116.   inline Modint operator+(int a){
  117.     return Modint(*this)+=Modint(a);
  118.   }
  119.   inline Modint operator-(int a){
  120.     return Modint(*this)-=Modint(a);
  121.   }
  122.   inline Modint operator*(int a){
  123.     return Modint(*this)*=Modint(a);
  124.   }
  125.   inline Modint operator/(int a){
  126.     return Modint(*this)/=Modint(a);
  127.   }
  128.   inline Modint operator+(long long a){
  129.     return Modint(*this)+=Modint(a);
  130.   }
  131.   inline Modint operator-(long long a){
  132.     return Modint(*this)-=Modint(a);
  133.   }
  134.   inline Modint operator*(long long a){
  135.     return Modint(*this)*=Modint(a);
  136.   }
  137.   inline Modint operator/(long long a){
  138.     return Modint(*this)/=Modint(a);
  139.   }
  140.   inline Modint operator-(void){
  141.     Modint res;
  142.     if(val){
  143.       res.val=MD-val;
  144.     }
  145.     else{
  146.       res.val=0;
  147.     }
  148.     return res;
  149.   }
  150.   inline operator bool(void){
  151.     return val!=0;
  152.   }
  153.   inline operator int(void){
  154.     return get();
  155.   }
  156.   inline operator long long(void){
  157.     return get();
  158.   }
  159.   inline Modint inverse(){
  160.     int a = val;
  161.     int b = MD;
  162.     int u = 1;
  163.     int v = 0;
  164.     int t;
  165.     Modint res;
  166.     while(b){
  167.       t = a / b;
  168.       a -= t * b;
  169.       swap(a, b);
  170.       u -= t * v;
  171.       swap(u, v);
  172.     }
  173.     if(u < 0){
  174.       u += MD;
  175.     }
  176.     res.val = u;
  177.     return res;
  178.   }
  179.   inline Modint pw(unsigned long long b){
  180.     Modint a(*this);
  181.     Modint res;
  182.     res.val = 1;
  183.     while(b){
  184.       if(b&1){
  185.         res *= a;
  186.       }
  187.       b >>= 1;
  188.       a *= a;
  189.     }
  190.     return res;
  191.   }
  192.   inline bool operator==(int a){
  193.     return ord(a)==val;
  194.   }
  195.   inline bool operator!=(int a){
  196.     return ord(a)!=val;
  197.   }
  198. }
  199. ;
  200. inline Modint operator+(int a, Modint b){
  201.   return Modint(a)+=b;
  202. }
  203. inline Modint operator-(int a, Modint b){
  204.   return Modint(a)-=b;
  205. }
  206. inline Modint operator*(int a, Modint b){
  207.   return Modint(a)*=b;
  208. }
  209. inline Modint operator/(int a, Modint b){
  210.   return Modint(a)/=b;
  211. }
  212. inline Modint operator+(long long a, Modint b){
  213.   return Modint(a)+=b;
  214. }
  215. inline Modint operator-(long long a, Modint b){
  216.   return Modint(a)-=b;
  217. }
  218. inline Modint operator*(long long a, Modint b){
  219.   return Modint(a)*=b;
  220. }
  221. inline Modint operator/(long long a, Modint b){
  222.   return Modint(a)/=b;
  223. }
  224. template<class T, class S> inline T pow_L(T a, S b){
  225.   T res = 1;
  226.   res = 1;
  227.   for(;;){
  228.     if(b&1){
  229.       res *= a;
  230.     }
  231.     b >>= 1;
  232.     if(b==0){
  233.       break;
  234.     }
  235.     a *= a;
  236.   }
  237.   return res;
  238. }
  239. inline double pow_L(double a, double b){
  240.   return pow(a,b);
  241. }
  242. #define main dummy_main
  243. int main(){
  244.   return 0;
  245. }
  246. #undef main
  247. class Solution{
  248.   public:
  249.   int minNonZeroProduct(int p){
  250.     return Modint((1LL<<p)-1) * ((pow_L((Modint((1LL<<p)-2)),((1LL<<(p-1))-1))));
  251.   }
  252. }
  253. ;
  254. // cLay version 20210816-1
  255.  
  256. // --- original code ---
  257. // #define main dummy_main
  258. // {}
  259. // #undef main
  260. // 
  261. // class Solution {
  262. // public:
  263. //   int minNonZeroProduct(int p) {
  264. //     return Modint((1LL<<p)-1) * ((Modint((1LL<<p)-2)) ** ((1LL<<(p-1))-1));
  265. //   }
  266. // };
  267.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/Scrt1.o: in function `_start':
(.text+0x20): undefined reference to `main'
collect2: error: ld returned 1 exit status
stdout
copy 
Standard output is empty
https://ideone.com/VPiZlZ
language:
C++ (gcc 8.3)
created:
2 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!