意思是用各種包含 114514 的數字加上 0 和省略後不影響 114514 完整表述的運算符號可以表示出任何自然數。

例如 114 - 5 × 14 = 34。

在表示時可以有 0。

歡迎硬核HOMO答題。

雖然不可以，但是有辦法變成可以，我們先把各位數相加，就算是999999999也才81，可以盡量向100內的數字靠，然後...

0=1+1-4+5+1-4

1=1+1*4*(5-1-4)

2=1+1+4*(5-1-4)

3=1+1*4-5-1+4

4=1+1+4-5-1+4

5=1+1+4-5+1*4

6=1+1+4+5-1-4

7=1+1+4+5-1*4

8=1+1+4+5+1-4

9=1+1*4*(5+1-4)

10=1+1+4*(5+1-4)

11=1+1+45/(1+4)

12=1+1*(45-1)/4

13=1+1-4-5*(1-4)

14=1+1+4+5-1+4

15=1+1+4+5+1*4

16=1+1+4+5+1+4

17=1+1+4*5-1-4

18=1+1+4*5-1*4

19=1+1+4*5+1-4

20=1+1*4-5*(1-4)

21=1+1+4-5*(1-4)

22=1+1+4+(5-1)*4

23=1+1+4*(5+1/4)

24=1+1*4+5+14

25=1+1+4+5+14

26=1+1+4+5*1*4

27=1+1+4*5+1+4

28=1-1+4+(5+1)*4

29=1+1*4+(5+1)*4

30=1+1+4+(5+1)*4

31=1+1+4+5*(1+4)

32=1+1*45-14

33=1+1+45-14

34=1+1+4*(5-1+4)

35=1+1*4*5+14

36=1+1+4*5+14

37=1+1*4*(5+1*4)

38=1+1+4*(5+1*4)

39=1+14+(5+1)*4

40=1+14+5*(1+4)

41=1+1*45-1-4

42=1+1+45-1-4

43=1+1+45-1*4

44=1+1+45+1-4

45=1+1-4+51-4

46=1+1*(4+5)*(1+4)

47=1+1+(4+5)*(1+4)

48=1-1+45-1+4

49=1+1*45-1+4

50=1+1+45-1+4

51=1+1+45+1*4

52=1+1+45+1+4

53=1+1+4+51-4

54=11-4+51-4

55=11*4*5*1/4

56=1*14*5-14

57=1+14*5-14

58=1+(1-4*5)*(1-4)

59=1-1+4+51+4

60=1+1*4+51+4

61=1+1+4+51+4

62=1+1-4*5*(1-4)

63=11*4+5+14

64=1-1+4*(5-1)*4

65=1+1*4*(5-1)*4

66=1+1+4*(5-1)*4

67=1+14*5-1*4

68=1+1-4+5*14

69=1*14+51+4

70=1+14+51+4

71=11-4*5*(1-4)

72=1*(14+5-1)*4

73=1*14*5-1+4

74=1+14*5-1+4

75=1+1*4+5*14

76=1+1+4+5*14

77=1+1*4*(5+14)

78=1+1+4*(5+14)

79=-(1-1*4*5*1*4)

80=1-1+4*5*1*4

81=1+1*4*5*1*4

82=1+1+4*5*1*4

83=-(1-14-5*14)

84=1-1+(4*5+1)*4

85=1+14+5*14

86=1+1+(4*5+1)*4

87=11+4*(5+14)

88=1*14*(5+1)+4

89=1+14*(5+1)+4

90=114-(5+1)*4

91=11+4*5*1*4

92=11*(4+5-1)+4

93=-(11+4*5)*(1-4)

94=114-5*1*4

95=114-5-14

96=1-1+4*(5+1)*4

97=1+1*4*(5+1)*4

98=1+1+4*(5+1)*4

99=11*4+51+4

100=1-1+4*5*(1+4)

100以後還能保持連續的

101 = 1+1*4*5*(1+4)

102 = 1+1+4*5*(1+4)

103 = 11*(4+5*1)+4

104 = 114-5-1-4

105 = 114+5-14

106 = 114-5+1-4

107 = 11+4*(5+1)*4

108 = 114-5-1^4

109 = 114-5*1^4

110 = 114-5+1^4

