Mensajes

Creo que habrá mucha gente más capacitada, que tenga ideales socialistas para el puesto... pero en fin, el que tiene el poder de elegir, elige...

Este comentario, desde luego es muy, muy, muy desafortunado lamentable...

Me gustan los de parche en el ojo y pata de palo, tú no.

...y es que pretender comparar un auténtico pirata que además de ladrón, era secuestrador, incendiario, asesino y tal vez violador... con alguien que se descarga una ***** de texto... ya retrata la forma de pensamiento cuadriculado que tiene.

Vaya detrás (para terminar), que nunca me he leído ninguna novela de este tipo, ni intención...

Espero eso sí, que como ministro separa estar a la altura, y que no acabe creyendo (como tantos), que la cultura es "el futuro económico de los 'artistas' "... porque entonces habrá dado claras muestras de su incultura.

Es completamente normal, se lo han ganado a pulso...

Insisten una y otra vez en imitar a Chrome, cuando los que usamos firefox, (básicamente) es porque detestamos Chrome. Desde el momento en que no haya apenas diferencia entre usar Firefox y Chrome, el salto hacia el 'lado oscuro', no supondrá ningún trauma.

...así que unos saltarán a Chorme, y otros hacia otros navegadores...

Su suma también la cuota del mercado abandonado (los que usan S.O. mas viejos, y para los que ya no se hacen versiones).

Esto no tiene nada que ver con la corrupción...

...y son bastantes las empresas que obligan a sus trabajadores a darse de alta de autónomo y operar como tales... está en el límite de la legalidad (para mí queda fuera de la ley), pero falta que haya verdadera voluntad en pararlo.

Esto es simplemente que hay empresas donde tienen demasidos listos, tratando de exprimir al trabajador al máximo. Antes las empresas ganaban dinero de sus clientes, ahora también quieren ganarlo de sus trabajadores...

¿Quizás hayan indicado 1 ó 10 millones y alguien ha perdido ceros?
Por que si son 10.000 dólares... para el gobierno de un país, es una miseria. Si esa es la cifra, mejor no donar nada, pués solo refleja miseria...

No entiendo en qué afecta la ley RGPD a un foro.
La ley exige que los usuarios explicitamente acepten los términos, y no que por defecto sea así y si el usuario no quiere, deba explicítamente dirigirse a ellos diciendo no...
En el caso de un foro, el propio registro supone la aceptación expresa por parte del usuario... como no sea que la ley tenga más detalles (a revisar por abogados)...

Bueno, de entrada Google, no es la "policía de internet". Básicamente son indexadores de páginas, no pueden garantizar de ninguna manera (ni nadie) que haya páginas falsas...

Si entraste una vez y no te deja una segunda, quzás detecten tu IP, y no quieren que alguien 'supuestamente ya timado', regrese a tomar pruebas... intenta interponiendo una VPN entre tu equipo y dicha página.

creo que seria mas sencillo si utilizo apuntadores o estoy equivocado.

mmm... no sabes lo que dices.
Tu dices sencillo, por ver 60 líneas de código, con las que no contabas?.
Es el código mínimo, escueto... 2 enumeraciones para saber con que se opera y qué se devuelve (aunque inicialmente son muy parecidas, cuando añades más tokens empieza a distanciarse el parecido) y 2 funciones (4 si se incluye la de meter tokens en la pila, y la última de efectuar el cálculo).

La primera función es la general, la que recibe la entrada chequea el carácter inicial y deriva hacia (la segunda función) el reconocimiento del token según dicho carácter (estado inicial). A su vuelta si no hubo errores y el reconocimiento fue efectivo, se invoca la 3ª función para almacenar el token, y finalmente cuando se termina de reconocer la entrada, toca realizar los cálculos.

Una calculadora la puedes hacer más simple si quieres:
Con la 'pantalla vacía', cuando empiece a escribir dígitos (basta 1 solo), está introduciendo el operando1, luego apenas el usuario introduzca un operador (pulsando la tecla, o escribiendo el carácter si no hay interfaz gráfica), almacenas el lo entrado como primer operando, cuando escriba otro dígito, almacenas el operador, y cuando de nuevo escriba otro operador efectúas la operación con los operandos previos, y el resultado se deja en el operando1... si el segundo operador era el símbolo "=", además muestras el resultado al usuario.
(nota que con la pantalla vacía ambos operandos tienen valor 0, luego si empieza introduciendo un operador, se considera almacenado como operando1 el valor 0).
Si no, cuando de nuevo introduzca un dígito, vuelves a guardar el operador, y tras un nuevo operador, los digitos recién metidos quedan almacenados como el 2º operando, y de nuevo se procesa ambos operandos con el operador introducido, y de nuevo el resultado se queda como el operando 1.

