10,958の問題

可能な限りすべてを解決するプログラムを作成しましたすべてを含む条件。コードは数日間実行されており、多くの近い結果が見つかりました。ベンチマークによると、行くのに数日かかるでしょう。その結果、私はすべての可能性をチェックし、結果を皆さんと共有したでしょう。

$ 1,2,3,4,5 、6,7,8,9 $、近いものを以下に更新します：

1

$（ 1 + 234）* 5/6 * 7 * 8-9 = 10957.67 \ simeq 10958 $

2

$（12 * 3 * 4/5 * 6 * 7 + 8）* 9 = 10958.4 \ simeq 10958 $

3

$ -1 +（234-5 / 6）*（7 * 8-9）= 10957.83 \ simeq 10958 $

4

$ 1 +（（（（2 + 34）/（5） ）^ 6）*（7/89））= 10958.28 \ simeq 10958 $

5。

$（（（1+（2 + 3）^ {4}）* 56）-7）^ {8/9} = 10957.50 \ simeq 10958 $

6。

$ 1 +（2 + 3 ^ {4/5 + 6 +（7 + 8） /9})=10958.36\simeq 10958 $

7。

$（1 +（（2-3 /（4 * 56））^ 7））* 89 = 10957.61 \ simeq 10958 $

8。

$ -1 +（2 +（（3/4）^ {5-6 * 7 * 8/9}））= 10957.85 \ simeq 10958 $

9

$ 1 +（2 * 3）^ {4-1 / 8 *（5/6）^ 7} * 9 = 10958.25 \ simeq 10958 $

10

$（（1+（2/3 + 4））^ 5 * 6-7）^ {8/9} = 10958.12 \ simeq 10958 $

11

$ -1 + 2-3 + 4 ^ {5-（6-7）/ 8} * 9 = 10957.73 \ simeq 10958 $

12

$（（（ 1 + 2/3）/ 4）^ 5）^ {6 + 7 / 8-9} = 10958.33 \ simeq 10958 $

13

$（（1+（2 ^ {3 ^ {（4 /（5 + 6）} + 7）-8}）^ 9 = 10957.63 \ simeq 10958 $

14

$（-1 /（2 + 3）+ 4 ^ {5-（6-7）/ 8} * 9 = 10957.93 \ simeq 10958 $

15

$ -1-2 / 3-4 ^ {5-（6-7）/ 8} * 9 = 10958.06 \ simeq 10958 $

16 最も近いもの

$-（1-2 ^ { 3 ^ 4/5} /（6 + 7/8）-9）= 10957.98 \ simeq 10958 $

これは十分に近いと思います回答として受け入れられました！

さらに、以下のように番号$ 6 $を使用せずに正確な解決策を見つけました：

$ 1-2 + 3 * 457 * 8-9 = 10958 $

コメント

• 私は’最初のアプローチとは異なり、数字は昇順である必要があることを明確に示しています。しかし、私はあなたの2番目のものが好きです。 ‘はほとんど不正行為ではありません。 +1
• 数字を逆にすることを許可しても、’ 5番目と6番目のソリューションが単項否定演算子に依存しているためカウントされるかどうかはわかりません。’その’がインバウンドを意図しているかどうかは、OPからは不明です。
• そこにはすでに降順で10958のソリューションであるため、最初の6つはカウントされません’。
• I ‘ “十分に近い”の答えが’ここで探しているものであるかどうかわからない。
• @残り半日で実行が完了しました。それはまだ実行中です。10958を除く12kまですべてを見つけました。実行が完了した後、コードと結果を共有します。おそらく10958の解決策はありません。ur情報のみの十分な結果を閉じます。

平方根を使用すると、次のことができます。

$（1234-5）\ times6 + 7 \ times8 ^ {\ sqrt9} = 10958 $

平方根や他の演算子の結果の連結がない場合、私ができる最善の方法は次のとおりです。

$ \ left（（1 + 2 \ div3 +4）^ 5 \ times6-7 \ right）^ {8 \ div9} \ upperx 10958.1155551728 $

他の演算子の結果を連結しない場合の最良の結果にも、連結が含まれないのは偶然です。

これは検索を行ったプログラムです。数年前に、「この数字の文字列にいくつかの演算子を貼り付ける」というジャンルの別のパズルを解くために作成しました。

