Foro SofosAgora

Foro abierto a los intereses de sus usuarios. Debate, aprende y diviértete.
Fecha actual 26 Sep 2018, 01:48

Todos los horarios son UTC + 1 hora [ DST ]




Nuevo tema Responder al tema  [ 2 mensajes ] 
Autor Mensaje
 Asunto: Pseudocódigo para hacer pscs q hagan 1 var basada en otra.
NotaPublicado: 21 Ene 2018, 04:03 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8464
Pseudocódigo para generar pseudocódigos que generen una variable basada en otra.

Actualización en el 2ndo post:
offtopic-general/pseudocodigo-para-hacer-pscs-hagan-var-basada-otra-t8609.html#p196184

Antiguo.
-------------------------------------------------------------

En otras palabras este pesudocódigo debería mostrar en pantalla algo así:
Citar:
Pseudocódigo 1:
C = V

Pseudocódigo 2:
C = V+F

Pseudocódigo 3:
C = V*F

etc
Donde:
- C es la variable a generar,
- V es la variable ya existente que se usa de base.
- F es un valor fijo que se asignaría al transformar el pseudocódigo en código.
- y los pseudocódigos pueden tener otro tipo de instrucciones, como Si, Ir a, etc.

Este tema viene a ser la práctica si este otro
offtopic-general/que-instrucciones-son-insustituibles-programacion-t8598.html
fuese la teoría, que no sé, pero sin duda es una continuación más práctica.

Si queremos generar números enteros hacemos
N = 0
N++

Para generar textos esta es una forma:
Código:
Escena 1
   actions for fotograma 1
      Data = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ";
      Char0ID = -1;
      Chars = 1;
      Resp = "";
   actions for fotograma 2
      C = "";
      Cursor = 0;
   actions for fotograma 3
      // Caracter listo para aumentar.
      Char_Cursor_ID = "Char"+Cursor+"ID";
      EvaledxChar_Cursor_IDxPlus1 = eval(Char_Cursor_ID)+1;
   actions for fotograma 4
      if (EvaledxChar_Cursor_IDxPlus1<27) {
         // Caracter puede aumentar.
         set (Char_Cursor_ID, EvaledxChar_Cursor_IDxPlus1);
         // Caracter aumenta.
         // Hay que actualizar C.
      } else {
         // El valor del char está fuera del límite.
         set (Char_Cursor_ID, 0);
         Cursor = Cursor+1;
         if (Cursor == Chars) {
            // Hay que agregar un char.
            set ("Char"+Cursor+"ID", 0);
            Chars = Chars+1;
            // Hay que actualizar C.
         } else {
            // Hay que aumentar el char siguiente.
            gotoAndPlay (3);
         }
      }
   actions for fotograma 5
      // Actualizar C.
      C = "";
      Cursor = 0;
   actions for fotograma 6
      C = Data.charAt(eval("Char"+Cursor+"ID"))+C;
      Cursor = Cursor+1;
   actions for fotograma 7
      if (Cursor<Chars) {
         // Continuar actualizando chars.
         gotoAndPlay (6);
      } else {
         // Listo, mostrar en pantalla y crear otro tx.
         Resp = C+"\n"+Resp;
         gotoAndPlay (2);
      }
En definitiva tenemos partes y las vamos combinando de modo que no se repitan y cada vez haya más partes unidas, suena sencillo. No me preocupo por que los textos tengan significado, tal vez debería, pero bue, creo que es otro tema.

El problema en cuanto al siguiente paso que pretendemos dar es que en este caso las partes no es claro cuales son y puede haber repeticiones en los resultados a menos que nos ingeniemos para evitarlos (algo similar podría decir respecto a resultados inútiles, por ejemplo con loops que nunca acaban, pero al igual que con los textos es algo que por ahora no me preocupa. Digamos que intento hacer que la máquina camine y esto otro sería como evitar que caiga en pozos, es algo avanzado que no me corresponde aún).

Será que hay un paso intermedio que nos estamos saltando, no sé cual.

Pero podemos simplificar el paso, que sea más corto. Olvidemos por ahora los Si, los Ir a, etc, sólo usemos la función de definir una variable, usando las "funciones" básicas, que no sé bien cuales conviene que sean (ver dudas), pero más o menos son +F, *F, etc.