El defecto de este modelo, son 2:
- El primero defecto: el usuario debe introducir las operaciones en orden, ya que la precedencia seguida es 'se ejecuta inmediatamente', luego obliga al usuario a introducir ordenadamente o el resultado final puede ser errado... 5+2*3=, con este diseño de calculadora arrojaría:
opn1 = 5
opr = "+"
si opr = "=" mostrar opn1
opn2 = 2
oprtemp = "*"
opn1 = opn1 opr opn2 = 5 + 2 = 7
opr= oprtemp
si opr = "=" mostrar opn1
opn2 = 3
oprtemp = "="
opn1 = opn1 opr opn2 = 7 * 3 = 21
opr = oprtemp
si opr = "=" mostrar opn1   mostrar 21
Por comodidad al operando1 sería mejor llamarlo acumulador, y al operando2, simplemente operando.

Con precedencia de operadores sería opn1 = 5+(2*3) = 11

- El segundo defecto: Al ser ejecutado de modo inmediato, (carece de memoria, solo mantiene 3 datos). El usuario no puede ver que ha escrito más allá de lo último entrado, es fácil equivocarse y repetir un operando ya escrito con anterioridad, tampoco puede hacer nada más complejo, le exige pensarlo antes de introducir datos, ni puede hacer modificaciones sobre la marcha...

Luego proveer que pueda entrar una expresión completa, es mucho más efectivo, una línea de texto con una expresión donde pueda modificar, añadir, verificar antes de procesar, es un diseño más 'potente' de calculadora...
Al tiempo, si de nuevo te vas conformas con +-*/=, no te compliques más... Esto es, si es un tarea escolar...

...pero desde el momento en que a futuro quieras añadir operandos más complejos (números reales, en diferentes bases numéricas) ú operadores más complejos (como seno, coseno, tangente, random, media aritmética, raíz cuadrada, raíz cúbica, Xor, And, etc... tendrás que permitir operadores en la forma: 'sin', 'cos', 'atn', 'rnd', 'mod' 'sqr', 'sq3', 'xor', 'and'...), sí o sí, vas a necesitar un analizador de tokens... esto será tanto más cierto, cuanto más complejo haya de ser... y cuanto más complejo haya de ser, proveer el mecanismo (el diseño) más eficaz será lo mejor para poder ampliarlo, sin dejarse los sesos en ello... ergo, ahí te he mostrado el camino a seguir... listo para ampliar cuando se precise, falta básicamente proveer un analizador de "identificador" (cuyo código es casi idéntico al de número), junto con algún token alfabetico-alfanumerico, etc...

Lo que se me complica con los apuntadores es como recorrerlo y luego hacer las operaciones.

Para manejar los datos, elige estructuras que sobretodo seas capaz de manejar, porque las conoces y entiendes, aunque no sea del todo óptimo. En primer lugar uno debe lograr que funcione, luego es tiempo de hacer optimizaciones... no tiene sentido que pretendas usar por ejemplo una tabla hash, si no sabes como usarla y menos como coinstruírla o mantenerla.
Primero logra que te funciones y luego ya mirarás de intentar optimizarlo...
Ten en cuenta que la entrada recibida es en un array de bytes-caracteres, realmente al caso es lo más óptimo.

[wolfbcn]

Esta noticia ya la puso wolfbcn hace poco más o menos que una semana.

https://foro.elhacker.net/noticias/facebook_quiere_que_le_envies_tus_fotos_intimas_para_evitar_el_porno_vengativo-t484087.0.html

jajaja... que bueno.
Si temes que tu pareja (o un conocido) suba una foto sin tu consentimiento, mejor sube tu mismo las 250 que tienes (a unos desconocidos). si no confías en tu pareja, porqué vas a confiar en unos desconocidos????. Absurdo.

Lo mejor es no hacerse nunca fotos salidas de tono y listo. Y si te las hiciste, elíminalas para siempre. Tu pareja ya te tiene 'en persona' no necesita tenerte en fotos.

Otro problema es que pasa con facebook y las colisiones... yo estoy seguro que si hasheao todas la imágenes de mis discos, posiblemente no haya colisión, pero con las fotos de cientos de millones de millones de personas, me temo que colisiones se van a dar sí o sí... con alguna frecuencia. Salvo que usen dos hashes distintos para una misma imagen.

["coma más ensalada para que conserve su linda silueta"]

