Pandigital aproximaciones racionales a la proporción áurea y la base del logaritmo natural

Question

Steven Stadnicki sugirió en un comentario que he puesto la siguiente pregunta.

La dorada de ración $\phi$ está dado por $$\phi = \frac{1+\sqrt{5}}{2} \approx 1.618033988.$$

Una racional aproximación está dada por $$\frac{987}{610} \approx 1.618032787.$$

Esto produce los siguientes pandigital fórmulas: $$\frac{4 * 3 + 975}{\left(8 + 2\right) * 61}$$ $$\frac{985 + 2}{1 + 7 * \left(6 + {3}^{4}\right)}$$ $$\frac{5 + 984 - 2}{\left(7 + 3\right) * 61}$$ $$\frac{987}{2 + 1 + \left({5}^{4}\right) - \left(6 * 3\right)}$$ $$\frac{7 * \left(98 + 43\right)}{\left(61 * 5\right) * 2}$$

Hay otra pandigital racional de la representación que se obtiene un mayor número de dígitos exactos?

La misma pregunta puede hacerse para la base del logaritmo natural $e$: $$e\approx 2.718281828.$$ Una racional aproximación es $$\frac{1457}{536}\approx 2.718283582.$$ Se produce el siguiente pandigital fórmulas: $$\frac{31 * \left(5 + 42\right)}{\left(76 - 9\right) * 8}$$ $$\frac{\left(\left({3}^{6}\right) * 2\right) - 1}{\left({5}^{4}\right) - \left(97 - 8\right)}$$ $$\frac{\left(6 * \left({3}^{5}\right)\right) - 1}{7 + {\left(\left(8 * 4\right) - 9\right)}^{2}}$$ $$\frac{1 + \left(6 * \left({3}^{5}\right)\right) - 2}{\left(9 * 7 + 4\right) * 8}$$ $$\frac{31 * \left(8 * 5 + 7\right)}{{2}^{9} + 6 * 4}$$ $$\frac{5 + \left(\left({9}^{3}\right) * 2\right) - 6}{8 * \left(71 - 4\right)}$$ $$\frac{31 * \left(\left(8 * 7\right) - 9\right)}{542 - 6}$$ Como antes le pedimos para una mejor racional aproximación que produce una mayor precisión.

Por otra parte (ver este post) pedimos más sofisticado algoritmo no trivial para el cálculo de ambos. Yo era capaz de obtener una mejora en el tiempo de ejecución por un factor de treinta a través de la re-codificación del algoritmo de Arce de otros post en C, incluyendo bastantes ideas que son de uso para la combinatoria programmmer, como la representación de los conjuntos de cadenas de bits o la enumeración de las permutaciones de una lista mediante el factorial de un número de sistema. Feliz computación! (Otra observación es que con las cinco operaciones y concatenación a nuestra disposición no son, probablemente, los valores de umbral para el numerador y el denominador de las aproximaciones racionales a partir de la continuación de la fracción donde quizá podamos dar una prueba de que no puede ser alcanzado.)

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int blog(int n) {
 assert(n >= 0);

 int res = -1; 

while(n>0){
 n >>= 1;
res++;
}

 return res;
}

int fact(int n)
{
 assert(n >= 0);

 si(n<2) return 1;

 return n*fact(n-1);
}

largo ipow(int m, int n)
{
 assert(n >= 0);

 if(n==0) return 1;
 if(n==1) return m;

 tiempo r = (n%2 ? ipow(m, (n-1)/2) : ipow(m, n/2));
 retorno (n%2 ? m*r*r r*r);
}

struct {
 int min, max;
} searchints[] = {
 {1, 50},
 {100, 120},
 {340, 360},
 {-1, -1}
};

en línea de acceso int(int val){
 int intervalo = 0, offs = 0;

 mientras(searchints[intervalo].min !=-1){
 int min = searchints[intervalo].min;
 int max = searchints[intervalo].max;

 if(val >= min && val <= max){
 volver offs + val-min;
}

 offs += max-min+1;
intervalo++;
}

 return -1;
}

int entcount = -1;

typedef struct {
 corto de la hoja;
 tiempo val;
 char llanura[128];
 char látex[256];
} expr;

expr *memo[1<<9];

expr *makememo(void)
{
 expr *entos = (expr *)malloc(entcount*sizeof(expr));

 int ind;
 para(ind=0; ind<entcount; ind++){
 entos[ind].val = -1;
}

 volver ents;
}