111 = 11+4*5*(1+4)

112 = 1*14*(5-1+4)

113 = 1+14*(5-1+4)

114 = 11*4+5*14

115 = 114+5-1*4

116 = 114+5+1-4

117 = -(1-14)*(5+1*4)

118 = 114+5-1^4

119 = 114+5*1^4

120 = 114+5+1^4

121.0 = 11*(45-1)/4

122 = 114+5-1+4

123 = 114+5+1*4

124 = 114+5+1+4

125 = 1*(1+4)*5*(1+4)

126 = 1-1+(4+5)*14

127 = 1+14*(5+1*4)

128 = 1+1+(4+5)*14

129 = 114-5*(1-4)

130 = 114+(5-1)*4

131 = 1*145-14

132 = 1+145-14

133 = 114+5+14

134 = 114+5*1*4

135 = 1-1-45*(1-4)

136 = 1-1*45*(1-4)

137 = 1+1-45*(1-4)

138 = 114+(5+1)*4

139 = 114+5*(1+4)

140 = 1*145-1-4

141 = 1+145-1-4

142 = 1+145-1*4

143 = 1+145+1-4

144 = 1*145-1^4

145 = 1+145-1^4

146 = 1+145*1^4

147 = 1+145+1^4

148 = 1*145-1+4

149 = 1+145-1+4

150 = 1+145+1*4

151 = 1+145+1+4

152 = (1+1)*4*(5+14)

153.0 = (1-1/4)*51*4

154 = 11*(4+5+1+4)

155 = (11+4*5)*(1+4)

156 = -(1+(1-4)*51-4)

157 = -(1-1*4)*51+4

158 = 1-(1-4)*51+4

159 = 1*145+14

160 = 1+145+14

161 = 114+51-4

upd：證明有點問題，改了一下，對不起大家，我什麼都會做的（悲

感謝大家的修正！ありがとナス！

完全可以。事實上，就算只用初等的數學記號，我們也完全可以將任何自然數只用這六個數字表示出來。我個人喜歡將它稱作

田所引理（Tadokoros Lemma）任意自然數可只用「1、1、4、5、1、4」及對數、根號、加號、減號表示。

證明 注意到對任意自然數 [公式] ，我們有

[公式]

將其中的三個 [公式] 分別用 [公式] ， [公式] ， 5＋1－4，可得

[公式]

[公式] （絕望）

順便，由這個定理，我們可以推得以下的定理：

下北沢第一定理（Shimokitazawas First Theorem， 簡記為dssq定律 (Law of DSSQ)） 一切物質皆為野獸先輩（絕望）

證明 不妨設這個物質有英文名（如果沒有英文名但有名字，則將其名字讀音用拉丁字母表示作為英文名；如果連名字都沒有，就隨便給它起個名（錯亂））那麼

  • 每個英文字母都有其唯一的ASCII編號
  • 因此該英文名可以用其對應的ASCII編號表示
  • 每個ASCII編號都是8位二進位數，二進位數前面可以保留0
  • 因此將這些二進位數從頭到尾拼起來，可以得到一個很長的數字
  • 將這個數字轉化為十進位數，則每個名字可以唯一對應一個十進位數，我們稱其為這個名字的「特徵值（eigenvalue）」
  • 由田所引理，任意一個特徵值可只用「1、1、4、5、1、4」及根號、加號、減號表示
  • 結合特徵值的唯一確定性，可知該英文名可以如此表示
  • 因此，該物質可以這樣表示
  • 於是，該物質可以被數字論證，故它是野獸先輩（絕望）

[公式] （噔噔咚）

那麼現在，無論你我，無論花草樹朩，都已經被數字論證為野獸先輩了。這，不正是好時代罵！

好時代，來臨罷！

以上（悲なしいな）

後人解碼相關影片時，才發現114514猜想的奧妙所在：0是多餘的

[公式]

全自動數字論證機（迫真）

不知道大家有沒有看過《詩云》？既然無法想到某些表示法，那麼就把所有的可能列出來罷！（狂喜）

眾所周知，OIer都事HOMO。本小鬼在以前暑假集訓無聊的時候剛好寫過一個數字論證搜索。幸運的是，只用1，1，4，5，1，4排列+括弧+加減乘除冪階乘所能表示的所有可能也就是一個G左右，篩選之後更是只有1.3M，我們就可以很快地查詢力