En estas condiciones, podemos deducir que todos los pseudocódigos comenzarían con "C =", salvo quizá que C fuese el resultado de, por ejemplo, una suma de 2 modificaciones a V, digamos VMod1+VMod2, en cuyo caso tal vez habría que comenzar por definir VMod1 y VMod2, yo lo haría pero no sé si es necesario o la única forma.

Olvidemos por ahora eso de VMod... Lo que sigue puede ser:
V+F
V*F
F/V
V^V
V^F
F^V

Acá se empieza a poner compleja la cosa porque aparecen más dudas...

No está -F ¿que pasa?
Que F puede ser negativo, así que los resultados por -F se pueden hacer con +F, así que no tiene sentido poner -F.

Que F pueda ser negativo simplifica esto pero complica la utilización que quiero hacer de los pseudocódigos generados. Aún así, pienso que está bien para empezar.

¿Y con -V qué pasa?
Que F puede ser -1 así que si se quiere V negativa se puede hacer eso.

¿V/F?
Por ejemplo V/4 = V*0.25, así que si se quiere evitar resultados repetidos conviene que no se usen ambas cosas.
No obstante, más adelante quizá lo incluya, porque por ejemplo V/3 no es posible de imitar (V*0.33333...)

¿Por qué sí está F/V?
No hallé suficientes motivos como para no incluirlo... ¿ideas?

¿Por qué V^V en vez de...?
Esto se los pregunto a uds.
Resulta que en vez de decir V+V+V+V decimos V*4.
En vez de V*V*V*V*V decimos V^5.
So, en vez de decir V^V^V^V^V ¿qué se diría? ¿existe algún símbolo para ello? ¿^^?
Imagino que estas preguntas o búsqueda de abreviaciones se pueden hacer hasta el infinito, aunque cada vez tienen menos sentido.

¿Raíz cuadrada?
Podría ser, pero si mal no recuerdo o entendí, se puede hacer con ^0. o ^-

¿Logaritmos?
Idem.

So... this is the code, for now.
Código:
Escena 1
   actions for fotograma 1
      Mod1 = "C = V+F;\n";
      Mod2 = "C = V*F;\n";
      Mod3 = "C = F/V;\n";
      Mod4 = "C = Math.pow ( V, V );\n";
      Mod5 = "C = Math.pow ( V, F );\n";
      Mod6 = "C = Math.pow ( F, V );\n";
      Line1ID = 0;
      Lines = 1;
      Resp = "";
   actions for fotograma 2
      C = "";
      Cursor = Lines;
   actions for fotograma 3
      Line_Cursor_ID = "Line"+Cursor+"ID";
      EvaledxLine_Cursor_IDxPlus1 = eval(Line_Cursor_ID)+1;
      // Línea lista para modificarse.
   actions for fotograma 4
      if (EvaledxLine_Cursor_IDxPlus1<7) {
         // Línea puede cambiar.
         set (Line_Cursor_ID, EvaledxLine_Cursor_IDxPlus1);
         A = 1;
         // Línea cambia.
         // Hay que actualizar C.
      } else {
         // La línea no puede cambiar, no hay más posibilidades para ella.
         set (Line_Cursor_ID, 1);
         Cursor = Cursor-1;
         if (Cursor>0) {
            // Hay que modificar la línea siguiente anterior.
            B = 1;
            gotoAndPlay (3);
         } else {
            // Hay que agregar una línea.
            Lines = Lines+1;
            set ("Line"+Lines+"ID", 1);
            // Hay que actualizar C.
            D = 1;
         }
      }
   actions for fotograma 5
      // Actualizar C.
      C = "";
      Cursor = Lines;
   actions for fotograma 6
      C = eval("Mod"+eval("Line"+Cursor+"ID"))+C;
      Cursor = Cursor-1;
   actions for fotograma 7
      if (Cursor>0) {
         // Continuar actualizando líneas.
         gotoAndPlay (6);
      } else {
         // Listo, mostrar en pantalla y crear otras instrucciones.
         Resp = C+"stop();"+"\n"+"\n"+Resp;
         gotoAndPlay (2);
      }
Resultado (aunque sólo llega a combinaciones de 3, es largo):
Spoiler: show
C = Math.pow ( F, V );
C = Math.pow ( F, V );
C = Math.pow ( F, V );
stop();

C = Math.pow ( F, V );
C = Math.pow ( F, V );
C = Math.pow ( V, F );
stop();

C = Math.pow ( F, V );
C = Math.pow ( F, V );
C = Math.pow ( V, V );
stop();

