10958-ongelma

Kirjoitin ohjelman ratkaisemaan kaikki mahdolliset olosuhteet mukaan lukien kaikki. Koodi on käynnissä muutaman päivän ajan ja olen löytänyt paljon läheisiä tuloksia. Vertailuarvon mukaan kestää muutama päivä mennä, minkä seurauksena olisin tarkistanut kaikki mahdollisuudet ja jakanut tuloksen teille.

1,2,3,4,5 dollaria , 6,7,8,9 $, aion päivittää läheiset alla oleviin:

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 Lähin yksi

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

Uskon, että tämä on tarpeeksi lähellä hyväksytty vastaukseksi!

Lisäksi olen löytänyt tarkan ratkaisun käyttämättä alla olevaa numeroa $ 6 $:

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

Kommentit

• En halua ’ t kuten ensimmäinen lähestymistapa, Siinä todetaan selvästi, että numeroiden on oltava nousevassa järjestyksessä. Mutta pidän toisesta. Se ’ ei melkein huijaa. +1
• Jopa sallien numeroiden kääntämisen, ’ en ole varma, lasketaanko 5. ja 6. ratkaisu luottaessaan unaariseen negaatio-operaattoriin.’ on epäselvä OP: sta, jos ’ tarkoitetaan olevan rajojen sisäisiä vai ei.
• Siellä on jo ratkaisu numerolle 10958 laskevassa järjestyksessä, joten ensimmäiset 6 eivät laskekaa.
• I ’ en ole varma löytämästä ” tarpeeksi lähelle ” vastausta, mitä me ’ etsimme täältä .
• @vain puoli päivää jäljellä juoksun suorittamiseen. se on edelleen käynnissä, olen löytänyt kaiken vuoteen 12k, paitsi 10958. Ajon jälkeen, jaan koodini ja tuloksen, luultavasti sanomatta ratkaisua vuodelle 10958. Sulje tarpeeksi tuloksia vain ur-tiedoille.

Neliöjuurilla voit tehdä tämän:

$ (1234-5) \ kertaa6 + 7 \ kertaa8 ^ {\ sqrt9} = 10958 $

Ilman neliöjuuria tai muiden operaattorien tulosten yhdistämistä paras voin tehdä:

$ \ left ((1 + 2 \ div3 +4) ^ 5 \ kertaa6-7 \ oikea) ^ {8 \ div9} \ noin 10958.1155551728 $

On vain sattumaa, että paras tulos ilman muiden operaattoreiden tulosten yhdistämistä ei myöskään sisällä ketjutusta numeroita.

Tämä on ohjelma, joka teki haun. Kirjoitin sen muutama vuosi sitten ratkaistakseni toisen palapelin ”kiinnitä joitain operaattoreita tähän numerosarjaan”.

Se ei kuitenkaan tee unaarista miinusta, joten ehkä on vielä parantamisen varaa.

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

Kommentit

• Tieteen mukaan luulen, että kaveri, joka ’ ei listaa ketjutusta operaattorina, mutta käyttää sitä silti, huijaa enemmän kuin kaveri, joka sanoo sen on operaattori ja käyttää sitä fiksummin.
• Kirjoitin samanlaisen koodin pythoniin, joka suorittaa satunnaisen haun kaikista mahdollisista lausekkeista: github.com/basarane/10958-Problem — Satunnainen haku / blob / master / …
• Hieman erilainen lähestymistapa: github.com/DaveJarvis/sequential

Löysin tämän ratkaisun YouTube-videosta (ei minun ratkaisuni), ja se on jopa lähempänä kuin alkuperäisessä kommentissa oleva lähin: $ 1 + (2- (3 ^ {(4 * 5/6/7) ))}) ^ {(- 8)} + 9 = 10958.0020579103 $

Uskon, että tällä kysymyksellä on jo vastaus, tässä on linkki Lasketaan numero 10 958 merkkijonolla 1 2 3 4 5 6 7 8 9

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

(tai)

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

Kommentit

• Tervetuloa Puzzling.SE-sivustoon! Yritä noudattaa yllä olevaan kysymykseen lähetettyjä sääntöjä. Erityisesti tässä käytetään neliöjuuria, mikä ei ole sallittua.
• (sama tekijä)
• @Rubio & lan, voimme ’ t saa tarkan vastauksen perustoiminnoilla. Tällöin joudut toistamaan minkä tahansa luvun 10958, kuten tämä .. (sääntöjen perusteella vastaukseni: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
• Mutta mistä tiedät, ettemme voi ’ saada tarkkaa vastausta näiden sääntöjen avulla? Se ’ d on mielestäni mielenkiintoinen todiste, ja ’ olen utelias näkemään sen.
• Ei, en saanut ’ tarkkaa vastausta. Kuulostaa siltä, että sanoit, ettei se ole ’ mahdollista (” Voimme ’ saada tarkka vastaus käyttämällä perustoimintoja ”), joten mietin, kuinka päädyit tähän johtopäätökseen.

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

Olemme päättäneet, että PEMDASista tulee PCEMDAS, jossa ”C” on concat-toiminto. Nauti toisesta ratkaisusta!

MUOKKAA: Meillä on joitain omistautuneita yrityskoneita, joissa on joitain kunnollisia teknisiä tietoja, joiden testien suorittaminen kestää vain noin 3 miljoonaa vuotta kaikkien tapausten saavuttamiseksi. Suurimman osan uskottavista pitäisi kuitenkin valmistua ensi viikolla.

kommentit

• En halua ’ luokitella tätä vastaukseksi, koska toimenpideohjelma ei sisältänyt ketjutusta hyväksyttävänä toimenpiteenä. Vaikka se voi olla oikea vastaus, se ei noudata palapelin ohjeita.
• Joo, olemme yrittäneet löytää ratkaisun ilman ketjutusta, mutta aloitimme sallimalla sen, koska tiesimme yhden ratkaisun, joka sisälsi ketjun käyttöä funktiona. Alkuperäinen paperi löytyy osoitteesta arxiv.org/pdf/1302.1479.pdf ja siellä hän sanoo, että a ^ b on sallittu sekä ab (eli concat).Mutta ratkaisuissaan hän tekee asioita, kuten (1 + 2) ^ 3, mikä tarkoittaa ” a ” olisi ” (1 + 2) ” ja sen jälkeen ajattelimme, että sen pitäisi olla sallittua tehdä ” (1 + 2) b ”. Jälleen toivomme löytävän ratkaisun, joka ’ ei sisällä tämän temppun tekemistä: D
• PÄIVITYS: löysi 27 tarkkaa ratkaisua ja tarkisti suurimman osan niistä. Kaikki sisältävät valitettavasti tämän tyhmän ketjutustemppun: /

$ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ Sallitaanko leikkaus ennen hakasulkua ja sen jälkeen? Varastin tämän periaatteessa henkilöltä, joka löysi vastauksen, joka ei käyttänyt 6.

Kommentit

• Tämä ei ole ’ t ” käyttämällä kaikkia 1–9 numeroa nousevassa järjestyksessä ja vain kerran ” – numerot eivät ole nousevia järjestys.