10. 958-oppgaven

Jeg skrev et program for å løse alle mulige forhold inkludert alt. Koden kjører i noen dager nå, og jeg har funnet mange nære resultater. I henhold til referanseindeksen vil det ta et par dager å gå, og som et resultat ville jeg ha sjekket hver eneste mulighet og delt resultatet med dere.

For $ 1,2,3,4,5 , 6,7,8,9 $, jeg skal oppdatere nære til nedenstående:

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 Nærmeste

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

Jeg tror dette er nær nok til å være akseptert som svar!

Videre har jeg funnet nøyaktig løsning uten å bruke nummer $ 6 $ som nedenfor:

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

Kommentarer

• Jeg vet ikke ‘ som din første tilnærming, står det tydelig at sifrene må være i stigende rekkefølge. Men jeg liker den andre. Det ‘ snyder nesten ikke. +1
• Selv om jeg tillater å reversere sifrene, er jeg ‘ usikker på om den femte og sjette løsningen teller da de stoler på den unære negasjonsoperatøren.Det ‘ er uklart fra OP om det ‘ er ment å være innenlands eller ikke.
• Der er allerede en løsning for 10958 i synkende rekkefølge, så de 6 første ikke ‘ t teller.
• I ‘ Jeg er ikke sikker på at jeg finner » nær nok » svaret er det vi ‘ leter etter her .
• @justhalf en dag igjen for å fullføre løpeturen. den kjører fremdeles, jeg har funnet alt til 12k bortsett fra 10958. Etter at kjøringen er fullført, vil jeg dele koden og resultatet, og antar sannsynligvis ingen løsning for 10958. Lukk nok resultater for bare informasjon.

Med kvadratrøtter kan du gjøre dette:

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

Uten kvadratrøtter eller sammenkobling av resultatene til andre operatører, er det beste jeg kan gjøre:

$ \ left ((1 + 2 \ div3 +4) ^ 5 \ times6-7 \ right) ^ {8 \ div9} \ ca 10958.1155551728 $

Det er bare en tilfeldighet at det beste resultatet uten sammenkobling av resultatene fra andre operatører også innebærer ingen sammenkobling av sifre.

Dette er programmet som søkte. Jeg skrev det for noen år siden for å løse et nytt puslespill i «stick some operators in this string of numbers» sjangeren.

Det gjør ikke unarisk minus, så kanskje det fortsatt er rom for forbedring.

#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; } 

Kommentarer

• For ordens skyld, jeg tror fyren som ikke ‘ ikke lister sammenføyning som operatør, men deretter bruker den uansett, jukser mer enn fyren som sier det er en operatør og bruker den mer smart.
• Jeg skrev en lignende kode i python, som utfører tilfeldig søk over alle mulige uttrykk: github.com/basarane/10958-Problem — Random-Search / blob / master / …
• En litt annen tilnærming: github.com/DaveJarvis/sequential

Jeg fant denne løsningen på YouTube-videoen (ikke løsningen min), og den er enda nærmere enn den nærmeste i den opprinnelige kommentaren: $ 1 + (2- (3 ^ {(4 * 5/6/7) ))}) ^ {(- 8)} + 9 = 10958.0020579103 $

Jeg tror dette spørsmålet allerede har svar, her er lenken Gjengivelse av tallet 10 958 med strengen 1 2 3 4 5 6 7 8 9

$ (1 + 2 + 34) \ times (5 \ times 6 + 7) \ times 8+ \ sqrt {9}! = 10958 $

(eller)

$ (12 \ ganger 3 \ ganger \ frac {4} {5} \ ganger 6 \ ganger 7 + 8) \ ganger 9 = 10958,4 $

Kommentarer

• Velkommen til Puzzling.SE! Prøv å overholde reglene som er lagt ut i spørsmålet ovenfor. Nærmere bestemt bruker dette kvadratrot, noe som ikke er tillatt.
• (samme for faktor)
• @Rubio & lan, Vi kan ‘ t får det eksakte svaret ved hjelp av grunnleggende operasjoner. I så fall må du gjenta et hvilket som helst tall for 10958, som dette .. (basert på regler mitt svar: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
• Men hvordan vet du at vi ikke kan ‘ t få det eksakte svaret ved hjelp av disse reglene? At ‘ d er et interessant bevis, synes jeg, og jeg ‘ ville være nysgjerrig på å se det.
• Nei, jeg fikk ikke ‘ et eksakt svar. Det høres ut som du sa at det ikke er ‘ t mulig (» Vi kan ‘ t får det eksakte svaret ved å bruke grunnleggende operasjoner «) så jeg lurte på hvordan du kom til den konklusjonen.

$ 1 || (2 || (3 * 4) * 5-6) -7-89 $

Vi har bestemt at PEMDAS blir PCEMDAS der «C» er konkatfunksjonen. Kos deg med en ny løsning!

REDIGERING: Vi har noen dedikerte bedriftsmaskiner med noen anstendige spesifikasjoner som kjører noen tester. Det tar bare omtrent 3 millioner år å treffe alle tilfeller. Men flertallet av de sannsynlige bør være ferdig i neste uke.

Kommentarer

• Jeg vil ikke ‘ t kvalifisere dette som et svar da OP ikke inkluderte sammenkobling som en akseptabel operasjon. Selv om det kan være det riktige svaret, følger det ikke puslespillretningslinjene.
• Ja, vi har prøvd å finne en løsning uten å bruke sammenkobling, men startet med å tillate det siden vi visste om en løsning som innebar å bruke konkat som en funksjon. Originalpapiret finnes arxiv.org/pdf/1302.1479.pdf og der sier han at a ^ b er tillatt så vel som ab (aka concat).Men i sine løsninger gjør han ting som (1 + 2) ^ 3 som betyr » a » ville være » (1 + 2) » og etter det tenkte vi at det burde være tillatt å gjøre » (1 + 2) b «. Igjen håper vi å finne en løsning som ikke ‘ ikke innebærer å gjøre dette trikset: D
• UPDATE: fant 27 eksakte løsninger, og sjekket de fleste av dem. Alle inkluderer det stumme sammenføyningstrikset dessverre: /

$ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ Er det tillatt å operere før og etter braketten? Jeg stjal i utgangspunktet dette fra personen som fant svaret som ikke brukte 6.

Kommentarer

• Dette er ikke ‘ t » bruker alle 1-9 sifrene i stigende rekkefølge og bare én gang » – sifrene er ikke i stigende bestilling.