由於python我沒怎麼用過，所以還是用的c++寫的，並且事在晚上訂正完考試寫的，所以稍微有些麻煩。

以下是代碼，想看效果的請直接跳到最後，謝謝茄子！

資料庫生成

大體思路就事生成一個排列，然後通過現成的計算器生成答案並且保存。

生成排列

dfs即可。代碼如下，主要用棧模擬

#include&
#include&
#include&
#include&
#include&
#include&
#include&
#include&
#include&
#pragma -g -std=c++11
using namespace std;
int t=0;
const int num[7]={0,1,1,4,5,1,4};
char s[10]={0,+,-,*,/,^,!};
const int mulj[4][7]={{0,0,0,0,0,0,0},{0,1,1,2,1,1,2},{0,0,0,4,2,0,4},{0,0,0,0,0,0,0}};
const int lenj[7]={0,1,1,2,3,1,2};
string ss;
int maxn=0;
int numb=0;
stack&ans;
const int MAX = 30;
const int DONE = 1;

//棧定義
template &
class Stack{
public:
Stack(int MaxStackSize=10);
~Stack() { delete [] stack;}
bool IsEmpty() const {return top==-1;}
bool IsFull() const {return top==MaxTop;}
T Top() const;
Stack& Add(const T x);
Stack& Del(T x);
void MakeEmpty(){top=-1;} //清空棧
void print(){
for(int i; i &< top + 1; i ++){ cout&
Stack&::Stack(int MaxStackSize){
MaxTop=MaxStackSize-1;
stack=new T[MaxStackSize];
top=-1;
}
template&
Stack& Stack&::Add(const T x){
if(IsFull())
{cout&
Stack& Stack&::Del(T x){
if(IsEmpty())
{cout&
T Stack&::Top() const{
return stack[top];
}

//判斷一個字元是否為數字
bool isNum(char c){
if((c &> 0||c == 0)(c &< 9||c == 9)) return true; else return false; } //刪除字元串中的空格 void deleteBlank(string s){ string::iterator i = s.begin(); while ((i=find(i, s.end(), ))!=s.end()) s.erase(i); } //計算器 class Calculator{ public: Calculator(string s); ~Calculator(); int outPriority(char); //返回棧外優先順序 int inPriority(char); //返回棧內優先順序 bool judgePri(char, char); //判斷優先順序 前一個為棧外符號，後一個為棧內符號 若前大於後返回1，否則返回0 int judgePri(char); //判斷運算符 若是#返回 -1，若是)返回 0，否則返回 1 void dealNum(); //處理數據 int calculate(); //計算 void setString(string const s){ this-&>s = # + s + #;
deleteBlank(this-&>s); //刪除字元串中的空格
}
private:
Stack& *s_sym; //符號棧
Stack& *s_num; //數據棧
string s;
};
Calculator::Calculator(string s){
this-&>s = # + s + #;
deleteBlank(this-&>s);
s_sym = new Stack&(MAX);
s_num = new Stack&(MAX);
}
Calculator::~Calculator(){
delete s_sym;
delete s_num;
}
int Calculator::outPriority(char symble){
switch(symble){
case #:
return 0;
case (:
return 8;
case +:
return 2;
case -:
return 2;
case *:
return 4;
case /:
return 4;
case %:
return 4;
case ^:
return 6;
case ):
return 1;
default:
throw 1;
}
}
int Calculator::inPriority(char symble){
switch(symble){
case #:
return 0;
case (:
return 1;
case +:
return 3;
case -:
return 3;
case *:
return 5;
case /:
return 5;
case %:
return 5;
case ^:
return 7;
case ):
return 8;
default:
throw 1;
}
}
bool Calculator::judgePri(char out, char in){
if(outPriority(out) &> inPriority(in))
return true;
else
return false;
}
int Calculator::judgePri(char symble){
if(symble == #)
return -1;
else if(symble == ))
return 0;
else
return 1;
}
void Calculator::dealNum(){
//將數據棧中的前兩個彈出進行計算，結果放回數據棧，符號棧彈出頂部元素
char _temp = 0;
int dtemp1 = 0;
int dtemp2 = 0;
s_sym-&>Del(_temp);
s_num-&>Del(dtemp1);
s_num-&>Del(dtemp2);
switch(_temp){
case +:
dtemp2 += dtemp1;
break;
case -:
dtemp2 = dtemp2 - dtemp1;
break;
case *:
dtemp2 = dtemp2 * dtemp1;
break;
case /:
if(dtemp1 == 0)
throw 0;
else
dtemp2 = dtemp2 / dtemp1;
break;
case %:
dtemp2 = dtemp2 % dtemp1;
break;
case ^:
dtemp2 = pow(dtemp2,dtemp1);
break;
default:
throw 1;
}
s_num-&>Add(dtemp2);
}
int Calculator::calculate(){
for(int i = 0; i &< s.size(); i ++){ //遍歷字元串 if(isNum(s[i])){ int temp = (int)(s[i]) - 48; //char強制類型轉換為int ascii 碼數值，減 48 轉換為對應整數值 int _temp = 0; if(i &> 0 isNum(s[i - 1])){
s_num-&>Del(_temp);
temp = _temp * 10 + temp;
}
s_num-&>Add(temp);
}else{
char temp = s[i];
if(s_sym-&>IsEmpty()){
s_sym-&>Add(temp);
}else{
if(judgePri(temp, s_sym-&>Top())){
s_sym-&>Add(temp);
}else if(judgePri(temp) == 1){ //棧外優先順序小於棧內優先順序，且不為 # 和 )
while(!judgePri(temp, s_sym-&>Top())){ //當棧外優先順序比棧內優先順序低時，執行棧內符號運算
dealNum();
}
s_sym-&>Add(temp);

}else if (judgePri(temp) == -1){
while(s_sym-&>Top() != #){
dealNum();
}
int result = s_num-&>Top();
s_sym-&>MakeEmpty();
s_num-&>MakeEmpty();
return result;
}
else if(judgePri(temp) == 0){
while(s_sym-&>Top() != (){
dealNum();
}
s_sym-&>Del(temp);
}
}
}
}
}
char nnans[101];
void exc(){
stack&st;
while(!ans.empty()){
st.push(ans.top());ans.pop();
}
int rs=-1,sta=1,nnn=0;
ss="";
while(!st.empty()){
char now=st.top();ans.push(now);st.pop();
ss+=now;
}
//Calculator c("");
int po=0;int numc=0;
for(int i=0;i&st;
while(!ans.empty()){
//printf("%d
",ans.size());
char sk=ans.top();
st.push(sk);ans.pop();
}
while(!st.empty()){
char now=st.top();ans.push(now);st.pop();
printf("%c",now);
}
putchar(10);
Sleep(500);
}
void dfs(int lev){
if(lev==6){
int tmp=numb;
while(numb--){
ans.push());
}
exc();
numb=tmp;
while(tmp--){
ans.pop();
}
return;
}
lev++;
for(int i=1;i&<=5;i++){ for(int k=1;k&<=lenj[lev];k++) ans.push(mulj[k][lev]+0); if(lev!=1) ans.push()),numb--; ans.push(s[i]); ans.push((),numb++; //out(); dfs(lev); for(int k=1;k&<=lenj[lev];k++) ans.pop(); if(lev!=1) ans.pop(),numb++; ans.pop(); ans.pop(); numb--; ans.push(char(num[lev]+0)); if(lev!=1) ans.push()),numb--; ans.push(s[i]); ans.push((),numb++; //out(); dfs(lev); if(lev!=1) ans.pop(),numb++; numb--; ans.pop(); ans.pop(); ans.pop(); for(int k=1;k&<=lenj[lev];k++) ans.push(mulj[k][lev]+0); ans.push(s[i]); ans.push((),numb++; //out(); dfs(lev); for(int k=1;k&<=lenj[lev];k++) ans.pop(); ans.pop(); numb--; ans.pop(); ans.push(num[lev]+0); ans.push(s[i]); ans.push((),numb++; //out(); dfs(lev); ans.pop(); ans.pop(); ans.pop(); numb--; } return; } int main(){ freopen("1.txt","w",stdout); dfs(0); return 0; }

計算答案並輸出資料庫

去重是一個很重要的問題。用map會RE，我只開了個2e7的桶來簡單去重。並且注意到重複一般都聚集在一起（搜索的時候一些相近的生成方案），記錄當前答案之前的幾個答案即可。

#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include& using namespace std;
const char Tab=0x9;
const int DIGIT=1;
const int MAXLEN=16384;
char s[MAXLEN],*endss;
int pcs=15;
double fun(double x,char op[],int *iop) {
while (op[*iop-1]&<32) //本行使得函數嵌套調用時不必加括弧,如 arc sin(sin(1.234)) 只需鍵入arc sin sin 1.234&
switch (op[*iop-1]) {
case 7: x=sin(x); (*iop)--;break;
case 8: x=cos(x); (*iop)--;break;
case 9: x=tan(x); (*iop)--;break;
case 10: x=sqrt(x); (*iop)--;break;
case 11: x=asin(x); (*iop)--;break;
case 12: x=acos(x); (*iop)--;break;
case 13: x=atan(x); (*iop)--;break;
case 14: x=log10(x);(*iop)--;break;
case 15: x=log(x); (*iop)--;break;
case 16: x=exp(x); (*iop)--;break;
}
return x;
}
double calc(char *expr,char **addr) {
static int deep; //遞歸深度
static char *fname[]={ "sin","cos","tan","sqrt","arcsin","arccos","arctan","lg","ln","exp",NULL};
double ST[10]={0.0}; //數字棧
char op[10]={+}; //運算符棧
char c,*rexp,*pp,*pf;
int ist=1,iop=1,last,i;
if (!deep) {
pp=pf=expr;
do {
c = *pp++;
if (c!= c!=Tab)
*pf++ = c;
} while (c!= );
}
pp=expr;
if ((c=*pp)==-||c==+) {
op[0] = c;
pp++;
}
last = !DIGIT;
while ((c=*pp)!= ) {
if (c==() {//左圓括弧
deep++;
ST[ist++]=calc(++pp,addr);
deep--;
ST[ist-1]=fun(ST[ist-1],op,iop);
pp = *addr;
last = DIGIT;
if (*pp == (||isalpha(*pp) strnicmp(pp,"Pi",2)) {//目的是：當右圓括弧的右惻為左圓括弧或函數名字時，默認其為乘法
op[iop++]=*;
last = !DIGIT;
c = op[--iop];
goto operate ;
}
}
else if (c==)) {//右圓括弧
pp++;
break;
} else if (isalpha(c)) {
if (!strnicmp(pp,"Pi",2)) {
if (last==DIGIT) {
return -1;
}
ST[ist++]=3.14159265358979323846264338328;
ST[ist-1]=fun(ST[ist-1],op,iop);
pp += 2;
last = DIGIT;
if (!strnicmp(pp,"Pi",2)) {
return -1;
}
if (*pp==() {
return -1;
}
} else {
for (i=0; (pf=fname[i])!=NULL; i++)
if (!strnicmp(pp,pf,strlen(pf))) break;
if (pf!=NULL) {
op[iop++] = 07+i;
pp += strlen(pf);
} else {
return -1;
}
}
} else if (c==+||c==-||c==*||c==/||c==^) {
char cc;
if (last != DIGIT) {
return -1;
}
pp++;
if (c==+||c==-) {
do {
cc = op[--iop];
--ist;
switch (cc) {
case +: ST[ist-1] += ST[ist];break;
case -: ST[ist-1] -= ST[ist];break;
case *: ST[ist-1] *= ST[ist];break;
case /: ST[ist-1] /= ST[ist];break;
case ^: ST[ist-1] = pow(ST[ist-1],ST[ist]);break;
}
} while (iop);
op[iop++] = c;
} else if (c==*||c==/) {
operate: cc = op[iop-1];
if (cc==+||cc==-) {
op[iop++] = c;
} else {
--ist;
op[iop-1] = c;
switch (cc) {
case *: ST[ist-1] *= ST[ist];break;
case /: ST[ist-1] /= ST[ist];break;
case ^: ST[ist-1] = pow(ST[ist-1],ST[ist]);break;
}
}
} else {
cc = op[iop-1];
if (cc==^) {
return -1;
}
op[iop++] = c;
}
last = !DIGIT;
} else {
if (last == DIGIT) {
return -1;
}
ST[ist++]=strtod(pp,rexp);
ST[ist-1]=fun(ST[ist-1],op,iop);
if (pp == rexp) {
return -1;
}
pp = rexp;
last = DIGIT;
if (*pp == (||isalpha(*pp)) {
op[iop++]=*;
last = !DIGIT;
c = op[--iop];
goto operate ;
}
}
}
*addr=pp;
if (iop&>=ist) {
exit(0);
}
while (iop) {
--ist;
switch (op[--iop]) {
case +: ST[ist-1] += ST[ist];break;
case -: ST[ist-1] -= ST[ist];break;
case *: ST[ist-1] *= ST[ist];break;
case /: ST[ist-1] /= ST[ist];break;
case ^: ST[ist-1] = pow(ST[ist-1],ST[ist]);break;
}
}
return ST[0];
}
int mp[20000000];
long long pr1=-114514,pr2=-1919810;
int main() {
freopen("1.txt","r",stdin);
freopen("senpai_database.txt","w",stdout);
while (1) {
gets(s);
double resu=calc(s,endss);if(resu==-1||resu&<0||(resu-floor(resu)&>0)||(resu&<=2e7(mp[int(resu)]))){ continue; }else if(((long long)resu==pr1)||((long long)resu==pr2)){ pr2=pr1,pr1=(long long)(resu);continue; } if(resu&<=2e7) mp[(int)resu]=1; printf("%lld = ",(long long)resu); long long nnn=0,cntt=0; int nn=strlen(s); for(long long i=0;i&

查詢資料庫

如果能排序二分的話能省不少時間，但是數據量太大了沒法排序，我就直接FOR過去了。實測字母少的時候很快。

#include &
#include &
#include &
#include &
#include&
using namespace std;

int tt=0;
char t[1001];
int main() {
//freopen("1.txt","r",stdin);
scanf("%s",t);
freopen("senpai_database.txt","r",stdin);
//freopen("out.txt","w",stdout);
char s[1001];
int li=strlen(t);
int key=0;
for(int i=0;i&

  • 0?t[i]-a+1:t[i]-0;
    if(li!=1) printf("%d",p);
    if(i&

    用法：直接輸入字母，如下

    • 如果想要自己嘗試請依次編譯運行上面三個，不過耗時會有點久，還佔內存（悲）

    其實還有更高級的運算可能，有些數字也還沒表示出來，不過大部分都可以，並且我急著要去和朋友曬一發，就沒有寫 （?你改悔罷?）

    以下內容純屬抖機靈，正確的證明請參考前面大佬的回答！！！

    ———哼啊啊啊啊這是分割線啊啊啊———

    很容易證明：

    我們知道，自然數具有很多有趣的規律，而其中一條極為重要的規律——田所引理——則是證明題主之猜想的重要依據。

    我們先來說說歷史

    根據田所引理，任何自然數都可以通過簡單線性運算得到1919/810的結果，這一引理揭示了任一自然數均能由1919/810通過簡單線性運算得到，即1919/810為一組自然標準基。

    在田所引理的基礎上，偉大的數學家浩二先生提出了著名的浩二變換。浩二先生在一次偶然中，將1919/810與46170分之493183作除，得到57/257，浩二先生敏銳的發現，分母257僅比分子57在百位上多了2，這絕不是一個簡單的發現！浩二先生果斷的將分子分母均加以係數2，得到了一個偉大的結果：114/514。我們很容易發現，自然標準基1919/810通過這一簡單變換，與偉大的114/514建立起直接聯繫。後來，為方便計算，人們也把114/514當作一組基，並命名為自然正交基，以與1919/810相區分。而為紀念浩二先生的偉大貢獻，人們將鏈接自然標準基與自然正交基的這一組變換命名為「浩二變換」。

    歷史講完了，現在來看看證明吧

    由田所引理，任何自然數均能由自然標準基1919/810表示，而根據浩二變換，自然標準基1919/810能通過係數493183/46170而由自然正交基114/514表示，因此很容易得出結論：任何自然數均能由自然正交基114/514表示。

    證畢。

    推薦閱讀：
    相关文章