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 $

댓글

• 나는 ‘ 첫 번째 접근 방식과 달리 숫자가 오름차순이어야 함을 명확하게 명시합니다. 하지만 두 번째가 좋아요. ‘ 거의 부정 행위가 아닙니다. +1
• 숫자 반전을 허용하더라도 ‘ 5 번째 및 6 번째 솔루션이 단항 부정 연산자에 의존하기 때문에 계산되는지 확실하지 않습니다.’가 ‘가 인바운드로 의도 된 것인지 아닌지 OP에서 명확하지 않습니다.
• 있습니다. 이미 내림차순으로 10958에 대한 솔루션이므로 처음 6 개는 포함되지 않습니다 ‘.
• I ‘ ” 충분히 가까운 ” 답변을 찾는 것이 ‘ 여기에서 찾고있는 것인지 잘 모르겠습니다. .
• @ 달리기를 완료하는 데 반나절 남았습니다. 아직 실행 중입니다. 10958을 제외하고 12k까지 모든 것을 찾았습니다. 실행이 완료된 후 코드와 결과를 공유하고 아마도 10958에 대한 해결책이 없을 것입니다. 귀하의 정보만을위한 충분한 결과를 닫습니다.

제곱근을 사용하면 다음을 수행 할 수 있습니다.

$ (1234-5) \ times6 + 7 \ times8 ^ {\ sqrt9} = 10958 $

제곱근이나 다른 연산자의 결과를 연결하지 않고 할 수있는 최선의 방법은 다음과 같습니다.

$ \ left ((1 + 2 \ div3 +4) ^ 5 \ times6-7 \ right) ^ {8 \ div9} \ approx 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-Problem — Random-Search / blob / master / …
• 약간 다른 접근 방식 : github.com/DaveJarvis/sequential

이 솔루션을 YouTube 동영상 (내 솔루션이 아님)에서 찾았으며 원래 댓글에서 가장 가까운 것보다 훨씬 더 가깝습니다 : $ 1 + (2- (3 ^ {(4 * 5 / 6 / 7 ))}) ^ {(-8)} + 9 = 10958.0020579103 $

이 질문에 이미 대답, 여기에 링크가 있습니다. 숫자 10,958을 문자열 1 2 3 4 5 6으로 렌더링 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”는 연결 함수입니다. 두 번째 솔루션을 즐기세요!

편집 : 일부 테스트를 실행하는 괜찮은 사양을 갖춘 헌신적 인 엔터프라이즈 머신이 있습니다. 모든 경우를 처리하는 데는 약 3 백만 년 밖에 걸리지 않습니다. 그러나 그럴듯한 것의 대부분은 다음 주에 끝날 것입니다.

댓글

• ‘ OP에 연결이 포함되지 않았으므로 답변으로 간주하지 않습니다. 허용되는 작업으로. 정답 일 수 있지만 퍼즐 지침을 따르지 않습니다.
• 예, 우리는 연결을 사용하지 않고 해결책을 찾으려고 노력했지만 concat을 사용하는 한 가지 해결책을 알고 있었기 때문에 허용하는 것으로 시작했습니다. 함수로. 원본 논문은 arxiv.org/pdf/1302.1479.pdf 에서 찾을 수 있으며 a ^ b와 ab (일명 concat)도 허용된다고 말합니다.그러나 그의 솔루션에서 그는 (1 + 2) ^ 3과 같은 작업을 수행합니다. 즉, ” a “는 (1 + 2) ” 다음을 수행 할 수 있어야한다고 생각했습니다. ” (1 + 2) b “. 다시 우리는 ‘이 트릭을 수행하지 않는 솔루션을 찾고 있습니다. : D
• 업데이트 : 27 개의 정확한 솔루션을 찾고 대부분을 확인했습니다. 모두 슬프게도 멍청한 연결 트릭을 포함합니다 ./

$ 1-2 + (-3 + 6) * 457 * 8-9 = 10958 $ 대괄호 전후에 작업이 허용됩니까? 기본적으로 “6을 사용하지 않은 답변을 찾은 사람에게서 이것을 훔쳤습니다.

댓글

• 이것은 ‘ t ” 1-9 자리 숫자를 모두 오름차순으로 한 번만 사용 “-숫자가 오름차순이 아닙니다. 주문.