No quería meterme en esta conversación, peor es que a veces resulta imposible aguantar tanta tontería...

Si alguien debe ser multado por "coma más ensalada para que conserve su linda silueta", entonces alguien que diga "M3 C460 3N 7U PU74 M4DR3, H1J0 D3 PU74, C48R0N", deberia ir a la cárcel directo, y más aún el que te amenza de muerte.

Y si eso fuera así, entonces los carteristas sin ir más lejos, como mínimo se les debería amputar la mano...

Hay algo que se llama justicia, y hay algo que se llama justificación y hay algo que se llama proporcionalidad. Y no hay proporcionalidad justificada para una justicia así.

...y con el asunto de la violación, eso es un delito por sí mismo, que de ser el caso, me temo que será un millón de veces más grave que una tontería de piropo... y que por tanto no viene al caso.

Al piropo ése, yo es que, ni le llamo piropo, es solo un simple comentario...

[Nota]

Es que has ido a lo fácil... operar con bytes (chars), resulta cómodo...

Bueno, la solución es que precisas una pequeña función que es un analizador léxico (en inglés lo suelen llamar scanner)... para ir leyendo la cadena de entrada y reconocer los números...

Te aproximo al resultado de lo que necesitas...


Se necesita unos estados para saber por donde andamos...y qué hacer a cada momento.
Nota como los valores constantes con más de 1 bit, su nombre cambia a ES_.... aunque luego no los usamos...

Código [Seleccionar] Expandir


enumeracion AtributosDeCaracteres
   ATRIB_CHAR_DESCONOCIDO = 0
   ATRIB_CHAR_DIGITO = 1
   ATRIB_CHAR_OPERADOR_ASIGNA = 2
   ATRIB_CHAR_OPERADOR_ARIT = 4   ' aritmético... si incluyes buleanos, o comparadores, añade las constantes antes de parentesis (y desplaza esos con sus valores más abajo)
       ES_ATRIB_CHAR_OPERADOR = (ATRIB_CHAR_OPERADOR_ASIGNA or ATRIB_CHAR_OPERADOR_ARIT)
   ATRIB_CHAR_PARENTESIS_ABRE = 8
   ATRIB_CHAR_PARENTESIS_CIERRA = 16
       ES_ATRIB_CHAR_PARENTESIS = (ATRIB_CHAR_PARENTESIS_ABRE or ATRIB_CHAR_PARENTESIS_CIERRA)
   ATRIB_CHAR_ESPACIO = 99  // espacio o tabulador... espacio duro, va hacer difícil que aparezca.
fin enumeracion

Se precisa un array que contendrá los atributos (que nos interesan) de todos los caracteres (que nos interesan).

Código [Seleccionar] Expandir


array bytes Atributos[0 a 255]

Y rellenar el array de atributos... (el resto de operadores te lo dejo para ti).

Código [Seleccionar] Expandir


funcion Main
   // empezamos borrando la basura...
   bucle para k desde 0 a 255
       Atributos[k] = ATRIB_CHAR_DESCONOCIDO
   siguiente

   // los dígitos...
   bucle para k desde 48 a 57
       Atributos[k] = ATRIB_CHAR_DIGITO
   siguiente

   // operadores...
   Atributos[43] = ATRIB_CHAR_OPERADOR_ARIT    // '+'
   Atributos[45] = ATRIB_CHAR_OPERADOR_ARIT    // '-'
   Atributos[42] = ATRIB_CHAR_OPERADOR_ARIT    // '*'
      ... el resto de operadores a considerar

   Atributos[61] = ATRIB_CHAR_OPERADOR_ASIGNA  // '='

   // paréntesis...
   Atributos[40] = ATRIB_CHAR_PARENTESIS_ABRE  // '('
   Atributos[41] = ATRIB_CHAR_PARENTESIS_CIERRA  // ')'

   // espacios...
   Atributos[09] = ATRIB_CHAR_ESPACIO  // tab
   Atributos[32] = ATRIB_CHAR_ESPACIO  // spc
fin funcion


Ya tenemos la base, va faltando la función para obtener los tokens con el analizador léxico.

Código [Seleccionar] Expandir


enumeracion TiposDeToken
   TOKEN_ERROR = 0
   TOKEN_NUMERO =1
   TOKEN_ASIGNA = 2
   TOKEN_OPERADOR =3
   TOKEN_PARENTESIS = 4
   
   TOKEN_IGNORA_ESPACIOS = 9
fin enumeracion