しかし、それは単一のマイナスを行わないので、おそらくまだ改善の余地があります。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include <float.h> #include <math.h> static double best; #define MAXDIGITS 9 /* Also try MAXSQRT 1 for solution with sqrts. It"s a lot slower! */ #define MAXSQRT 0 struct node { enum { LEAF, /* must be 0 */ ADD, /* must be first binary op */ SUB, MUL, DIV, EXP /* must be last binary op */ } type; /* valid in LEAF nodes only */ char digits[MAXDIGITS+1]; double leafval[MAXSQRT+1]; int digitsoffset; /* valid in non-LEAF nodes only */ struct node *left, *right; /* valid in all nodes */ int sqrtcount; }; static void usage(const char *progname) { fprintf(stderr, "Usage: %s digits goal depth\n", progname); exit(2); } static double getval(struct node *n) { double v; int i; switch(n->type) { case LEAF: return n->leafval[n->sqrtcount]; case ADD: v=getval(n->left) + getval(n->right); break; case SUB: v=getval(n->left) - getval(n->right); break; case MUL: v=getval(n->left) * getval(n->right); break; case DIV: v=getval(n->left) / getval(n->right); break; case EXP: v=pow(getval(n->left), getval(n->right)); break; default: assert(!"Unreachable"); } for(i=0;i<n->sqrtcount;++i) v=sqrt(v); return v; } static void printexpr(struct node *n) { int i; for(i=0;i<n->sqrtcount;++i) printf("sqrt("); switch(n->type) { case LEAF: printf("%s", n->digits); break; case ADD: if(!n->sqrtcount) printf("("); printexpr(n->left); printf("+"); printexpr(n->right); if(!n->sqrtcount) printf(")"); break; case SUB: if(!n->sqrtcount) printf("("); printexpr(n->left); printf("-"); printexpr(n->right); if(!n->sqrtcount) printf(")"); break; case MUL: if(!n->sqrtcount) printf("("); printexpr(n->left); printf("*"); printexpr(n->right); if(!n->sqrtcount) printf(")"); break; case DIV: if(!n->sqrtcount) printf("("); printexpr(n->left); printf("/"); printexpr(n->right); if(!n->sqrtcount) printf(")"); break; case EXP: if(!n->sqrtcount) printf("("); printexpr(n->left); printf("**"); printexpr(n->right); if(!n->sqrtcount) printf(")"); break; default: assert(!"Unreachable"); } for(i=0;i<n->sqrtcount;++i) printf(")"); } int nodesused; struct node nodes[MAXDIGITS*2-1]; #define root (&nodes[0]) int last_split_offset; static void do_splits(int maxsplits, double goal) { struct node *n; int splitnode, length, leftlength, save_last_split_offset; double v, e; v=getval(root); e=fabs(v-goal); if(e < best) { best=e; printexpr(root); printf(" = %.18g\n", v); } if(!maxsplits) return; /* Try each leaf node with more than 1 digit that is not left of the last split point */ for(splitnode=0 ; splitnode<nodesused ; ++splitnode) { n=&nodes[splitnode]; if(n->type!=LEAF || !n->digits[1] || n->digitsoffset<last_split_offset) continue; /* Record the node being split, and remember the previous one */ save_last_split_offset=last_split_offset; last_split_offset=n->digitsoffset; /* Attach children */ n->left=&nodes[nodesused++]; n->left->type=LEAF; n->right=&nodes[nodesused++]; n->right->type=LEAF; /* Try each split point */ length=strlen(n->digits); memcpy(n->left->digits, n->digits, length-1); n->left->digitsoffset=n->digitsoffset; n->right->digitsoffset=n->digitsoffset+length-1; for(leftlength=length-1 ; leftlength>0 ; --leftlength) { /* Distribute digits to children */ /*memcpy(n->left->digits, n->digits, leftlength);*/ n->left->digits[leftlength]=0; n->left->leafval[0]=atof(n->left->digits); #if MAXSQRT n->left->leafval[1]=sqrt(n->left->leafval[0]); #endif strcpy(n->right->digits, n->digits+leftlength); n->right->leafval[0]=atof(n->right->digits); #if MAXSQRT n->right->leafval[1]=sqrt(n->right->leafval[0]); #endif --n->right->digitsoffset; /* Try each binary operator */ for(n->type=ADD ; n->type<=EXP ; ++n->type) { do_splits(maxsplits-1, goal); #if MAXSQRT==1 ++n->left->sqrtcount; do_splits(maxsplits-1, goal); ++n->right->sqrtcount; do_splits(maxsplits-1, goal); --n->left->sqrtcount; do_splits(maxsplits-1, goal); --n->right->sqrtcount; #endif } } /* Unsplit: free children and revert to leaf. n->digits[] is still good. */ nodesused-=2; n->type=LEAF; /* Restore remembered stuff */ last_split_offset=save_last_split_offset; } } static void search(const char *digits, int maxsplits, double goal) { root->type=LEAF; strcpy(root->digits, digits); root->leafval[0]=atof(root->digits); #if MAXSQRT root->leafval[1]=sqrt(root->leafval[0]); #endif root->digitsoffset=0; root->sqrtcount=0; nodesused=1; last_split_offset=0; do_splits(maxsplits, goal); #if MAXSQRT ++root->sqrtcount; do_splits(maxsplits, goal); --root->sqrtcount; #endif assert(nodesused==1); nodesused=0; } int main(int argc, char **argv) { const char *digits; char *endp; double goal; int splits; if(argc!=4) usage(argv[0]); digits=argv[1]; if(strspn(digits, "0123456789")!=strlen(digits)) usage(argv[0]); if(strlen(digits)>MAXDIGITS) { fprintf(stderr, "Too many digits (max is %d).\n" "Increase MAXDIGITS and recompile.\n", MAXDIGITS); return 1; } goal=strtod(argv[2], &endp); if(*endp) usage(argv[0]); splits=strtol(argv[3], &endp, 10); if(*endp) usage(argv[0]); if(splits>=(int)strlen(digits)) { fprintf(stderr, "Not enough digits to perform %d splits\n", splits); return 1; } best=DBL_MAX; search(digits, splits, goal); return 0; } 