C = Math.pow ( F, V );
C = Math.pow ( F, V );
C = F/V;
stop();

C = Math.pow ( F, V );
C = Math.pow ( F, V );
C = V*F;
stop();

C = Math.pow ( F, V );
C = Math.pow ( F, V );
C = V+F;
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, F );
C = Math.pow ( F, V );
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, F );
C = Math.pow ( V, F );
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, F );
C = Math.pow ( V, V );
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, F );
C = F/V;
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, F );
C = V*F;
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, F );
C = V+F;
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, V );
C = Math.pow ( F, V );
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, V );
C = Math.pow ( V, F );
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, V );
C = Math.pow ( V, V );
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, V );
C = F/V;
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, V );
C = V*F;
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, V );
C = V+F;
stop();

C = Math.pow ( F, V );
C = F/V;
C = Math.pow ( F, V );
stop();

C = Math.pow ( F, V );
C = F/V;
C = Math.pow ( V, F );
stop();

C = Math.pow ( F, V );
C = F/V;
C = Math.pow ( V, V );
stop();

C = Math.pow ( F, V );
C = F/V;
C = F/V;
stop();

C = Math.pow ( F, V );
C = F/V;
C = V*F;
stop();

C = Math.pow ( F, V );
C = F/V;
C = V+F;
stop();

C = Math.pow ( F, V );
C = V*F;
C = Math.pow ( F, V );
stop();

C = Math.pow ( F, V );
C = V*F;
C = Math.pow ( V, F );
stop();

C = Math.pow ( F, V );
C = V*F;
C = Math.pow ( V, V );
stop();

C = Math.pow ( F, V );
C = V*F;
C = F/V;
stop();

C = Math.pow ( F, V );
C = V*F;
C = V*F;
stop();

C = Math.pow ( F, V );
C = V*F;
C = V+F;
stop();

C = Math.pow ( F, V );
C = V+F;
C = Math.pow ( F, V );
stop();

C = Math.pow ( F, V );
C = V+F;
C = Math.pow ( V, F );
stop();

C = Math.pow ( F, V );
C = V+F;
C = Math.pow ( V, V );
stop();

C = Math.pow ( F, V );
C = V+F;
C = F/V;
stop();

C = Math.pow ( F, V );
C = V+F;
C = V*F;
stop();

C = Math.pow ( F, V );
C = V+F;
C = V+F;
stop();

C = Math.pow ( V, F );
C = Math.pow ( F, V );
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, F );
C = Math.pow ( F, V );
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, F );
C = Math.pow ( F, V );
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, F );
C = Math.pow ( F, V );
C = F/V;
stop();

C = Math.pow ( V, F );
C = Math.pow ( F, V );
C = V*F;
stop();

C = Math.pow ( V, F );
C = Math.pow ( F, V );
C = V+F;
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, F );
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, F );
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, F );
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, F );
C = F/V;
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, F );
C = V*F;
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, F );
C = V+F;
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, V );
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, V );
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, V );
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, V );
C = F/V;
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, V );
C = V*F;
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, V );
C = V+F;
stop();

C = Math.pow ( V, F );
C = F/V;
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, F );
C = F/V;
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, F );
C = F/V;
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, F );
C = F/V;
C = F/V;
stop();

C = Math.pow ( V, F );
C = F/V;
C = V*F;
stop();

C = Math.pow ( V, F );
C = F/V;
C = V+F;
stop();

C = Math.pow ( V, F );
C = V*F;
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, F );
C = V*F;
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, F );
C = V*F;
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, F );
C = V*F;
C = F/V;
stop();

C = Math.pow ( V, F );
C = V*F;
C = V*F;
stop();

C = Math.pow ( V, F );
C = V*F;
C = V+F;
stop();

C = Math.pow ( V, F );
C = V+F;
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, F );
C = V+F;
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, F );
C = V+F;
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, F );
C = V+F;
C = F/V;
stop();

C = Math.pow ( V, F );
C = V+F;
C = V*F;
stop();

C = Math.pow ( V, F );
C = V+F;
C = V+F;
stop();

C = Math.pow ( V, V );
C = Math.pow ( F, V );
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, V );
C = Math.pow ( F, V );
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, V );
C = Math.pow ( F, V );
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, V );
C = Math.pow ( F, V );
C = F/V;
stop();

C = Math.pow ( V, V );
C = Math.pow ( F, V );
C = V*F;
stop();