expr *repr(int subsind)
{
 si(memo[subsind] != NULL){ return memo[subsind]; };

 int elcount = 0; int elementos[9+1];

 int pos, bitpat = subsind;
 for(pos=0; pos<9; pos++){
 si(bitpat & 1 == 1){
 elementos[elcount++] = pos+1;
}
 bitpat >>= 1;
}
 elementos[elcount] = -1;

 expr *res = makememo();
 int idx;

 si(elcount == 1){
 idx = acceso(elementos[0]);
 res[idx].hoja = 1;
 res[idx].val = elementos[0];
 sprintf(res[idx].llano, "%d", elementos[0]);
 sprintf(res[idx].látex, "%d", elementos[0]);

 memo[subsind] = res; return res;
}

 int count = 0;

 si(elcount >= 2 && elcount <= 4){
 int perm[9+1], el;

 for(pos=0; pos<elcount; pos++){ 
 perm[pos] = elementos[pos];
}

 int superior = fact(elcount);
 for(pos=0; pos<superior; pos++){
 idx = pos;
 int el;
 (el=elcount; el>0; el--){
 int targ = idx % el;

 int tmp = perm[targ];
 perm[targ] = perm[el-1];
 perm[el-1] = tmp;

 idx /= el;
}
}

 char buf[9+1], *dígitos = "123456789";
 para(idx=0; idx<elcount; idx++){
 buf[idx] = dígitos[perm[idx]-1];
}
 buf[idx] = 0;

 int numval; sscanf(buf, "%d", &numval);

 idx = acceso(numval);
 si(idx != -1){
 res[idx].hoja = 1;
 res[idx].val = numval;
 sprintf(res[idx].llano, "%d", numval);
 sprintf(res[idx].látex, "%d", numval);

count++;
}
}

 int subsubind;
 para(subsubind=1; subsubind<(1<<elcount)-1; subsubind++){
 int leftel[9+1], rightel[9+1], leftpos=0, rightpos=0;

 bitpat = subsubind;
 for(pos=0; pos<elcount; pos++){
 si(bitpat & 1 == 1){
 leftel[leftpos++] = elementos[pos];
}
else{
 rightel[rightpos++] = elementos[pos];
}

 bitpat >>= 1;
}

 int lidx = 0, ridx = 0, innerpos;
 para(innerpos=0; innerpos<leftpos; innerpos++){
 lidx += 1<<(leftel[innerpos]-1);
}
 para(innerpos=0; innerpos<rightpos; innerpos++){
 ridx += 1<<(rightel[innerpos]-1);
}

 expr *lres = repr(lidx), *rres = repr(ridx);

 if(contador>=entcount){ continue; }

 int opl, rpos;
 para(opl=0; lpos<entcount; lpos++){
 para(rpos=0; rpos<entcount; rpos++){
 expr exl = lres[lpos], exr = rres[rpos];
 int newval, newind;

 si(exl.val != -1 && exr.val != -1){
 char plainl[256], plainr[256];
 sprintf(plainl, (exl.hoja ? "%s" : "(%s)"), exl.llano);
 sprintf(plainr, (exr.hoja ? "%s" : "(%s)"), exr.llano);

 char latexl[256], latexr[256];
 sprintf(latexl, (exl.hoja ? "%s" : "\\izquierdo(%s\\right)"), exl.látex);
 sprintf(latexr, (exr.hoja ? "%s" : "\\izquierdo(%s\\right)"), exr.látex);

 newval = exl.val + exr.val;
 si((newind = acceso(newval))!=-1){
 res[newind].hoja = 0;
 res[newind].val = newval;

 sprintf(res[newind].llano, "%s + %s", exl.llanura, exr.llano);
 sprintf(res[newind].látex, "%s + %s", exl.látex, exr.látex);

count++;
}

 newval = exl.val - exr.val;
 si(newval>0 && (newind = acceso(newval))!=-1){
 res[newind].hoja = 0;
 res[newind].val = newval;

 sprintf(res[newind].llano, "%s - %s", plainl, plainr);
 sprintf(res[newind].látex, "%s - %s", latexl, latexr);

count++;
}

 si(exl.val>1 && exr.val>1){
 newval = exl.val * exr.val;
 si((newind = acceso(newval))!=-1){
 res[newind].hoja = 0;
 res[newind].val = newval;

 sprintf(res[newind].llano, "%s * %s", plainl, plainr);
 sprintf(res[newind].látex, "%s * %s", latexl, latexr);

count++;
}
}

 si(exr.val>1 && (exl.val % exr.val) == 0){
 newval = exl.val / exr.val;
 si((newind = acceso(newval))!=-1){
 res[newind].hoja = 0;
 res[newind].val = newval;

 sprintf(res[newind].llano, "%s / %s", plainl, plainr);
 sprintf(res[newind].látex, "\\frac{%s}{%s}", exl.látex, exr.látex);

count++;
}
}

 si(exl.val>1 && exr.val>1 && exr.val*blog(exl.val)<32){
 newval = ipow(exl.val, exr.val);
 si((newind = acceso(newval))!=-1){
 res[newind].hoja = 0;
 res[newind].val = newval;

 sprintf(res[newind].llano, "%s ^ %s", plainl, plainr);
 sprintf(res[newind].látex, "{%s}^{%s}", latexl, exr.látex);

count++;
}
}
}
}
}
}

 memo[subsind] = res; return res;
}


