Het 10.958 probleem

Ik heb een programma geschreven om al het mogelijke op te lossen voorwaarden inclusief alles. De code draait nu een paar dagen en ik heb veel goede resultaten gevonden. Volgens de benchmark duurt het een paar dagen om te gaan en als resultaat zou ik elke mogelijkheid hebben gecontroleerd en het resultaat met jullie hebben gedeeld.

Voor $ 1,2,3,4,5 , 6,7,8,9 $, ik ga de meest nabije versies bijwerken naar de onderstaande:

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 Dichtstbijzijnde

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

Ik denk dat dit dichtbij genoeg is om geaccepteerd als antwoord!

Bovendien heb ik de exacte oplossing gevonden zonder nummer $ 6 $ te gebruiken, zoals hieronder:

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

Reacties

• Ik don ‘ Net als je eerste benadering, staat er duidelijk in dat de cijfers in oplopende volgorde moeten zijn. Maar ik vind je tweede leuk. Het ‘ is bijna niet vals spelen. +1
• Zelfs als ik de cijfers omkeer, weet ik ‘ niet zeker of de 5e en 6e oplossing meetellen omdat ze vertrouwen op de unaire ontkenningsoperator.Het ‘ is onduidelijk van het OP of dat ‘ s bedoeld was om in-bounds te zijn of niet.
• Daar is al een oplossing voor 10958 in aflopende volgorde, dus de eerste 6 tellen niet ‘ niet.
• I ‘ Ik weet niet zeker of het vinden van ” dichtbij genoeg ” antwoord is wat we ‘ hier zoeken .
• Nog maar een halve dag om mijn run te voltooien. het draait nog steeds, ik heb alles gevonden tot 12k behalve 10958. nadat de run voltooid is, zal ik mijn code en het resultaat delen, waarschijnlijk vertel ik geen oplossing voor 10958. Sluit voldoende resultaten voor alleen jouw informatie.

Met vierkantswortels kun je dit doen:

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

Zonder vierkantswortels of aaneenschakeling van de resultaten van andere operatoren is het beste wat ik kan doen:

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

Het is gewoon toeval dat het beste resultaat zonder aaneenschakeling van resultaten van andere operatoren ook geen aaneenschakeling inhoudt van cijfers.

Dit is het programma dat de zoekopdracht heeft uitgevoerd. Ik heb het een paar jaar geleden geschreven om een andere puzzel op te lossen in het genre “plak enkele operatoren in deze reeks getallen”.

Het is echter geen unair minpunt, dus misschien is er nog ruimte voor verbetering.

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

Reacties

• Voor de goede orde, ik denk dat de man die geen ‘ t lijst van aaneenschakeling opslaat als een operator, maar deze dan toch gebruikt, meer bedriegt dan de man die het zegt is een operator en gebruikt het slimmer.
• Ik heb een vergelijkbare code geschreven in Python, die willekeurige zoekopdrachten uitvoert voor alle mogelijke uitdrukkingen: github.com/basarane/10958-Problem — Random-Search / blob / master / …
• Een iets andere benadering: github.com/DaveJarvis/sequential

Ik heb deze oplossing gevonden in de YouTube-video (niet mijn oplossing), en deze is zelfs nog dichterbij dan de dichtstbijzijnde in de oorspronkelijke opmerking: $ 1 + (2- (3 ^ {(4 * 5/6/7 ))}) ^ {(- 8)} + 9 = 10958.0020579103 $

Ik denk dat deze vraag al de antwoord, hier is de link Het getal 10.958 weergeven met de string 1 2 3 4 5 6 7 8 9

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

(of)

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

Opmerkingen

• Welkom bij Puzzling.SE! Probeer u te houden aan de regels die in de bovenstaande vraag zijn vermeld. Dit gebruikt specifiek vierkantswortel, wat niet is toegestaan.
• (hetzelfde voor faculteit)
• @Rubio & lan, We kunnen ‘ krijg het exacte antwoord niet door basisbewerkingen te gebruiken. In dat geval moet je een willekeurig nummer herhalen voor 10958, zoals dit .. (op basis van regels mijn antwoord: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
• Maar hoe weet je dat we ‘ niet het exacte antwoord kunnen krijgen met behulp van die regels? Dat ‘ een interessant bewijs zou zijn, denk ik, en ik ‘ zou er nieuwsgierig naar zijn.
• Nee, ik heb geen ‘ een exact antwoord gekregen. Het klinkt alsof je zei dat het niet ‘ niet mogelijk is (” We kunnen ‘ niet krijgen het exacte antwoord door basisbewerkingen te gebruiken “), dus ik vroeg me af hoe je tot die conclusie kwam.

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

We hebben besloten dat PEMDAS PCEMDAS wordt waar de “C” is de concat-functie. Geniet van een tweede oplossing!

EDIT: we hebben een aantal toegewijde enterprise-machines met een aantal fatsoenlijke specificaties die enkele tests uitvoeren, het zou ongeveer 3 miljoen jaar duren om alle gevallen te doorstaan. Maar de meeste van de plausibele zouden in de komende week moeten eindigen.

Reacties

• Ik zou ‘ dit niet als een antwoord kwalificeren aangezien het OP geen aaneenschakeling bevatte als een acceptabele operatie. Hoewel het misschien het juiste antwoord is, volgt het niet de puzzelrichtlijnen.
• Ja, we hebben geprobeerd een oplossing te vinden zonder aaneenschakeling te gebruiken, maar begonnen met het toe te staan omdat we één oplossing kenden waarbij concat werd gebruikt als een functie. De originele paper is te vinden arxiv.org/pdf/1302.1479.pdf en daar zegt hij dat a ^ b zowel is toegestaan als ab (ook bekend als concat).Maar in zijn oplossingen doet hij dingen als (1 + 2) ^ 3 wat betekent dat ” een ” zou zijn ” (1 + 2) ” en daarna dachten we dat het toegestaan zou moeten zijn om ” (1 + 2) b “. Opnieuw hopen we een oplossing te vinden die niet ‘ deze truc met zich meebrengt: D
• UPDATE: vond 27 exacte oplossingen, en controleerde de meeste ervan. Ze bevatten helaas allemaal die stomme aaneenschakelingstruc: /

$ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ Is het toegestaan om voor en na de beugel een operatie uit te voeren? Ik heb dit in feite gestolen van de persoon die het antwoord vond dat “geen 6 gebruikte”.

Opmerkingen

• Dit is niet ‘ t ” met alle 1-9 cijfers in oplopende volgorde en slechts één keer ” – de cijfers zijn niet oplopend bestelling.