A 10 958 probléma

Programot írtam az összes lehetséges megoldás megoldására feltételek, beleértve mindent. A kód néhány napja fut, és rengeteg közeli eredményt találtam. A benchmark szerint néhány napra lesz szükség, és ennek eredményeként minden lehetőséget megvizsgáltam volna, és megosztottam veletek az eredményt.

1,2,3,4,5 USD-ért , 6,7,8,9 $, frissíteni fogom az alábbiakat:

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 Legközelebbi

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

Úgy gondolom, hogy ez elég közel van ahhoz, hogy válaszként elfogadva!

Ezenkívül megtaláltam a pontos megoldást a $ 6 $ használata nélkül az alábbiak szerint:

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

Megjegyzések

• Nem ‘ nem tetszik az első megközelítés, egyértelműen kijelenti, hogy a számjegyeknek növekvő sorrendben kell lenniük. De tetszik a második. ‘ szinte nem csal. +1
• Még a számjegyek megfordítását is lehetővé téve,

Szögletes gyökerekkel ezt megteheti:

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

Négyzetgyök és más operátorok eredményeinek összefűzése nélkül a legjobb, amit tehetek:

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

Csak véletlen, hogy a legjobb eredmény más operátorok eredményeinek összefűzése nélkül nem jár összefűzéssel számjegyű.

Ez az a program, amely a keresést végezte. Néhány évvel ezelőtt azért írtam, hogy megoldjak egy újabb puzzle-t a “ragasszon néhány operátort ebbe a számhúrba” műfajban.

Ez azonban nem unáris mínusz, így talán van még mit javítani.

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

Hozzászólások

• Megjegyzendő, hogy szerintem az a srác, aki ‘ t nem sorolja fel az összefűzést operátorként, de aztán mégis használja, jobban csal, mint az a srác, aki mondja operátor, és okosabban használja.
• Hasonló kódot írtam a pythonban, amely véletlenszerű keresést hajt végre az összes lehetséges kifejezés felett: github.com/basarane/10958-Problem — Véletlenszerű keresés / blob / master / …
• Kissé eltérő megközelítés: github.com/DaveJarvis/sequential

Ezt a megoldást a YouTube-videón találtam (nem az én megoldásom), és még közelebb van, mint az eredeti megjegyzés legközelebbi: $ 1 + (2- (3 ^ {(4 * 5/6/7) ))}) ^ {(- 8)} + 9 = 10958.0020579103 $

Úgy gondolom, hogy ennek a kérdésnek már megvolt a válasz, itt van a link A 10 958 szám renderelése az 1 2 3 4 5 6 karakterlánccal 7 8 9

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

(vagy)

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

Megjegyzések

• Üdvözöljük a Puzzling.SE oldalon! Kérjük, próbálja betartani a fenti kérdésben feltett szabályokat. Pontosabban, ez négyzetgyököt használ, ami nem megengedett.
• (ugyanez a faktoriálisnál)
• @Rubio & lan, Tudunk ‘ nem kapja meg a pontos választ az alapműveletek használatával. Ebben az esetben tetszőleges számot kell megismételnie az 10958 számra, így: (szabályok alapján válaszom: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
• De honnan tudhatja, hogy ‘ nem kaphatjuk meg a pontos választ e szabályok használatával? Azt hiszem, hogy ‘ érdekes bizonyíték, és ‘ kíváncsi lennék rá.
• Nem, nem kaptam pontos választ ‘. Úgy hangzik, mintha azt mondtad volna, hogy nem ‘ lehetséges (” ‘ nem kaphatunk a pontos válasz az alapműveletek használatával “), ezért kíváncsi voltam, hogyan jutottál erre a következtetésre.

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

Úgy döntöttünk, hogy a PEMDAS PCEMDAS lesz, ahol a A “C” a konkat függvény. Élvezze a második megoldást! De az elfogadható többségnek a következő héten be kell fejeznie.

Megjegyzések

• Nem minősíteném ezt válaszként válasznak, mivel az OP nem tartalmazott összefűzést mint elfogadható művelet. Bár lehet, hogy ez a helyes válasz, nem követi a rejtvényeket.
• Igen, megpróbáltunk megoldást találni összefűzés használata nélkül, de azzal kezdtük, hogy megengedtük, mivel tudtunk egy olyan megoldásról, amely a concat használatával járt függvényként. Az eredeti cikk megtalálható arxiv.org/pdf/1302.1479.pdf , és ott azt mondja, hogy az a ^ b megengedett, valamint az ab (más néven concat).De megoldásaiban olyan dolgokat csinál, mint (1 + 2) ^ 3, azaz ” a ” ” (1 + 2) ” és ezt követően úgy gondoltuk, hogy lehetővé kell tenni ” (1 + 2) b “. Ismét remélünk olyan megoldást találni, amely nem ‘ nem vonja maga után ezt a trükköt: D
• UPDATE: 27 pontos megoldást talált, és a legtöbbjüket ellenőrizte. Mindegyik szomorúan összefoglalja ezt a néma összefűzési trükköt: /

$ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ Szabad-e műveletet végrehajtani a zárójel előtt és után? Alapvetően elloptam ezt annak a személynek, aki megtalálta a választ, amely nem használta a 6-ot.

Megjegyzések

• Ez nem ‘ t ” az összes 1–9 számjegyet növekvő sorrendben és csak egyszer használva ” – a számjegyek nem növekvő rend.