Problem 10 958

Napisałem program, aby rozwiązać wszystkie możliwe warunki, w tym wszystko. Kod działa już od kilku dni i znalazłem wiele podobnych wyników. Zgodnie z benchmarkiem zajmie to kilka dni, w wyniku czego sprawdziłbym każdą możliwą możliwość i podzieliłbym się z wami wynikiem.

Za 1,2,3,4,5 USD , 6,7,8,9 $, mam zamiar zaktualizować najbliższe poniżej:

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 Najbliższy

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

Uważam, że to wystarczy, aby być zaakceptowane jako odpowiedź!

Ponadto znalazłem dokładne rozwiązanie bez użycia numeru $ 6 $, jak poniżej:

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

Komentarze

• Nie ' t jak twoje pierwsze podejście, jasno stwierdza, że cyfry muszą być w porządku rosnącym. Ale podoba mi się twój drugi. To ' prawie nie oszukuje. +1
• Nawet pozwalając na odwrócenie cyfr, ' nie jestem pewien, czy piąte i szóste rozwiązanie liczy się, ponieważ opierają się na jednoargumentowym operatorze negacji.Z OP nie jest jasne ', czy ' ma być w granicach, czy nie.
• Tam jest już rozwiązaniem dla 10958 w porządku malejącym, więc pierwszych 6 nie liczy ' t.
• I ' Nie jestem pewien, czy ” wystarczająco blisko ” ' szukamy tutaj .
• @justhalf dnia na ukończenie biegu. nadal działa, znalazłem wszystko do 12k oprócz 10958. Po zakończeniu uruchomienia udostępnię mój kod i wynik, prawdopodobnie nie podając rozwiązania dla 10958. Wyniki są wystarczające tylko dla informacji o ur.

Za pomocą pierwiastków kwadratowych możesz to zrobić:

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

Bez pierwiastków kwadratowych lub konkatenacji wyników innych operatorów najlepsze co mogę zrobić to:

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

To tylko zbieg okoliczności, że najlepszy wynik bez konkatenacji wyników innych operatorów również nie obejmuje konkatenacji cyfr.

To jest program, który przeprowadził wyszukiwanie. Napisałem go kilka lat temu, aby rozwiązać kolejną zagadkę z gatunku „wbij kilka operatorów w ten ciąg liczb”.

Nie robi jednak jednoargumentowego minus, więc może jest jeszcze miejsce na ulepszenia.

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

Komentarze

• Dla przypomnienia, myślę, że facet, który nie ' t list konkatenacji jako operator, ale potem i tak go używa, oszukuje bardziej niż facet, który to mówi jest operatorem i używa go sprytniej.
• Napisałem podobny kod w Pythonie, który wykonuje losowe wyszukiwanie we wszystkich możliwych wyrażeniach: github.com/basarane/10958-Problem — Random-Search / blob / master / …
• Trochę inne podejście: github.com/DaveJarvis/sequential

Znalazłem to rozwiązanie na wideo YouTube (nie moje rozwiązanie) i jest jeszcze bliższe niż najbliższe w oryginalnym komentarzu: 1 $ + (2- (3 ^ {(4 * 5/6/7 ))}) ^ {(- 8)} + 9 = 10958.0020579103 $

Myślę, że to pytanie ma już odpowiedź, oto link Renderowanie liczby 10 958 za pomocą ciągu 1 2 3 4 5 6 7 8 9

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

(lub)

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

Komentarze

• Witamy w Puzzling.SE! Spróbuj zastosować się do zasad zamieszczonych w powyższym pytaniu. W szczególności używa się pierwiastka kwadratowego, co jest niedozwolone.
• (to samo dla silni)
• @Rubio & lan, możemy ' t uzyskać dokładną odpowiedź za pomocą podstawowych operacji. W takim przypadku musisz powtórzyć dowolną liczbę dla 10958, taką jak ta .. (na podstawie reguł moja odpowiedź: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
• Ale skąd wiesz, że możemy ' uzyskać dokładną odpowiedź, korzystając z tych reguł? Myślę, że ' byłby interesującym dowodem, a ja ' byłbym ciekawy.
• Nie, nie ' nie otrzymałem dokładnej odpowiedzi. Wygląda na to, że powiedziałeś, że nie jest ' niemożliwe (” Nie możemy ' uzyskać dokładną odpowiedź przy użyciu podstawowych operacji „), więc zastanawiałem się, jak doszedłeś do takiego wniosku.

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

Zdecydowaliśmy, że PEMDAS stanie się PCEMDAS, gdzie „C” to funkcja concat. Ciesz się drugim rozwiązaniem!

EDYCJA: Mamy kilka dedykowanych komputerów klasy korporacyjnej z przyzwoitymi specyfikacjami i wykonującymi pewne testy, których uruchomienie we wszystkich przypadkach powinno zająć około 3 milionów lat. Ale większość prawdopodobnych powinna zakończyć się w przyszłym tygodniu.

Komentarze

• Nie ' nie zakwalifikowałbym tego jako odpowiedzi, ponieważ OP nie zawierał konkatenacji jako dopuszczalną operację. Chociaż może to być poprawna odpowiedź, nie jest zgodna z wytycznymi dotyczącymi łamigłówki.
• Tak, próbowaliśmy znaleźć rozwiązanie bez użycia konkatenacji, ale zaczęliśmy od zezwolenia, ponieważ znaliśmy jedno rozwiązanie, które wymagało użycia concat jako funkcja. Oryginalny artykuł można znaleźć arxiv.org/pdf/1302.1479.pdf i mówi on, że dozwolone jest zarówno a ^ b, jak i ab (aka concat).Ale w swoich rozwiązaniach robi takie rzeczy, jak (1 + 2) ^ 3, co oznacza ” a ” byłoby ” (1 + 2) ” i w związku z tym uznaliśmy, że powinno być dozwolone wykonanie ” (1 + 2) b „. Ponownie mamy nadzieję znaleźć rozwiązanie, które ' nie wymaga wykonania tej sztuczki: D
• AKTUALIZACJA: znaleźliśmy 27 dokładnych rozwiązań i sprawdziliśmy większość z nich. Wszystkie niestety zawierają tę głupią sztuczkę konkatenacji: /

$ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ Czy można wykonać operację przed i po nawiasie? Zasadniczo ukradłem to osobie, która znalazła odpowiedź, która nie używała 6.

Komentarze

• To nie jest ' t ” używając wszystkich 1-9 cyfr w porządku rosnącym i tylko jeden raz ” – cyfry nie są rosnące zamówienie.