コメント

• 記録として、’連結を演算子としてリストしていないが、とにかくそれを使用している人は、それを言う人よりも不正行為をしていると思いますは演算子であり、より巧妙に使用します。
• Pythonで同様のコードを記述しました。これは、考えられるすべての式に対してランダム検索を実行します。 github.com/basarane/10958-問題— Random-Search / blob / master / …
• 少し異なるアプローチ： github.com/DaveJarvis/sequential

この解決策は（私の解決策ではなく）YouTubeビデオで見つかりましたが、元のコメントの最も近い解決策よりもさらに近いです：$ 1 +（2-（3 ^ {（4 * 5/6/7 ））}）^ {（-8）} + 9 = 10958.0020579103 $

この質問にはすでに答え、ここにリンクがあります文字列12 3 4 56で数値10,958をレンダリングします7 8 9

$（1 + 2 + 34）\ times（5 \ times 6 + 7）\ times 8+ \ sqrt {9}！= 10958 $

（または）

$（12 \ times 3 \ times \ frac {4} {5} \ times 6 \ times 7 + 8）\ times 9 = 10958.4 $

コメント

• Puzzling.SEへようこそ！上記の質問に掲載されているルールを遵守してください。具体的には、これは許可されていない平方根を使用します。
• （階乗についても同じ）
• @Rubio & lan、できます’基本的な操作を使用して正確な答えを得ることができません。その場合、次のように10958に対して任意の数を繰り返す必要があります。（私の答えのルールに基づく：（1 + 2）^（3 + 4）* 5 +（6 +（-7 + 7）+ 8 + 9 ）= 10958）
• しかし、これらのルールを使用して正確な答えを得ることができないことをどうやって知っていますか？’ ‘は興味深い証拠だと思いますが、’それを見てみたいと思います。
• いいえ、’正確な答えは得られませんでした。 ‘不可能だとおっしゃっていたようです（”取得できません’基本的な操作を使用した正確な答え”）だから、どうやってその結論に至ったのか疑問に思いました。

$ 1 ||（2 ||（3 * 4）* 5-6）-7-89 $

PEMDASがPCEMDASになることを決定しました。 「C」は連結関数です。 2番目のソリューションをお楽しみください！

編集：いくつかのテストを実行するいくつかのまともなスペックを備えた専用のエンタープライズマシンがいくつかありますが、すべてのケースにヒットするのに約300万年かかるはずです。しかし、もっともらしいものの大部分は来週に終了するはずです。

コメント

• OPに連結が含まれていなかったため、これを回答として認定しません’許容できる操作として。正解かもしれませんが、パズルのガイドラインに従っていません。
• そうです、連結を使用せずに解決策を見つけようとしましたが、連結を使用する1つの解決策を知っていたので、許可することから始めました。関数として。元の論文は arxiv.org/pdf/1302.1479.pdf にあり、ab（別名concat）と同様にa ^ bも許可されていると彼は言います。しかし、彼のソリューションでは、（1 + 2）^ 3のようなことを行います。つまり、” a “は”（1 + 2）”それに続いて、”（1 + 2）を実行できるようにする必要があると考えました。 b “。ここでも、’このトリックを実行しないソリューションを見つけたいと考えています：D
• 更新：27の正確なソリューションを見つけ、それらのほとんどをチェックしました。悲しいことに、すべてにそのばかげた連結トリックが含まれています：/

$ 1-2 +（-3 + 6） * 457 * 8-9 = 10958 $ブラケットの前後で操作を行うことはできますか？私は基本的に、「6を使用しなかった」という答えを見つけた人からこれを盗みました。

コメント

• これは t ” 1〜9桁すべてを昇順で1回だけ使用”-桁は昇順ではありません注文します。