int main(int argc, char **argv)
{
 a largo p, q;

if(argc!=3){
 fprintf(stderr, "uso: %s <p> <q>\n", argv[0]);
exit(-1);
}

 sscanf(argv[1], "%ld", &p);
 sscanf(argv[2], "%ld", &p);

 si(p<1 || q<1){
 fprintf(stderr, 
 "enteros positivos por favor, consiguió %ld y %ld\n",
 p, q);
exit(salir) (-2);
}

 int ind = 0, ent;

 entcount = 0;
 mientras(searchints[ind].min != -1){
 entcount += searchints[ind].max-searchints[ind].min+1;
ind++;
}

 para(ind=0; ind<(1<<9); ind++){
 memo[ind] = NULL;
}

 para(ind=1; ind<(1<<9)-1; ind++){
 expr *leftres = repr(ind), *rightres = repr((1<<9)-1-ind);
 int idxleft = acceso(p), idxright = acceso(q);

 si(idxleft != -1 && idxright != -1){
 expr = izquierda leftres[idxleft];
 expr derecha = rightres[idxright];

 si(a la izquierda.val != -1 && derecho.val != -1){
 printf("(%s) / (%s); %d / %d; %.15lf\n", 
 a la izquierda.llanura, a la derecha.llanura, p, q,
(doble)a la izquierda.val/(doble)a la derecha.val);
 printf("\\frac{%s}{%s}\n", a la izquierda.látex, a la derecha.látex);
}
}
}

 return 0;
}

Answer 1

Aquí es una fórmula Pandigital (que se encuentra por R. Sabey en 2004, según http://mathworld.wolfram.com/eApproximations.html ) que tiene una precisión de$18457734525360901453873570$ dígitos (eso dicen): \begin{align} \left(1+9^{-4^{7\cdot 6}}\right)^{3^{2^{85}}}, \end {align}, que está justo \begin{align} \left(1+1/z\right)^{z} \end {align} con$z=3^{2^{85}}$ en el encubrimiento. Esto se basa en el hecho de que$e = \lim_{x\rightarrow\infty}(1+\frac{1}{x})^x$.

Answer 2

Mi mejor racional aproximación de $\large\phi$ $(1.618033988749894848204586834365...)$ es $$ \phi \approx \dfrac{6}{3-\dfrac{2}{7}+\left(1-8 \cdot 9^{-4}\right)^5} = 1.618033988\color{Bronceado}{913633}...; \etiqueta{1} $$ de error es:$\Delta = 1.637385... \times 10^{-10}$.

Y les voy a mostrar otro de niza $\phi$ aproximaciones: $$ \phi\approx \dfrac{736}{\dfrac{8^4}{9}-\dfrac{5}{21}} = \dfrac{46368}{28657}=\color{blue}{\dfrac{F_{24}}{F_{23}}} = 1.618033988\color{Bronceado}{205325}... , \etiqueta{2} $$ $$ \phi \aprox {\large\dfrac{3^6+\frac{2+9}{8+7}}{451}} = \dfrac{10946}{6765}=\color{blue}{\dfrac{F_{21}}{F_{20}}} = 1.6180339\color{Bronceado}{985218}... , \etiqueta{3} $$ donde $\color{blue}{F_n}$ $-$ los números de Fibonacci.

Answer 3

He encontrado la siguiente aproximación racional en la serie de $\phi$, es $$\phi \approx\frac{4181}{2584} =1.618034.$$ El pandigital fórmula es $$ \left(\frac{13}{8}\right) - \left(\frac{2 + 7}{5 + \left({6}^{4}\right) - 9}\right).$$ Otro es $$\left(\frac{13}{8}\right) - \left(\frac{{2}^{- 4}}{9 - \left({6}^{- \left(7 - 5\right)}\right)}\right).$$ EDICIÓN de Agosto 6 Aún mejor, mediante el establecimiento de

struct {
 int min, max;
} numerints[] = {
 {1, 550},
 {800, 1000},
 {1580, 1600},
 {2570, 2590},
 {4150, 4200},
 {6720, 6820},
 {-1, -1}
}, denomints[] = {
 {1, 136},
 {2550, 2600},
 {4150, 4200},
 {-1, -1}
};

He calculado que el racionalaproximación $$\phi\approx\frac{6765}{4181}\approx 1.618033963,$$ con pandigital fórmula $$\frac{5 * \left(2 + 9\right)}{34 - \left(\frac{7}{861}\right)} .$$ Aunque $861$ no aparece como una posible denominador era, sin embargo admitió que debido a $7/861$ es igual a $1/123,$ que hace ajuste el valor de la máscara.

Edición de 12 de Agosto de La siguiente configuración

struct {
 int min, max;
} numerints[] = {
 {1, 850},
 {10920, 10980},
 {-1, -1}
}, denomints[] = {
 {1, 210},
 {6755, 6780},
 {-1, -1}
};

se producen $$\frac{{3}^{6} + \frac{2 + 9}{7 + 8}}{451},$$ que también fue encontrado por los demás.

Answer 4

La aproximación$$\frac{23225}{8544} \approx 2.718281835205993$ $ has the pandigital representation $ $\displaystyle\frac{\left({3}^{5}\right) - \left(1 + \frac{{2}^{- 4}}{\frac{6}{7}}\right)}{89}.$$%