C = Math.pow ( V, V );
C = Math.pow ( F, V );
C = V+F;
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, F );
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, F );
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, F );
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, F );
C = F/V;
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, F );
C = V*F;
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, F );
C = V+F;
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, V );
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, V );
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, V );
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, V );
C = F/V;
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, V );
C = V*F;
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, V );
C = V+F;
stop();

C = Math.pow ( V, V );
C = F/V;
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, V );
C = F/V;
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, V );
C = F/V;
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, V );
C = F/V;
C = F/V;
stop();

C = Math.pow ( V, V );
C = F/V;
C = V*F;
stop();

C = Math.pow ( V, V );
C = F/V;
C = V+F;
stop();

C = Math.pow ( V, V );
C = V*F;
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, V );
C = V*F;
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, V );
C = V*F;
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, V );
C = V*F;
C = F/V;
stop();

C = Math.pow ( V, V );
C = V*F;
C = V*F;
stop();

C = Math.pow ( V, V );
C = V*F;
C = V+F;
stop();

C = Math.pow ( V, V );
C = V+F;
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, V );
C = V+F;
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, V );
C = V+F;
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, V );
C = V+F;
C = F/V;
stop();

C = Math.pow ( V, V );
C = V+F;
C = V*F;
stop();

C = Math.pow ( V, V );
C = V+F;
C = V+F;
stop();

C = F/V;
C = Math.pow ( F, V );
C = Math.pow ( F, V );
stop();

C = F/V;
C = Math.pow ( F, V );
C = Math.pow ( V, F );
stop();

C = F/V;
C = Math.pow ( F, V );
C = Math.pow ( V, V );
stop();

C = F/V;
C = Math.pow ( F, V );
C = F/V;
stop();

C = F/V;
C = Math.pow ( F, V );
C = V*F;
stop();

C = F/V;
C = Math.pow ( F, V );
C = V+F;
stop();

C = F/V;
C = Math.pow ( V, F );
C = Math.pow ( F, V );
stop();

C = F/V;
C = Math.pow ( V, F );
C = Math.pow ( V, F );
stop();

C = F/V;
C = Math.pow ( V, F );
C = Math.pow ( V, V );
stop();

C = F/V;
C = Math.pow ( V, F );
C = F/V;
stop();

C = F/V;
C = Math.pow ( V, F );
C = V*F;
stop();

C = F/V;
C = Math.pow ( V, F );
C = V+F;
stop();

C = F/V;
C = Math.pow ( V, V );
C = Math.pow ( F, V );
stop();

C = F/V;
C = Math.pow ( V, V );
C = Math.pow ( V, F );
stop();

C = F/V;
C = Math.pow ( V, V );
C = Math.pow ( V, V );
stop();

C = F/V;
C = Math.pow ( V, V );
C = F/V;
stop();

C = F/V;
C = Math.pow ( V, V );
C = V*F;
stop();

C = F/V;
C = Math.pow ( V, V );
C = V+F;
stop();

C = F/V;
C = F/V;
C = Math.pow ( F, V );
stop();

C = F/V;
C = F/V;
C = Math.pow ( V, F );
stop();

C = F/V;
C = F/V;
C = Math.pow ( V, V );
stop();

C = F/V;
C = F/V;
C = F/V;
stop();

C = F/V;
C = F/V;
C = V*F;
stop();

C = F/V;
C = F/V;
C = V+F;
stop();

C = F/V;
C = V*F;
C = Math.pow ( F, V );
stop();

C = F/V;
C = V*F;
C = Math.pow ( V, F );
stop();

C = F/V;
C = V*F;
C = Math.pow ( V, V );
stop();

C = F/V;
C = V*F;
C = F/V;
stop();

C = F/V;
C = V*F;
C = V*F;
stop();

C = F/V;
C = V*F;
C = V+F;
stop();

C = F/V;
C = V+F;
C = Math.pow ( F, V );
stop();

C = F/V;
C = V+F;
C = Math.pow ( V, F );
stop();

C = F/V;
C = V+F;
C = Math.pow ( V, V );
stop();

C = F/V;
C = V+F;
C = F/V;
stop();

C = F/V;
C = V+F;
C = V*F;
stop();

C = F/V;
C = V+F;
C = V+F;
stop();

C = V*F;
C = Math.pow ( F, V );
C = Math.pow ( F, V );
stop();

