O problema 10.958

Eu escrevi um programa para resolver todos os possíveis condições incluindo tudo. O código está em execução há alguns dias e encontrei muitos resultados aproximados. De acordo com o benchmark, levará alguns dias para chegar e, como resultado, eu teria verificado todas as possibilidades e compartilhado o resultado com vocês.

Por $ 1,2,3,4,5 , 6,7,8,9 $, irei atualizar os próximos para o seguinte:

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 O mais próximo

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

Acredito que seja perto o suficiente para ser aceito como uma resposta!

Além disso, encontrei a solução exata sem usar o número $ 6 $ como abaixo:

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

Comentários

• Eu não ' t como sua primeira abordagem, afirma claramente que os dígitos precisam estar em ordem crescente. Mas eu gosto do seu segundo. É ' quase não trapacear. +1
• Mesmo permitindo a reversão dos dígitos, eu ' não tenho certeza se a 5ª e a 6ª soluções contam, pois dependem do operador de negação unário.Não ' não está claro no OP se ' pretende ser dentro dos limites ou não.
• já é uma solução para 10958 em ordem decrescente, então os primeiros 6 não ' t contam.
• I ' Não tenho certeza se encontrar " perto o suficiente " resposta é o que ' estamos procurando aqui .
• @ falta apenas meio dia para terminar minha corrida. ainda está em execução, encontrei tudo até 12k exceto 10958. após a conclusão da execução, compartilharei meu código e o resultado, provavelmente sem solução para 10958. Resultados próximos o suficiente apenas para suas informações. / div>
  

  Resposta

  Com raízes quadradas, você pode fazer isso:

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

  Sem raízes quadradas ou concatenação dos resultados de outros operadores, o melhor que posso fazer é:

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

  É apenas uma coincidência que o melhor resultado sem concatenação de resultados de outros operadores também não envolve concatenação de dígitos.

  Este é o programa que fez a pesquisa. Eu o escrevi há alguns anos para resolver outro quebra-cabeça no gênero “cole alguns operadores nesta seqüência de números”.

  No entanto, não faz menos unário, então talvez ainda haja espaço para melhorias.

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

  Comentários

  • Para que fique registrado, acho que o cara que não ' lista a concatenação como um operador, mas a usa de qualquer maneira, está trapaceando mais do que o cara que diz isso é um operador e o usa de maneira mais inteligente.
  • Escrevi um código semelhante em python, que realiza pesquisas aleatórias em todas as expressões possíveis: github.com/basarane/10958-Problem — Random-Search / blob / master / …
  • Uma abordagem ligeiramente diferente: github.com/DaveJarvis/sequential

  Resposta

  Eu encontrei esta solução no vídeo do YouTube (não é a minha solução), e é ainda mais próxima do que a mais próxima no comentário original: $ 1 + (2- (3 ^ {(4 * 5/6/7 ))}) ^ {(- 8)} + 9 = 10958.0020579103 $

  Resposta

  Acredito que esta pergunta já tenha o resposta, aqui está o link Renderizando o número 10.958 com a string 1 2 3 4 5 6 7 8 9

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

  (ou)

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

  Comentários

  • Bem-vindo ao Puzzling.SE! Tente seguir as regras postadas na pergunta acima. Especificamente, ele usa raiz quadrada, o que não é permitido.
  • (o mesmo para fatorial)
  • @Rubio & lan, Podemos ' t obtenha a resposta exata usando operações básicas. Nesse caso, você deve repetir qualquer número para 10958, assim .. (com base nas regras minha resposta: (1 + 2) ^ (3 + 4) * 5 + (6 + (- 7 + 7) + 8 + 9 ) = 10958)
  • Mas como você sabe que não podemos ' obter a resposta exata usando essas regras? Que ' seria uma prova interessante, eu acho, e eu ' estaria curioso para vê-la.
  • Não, eu não ' não obtive uma resposta exata. Parece que você disse que não é ' possível (" Não podemos ' obter a resposta exata usando operações básicas "), então eu queria saber como você chegou a essa conclusão.

  Resposta

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

  Decidimos que PEMDAS se torna PCEMDAS onde o “C” é a função concat. Aproveite uma segunda solução!

  EDITAR: Temos algumas máquinas corporativas dedicadas com algumas especificações decentes executando alguns testes, deve levar apenas cerca de 3 milhões de anos para acertar todos os casos. Mas a maioria dos plausíveis deve terminar na próxima semana.

  Comentários

  • Eu não ' não qualificaria isso como uma resposta, pois o OP não inclui concatenação como uma operação aceitável. Embora possa ser a resposta correta, ela não segue as diretrizes do quebra-cabeça.
  • Sim, temos tentado encontrar uma solução sem usar concatenação, mas começamos permitindo, pois conhecíamos uma solução que envolvia o uso de concat Como uma função. O artigo original pode ser encontrado arxiv.org/pdf/1302.1479.pdf e lá ele diz que a ^ b é permitido, bem como ab (também conhecido como concat).Mas em suas soluções ele faz coisas como (1 + 2) ^ 3 que significa " a " seria " (1 + 2) " e, em seguida, pensamos que deveria ser permitido fazer " (1 + 2) b ". Mais uma vez, esperamos encontrar uma solução que não ' envolva fazer este truque: D
  • ATUALIZAÇÃO: encontrou 27 soluções exatas e verificou a maioria delas. Todos incluem aquele truque idiota de concatenação, infelizmente: /

  Resposta

  $ 1-2 + (- 3 + 6) * 457 * 8-9 = 10958 $ É permitido fazer uma operação antes e depois do colchete? Basicamente, roubei isso da pessoa que encontrou a resposta que não “usava 6.

  Comentários

  • Isso não é ' t " usando todos os 1-9 dígitos em ordem crescente e apenas uma vez " – os dígitos não estão em ordem crescente pedido.