10,958-problemet

Jeg skrev et program for at løse alle mulige forhold inklusive alt. Koden kører i nogle dage nu, og jeg har fundet mange tætte resultater. Ifølge benchmarket vil det tage et par dage at gå, og som et resultat ville jeg have tjekket hver eneste mulighed og dele resultatet med jer.

For $ 1,2,3,4,5 , 6,7,8,9 $, jeg vil opdatere 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, det er tæt nok på at være accepteret som svar!

Desuden har jeg fundet den nøjagtige løsning uden at bruge nummer $ 6 $ som nedenfor:

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

Kommentarer

• Jeg don ‘ ikke som din første tilgang. Det siger klart, at cifrene skal være i stigende rækkefølge. Men jeg kan godt lide din anden. Det ‘ snyder næsten ikke. +1
• Selvom det er muligt at vende cifrene, er jeg ‘ usikker på, om den 5. og 6. løsning tæller, da de stoler på den unære negationsoperator.Det ‘ er uklart fra OPet, om det ‘ er beregnet til at være inden for rammerne eller ej.
• Der er allerede en løsning til 10958 i faldende rækkefølge, så de første 6 tæller ikke ‘ t.
• I ‘ Jeg er ikke sikker på at finde ” tæt nok ” svar er det, vi ‘ leder efter her .
• @justhalf en dag tilbage til at fuldføre mit løb. den kører stadig, jeg har fundet alt indtil 12k undtagen 10958. Efter afslutningen vil jeg dele min kode og resultat, sandsynligvis fortæller jeg ingen løsning til 10958. Luk nok resultater til kun din information.

Med kvadratrødder kan du gøre dette:

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

Uden kvadratrødder eller sammenkædning af resultaterne fra andre operatører er det bedste, jeg kan gøre:

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

Det er bare en tilfældighed, at det bedste resultat uden sammenkædning af resultater fra andre operatører også indebærer ingen sammenkædning af cifre.

Dette er det program, der foretog søgningen. Jeg skrev det for et par år siden for at løse et andet puslespil i genren “stick some operators in this string of numbers”.

Det gør dog ikke unært minus, så måske er der stadig plads til forbedringer.

#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 tror jeg den fyr, der ikke ‘ ikke lister sammenkædning som en operatør, men derefter bruger den alligevel, snyder mere end den fyr, der siger det er en operatør og bruger den mere klogt.
• Jeg skrev en lignende kode i python, som udfører tilfældig søgning over alle mulige udtryk: github.com/basarane/10958-Problem — Random-Search / blob / master / …
• En lidt anden tilgang: github.com/DaveJarvis/sequential

Jeg fandt denne løsning på YouTube-videoen (ikke min løsning), og den er endnu tættere på den nærmeste i den originale kommentar: $ 1 + (2- (3 ^ {(4 * 5/6/7) ))}) ^ {(- 8)} + 9 = 10958.0020579103 $

Jeg mener, at dette spørgsmål allerede har svar, her er linket Gengiver tallet 10.958 med strengen 1 2 3 4 5 6 7 8 9

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

(eller)

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

Kommentarer

• Velkommen til Puzzling.SE! Prøv at overholde reglerne i ovenstående spørgsmål. Specifikt bruger dette kvadratroden, hvilket ikke er tilladt.
• (samme for faktor)
• @Rubio & lan, vi kan ‘ t få det nøjagtige svar ved hjælp af grundlæggende handlinger. I så fald skal du gentage et hvilket som helst nummer for 10958, som dette .. (baseret på regler mit svar: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
• Men hvordan ved du, at vi ‘ ikke kan få det nøjagtige svar ved hjælp af disse regler? At ‘ d er et interessant bevis, synes jeg, og jeg ‘ ville være nysgerrig efter at se det.
• Nej, jeg fik ikke ‘ et nøjagtigt svar. Det lyder som om du sagde, at det ikke er ‘ t muligt (” Vi kan ‘ ikke få det nøjagtige svar ved hjælp af grundlæggende operationer “) så jeg tænkte på, hvordan du kom til den konklusion.

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

Vi har besluttet, at PEMDAS bliver PCEMDAS, hvor “C” er konkatfunktionen. Nyd en anden løsning!

EDIT: Vi har nogle dedikerede virksomhedsmaskiner med nogle anstændige specifikationer, der kører nogle tests, og det skal kun tage cirka 3 millioner år at ramme alle sager. Men de fleste af de sandsynlige bør være færdige i den næste uge.

Kommentarer

• Jeg ville ikke ‘ ikke kvalificere dette som et svar, da OP ikke inkluderede sammenkædning som en acceptabel operation. Selv om det kan være det rigtige svar, følger det ikke puslespilretningslinjerne.
• Ja, vi har forsøgt at finde en løsning uden at bruge sammenkædning, men startede med at tillade det, da vi kendte en løsning, der involverede brug af konkat som en funktion. Det originale papir kan findes arxiv.org/pdf/1302.1479.pdf og der siger han, at a ^ b er tilladt såvel som ab (aka concat).Men i sine løsninger gør han ting som (1 + 2) ^ 3, der betyder ” en ” ville være ” (1 + 2) ” og efterfølgende troede vi, at det skulle være tilladt at gøre ” (1 + 2) b “. Igen håber vi at finde en løsning, der ikke ‘ ikke involverer at gøre dette trick: D
• UPDATE: fundet 27 nøjagtige løsninger og kontrolleret de fleste af dem. Alle inkluderer det dumme sammenkædningstrick desværre: /

$ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ Er det tilladt at have en operation før og efter beslaget? Jeg stjal grundlæggende dette fra den person, der fandt svaret, der ikke brugte 6.

Kommentarer

• Dette er ikke ‘ t ” bruger alle 1-9 cifre i stigende rækkefølge og kun én gang ” – cifrene er ikke i stigende ordre.