// devuelve el tipo de token hallado y por referencia un string con el valor del token, y el índice (se va actualizando)
// Parámetros:
//     Entrada: es el array de caracteres que se reciben...
//     Indice: es el índice actual siendo analizado. Es un parámetro por referencia.
//     Limite: es el tamaño del array (para no andar preguntando cada vez que se entra a la funcion).
//     Token: el valor a devolver para almacenar... puedes devolver un entero si lo prefieres...
// Devuelve: el tipo de token hallado. Error si el carácter no pertenece a ningún tipo de token que el programa reconoce.
TiposDeToken = funcion GetToken(array chars Entrada[], entero (ref) Indice, entero limite, string (ref) Token)
   AtributosDeCaracteres ch
   entero j, k

   Token = Entrada(indice)
   ch = Atributos[entrada[indice]]
   indice +=1
   Seleccionar caso ch
       caso ATRIB_CHAR_DIGITO            
           Hacer mientras (indice < limite)
               Si (Atributos[entrada[indice]] != ATRIB_CHAR_DIGITO )  // empieza otro token, devolver el número hallado.
                   devolver TOKEN_NUMERO
               fin si
               Token += Entrada(indice)  // concatena otro dígito...
               indice +=1
           repetir
           devolver TOKEN_NUMERO   // fin del array.
       caso ATRIB_CHAR_OPERADOR_ARIT
           devolver TOKEN_OPERADOR
       caso ATRIB_CHAR_OPERADOR_ASIGNA
           //token = "="
           devolver TOKEN_ASIGNA            
       caso ATRIB_CHAR_PARENTESIS_ABRE
           //token = "("
           devolver TOKEN_PARENTESIS
       caso ATRIB_CHAR_PARENTESIS_CIERRA
           //token = ")"
           devolver TOKEN_PARENTESIS
       caso ATRIB_CHAR_ESPACIO  // es idéntico a dígitos, salvando las distancias, y que aquí, no precisa devolver el string del Token
           Token = ""
           Hacer mientras (indice < limite)
               Si (Atributos[entrada[indice]] != ATRIB_CHAR_ESPACIO) // [s]TOKEN_IGNORA_ESPACIOS )[/s]  // fin de espacios...
                   devolver TOKEN_IGNORA_ESPACIOS
               fin si
               indice +=1
           repetir
           devolver TOKEN_IGNORA_ESPACIOS
       resto casos // ATRIB_CHAR_DESCONOCIDO
           Token = ""
           devolver TOKEN_ERROR
   fin seleccion
fin funcion


Y ahora falta la función general que recibe la entrada, genera los tokens partiendo de la entrada recibiday que manda almacenar...

Código [Seleccionar] Expandir


buleano = funcion CalcularExpresion(char Cadena[100]
   entero j, k
   string Token
   TiposDeToken tTok

   k= tamaño de Cadena
   j=0
   Hacer mientras (j<K)
       tTok = GetToken(cadena, j, k,Token)
       Si (tTok = TOKEN_ERROR)
            mensaje de error
            devolver FALSE
       Sino
           Si (tTok != TOKEN_IGNORA_ESPACIOS)
               GuardarTokenEnPila(Token, tTok) // entrar Token para meter en la pila en la notación elegida (polaca, polaca inversa, etc...)
           fin si
       fin si
   Repetir

   // la función que toma la pila y evalúa la expresión... si la haces sobre la marcha,
   //   si no hay otra precedencia en operadores que el orden de entrada,
   //   esto sobraría... sino, no puede evaluarse hasta procesar toda la entrada.
   Calcular
   
   Devolver True
fin funcion


No he revisado tu código, pero a simple vista, parece subóptimo, de todos modos si dices que te funciona, pués listo...
Añade lo señalado y actualiza como convenga...
Ahora te llega un array de bytes-caracteres y el analizador va hallando los números (múltiples dígitos), operadores y parentesis, además ignora espacios y tabuladores y chequea por caracteres no admitidos...
Nota que es solo un analizador léxico, de expresiones aritméticas numéricas, si metes demasiados dígitos que superen el entero generará error, esa comprobación realmente corresponde al analizador semántico, pero para lo sencillo que es el programa, lo puedes verificar justo antes de llamar a almacenar en la pila... antes de "GuardarTokenEnPila", si es un token numérico.
Nota que te falta rellenar datos... en el array los valores de otros operadores... en Main



P.d.: Fe de erratas (la constante tachada no procede, si no la que se ha puesto a  en su sitio):
Si (Atributos[entrada[indice]] != ATRIB_CHAR_ESPACIO) TOKEN_IGNORA_ESPACIOS )  // fin de espacios...