C = V*F;
C = Math.pow ( F, V );
C = Math.pow ( V, F );
stop();

C = V*F;
C = Math.pow ( F, V );
C = Math.pow ( V, V );
stop();

C = V*F;
C = Math.pow ( F, V );
C = F/V;
stop();

C = V*F;
C = Math.pow ( F, V );
C = V*F;
stop();

C = V*F;
C = Math.pow ( F, V );
C = V+F;
stop();

C = V*F;
C = Math.pow ( V, F );
C = Math.pow ( F, V );
stop();

C = V*F;
C = Math.pow ( V, F );
C = Math.pow ( V, F );
stop();

C = V*F;
C = Math.pow ( V, F );
C = Math.pow ( V, V );
stop();

C = V*F;
C = Math.pow ( V, F );
C = F/V;
stop();

C = V*F;
C = Math.pow ( V, F );
C = V*F;
stop();

C = V*F;
C = Math.pow ( V, F );
C = V+F;
stop();

C = V*F;
C = Math.pow ( V, V );
C = Math.pow ( F, V );
stop();

C = V*F;
C = Math.pow ( V, V );
C = Math.pow ( V, F );
stop();

C = V*F;
C = Math.pow ( V, V );
C = Math.pow ( V, V );
stop();

C = V*F;
C = Math.pow ( V, V );
C = F/V;
stop();

C = V*F;
C = Math.pow ( V, V );
C = V*F;
stop();

C = V*F;
C = Math.pow ( V, V );
C = V+F;
stop();

C = V*F;
C = F/V;
C = Math.pow ( F, V );
stop();

C = V*F;
C = F/V;
C = Math.pow ( V, F );
stop();

C = V*F;
C = F/V;
C = Math.pow ( V, V );
stop();

C = V*F;
C = F/V;
C = F/V;
stop();

C = V*F;
C = F/V;
C = V*F;
stop();

C = V*F;
C = F/V;
C = V+F;
stop();

C = V*F;
C = V*F;
C = Math.pow ( F, V );
stop();

C = V*F;
C = V*F;
C = Math.pow ( V, F );
stop();

C = V*F;
C = V*F;
C = Math.pow ( V, V );
stop();

C = V*F;
C = V*F;
C = F/V;
stop();

C = V*F;
C = V*F;
C = V*F;
stop();

C = V*F;
C = V*F;
C = V+F;
stop();

C = V*F;
C = V+F;
C = Math.pow ( F, V );
stop();

C = V*F;
C = V+F;
C = Math.pow ( V, F );
stop();

C = V*F;
C = V+F;
C = Math.pow ( V, V );
stop();

C = V*F;
C = V+F;
C = F/V;
stop();

C = V*F;
C = V+F;
C = V*F;
stop();

C = V*F;
C = V+F;
C = V+F;
stop();

C = V+F;
C = Math.pow ( F, V );
C = Math.pow ( F, V );
stop();

C = V+F;
C = Math.pow ( F, V );
C = Math.pow ( V, F );
stop();

C = V+F;
C = Math.pow ( F, V );
C = Math.pow ( V, V );
stop();

C = V+F;
C = Math.pow ( F, V );
C = F/V;
stop();

C = V+F;
C = Math.pow ( F, V );
C = V*F;
stop();

C = V+F;
C = Math.pow ( F, V );
C = V+F;
stop();

C = V+F;
C = Math.pow ( V, F );
C = Math.pow ( F, V );
stop();

C = V+F;
C = Math.pow ( V, F );
C = Math.pow ( V, F );
stop();

C = V+F;
C = Math.pow ( V, F );
C = Math.pow ( V, V );
stop();

C = V+F;
C = Math.pow ( V, F );
C = F/V;
stop();

C = V+F;
C = Math.pow ( V, F );
C = V*F;
stop();

C = V+F;
C = Math.pow ( V, F );
C = V+F;
stop();

C = V+F;
C = Math.pow ( V, V );
C = Math.pow ( F, V );
stop();

C = V+F;
C = Math.pow ( V, V );
C = Math.pow ( V, F );
stop();

C = V+F;
C = Math.pow ( V, V );
C = Math.pow ( V, V );
stop();

C = V+F;
C = Math.pow ( V, V );
C = F/V;
stop();

C = V+F;
C = Math.pow ( V, V );
C = V*F;
stop();

C = V+F;
C = Math.pow ( V, V );
C = V+F;
stop();

