Das 10.958-Problem

Ich habe ein Programm geschrieben, um alle möglichen Probleme zu lösen Bedingungen einschließlich alles. Der Code läuft seit einigen Tagen und ich habe viele enge Ergebnisse gefunden. Laut Benchmark wird es ein paar Tage dauern, und als Ergebnis hätte ich jede einzelne Möglichkeit geprüft und das Ergebnis mit euch geteilt.

Für $ 1,2,3,4,5 , 6,7,8,9 $, werde ich die folgenden Punkte wie folgt aktualisieren:

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ächste

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

Ich glaube, das ist nah genug, um zu sein Als Antwort akzeptiert!

Außerdem habe ich eine genaue Lösung gefunden, ohne die Nummer $ 6 $ wie folgt zu verwenden:

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

Kommentare

• Ich habe keine ‚ Wie bei Ihrem ersten Ansatz wird deutlich, dass die Ziffern in aufsteigender Reihenfolge sein müssen. Aber ich mag deinen zweiten. Es ‚ betrügt fast nicht. +1
• Selbst wenn ich die Ziffern umkehren kann, bin ich mir nicht sicher, ob die 5. und 6. Lösung zählen, da sie auf dem unären Negationsoperator beruhen.‘ ist aus dem OP unklar, ob diese ‚ beabsichtigt ist, in-bounds zu sein oder nicht.
• Dort ist bereits eine Lösung für 10958 in absteigender Reihenfolge, daher zählen die ersten 6 nicht ‚.
• I ‚ Ich bin mir nicht sicher, ob ich “ nahe genug finde. “ Antwort ist das, wonach wir ‚ hier suchen .
• @ Nur noch ein halber Tag, um meinen Lauf abzuschließen. es läuft noch, ich habe alles bis 12k gefunden, außer 10958. Nach Abschluss des Laufs werde ich meinen Code und mein Ergebnis teilen und wahrscheinlich keine Lösung für 10958 angeben. Schließen Sie genügend Ergebnisse nur für Ihre Informationen.

Mit Quadratwurzeln können Sie dies tun:

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

Ohne Quadratwurzeln oder Verkettung der Ergebnisse anderer Operatoren kann ich nur Folgendes tun:

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

Es ist nur ein Zufall, dass das beste Ergebnis ohne Verkettung der Ergebnisse anderer Operatoren auch keine Verkettung beinhaltet

Dies ist das Programm, das die Suche durchgeführt hat. Ich habe es vor einigen Jahren geschrieben, um ein weiteres Rätsel im Genre „Einige Operatoren in diese Zahlenfolge stecken“ zu lösen.

Es ist jedoch kein unäres Minus, daher gibt es möglicherweise noch Verbesserungspotenzial.

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

Kommentare

• Um es festzuhalten, ich denke, der Typ, der die Verkettung nicht als Operator auflistet, aber sie trotzdem verwendet, betrügt mehr als der Typ, der sie sagt ist ein Operator und verwendet ihn geschickter.
• Ich habe einen ähnlichen Code in Python geschrieben, der eine zufällige Suche über alle möglichen Ausdrücke durchführt: github.com/basarane/10958-Problem — Zufallssuche / blob / master / …
• Ein etwas anderer Ansatz: github.com/DaveJarvis/sequential

Ich glaube, diese Frage hat bereits die Antwort, hier ist der Link Rendern der Nummer 10.958 mit der Zeichenfolge 1 2 3 4 5 6 7 8 9

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

(oder)

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

Kommentare

• Willkommen bei Puzzling.SE! Bitte versuchen Sie, die in der obigen Frage angegebenen Regeln einzuhalten. Dies verwendet insbesondere die Quadratwurzel, die nicht zulässig ist.
• (dasselbe gilt für Fakultät)
• @Rubio & lan, We can ‚ Erhalten Sie nicht die genaue Antwort, indem Sie grundlegende Operationen verwenden. In diesem Fall müssen Sie eine beliebige Zahl für 10958 wie folgt wiederholen. (Basierend auf Regeln meine Antwort: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
• Aber woher wissen Sie, dass wir ‚ mit diesen Regeln keine genaue Antwort erhalten können? Das ‚ wäre ein interessanter Beweis, denke ich, und ich ‚ wäre neugierig, es zu sehen.
• Nein, ich habe ‚ keine genaue Antwort erhalten. Es hört sich so an, als hätten Sie gesagt, es sei ‚ nicht möglich (“ Wir können ‚ nicht bekommen Die genaue Antwort unter Verwendung der Grundoperationen „) Ich habe mich gefragt, wie Sie zu diesem Schluss gekommen sind.

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

Wir haben entschieden, dass PEMDAS zu PCEMDAS wird, wo die „C“ ist die Concat-Funktion. Genießen Sie eine zweite Lösung!

BEARBEITEN: Wir haben einige dedizierte Unternehmensmaschinen mit einigen anständigen Spezifikationen, die einige Tests ausführen. Es sollte nur ungefähr 3 Millionen Jahre dauern, bis alle Fälle erreicht sind. Aber die Mehrheit der plausiblen sollte in der nächsten Woche fertig sein.

Kommentare

• Ich würde ‚ dies nicht als Antwort qualifizieren, da das OP keine Verkettung enthielt als akzeptable Operation. Es ist zwar die richtige Antwort, entspricht jedoch nicht den Puzzle-Richtlinien.
• Ja, wir haben versucht, eine Lösung ohne Verkettung zu finden, aber zunächst haben wir dies zugelassen, da wir von einer Lösung wussten, bei der Concat verwendet wurde als eine Funktion. Das Originalpapier ist zu finden arxiv.org/pdf/1302.1479.pdf und dort sagt er, dass a ^ b ebenso erlaubt ist wie ab (aka concat).Aber in seinen Lösungen macht er Dinge wie (1 + 2) ^ 3, was bedeutet, dass “ ein “ (1 + 2) “ und danach dachten wir, es sollte erlaubt sein, “ (1 + 2) zu tun. b „. Wir hoffen erneut, eine Lösung zu finden, die nicht ‚ diesen Trick beinhaltet: D
• UPDATE: 27 genaue Lösungen gefunden und die meisten davon überprüft. Alle enthalten diesen dummen Verkettungstrick leider: /

$ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ Darf eine Operation vor und nach der Klammer durchgeführt werden? Ich habe dies im Grunde der Person gestohlen, die die Antwort gefunden hat, die nicht 6 verwendet hat.

Kommentare

• Dies ist nicht ‚ t “ verwendet alle 1-9 Ziffern in aufsteigender Reihenfolge und nur einmal “ – die Ziffern sind nicht aufsteigend bestellen.