Il problema 10.958

Ho scritto un programma per risolvere tutto il possibile condizioni compreso tutto. Il codice è in esecuzione da alcuni giorni e ho trovato molti risultati vicini. Secondo il benchmark, ci vorranno un paio di giorni per andare e di conseguenza avrei verificato ogni singola possibilità e condividere il risultato con voi ragazzi.

Per $ 1,2,3,4,5 , 6,7,8,9 $, aggiornerò quelli vicini ai seguenti:

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 Closest One

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

Credo che questo sia abbastanza vicino da essere accettato come risposta!

Inoltre, ho trovato la soluzione esatta senza utilizzare il numero $ 6 $ come di seguito:

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

Commenti

• Non ‘ t come il tuo primo approccio, afferma chiaramente che le cifre devono essere in ordine crescente. Ma mi piace il tuo secondo. ‘ quasi non tradisce. +1
• Anche consentendo di invertire le cifre, ‘ non sono sicuro se la quinta e la sesta soluzione contano poiché si basano sulloperatore di negazione unario.’ non è chiaro dallOP se ‘ è destinato a essere in-bound o no.
• è già una soluzione per 10958 in ordine decrescente, quindi i primi 6 non ‘ t count.
• I ‘ Non sono sicuro che trovare ” abbastanza vicino ” risposta sia ciò che ‘ stiamo cercando qui .
• Manca solo mezza giornata per completare la mia corsa. è ancora in esecuzione, ho trovato tutto fino a 12k tranne 10958. al termine dellesecuzione condividerò il mio codice e il risultato, probabilmente non fornirò alcuna soluzione per 10958. Risultati abbastanza vicini solo per le tue informazioni.

Con le radici quadrate puoi fare questo:

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

Senza radici quadrate o concatenazione dei risultati di altri operatori, il meglio che posso fare è:

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

È solo una coincidenza che il miglior risultato senza la concatenazione dei risultati di altri operatori non comporta nemmeno la concatenazione di cifre.

Questo è il programma che ha eseguito la ricerca. Lho scritto alcuni anni fa per risolvere un altro enigma del genere “incolla alcuni operatori in questa stringa di numeri”.

Tuttavia, non fa meno unario, quindi forse cè ancora spazio per miglioramenti.

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

Commenti

• Per la cronaca, penso che il tizio che ‘ t elenca la concatenazione come operatore, ma poi la usa comunque, sta barando più di colui che lo dice è un operatore e lo usa in modo più intelligente.
• Ho scritto un codice simile in Python, che esegue una ricerca casuale su tutte le espressioni possibili: github.com/basarane/10958-Problem — Random-Search / blob / master / …
• Un approccio leggermente diverso: github.com/DaveJarvis/sequential

Ho trovato questa soluzione nel video di YouTube (non la mia soluzione), ed è ancora più vicina di quella più vicina nel commento originale: $ 1 + (2- (3 ^ {(4 * 5/6/7 ))}) ^ {(- 8)} + 9 = 10958.0020579103 $

Credo che questa domanda abbia già il risposta, ecco il link Rendendo il numero 10.958 con la stringa 1 2 3 4 5 6 7 8 9

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

(o)

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

Commenti

• Benvenuto in Puzzling.SE! Si prega di provare ad aderire alle regole pubblicate nella domanda sopra. Nello specifico, utilizza la radice quadrata, che non è consentita.
• (lo stesso per fattoriale)
• @Rubio & lan, Possiamo ‘ per ottenere la risposta esatta utilizzando le operazioni di base. In tal caso devi ripetere qualsiasi numero per 10958, in questo modo .. (in base alle regole la mia risposta: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
• Ma come fai a sapere che non possiamo ‘ ottenere la risposta esatta utilizzando queste regole? Quella ‘ sarebbe una prova interessante, credo, e ‘ sarei curioso di vederla.
• No, ‘ non ho ottenuto una risposta esatta. Sembra che tu abbia detto che non è ‘ possibile (” Non possiamo ‘ la risposta esatta utilizzando le operazioni di base “), quindi mi chiedevo come sei arrivato a questa conclusione.

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

Abbiamo deciso che PEMDAS diventa PCEMDAS dove “C” è la funzione concat. Goditi una seconda soluzione!

EDIT: Abbiamo alcune macchine aziendali con alcune specifiche decenti che eseguono alcuni test, dovrebbero impiegare solo circa 3 milioni di anni per raggiungere tutti i casi. Ma la maggior parte di quelli plausibili dovrebbe terminare nella prossima settimana.

Commenti

• Non ‘ t qualificherei questa come una risposta poiché lOP non includeva la concatenazione come operazione accettabile. Sebbene possa essere la risposta corretta, non segue le linee guida del puzzle.
• Sì, abbiamo cercato di trovare una soluzione senza utilizzare la concatenazione, ma abbiamo iniziato consentendola poiché conoscevamo una soluzione che implicava luso di concatenazione come una funzione. Il documento originale può essere trovato arxiv.org/pdf/1302.1479.pdf e lì dice che a ^ b è consentito così come ab (aka concat).Ma nelle sue soluzioni fa cose come (1 + 2) ^ 3 che significa ” a ” sarebbe ” (1 + 2) ” e in seguito abbiamo pensato che dovesse essere consentito di fare ” (1 + 2) b “. Ancora una volta speriamo di trovare una soluzione che ‘ non implichi questo trucco: D
• AGGIORNAMENTO: trovate 27 soluzioni esatte e controllate la maggior parte di esse. Tutti includono quello stupido trucco della concatenazione purtroppo: /

$ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ È consentito eseguire unoperazione prima e dopo la parentesi? Fondamentalmente lho rubato alla persona che ha trovato la risposta che non ha usato “t” 6.

Commenti

• Questo non è ‘ t ” utilizzando tutte le cifre da 1 a 9 in ordine crescente e solo una volta ” – le cifre non sono in ordine crescente ordine.