C = V+F;
C = F/V;
C = Math.pow ( F, V );
stop();

C = V+F;
C = F/V;
C = Math.pow ( V, F );
stop();

C = V+F;
C = F/V;
C = Math.pow ( V, V );
stop();

C = V+F;
C = F/V;
C = F/V;
stop();

C = V+F;
C = F/V;
C = V*F;
stop();

C = V+F;
C = F/V;
C = V+F;
stop();

C = V+F;
C = V*F;
C = Math.pow ( F, V );
stop();

C = V+F;
C = V*F;
C = Math.pow ( V, F );
stop();

C = V+F;
C = V*F;
C = Math.pow ( V, V );
stop();

C = V+F;
C = V*F;
C = F/V;
stop();

C = V+F;
C = V*F;
C = V*F;
stop();

C = V+F;
C = V*F;
C = V+F;
stop();

C = V+F;
C = V+F;
C = Math.pow ( F, V );
stop();

C = V+F;
C = V+F;
C = Math.pow ( V, F );
stop();

C = V+F;
C = V+F;
C = Math.pow ( V, V );
stop();

C = V+F;
C = V+F;
C = F/V;
stop();

C = V+F;
C = V+F;
C = V*F;
stop();

C = V+F;
C = V+F;
C = V+F;
stop();

C = Math.pow ( F, V );
C = Math.pow ( F, V );
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, F );
stop();

C = Math.pow ( F, V );
C = Math.pow ( V, V );
stop();

C = Math.pow ( F, V );
C = F/V;
stop();

C = Math.pow ( F, V );
C = V*F;
stop();

C = Math.pow ( F, V );
C = V+F;
stop();

C = Math.pow ( V, F );
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, F );
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, F );
C = F/V;
stop();

C = Math.pow ( V, F );
C = V*F;
stop();

C = Math.pow ( V, F );
C = V+F;
stop();

C = Math.pow ( V, V );
C = Math.pow ( F, V );
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, F );
stop();

C = Math.pow ( V, V );
C = Math.pow ( V, V );
stop();

C = Math.pow ( V, V );
C = F/V;
stop();

C = Math.pow ( V, V );
C = V*F;
stop();

C = Math.pow ( V, V );
C = V+F;
stop();

C = F/V;
C = Math.pow ( F, V );
stop();

C = F/V;
C = Math.pow ( V, F );
stop();

C = F/V;
C = Math.pow ( V, V );
stop();

C = F/V;
C = F/V;
stop();

C = F/V;
C = V*F;
stop();

C = F/V;
C = V+F;
stop();

C = V*F;
C = Math.pow ( F, V );
stop();

C = V*F;
C = Math.pow ( V, F );
stop();

C = V*F;
C = Math.pow ( V, V );
stop();

C = V*F;
C = F/V;
stop();

C = V*F;
C = V*F;
stop();

C = V*F;
C = V+F;
stop();

C = V+F;
C = Math.pow ( F, V );
stop();

C = V+F;
C = Math.pow ( V, F );
stop();

C = V+F;
C = Math.pow ( V, V );
stop();

C = V+F;
C = F/V;
stop();

C = V+F;
C = V*F;
stop();

C = V+F;
C = V+F;
stop();

C = Math.pow ( F, V );
stop();

C = Math.pow ( V, F );
stop();

C = Math.pow ( V, V );
stop();

C = F/V;
stop();

C = V*F;
stop();

C = V+F;
stop();


-------------------------------------------------------------
Edit:
Me he dado cuenta de que está mal, es decir, la 1era línea está bien, pero las demás en donde se defina C no deben sustituir a las anteriores, sino que deben basarse en C. Por ejemplo:
C = V+F;
C = C*V;

O sea, todas las líneas donde se defina C deben mencionar a C, salvo que sea la 1era vez.
-------------------------------------------------------------

Tras haber logrado esto quiero reirme como LOCO, MWAJAJAJAJAJAJAJAJAJAJA AHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH!!!!! Y quiero seguir, pero la máquina se me tranca y no quiero que el post se alargue hacia el costado. Es que tuve que esforzarme como LOCOOOOOOOOO para poder hacer esta cosita de nada.

Próximos pasos:
- Hacer al código más eficiente, porque al actualizar C se actualiza cada parte y eso no es necesario, basta con que se actualicen las partes que cambiaron.
- Ir agregando modificadores.
- Evitar ciertos sin sentidos, tal vez lo haga 1ero con textos.

