Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.
Cita de: string Manolo en 15 Octubre 2019, 21:57 PMTodos esos números son gratuitos... son a los que puedes llamar incluso aunque tu tf. no tuviere saldo o tuvieres deudas con tu empresa de telefonía...
No es gratuito, o sí?
constantes byte RosaR=255, RosaA=255, RosaV=0 // valor canales del rosa-chicle
byte nivSimil // nivel de similitud
byte r, a, v // canal de cada colores
int f, p // num filas y valor píxel
string hexColor // color en hexadecimal.
int ancho, alto // medidas d ela imagen
array int Imagen(,) // array de dos dimensiones o unidimensional si se calcula fila a fila la posición absoluta del píxel...
fichero fiI // fichero de entrada (Input), el de la imagen
fichero fio // fichero de salida (output), el del resultado
fiI.Abrir(rutaImagen) // se abre el fichero de entrada
fio.Abrir(ruta) // se abre el fichero de salida.
alto = fiI.LeerEnCabecera(alto)
ancho = fiI.LeerEnCabecera(ancho)
// solo la que proceda... se leen los píxeles desde final de cabecera...
// se supone que la imagen está descomprimida, sino es así, se precisa
// el decodificador del formato de imagen para obtener el array de píxeles...
// se da por supuesto conocer tal circunstancia.
Imagen(alto * ancho) = fiI.LeerPixeles //lectura unidimensional
Imagen(alto, ancho) = fiI.LeerPixeles // lectura bidimensional
fiI.Cerrar
nivSimil = 16
bucle f por cada fila en la imagen //imagen sería un array de píxeles, por ejemplo.
bucle p por cada pixel en f // p es el enésimo píxel en la f (fila) actual.
// 1 obtener los canales del pixel.
r = (p and 255)
v = ((p \ 256) and 255)
b = (p \ 65536)
// 2 descartar si es rosa o similar... vamos a suponer algún grado de similitud
// si, el color está 16 valores a un lado u otro por canal consideramos que es similar... y en tal caso se descarta, si no, se acepta.
// como dicho rosa está en los extremos, basta mirar hacia el otro extremo.
Si (((v > = (RosaV + nivSimil )) y ((R <= (RosaV - nivSimil)) y ((a <= (RosaA - nivSimil)) )
// formato: AAVVRR (esto es primero azul, luego verde, luego rojo)
// el operador '+' actúa como un concatenador de caracteres...
hexcolor = (((a\16).ToChar) + ((a and 15).ToChar) + ((v\16).ToChar) + ((v and 15).ToChar) + ((r\16).ToChar) + ((r and 15).ToChar)) + " "
fiO.SaveToFile(appendtofinal, hexcolor)
Sino
fiO.SaveToFile(appendtofinal, "------ ") // color rosa se guarda así, necesario si
// ...se quiere mantener posición relativa de cada color que no sea rosa.
// cada clor va separado por un espacio, para facilitar su 'lectura', visualmente...
fin si
siguiente
siguiente
fiO.Cerrar
Estructura Posicion
int X
int Y
Fin estructura
Estructura Extremo
posicion Inicial // izquierda o superior
posicion Final // derecha o inferior
fin estructura
Array de Extremo PerimVertical(alto)
array de Extremo PerimHorizontal(ancho)
Array Extremo NumPuntos(0 a 1) // 0 refiere vertical, 1 refiere horizontal, cantidad de puntos que cvontiene el array (el resto sobra)
int x, y, n // punteros de avance para cada array...
// obtener la parte vertical izquierda...
n=0
bucle para y desde 0 hasta Alto-1
bucle para x desde 0 hasta Ancho-1
Si (Similar(Rosa, imagen(y, x), 16) = FALSE)
PerimVertical(n).Inicial.X = x
PerimVertical(n).Inicial.y = y
n = (n +1)
Salir del bucle
fin si
siguiente
siguiente
NumPuntos(0).Inicial = n // solo los primeros 'n' puntos dle array PerimVertical son válidos
// obtener la parte vertical derecha...
n=0
bucle para y desde 0 hasta Alto-1
bucle para x desde Ancho-1 hasta 0 retrocediendo
Si (Similar(Rosa, imagen(y, x), 16) = FALSE)
PerimVertical(n).Final.X = x
PerimVertical(n).Final.y = y
n = (n +1)
Salir del bucle
fin si
siguiente
siguiente
NumPuntos(0).Final = n // solo los primeros 'n' puntos dle array PerimVertical son válidos
// obtener la parte horizontal superior...
n=0
bucle para x desde 0 hasta Ancho-1
bucle para y desde 0 hasta Alto-1
Si (Similar(Rosa, imagen(y, x), 16) = FALSE)
PerimHorizontal(n).Inicial.X = x
PerimHorizontal(n).Inicial.y = y
n = (n +1)
Salir del bucle
fin si
siguiente
siguiente
NumPuntos(1).Inicial = n // solo los primeros 'n' puntos dle array PerimHorizontal son válidos
// obtener la parte horizontal inferior...
n=0
bucle para x desde Ancho-1 hasta 0 retrocediendo
bucle para y desde 0 hasta Alto-1
Si (Similar(Rosa, imagen(y, x), 16) = FALSE)
PerimHorizontal(n).Final.X = x
PerimHorizontal(n).Final.y = y
n = (n +1)
Salir del bucle
fin si
siguiente
siguiente
NumPuntos(1).Final = n // solo los primeros 'n' puntos dle array PerimHorizontal son válidos
Buleano = ColorSimilar(int Color, int colCandidato, int nivel)
int r1, v1, a1, r2, g2, a2, r3, g3, a3
// Descomponer el color base a comparar aplicado sus niveles máximo y minimo a cada canal...
r1= fixToRangoByte((color and 255) + nivel)
r2 =fixToRangoByte((color and 255) - nivel)
g1= fixToRangoByte(((color \ 256) and 255) + nivel)
g2 =fixToRangoByte(((color \ 256) and 255) - nivel)
a1= fixToRangoByte((color \ 65536) + nivel)
a2 =fixToRangoByte((color \ 65536) - nivel)
// Descomponer el color candidato en sus canales...
r3 = (colCandidato and 255)
g3 = ((colCandidato\ 256) and 255)
a3 = (colcandidato \ 65536)
// Comparación:
// ejemplo para canal rojo: r= 45; r1=(45+16) = 61; r2= (45-16) = 29
// si r3 cae ente 29 y 61 el rojo es similar... igual para el resto de canales.
Si ((r3 <= r1) y (r3 >= r2))
Si ((g3 <= g1) y (g3 >= g2))
Si ((a3 <= a1) y (a3 >= a2))
devolver TRUE
fin si
fin si
fin si
fin funcion
Byte = fixToRangoByte(int Valor)
Si (valor < 0 )
valor = 0
osi (Valor > 255)
valor = 255
fin si
devolver Valor
Fin funcion
Enumeracion AtributosChar
ATRIBCHAR_ERROR = -1 // cualquier otro carácter (no considerado a continuación)...
ATRIBCHAR_IGNORA = 0 // espacios
ATRIBCHAR_OPERADOR_PRECEDENCIA_1 = 1 // */
ATRIBCHAR_OPERADOR_PRECEDENCIA_2 = 2 // +-
ATRIBCHAR_OPERADOR_MAX = 2 // Valor mayor de la precedencia (no precedencia mayor, pués están en orden inverso).
// Este valor se consigna desde NextToken, pero no se asigna en la tabla.
ATRIBCHAR_OPERADOR_UNARIO = 3 // +- (pero cuando va delante de otro operador o de un paréntesis de apertura,o al comienzo.
ATRIBCHAR_DELIMITADOR_ABRE = 5 // (
ATRIBCHAR_DELIMITADOR_CIERRA = 6 // )
ATRIBCHAR_OPERANDO = 7 // [±] (A-Z|a-z|0-9) ...aunque solo operamos con dígitos, porque luego quieres calcular resultados...
fin Enumeracion
Estructura RegistroTblSimb
string Valor
AtributosChar Token
//real Calculo
End Type
Array de Atributoschar s_Tabla(0 a 255)
array de RegistroTblSimb s_TblSimb(0 a 79)
//80 parece un número suficiente para probar la calculadora, será raro que en una calculadora sencilla haya expresiones con más de 80 tokens...
//pero vamos si se espera que suceda, basta ampliar el número a lo que se considere adecuado.
// y rellenamos ya el array de atributos de los caracteres...
funcion Main
llamada a CrearTabla
fin funcion
// se deja en una función aparte para mantener despejado 'main', y para centrar la función a lo que dice su nombre y hace.
funcion CrearTabla
int k
// Todos se marcan como error, luego los válidos con su valor adecuado...
Bucle para k desde 0 hasta 255
s_Tabla(k) = ATRIBCHAR_ERROR // todos excepto los que siguen.
Siguiente
// Digitos:
Bucle para k desde 48 hasta 57
s_Tabla(k) = ATRIBCHAR_OPERANDO // 0-9
siguiente
// Caracteres:
Bucle para k desde 65 hasta 90
s_Tabla(k) = ATRIBCHAR_OPERANDO // A-Z
s_Tabla(k + 32) = ATRIBCHAR_OPERANDO // a-z
siguiente
// Separador:
s_Tabla(32) = ATRIBCHAR_IGNORA // el espacio (también se podría poner l espacio duro)
// Delimitadores:
s_Tabla(40) = ATRIBCHAR_DELIMITADOR_ABRE // (
s_Tabla(41) = ATRIBCHAR_DELIMITADOR_CIERRA // )
// Operadores:
s_Tabla(42) = ATRIBCHAR_OPERADOR_PRECEDENCIA_1 // *
s_Tabla(43) = ATRIBCHAR_OPERADOR_PRECEDENCIA_2 // +
s_Tabla(45) = ATRIBCHAR_OPERADOR_PRECEDENCIA_2 // -
s_Tabla(47) = ATRIBCHAR_OPERADOR_PRECEDENCIA_1 // /
fin funcion
// El scan léxico: Debe reconocer cada tipo de token válido.
// que almacena en el array s_TblSimb
// Devuelve la cantidad de tokens hallados, si devuelve 0, es que hubo algún problema:
// 1 - El string de entrada estaba vacío: ""
// 2 - Hay caracteres 'raros' no considerados en nuestra tabla: 5+3-6+?*@ (? y @ no sons ímbolos admitidos en 'nuestra gramática').
// 3 - La expresion está mal formada (error sintáctico): 5****3; 4+345; 5+(((3-2)
int = Funcion ScanLex(string Expr )
int k, n
string st
AtributosChar tk
// n = 1 ciertos lenguajes considera el primer carácter de un string, como el 1, no el 0, descomentar en tal caso...
Hacer mientras (n <= Expr.Size)
st = NextToken(Expr, n, tk)
Si (tk = ATRIBCHAR_ERROR)
devolver 0
Osi (tk = ATRIBCHAR_OPERADOR_UNARIO)
// Un operador unario solo afecta a un operando, simulamos que el otro es 0
// y lo encerramos entre paréntesis, para forzar la precedencia dentro.
// ejemplo: 5*-1 = -5 ó -1*5 = -5 También si se usa el signo + 5*+7
// queda como si fuera: 5*(0-1) (0-1)*5 5*(0+7)
// la misma técnica vale para otros operadores unarios como not(x), cos(x), Abs(x), etc...
s_TblSimb(k).Valor = "("
s_TblSimb(k).Token = ATRIBCHAR_DELIMITADOR_ABRE
k = (k + 1)
s_TblSimb(k).Valor = "0"
s_TblSimb(k).Token = ATRIBCHAR_OPERANDO
k = (k + 1)
s_TblSimb(k).Valor = st
s_TblSimb(k).Token = ATRIBCHAR_OPERADOR_PRECEDENCIA_2
k = (k + 1)
// y ahora pedimos el operando suelto, para luego cerrar el paréntesis, antes de seguir...
st = NextToken(Expr, n, tk)
s_TblSimb(k).Valor = st
s_TblSimb(k).Token = tk
k = (k + 1)
s_TblSimb(k).Valor = ")"
s_TblSimb(k).Token = ATRIBCHAR_DELIMITADOR_CIERRA
YSiNo
// introduccir los datos del token en la tabla de símbolos.
s_TblSimb(k).Valor = st
s_TblSimb(k).Token = tk
Fin si
k = (k + 1)
Siguiente
devolver k
fin Funcion
// NOTA: Se considera token de 1 solo carácter
// operando: [±] A-Z|a-z|0-9
// operador: *|/|+|-
// parentesis: (|)
// Para algo más exahustivo, habría que reconocer:
// - identificador y número
// - operadores de 1 o más símbolos (como en '>=')
// OJO: No se verifica si se alcanza el límite de la expresión,
// lo cual puede suceder con expresiones mal formadas
// (con caracteres no esperados a la derecha del último caracter válido).
// Los 3 parámetros son pasados por referencia...
string = funcion NextToken(string Expr, int Index, AtributosChar tkUltimo)
string s
AtributosChar ac
Hacer
s = Expr.Substring(Index, 1) // tomamos el carácter en la posición index
ac = s_Tabla(s.toByte) // Evaluamos de qué tipo es el caracter.
// en ciertos lenguajes caracter y byte se usan indistintamente, en otros marca error,
// luego exige una conversión a bytes implícita, explícita, por casting o por coerción...
Index += 1
repetir mientras (ac = ATRIBCHAR_IGNORA) // saltar espacios
// cualquier otro carácter no aceptado será detectado como error, tras la devolución.
// Detectar si es un operador unario... Esto se sabe si hay otro operador delante.
// casos: *+2, /-2, +-4, -+4, (-1, +1 (total: 6 casos distintos)
// es decir aparece un ± detrás de otro operador, de un paréntesis de apertura, o al comienzo de expresión.
Si (ac = ATRIBCHAR_OPERADOR_PRECEDENCIA_2) // solo signos +- que son los posibles unarios en esta implementación.
Si ((tkUltimo <= ATRIBCHAR_DELIMITADOR_ABRE) // es posible hacerlo así de simple,
// porque se ha estudiado el orden de los tipos en la enumeración. Así acepta los 6 casos.
ac = ATRIBCHAR_OPERADOR_UNARIO
//marcamos temporalmente como un token de operador unario,
Fin si
fin Si
tkUltimo = ac
Devolver s
Fin Funcion
// Ini y fin, son el punto de la tabla de símbolos entre los que queramos analizar.
// Si siempre va a ser desde el comienzo, ini puede dejar de ser un parámetro para ser una variable interna de la función con valor 0.
// Fin en cualquier caso, indica el final, o para la situación anterior la cantidad-1 de tokens almacenados durante el análisis léxico.
string = Funcion DijkstraRPN(int Ini, int Fin)
AtributosChar AtChar As , PrevTkChar // tipo de token.
string cola, int ixCola // cola de operandos (y operadores) y su puntero.
string pila, int ixPila // pila de operadores y su puntero
int IxMax = (Fin - Ini + 1)
ixPila = (IxMax + 1)
ixCola = 0 // 1, si el lenguaje considera el primer carácter de un string, como 1.
// creamos el espacio máximo de cada string, en realidad cola, nunca crece mucho...
// Si se opera con arrays de chars, incluso mejor, cuando el lenguaje no supone pérdida de eficiencia en conversiones 'tontas' entre char y byte.
// la reserva de espacio en el string, al giaul que en un array, previene que la modificación de su tamaño exija contruir y copiar el contenido en otro, como sucede con append, etc...
pila = Espacios(IxMax)
cola = espacios(IxMax)
Hacer mientras (Ini <= Fin)
AtChar = s_TblSimb(Ini).Token
Seleccionar Caso para AtChar
Caso ATRIBCHAR_OPERANDO // accion: añadir a la cola
cola.Replace(ixCola, 1) = s_TblSimb(Ini).Valor // remplaza el carácter en la posición indicada.
ixCola += 1
Caso ATRIBCHAR_DELIMITADOR_ABRE // accion: Añadir a la pila.
ixPila -= 1
pila.Replace(ixPila, 1) = s_TblSimb(Ini).Valor
Caso ATRIBCHAR_DELIMITADOR_CIERRA
// Accion: mover operadores de la pila a la cola, hasta que
// se encuentre el paréntesis de apertura de su mismo anidamiento.
Hacer mientras (s_Tabla(pila.Substring(ixPila, 1).ToByte) <> ATRIBCHAR_DELIMITADOR_ABRE)
cola.Replace(ixCola, 1) = pila.Substring(ixPila, 1) // mover elemento a la cola
ixCola += 1
pila.Replace(ixPila, 1) = " " // eliminar de la pila (basta poner un espacio)
ixPila += 1
si (ixPila = IxMax) Salir del bucle
Repetir
pila.replace(ixPila, 1) = " " // eliminar paréntesis de apertura encontrado.
ixPila += 1
Resto de casos // operadores: considerar precedencia.
// Accion: Mover a la cola, mientras el operador en la pila siendo examinado
// sea de menor o igual precedencia que el operador actual.
Si (ixPila <= IxMax) // es habitual que la pila quede vacía...
PrevTkChar = s_Tabla(pila.Substring(ixPila, 1).ToByte)
Hacer mientras (PrevTkChar <= AtChar) // y (PrevTkChar <> ATRIBCHAR_DELIMITADOR_ABRE)), pero el diseño en la enumeración ya considera esto, con la previa condición.
cola.Replace(ixCola, 1) = pila.Substring(ixPila, 1) // mover elemento a la cola
ixCola += 1
pila.Replace(ixPila, 1) = " " // eliminar de la pila (basta poner un espacio)
ixPila += 1
si (ixPila > IxMax) Salir del bucle
PrevTkChar = s_Tabla(pila.Substring(ixPila, 1).ToByte)
Repetir // el bucle se parece bastante al anterior, pero no llegan a ser iguales...
Fin si
ixPila -= 1 // la pila crece hacia abajo...
pila.Replace( ixPila, 1) = s_TblSimb(Ini).Valor
Fin seleccion de casos
imprimir cola tabulador pila // solo para ver como evoluciona...
Ini += 1
Repetir
// Pasar contenido restante de la pila a la cola (pero si quedan paréntesis = error).
// En realidad, no se espera este error, toda vez que pasó un scan léxico.
// Sin embargo se deja por si se decide modificar el algoritmo para aceptar directamente
// el texto de la expresión como parámetro, e ignorar el scan léxico previo....
pila = pila.Right(IxMax - ixPila + 1) // la pila descarta los espacios a la izquierda...
Si (pila.Contiene( "(")) = FALSE)
cola.Replace(ixCola) = pila // copia el contenido de la pila en la cola, a partir de la posición indicada.
ixCola += pila.Size
imprimir cola tabulador pila // solo para ver el resultado final ...
devolver cola.Left(ixCola - 1) // devuelve el contenido de la cola, descartando los espacios a su derecha.
fin si
fin funcion
// Calcula el valor de una expresión postfija.
// A - Se supone que es una expresión aritmética, donde todos los operandos son números.
// B - Si se admite que fueran identificadores, se supone que estos o bien refieren direcciones de memoria o bien su valor se haya en una tabla hash (por ejemplo),
// luego antes de guardar a la 'pila' se debe dereferenciar el identificador. Por ejemplo: s_Temp(i) = tHash(identificador)
// Por eso si el propósito es meramente un ejercicio, es preferible ceñirse al caso 'A', exclusivamente y usar solo dígitos.
// devuelve el valor calclado, como puede tener decimales... el array temporal conviene que así sea...
real = Funcion CalcularRPN(string RPN)
int k, i, X, Y
AtributosChar tk
string s
real Temp(0 a 79) // mismo tamaño que dejamos para la tabla de símbolos, adaptar según necesidades..
// incluso conviene mover este array al nivel del módulo...
bucle para k desde 0 hasta RPN.Size-1 // nuevamente si el lenguaje trata el primer char de la cadena , como 1, ira de 1 a rpn.size
s = RPN.Substring( k, 1) // toma el enésimo carácter de la cadena (o array)
tk = s_Tabla(s.ToByte)
// Mientras se obtengan operandos se guardan en temp
// cuando aparece un operador se toma los dos últimos operandos guardados y se opera con ellos
Si (tk <= ATRIBCHAR_OPERADOR_MAX)
// sacar dos últimos operandos de la pila
i -= 2
X = Temp(i)
Y = Temp(i + 1)
// calcular y almacenar en la pila.
Seleccionar Caso para s
Caso "*"
Temp(i) = (X * Y)
Caso "/"
Temp(i) = (X / Y)
Caso "+"
Temp(i) = (X + Y)
Caso "-"
Temp(i) = (X - Y)
fin seleccion casos
Ysino // Osi (tk = ATRIBCHAR_OPERANDO)
// una expresión RPN (bien formada) solo tiene operandos y operadores.
// leer y almacenar operandos hasta encontrar un operador...
Temp(i) = s
// YSiNo
// solo si se espera errores en caso de expresion malformada... activar el 'Osi' del caso anterior y activar este 'YSino'
Fin Si
i += 1
Siguiente
devolver Temp(0) // i acabará valiendo 1
Fin funcion
funcion Main (string command)
string rpn
real valor
llamada a CrearTabla
rpn = ExpToRPN(command)
Si (rpn.size > 0)
valor = CalcularRPN(rpn)
imprimir rpn tabulador valor
Ysino
Mensaje "el texto de la expresion no es correcto..."
fin si
fin funcion
string = Function ExpToRPN(string Expr )
int k As Integer
k = ScanLex(Expr)
si (k = 0) devolver ""
devolver DijkstraRPN(0, k - 1)
fin Funcion