10 958-problemet

Jag skrev ett program för att lösa alla möjliga villkor inklusive allt. Koden körs i några dagar nu och jag har hittat många nära resultat. Enligt riktmärket tar det några dagar att gå och som ett resultat skulle jag ha kontrollerat varje enskild möjlighet och dela resultatet med er.

För $ 1,2,3,4,5 , 6,7,8,9 $, jag ska uppdatera nära till följande:

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ärmast en

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

Jag tror att detta är tillräckligt nära för att vara accepterat som svar!

Dessutom har jag hittat exakt lösning utan att använda siffran $ 6 $ enligt nedan:

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

Kommentarer

• Jag don ’ Tycker inte om ditt första tillvägagångssätt, det står tydligt att siffrorna måste vara i stigande ordning. Men jag gillar din andra. Det ’ fuskar nästan inte. +1
• Till och med för att vända siffrorna är jag ’ osäker på om den 5: e och 6: e lösningen räknas som de litar på den unära negationsoperatören.Det är ’ oklart från OP om att ’ är avsedda att vara inom gränserna eller inte.
• Där är redan en lösning för 10958 i fallande ordning, så de 6 första räknar inte ’.
• I ’ jag är inte säker på att hitta ” tillräckligt nära ” svaret är vad vi ’ letar efter här .
• @justhalf en dag kvar för att slutföra min körning. den är fortfarande igång, jag har hittat allt fram till 12k utom 10958. efter körningen kommer jag att dela min kod och resultat, förmodligen säger jag ingen lösning för 10958. Stäng tillräckligt med resultat för din information.

Med kvadratrötter kan du göra detta:

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

Utan kvadratrötter eller sammankoppling av resultaten från andra operatörer är det bästa jag kan göra:

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

Det är bara en tillfällighet att det bästa resultatet utan sammankoppling av resultat från andra operatörer också innebär ingen sammanfogning av siffror.

Detta är programmet som gjorde sökningen. Jag skrev det för några år sedan för att lösa ett annat pussel i genren ”stick some operators in this string of numbers”.

Det gör dock inte unärt minus, så kanske finns det fortfarande utrymme för förbättringar.

#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

• För ordens skull tror jag att killen som inte ’ inte listar sammankoppling som operatör, men sedan använder den ändå, fuskar mer än killen som säger det är en operatör och använder den smartare.
• Jag skrev en liknande kod i python, som utför slumpmässig sökning över alla möjliga uttryck: github.com/basarane/10958-Problem — Random-Search / blob / master / …
• Ett lite annorlunda tillvägagångssätt: github.com/DaveJarvis/sequential

Jag hittade den här lösningen på YouTube-videon (inte min lösning), och den är ännu närmare än den närmaste i originalkommentaren: $ 1 + (2- (3 ^ {(4 * 5/6/7) ))}) ^ {(- 8)} + 9 = 10958.0020579103 $

Jag tror att den här frågan redan har svar, här är länken Rendering av numret 10,958 med strängen 1 2 3 4 5 6 7 8 9

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

(eller)

$ (12 \ gånger 3 \ gånger \ frac {4} {5} \ gånger 6 \ gånger 7 + 8) \ gånger 9 = 10958.4 $

Kommentarer

• Välkommen till Puzzling.SE! Försök att följa reglerna i frågan ovan. Specifikt använder detta kvadratrot, vilket inte är tillåtet.
• (samma för faktoria)
• @Rubio & lan, vi kan ’ t få det exakta svaret med hjälp av grundläggande operationer. I så fall måste du upprepa valfritt tal för 10958, så här .. (baserat på regler mitt svar: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
• Men hur vet du att vi inte ’ kan få det exakta svaret med dessa regler? Att ’ skulle vara ett intressant bevis tror jag och jag ’ skulle vara nyfiken på att se det.
• Nej, jag fick inte ’ ett exakt svar. Det låter som om du sa att det inte är ’ t möjligt (” Vi kan ’ t får det exakta svaret genom att använda grundläggande operationer ”) så jag undrade hur du kom till den slutsatsen.

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

Vi har beslutat att PEMDAS blir PCEMDAS där ”C” är konkatfunktionen. Njut av en andra lösning!

EDIT: Vi har några dedikerade företagsmaskiner med några anständiga specifikationer som kör några tester, det borde bara ta ungefär 3 miljoner år att träffa alla fall. Men majoriteten av de trovärdiga bör avslutas nästa vecka.

Kommentarer

• Jag skulle inte vilja ’ t kvalificera detta som ett svar eftersom OP inte inkluderade sammankoppling som en acceptabel operation. Även om det kan vara rätt svar följer det inte pusselriktlinjerna.
• Ja, vi har försökt hitta en lösning utan att använda sammankoppling men började med att tillåta det eftersom vi kände till en lösning som innebar att använda konkat som en funktion. Originalet finns arxiv.org/pdf/1302.1479.pdf och där säger han att a ^ b är tillåtet liksom ab (aka concat).Men i sina lösningar gör han saker som (1 + 2) ^ 3 som betyder ” a ” skulle vara ” (1 + 2) ” och därefter trodde vi att det borde vara tillåtet att göra ” (1 + 2) b ”. Återigen hoppas vi hitta en lösning som inte ’ inte innebär att göra det här tricket: D
• UPPDATERING: hittade 27 exakta lösningar och kontrollerade de flesta av dem. Alla inkluderar det dumma sammanfogningstricket tyvärr: /

$ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ Är det tillåtet att göra en operation före och efter konsolen? Jag stal i princip detta från personen som hittade svaret som inte använde 6.

Kommentarer

• Detta är inte ’ t ” använder alla 1-9 siffror i stigande ordning och bara en gång ” – siffrorna är inte i stigande beställa.