En serio mi compu está tortuga por el largo del post, bye.

fin de lo Antiguo.

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Última edición por Tachikomaia el 07 Feb 2018, 18:13, editado 1 vez en total

Arriba
 Perfil  
Responder citando  
 Asunto: Re: Pseudocódigo para hacer pscs q hagan 1 var basada en otr
NotaPublicado: 07 Feb 2018, 18:08 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 8464
Actualización:
Código:
Escena 1
   actions for fotograma 1
      Mod1 = "C = V+F;\n";
      Mod2 = "C = V*F;\n";
      Mod3 = "C = F/V;\n";
      Mod4 = "C = Math.pow ( V, V );\n";
      Mod5 = "C = Math.pow ( V, F );\n";
      Mod6 = "C = Math.pow ( F, V );\n";
      // 2nda línea.
      Mod7 = "C = C+V;\n";
      Mod8 = "C = C+F;\n";
      Mod9 = "C = C*V;\n";
      Mod10 = "C = C*F;\n";
      Mod11 = "C = V/C;\n";
      Mod12 = "C = F/C;\n";
      Mod13 = "C = Math.pow ( C, C );\n";
      Mod14 = "C = Math.pow ( C, V );\n";
      Mod15 = "C = Math.pow ( V, C );\n";
      Mod16 = "C = Math.pow ( C, F );\n";
      Mod17 = "C = Math.pow ( F, C );\n";
      Line1ID = 0;
      Lines = 1;
      Resp = "";
   actions for fotograma 2
      C = "";
      Cursor = Lines;
   actions for fotograma 3
      Line_Cursor_ID = "Line"+Cursor+"ID";
      EvaledxLine_Cursor_IDxPlus1 = eval(Line_Cursor_ID)+1;
      // Línea lista para modificarse.
   actions for fotograma 4
      if (Cursor>1) {
         if (EvaledxLine_Cursor_IDxPlus1<18) {
            // Línea puede cambiar.
            set (Line_Cursor_ID, EvaledxLine_Cursor_IDxPlus1);
            // Línea cambia.
            // Hay que actualizar C.
         } else {
            // La línea no puede cambiar, no hay más posibilidades para ella.
            set (Line_Cursor_ID, 7);
            Cursor = Cursor-1;
            // Hay que modificar la línea anterior.
            gotoAndPlay (3);
         }
      } else if (EvaledxLine_Cursor_IDxPlus1<7) {
         // Línea 1 puede cambiar.
         set (Line_Cursor_ID, EvaledxLine_Cursor_IDxPlus1);
         // Línea cambia.
         // Hay que actualizar C.
      } else {
         // La línea 1 no puede cambiar, no hay más posibilidades para ella.
         set (Line_Cursor_ID, 1);
         // Hay que agregar una línea.
         Lines = Lines+1;
         set ("Line"+Lines+"ID", 7);
         // Hay que actualizar C.
      }
   actions for fotograma 5
      // Actualizar C.
      C = "";
      Cursor = Lines;
   actions for fotograma 6
      C = eval("Mod"+eval("Line"+Cursor+"ID"))+C;
      Cursor = Cursor-1;
   actions for fotograma 7
      if (Cursor>0) {
         // Continuar actualizando líneas.
         gotoAndPlay (6);
      } else {
         // Listo, mostrar en pantalla y crear otras instrucciones.
         Resp = C+"\n"+Resp;
         gotoAndPlay (2);
      }


- Corregí los errores que se daban a partir de la 2nda línea. Por lo que vi, funciona bien.

Cosas por hacer:
- Optimizar la actualización de C. Lo intenté...
- Agregar más modificadores, como "tomar caracter X", e if, gotos, y lo necesario para imitar paréntesis.
- Pensar cómo puedo evitar que se muestren "combinaciones" sin sentido.

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Arriba
 Perfil  
Responder citando  
Mostrar mensajes previos:  Ordenar por  
Nuevo tema Responder al tema  [ 2 mensajes ] 

Todos los horarios son UTC + 1 hora [ DST ]


¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 1 invitado


No puede abrir nuevos temas en este Foro
No puede responder a temas en este Foro
No puede editar sus mensajes en este Foro
No puede borrar sus mensajes en este Foro

Buscar:
Saltar a:  
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
Traducción al español por Huan Manwë para phpbb-es.com
phpBB SEO