Mensajes

La solución de un problema dado puede aparecer en cualquier punto dentro de una función.
En general si se sale de una función desde "cualquier" parte, el único problema que presenta es que para "ojos ajenos", pueda ser más difícil de leer...

Entonces si programas para tí, haz lo que te venga en gana según tu criterio, y si programas para una empresa, sométete a la regla que allí sigan.

En cualquier caso, la salida se puede diferir siempre al final de la función de modo que allí se resuma la devolución.

Código [Seleccionar] Expandir


entero = funcion X(entero p)
  Si p=5
      devolver p+2
  OSi p<0
      devolver 0
  Osi p>129
      devolver 32
  Osi p=51
      devolver Sumatorio(p/3)
  Sino
      devolver p
  Fin si
Fin funcion

La función previa de ejemplo tiene varias salidas, pero todas pueden cosiderarse finales, por cuanto tras cada devolución, no hay más código que se fuera a ejecutar. Aún así los puristas prefieren siempre 1 o a lo sumo dos devoluciones, en tal caso puede modificarse como sigue:

Código [Seleccionar] Expandir


entero = funcion X(entero p)
  entero y

  Si p=5
      y= p+2
  OSi p<0
      y= 0
  Osi p>129
      y= 32
  Osi p=51
      y = Sumatorio(p/3)
  Sino
      y= p
  Fin si

  devolver y
Fin funcion
Para mi, no gana en claridad, tampoco en velocidad, ni en ahorro de memoria, aunque si que puede ganar en mantenimiento si en un futuro hubiese de sufrir cambios (en general), al final sigue devolviendo, lo que sea que previamente se haya calculado-considerado. Cuando el código tiene a ser complejo es cuando suele resultar de más interés, peor especialmente si otros han de leer tu código (o si a tí mismo resulta complicado leerte pasado el tiempo, que les pasa a muchos).

Ya se te ha comentado en alguna ocasión...

Aprende al menos lo básico y elemental para programar, antes de ponerte a hacer nada más complejo que el "hola mundo".

No se puede pretender hacer un avión, si uno está continuamente tropezando con cada tornillo y tuerca que aparezca a la vista.

Sin aprender lo más básico sobre programar carece de sentido dar soporte de ningún tipo, es tiempo perdido, para tí y para el que te responde. Tu copias-pegas, resuelves el problema puntual y vuelves a tropezar en el siguiente paso. Así no se aprende, tómate un par de libros y estudia unos meses (y practica los ejercicios que pudieran traer, con paciencia).

Aprende lo elemental o abandona. "Programadores copypaste", sobran en el mundo...

Darte un código, no me parece lo más adecuado.
Con copiar y pegar, no se aprende. Debes pensar por ti mismo, aunque tengas orientación.

Supongamos que las líneas contienen 4 bolas que el usuario debe resolver, elegibles sobre un total de 8 bolas

Quiere el jugador seguir jugando?

Código [Seleccionar] Expandir


buleano = Funcion PedirPartida
   dato= PedirDatoAlUsuario("¿ DeseaJugar otra partida (S/N)? ")
   Si (dato="S") ó (dato="s") luego
       devolver TRUE
   Sino
       devolver FALSE
   Fin si
Fin funcion


Crear el array de bolas de la 'banca' y barajarlo...

Código [Seleccionar] Expandir


Array de bytes =Funcion BarajarBolas(entero cantidad) //8 bolas
    Array bytes Bolas()
   entero i, j, k

   RedimensionarArray Bolas(0 a cantidad-1)

   // Meter en el "saco" todas las bolas que participan
   bucle para k desde 0 a cantidad-1
       Bolas(k) = k    
   Repetir

   //Barajar el array.
   // aunque se barajan todas, el usuario solo debe resolver las 4 primeras.
   bucle para k desde cantidad-1 a 1 regresivamente
       j= Random(entre 0 y k)
       i=bolas(k)
       bolas(k)= bolas(j)
       bolas(j)=i
   repetir
   
   devolver bolas //devuelve el array barajado.
Fin funcion


Cuando el jugador completa su apuesta (todas las bolas d euna línea), se verifica si es la 'respuesta' coincidente con la que almacena la banca.
cantidad es el tamaño del array bolas (8), y cantidadUser son 4, las que debe resolver el jugador.
Devuelve FALSE si la partida terminó.

Código [Seleccionar] Expandir


buleano = funcion VerificarLinea(entero cantidad, entero cantidadUser, arraybytes bolasUser())
   entero h, i, j, k

   bucle para k desde 0 a cantidadUser-1
       j= EstaBolaUserEnBanca(bolasUser(k), cantidad)
       Si (j>=0) luego  //la bola que eligió el jugador está en la línea...
           i +=1
           si (j= bolas(k)) luego //además coincide en el sitio
               h +=1
           fin si
        fin si
   Fin bucle
   Pintar h bolas, de blanco //indicador de bolas correctas y en su sitio.
   Si (h=cantidadUser) luego
       mensaje "enhorabuena, juego resuelto"
       devolver FALSE
   Sino
       pintar i-h bolas, de gris // indicador de bolas correctas pero fuera de sitio.
       pintar cantidaduser - i bolas, de negro //indicador de bolas erróneas
       tiradas +=1  //intentos del jugador
       Si (tiradas = Maxtiradas) luego // por ejemplo 10, ó 12 tintentos
          mensaje "Lo sentimos, perdiste todas tus oportunidades de acertar. GAME OVER"
           devolver FALSE
       sino
           devolver TRUE //el jugador puede seguir jugando...
       Fin si
   Fin si
   // puede resumirse en (pintar) solo dos informaciones en vez de en 3... al gusto (omitiendo el 1º de los 3 puntosm, pintar h bolas de blanco), y/o cambiar colores para expresar una u otra cosa.
Fin funcion


Verifica si la bola apostada, consta en la línea de la banca...
Si está devuelve su posición, si no está devuelve -1

Código [Seleccionar] Expandir


entero = Funcion EstaBolaUserEnBanca(entero Bola, entero cantidad) // esta cantidad es la de bolas totales que hay
    entero k

   bucle para k desde 0 a cantidad-1
       si bola = Bolas(k) luego
           devolver k
       fin si
   fin bucle

   devolver -1    
Fin funcion


Verifica si la bola y la posición donde el jugador la quiere depositar es válida.
Devuelve FALSE mientras al jugador le falte colocar alguna bola
No se verifica 'posición', se supone que si el jugador solo puede posicionarla en 4 posiciones no va a poder elegir un valor fuera del rango 0-3 (tampoco se verifica que la bola esté en el rango esperado (0-7)

Código [Seleccionar] Expandir


buleano = Funcion BolaValida(entero bola, entero posicion, entero cantidadUser)
   entero j, k

   Si (bola=-1) luego  // equivale a eliminar una bola, ...para ubicarla en otra posición
       bolasUser(posicion) = -1 // -1 equivale a un hueco libre en el array de apuesta del jugador
       devolver FALSE  
   fin si
   
   // Comprobar que esa bola no haya sido ya elegida
   bucle para k desde 0 a cantidadUser-1
       Si (bola = bolasUser(k)) luego
           mensaje "Ya tienes esa bola elegida"
           devolver FALSE  //solo puede elegirse una vez una bola del mismo color.
       sino
           Si (bolasUser(k) >-1) luego
               Si (k=posicion) luego // pretende ubicarse la bola  en una posición ya ocupada...
                                                       // podria hacerse diferentes cosas, pero lo mejor es impedirlo e indicarlo.
                   mensaje "Ya hay una bola en esa posición, solo puede colocar bolas en huecos libres. si lo precisa retire una bola de la posición deseada antes de colocar otra.                                    
               fin si
           sino
               Si (k=posicion) luego
                   bolasUser(k)= bola //el jugador mete su bola en un hueco
               sino
                   j +=1  // queda un hueco más en el array para alojar una bola...
               fin si
           fin si
       fin si
   fin bucle

   Si (j=0)
       devolver TRUE //Si no hay huecos, si ya tiene todas las bolas devuelve TRUE
   sino
       devolver FALSE
   fin si
fin funcion



Función principal...

Código [Seleccionar] Expandir


Funcion IniciarPartida
   array bytes bolas(), bolasUser()
   entero bola, posicion, tiradas, maxTiradas

   maxTiradas=10
   Hacer mientras PedirPartida = TRUE
       bolas = llamada a BarajarBolas(8)
       tiradas =0

       Hacer // nueva tirada del jugador
           bolasUser = llamada a BorrarBolasUser(4)
           Hacer // pedir bolas de una línea al jugador
               bola = PedirDatoBola al jugador (0-7) // volver a pedir mientras esté fuera del rango 0-7
               posicion = pedirDatoPosicion al jugador (0-3) // volver a pedir mientras quede fuera del rango 0-3
           Repetir mientras BolaValida(bola, posicion, 4) = FALSE    
           // al salir del bucle el jugador completo su apuesta y consta en el array bolasUser  

       Repetir mientras VerificarLinea(8, 4, bolasUser) = TRUE
   Repetir
fin funcion


Se resetea la apuesta del jugador (todo el array a valor -1)

Código [Seleccionar] Expandir


arrayBytes = funcion BorrarBolasUser(entero cantidadUser)
   array bytes arr()
   entero k
 
   bucle para k desde 0 a cantidadUser-1
       arr(k) = -1
   fin bucle    
   
   devolver arr
fin funcion


Quizás me deje alguna pequeña funcionalidad en el tintero, pero ya tienes suficientes detalles para entenderlo y modificarlo a tu antojo... eso sí, pensando... que es de lo que trata la programación (para copiar y pegar están las impresoras, los escáneras, las cámaras de fotos... pero ellas no cran programas, se requiere pensar).

p.d.: Los niveles de dificultad, pueden crearse modificando el número de intentos que tiene el jugador así como el número de bolas que debe acertar y las bolas elegibles...
- Cuantos menos intentos, más difícil.
- Cuantas más bolas deba acertar (tenga la línea d ela banca a acertar), más difícil.
- Cuantas más bolas elegibles entre las que apostar, más difícil...

VB6 puede operar con dos tipos de cadenas.
1 byte por carácter y con 2 bytes por carácter,  y para pasar de una a otras se utiliza la función Strconv (o bien hacerlo manualmente). Aparte las cadenas de longitud fija herencia de Basic más antiguos (QuickBasic)...
Básicamente si usa dos bytes por carácter, el segundo (los impares) debe ser un null (byte 0) y la cadena de texto siempre debe acabar en un null (el último byte par).

Cuando se usa en Dll, el error más común suele aparecer porque se considere o no el carácter de fin de cadena (null), o bien porque no se pase correctamente el puntero de la cadena.

Cuando proceda (o inténtalo y ver si así se resuelve tu problema), pasa un array de bytes. VB6 convierte automáticamente un array de bytes en cadena así como una cadena en un array de bytes, cuando se haga dicha asignación.

Código (vb) [Seleccionar] Expandir


Private Sub Form_Load()
    Dim miArray() As Byte
    Dim texto As String, otroTexto As String
    Dim k As Long

    texto = "ejemplo"
    miArray = texto

    For k = 0 To UBound(miArray)
        MsgBox Chr$(miArray(k))
    Next
    otroTexto = miArray
    MsgBox otroTexto
End Sub

Salida:
E
null
j
null
e
null
m
null
p
null
l
null
o
null



Técnicamente un "string" en VB6 es un "BStr" de C.
https://msdn.microsoft.com/es-es/library/windows/desktop/ms221069(v=vs.85).aspx

A ver, si el problema se limita a mover un valor a una determinada posición en un array bidimensional... pués es bastante obvio:

Sea z el valor a colocar en la cordenada x,y:

Código [Seleccionar] Expandir

Array(y,x) = z
Si el array es unidimensional no es mucho más complejo, sabiendo el 'ancho' de la diemsnión...

Código [Seleccionar] Expandir

Array((y*ancho) + x) = z

La letra P, tiene dos bits a 1, el 64 y el 16, porque 64+16=80, el resto son 0.
Luego quiere decir que necesitas un bucle de 8 ciclos (porque 8 bits tiene  un byte), alojado dentro de otro bucle cuya cantidad de ciclos sean los caracteres.
Así que en pseudocodigo sería algo como:

Código [Seleccionar] Expandir


entero i, j, k
byte letra

Bucle j por cada letra en Palabra
   i=1
   Bucle para k de 0 a 7
       bit= (letra and i)  //entiendo que si el bit está a 0, se consigna un 0.
       letra /=2      
       llamada a funcion Posicionar(k, bit)
       i +=i // así va tomando valores 1,2,4,8,16...
   Fin bucle
Fin bucle
Tu problema luego se resume en que no hay una única forma d eposicionar en el array... "x" e "y", se modifican de forma diferente a cada caso... luego necesitas una función para cada caso, y posiblemente eso suponga que el bucle externo, no pueda ser un bucle y deba ser código lineal...

Código [Seleccionar] Expandir


letra= palabra.char(0)
 i=1
 bucle para k de 0 a 7
    bit= (letra and i)  //entiendo que si el bit está a 0, se consigna un 0.
    letra /=2
    llamada a función x001(k,bit)
    i +=i // así va tomando valores 1,2,4,8,16...
 fin bucle

letra= palabra.char(1)
 i=1
 bucle para k de 0 a 7
    bit= (letra and i)  //entiendo que si el bit está a 0, se consigna un 0.
    letra /=2
    llamada a función x002(k,bit)
    i +=i // así va tomando valores 1,2,4,8,16...
 fin bucle

letra= palabra.char(2)
 i=1
 bucle para k de 0 a 7
    bit= (letra and i)  //entiendo que si el bit está a 0, se consigna un 0.
    letra /=2
    llamada a función x003(k,bit)
    i +=i // así va tomando valores 1,2,4,8,16...
 fin bucle
...etc...


Y dichas funciones, como puedes apreciar reciben dos parámetros, el valor del bit y el índice del bit... el índice es necesario para reposicionar el par de cordenadas X e Y, al punto correcto...
Ejemplo para una de ellas:

Código [Seleccionar] Expandir


entero x, y //declaradas al nivel del módulo, no dentro de una función, pues sus valores deben permanecer inalteradas tras salir de la función.
Funcion PosicionarCuadrante1119(entero indice, entero bit)
   Si (indice=0) luego  //Reset X e Y al inicio del cuadrante
      x= 19
      y= 11
   Sino
      Si (x=20) luego
          x= 19
          y +=1
      Sino
         x +=1   // x= 20
      Fin si
   Fin si

   Array(x,y) = bit
Fin funcion
Como hay diferentes cuadrantes, y cada uno tiene sus propias cordenadas, las diferencias entre cada función se limitan a señalar correctamente los valores X e Y a cada caso...

...resumiendo, nada de otro mundo... nada que con un mínimo de atención pueda conseguir cualquiera...
queda a tu esfuerzo el resto de funciones, la llamada como: "PosicionarCuadrante1119", se aplica al cuadrante que apuntas en la inagen con una llave, más exactamente al cuadrante que comienza en Y=11 y x=19... (de ahí el nombre). Puede haber más cuadrantes que se 'rellenen' del mismo modo, por lo que también queda a tu esfuerzo simplificar el código (esto es, reunir todas las que se rellenan igual en una sola)... y así tendrías solo una función por cada forma distinta de llenar un cuadrante y para todos los cuadrantes que se rellenan igual, se diferenciarían sólo en los valores iniciales de sus cordenadas. Ya está todo dicho...

[hay veces]

mi duda era que cual uso cuando hago un metodo para ordenar de mayor a menor y de menor a mayor eso es lo que quiero saber que simbolo uso para ordenar de ambas maneras...

No importa.
¿(5>3)? da la misma respuesta que preguntar ¿(3<5)?

Da lo mismo decir "no es lunes, ni martes, ni miércoles ni jueves, ni viernes, ni sábado", que decir "es domingo", lo uno si es lo inverso de lo otro, no importa entonces como se describa, si como afirmando lo uno o negando el resto. en general se usa lo que resulte más breve, legible o entendible... en el ejemplo: es domingo es más conciso y claro.
Igualmente puede valorarse:

Código [Seleccionar] Expandir

Si (x < y) luego
que

Código [Seleccionar] Expandir

Si (y => x) luego
Eso si, nota que no siempre al hacer algoritmos la inclusión del símbolo igual genera el mismo resultado, es decir hay veces en que:

Código [Seleccionar] Expandir

Si (x <= y) luego
en un algoritmo puede llegar a ser igual que

Código [Seleccionar] Expandir

Si (y >= x) luego
por lo que antes de expresar algo de una forma opuesta, se debe estar plenamente seguro de si la exclusión es totalmente correcta.

Cuando un caso tenga numerosas variables en juego, lo mejor es hacer una tabla de verdad, con ella se elige luego la forma que mejor resume y lleve a cabo (la que requiera menos comparaciones en general, además de más rápida es más clara) y si algo no resulta evidente, siempre dejar un comentario en el código... pasado el tiempo, puede ser que no recuerdes lo que tiempo atrás era muy evidente y hacer cambios que luego fallan.

Hay varios quids a los que atender...

De entrada el bucle priuncipal no está óptimamente planteado.
Verás si haces un bucle 'Mientras X', es una redundancia inútil, preguntar acto seguido lo mismo Si x luego...
Piensa en un condicional como un bucle de un solo ciclo, si se cumple se entra y se ejecuta 1 vez y si no, no... un bucle persé es lo mismo, solo que permite entrar muchas más veces retornando al origen.

Tu bucle debiera se rmejor así:

Código [Seleccionar] Expandir


texto = sc.nextLine();
Si  (!texto.equals("FIN")) luego
     Hacer
         ... todo el trabajo que realizas
         texto = sc.nextLine();
     Repetir mientras   (!texto.equals("FIN"))
Fin si
Y aún más ióptimo cuando un lenguaje admite en el bucle condcionarlo al comienzo:

Código [Seleccionar] Expandir


texto = sc.nextLine();
Hacer mientras  (!texto.equals("FIN"))
     ... todo el trabajo que realizas
     texto = sc.nextLine();
Repetir

Luego, llamas múkltiples veces desde dentro del bucle a un rutina externa a la propia donde yace el bucle, cada llamada externa a otra función es una sobrecarga porque exige depositar en la pila el estado actual en dicha función, antes de llamar a la función (cifrar) y a su vez tras la llamada, volver a restablecer el estado en dicha función sacando los datos de la pila... y esto se hace por cada letra...
ergo... mete ese código dentro del bucle, no en una función aparte. Sólo con eso ganarás en velocidad.

Por último, aunque tu función "cifrar" es clara, no es nada óptima, esto no debe resolverse invocando a una función, desde el momento en que F=X, es deicr en que hay una asignación directa, lo correcto es meterlo en un array, ya que no requiere un cálculo complejo tal que con la misma entrada pudiera dar lugar a diferentes salidas...

Ergo genera una array, al inicio de tu aplicación donde se establezca la igualdad d ela asignación:

Array(0) = 65  /A
Array(1)= 66  /B
Array(2)= 67 /C
...
Array(25) = 90 //Z
Array(26) = 65 //A

Y ahora en tu código simplemente codificas para redirigir un valor a un índice correcto. Tu array podría llamarse Cifrar (para más inri)
   CadenaSalida += Cifrar(ValorASCII(Texto.CharEn(I))-65+dpz)
Esto es: debe tomarse el valor ASCII del caracter obtenido en: Texto.charEn(i)
Como "A", es el carácter 65º y nuestro array comienza en 0, le restamos 65 y como estmaos haciendo una codificación césar, el dpz, suma el valor a desplazar en este caso dpz=1, si en vez de 1, usas dpz la misma función te vale para codificar con diferentes valores.
Más eficaz aún sería si el array en vez de asignarse la "A" en el índice 0, se asignara en el propio indice 65, así se evitaría también la resta de -65 para cada carácter.
Así al inciio crea un array estático así:

Código [Seleccionar] Expandir


Bucle para k desde 0 a 255
   ArrayCifrado(k) = k
Fin bucle
Que es una tabla ASCII, es decir cada índice contiene el código de cáracter de la tabla ASCII, ArrayCifrado(65) = 65, qeu es el código de la letra "A".
Todavía queda ajustar cuando excede la suma del desplazamiento. en el previo yo he provisto un índice 26 par ala "A" cuando la letra a codfificar fuera la "Z", pero si el desplazamiento fuera mayor de 1, necesitaría un indice 27 y contener la "B", etc... mejor que eso es ver si el ídnice supera el límite y en tal caso 'modular'...
indice = ASCII(Texto.CharEn(i)) + dpz
Si indice> 90 luego
   indice = ((indice modulo 90) + 65)
Fin si
Cadenasalida += CharFromASCII(ArrayCifrado(indice)) //CVharFromASCII, sería la función opuesta a ASCII, es decir le das un código ASCII y te devuelve el carácter correspondiente.

Y por último tu código peca de ineficiencia en la concatenación de la cadena que vas generando...
CadenaSalida += ...
Cada vez que concatenas un carácter o un texto a otro, requiere construir otra cadena del tamaño adecuado (del tamaño exacto que se reclama tendrá), y copiar allí el texto original y luego el otro que se concatena, y luego destruir la cadena previa, esto es, supone buscar espacio libre en la memoria, reservarlo, copiar y luego apuntar la dirección de esa memoria a la variable cuyo nombre se usa...
El modo óptimo es que si se puede precalcular el tamaño que tendrá el texto al final, se genere de una sola vez una cadena de texto de ese tamaño (aunque sea repleto de espacios) y luego en vez de concatenar se va alterando el contenido del carácter en la posición x...

Con todos estos consejos llevados a cabo, ten por seguro que incluso vas a superar los valores que tu señalas como más rápidos que el tuyo...

Debes pensar las cosas, no 'solo escribir' ni 'solo oir', la "velocidad" de enseñanza en las univesidades suele ser contraproducente, porque al final solo aprenderías cosas de memoria, sin entenderlas, así que haces bien en preguntar... aunque si por tu propia cuenta lo pensaras despacio un poco, tú mismo descubrirías el proqué.

1 - Veamos al comienzo, la línea:

Código [Seleccionar] Expandir

int fin = modelos.length - 1;
el -1 responde al hecho de que el tamaño de un array indica SIEMPRE la cantidad de elementos que contiene, por ejemplo si dice 10, tiene 10 elementos, pero contados a partir del 0, el último será el índice 9, si fueran 87 elemento, empezando en 0, el último sería el 86, ídem si tuviera 2514 elementos, el último sería el índice 2513, ergo el último índice siempre es: tamaño-1
Si en vez de empezar en 0, empezaras en 5, sería tamaño-1+5, porque para 10 elementos iría desde el 5,6,7,8,9-10,11,12,13,14.
Y si empezara en un índice de valor negativo, (por ejemplo -11 con tamaño 27) el último índice sería:  tamaño-1+(-11) = 27-1-11 = 15
(-11,-10,-9,-8,-7; -6,-5,-4,-3,-2; -1,0,1,2,3; 4,5,6,7,8; 9,10,11,12,13; 14,15)
Es decir la fórmula general para conocer el último índice en un array, siempre es: Tamaño-1+límiteInferior. Y dado que la casi absoluta comunidad de lenguajes arranca sus indíces en el 0, la suma del límite inferior es redundante.

2 - Búsqueda dicotómica, (como no), es nombre muy apropiado para libros y universidades, pero es más universal y entendible para todo el mundo (y no solo el mundillo informático), "Búsqueda binaria".
La búsqueda binaria requiere que el array (o el tipo de colección que se utilice) esté ordenada. Luego si se desea buscar un valor concreto, pongamos el 22 y pongamos (que el array de partida tiene 100 elementos, (sí del 0 al 100-1), y que en cada índice contiene casualmente el valor cuyo índice señala: Arr(0) = 0, Arr(1)=1, Arr(2)=2 ... Arr(99)=99, por simplicidad en las comprobaciones)...

3 - Entonces tendremos que (eliminado la morralla que oscurece la sencillez del algoritmo, esto es expresándolo en pseudocódigo):

Código [Seleccionar] Expandir


entero = Funcion BusquedaBinaria(array de enteros Valores(), entero Valor) //el que se busca
   entero ini, medio, fin
   
   fin = Tamaño(Valores)-1: ini = 0
   
   Hacer mientras (ini <= fin) //menor o igual que
       medio = (ini + fin) \ 2
               
       Si Valores(medio) > Valor luego
           fin = medio - 1
       Osi Valores(medio) < Valor luego
           ini = medio + 1
       Sino
           devolver medio //valor encontrado
       fin si
   repetir
     
   // Si no se encuentra el valor puede devolverse el índice evaluado (medio) en negativo,
   //    queriendo indicar con ello que de existir se alojaría en ese índice
   //    (es ideal si se quisiera insertar ordenado)
    //    y eso es mucho mejor que -1, pero si te reclaman devolver -1, pues hale...
   Devolver -medio
Fin Funcion
4 - AQUÍ: la devolución de un índice negativo, expresa 'no encontrado', y a la devolución mejor que considerar:
 

Código [Seleccionar] Expandir

Si Buscarbin(x,y) =-1 luego no hallado
mucho mejor expresarlo así:
 

Código [Seleccionar] Expandir

Si BuscarBin(x,y)<0 luego no hallado

Y ahora pasando ese array preestablecdio de 100 elementos con valores numerados del 0 al 99 y buscando el valor 22, hagamos paso a paso lo que sucede (que es lo que tu deberías haber hecho, dibujar una tabla y en cada línea anotar los valores que tienen cada variable, así como el resultado de las comparaciones evaluadas (True/False) ):
Previo:
ini=0
fin = 100-1

Primer ciclo
Medio= (0+99)\2 = 49 // hacmeos una división entera, los ínidces siempre son enteros, no decimales, luego 49'5 se trunca en 49.
Ahora la primera comprobación (dentro del bucle):
Si Valores(49) >22 luego //que es la condición que se cumple
     fin= (medio-1), = 49-1 = 48, es decir el valor en el medio es mayor que el buscado, nos queda que mirar or debajo del medio, el índice inmediatamente por debajo del medio es justamente: medio -1, ese pasa a ser ahora el fin, el último hasta el que buscaríamos...

Siguiente ciclo:
Medio = (0 + 48)\2= 24
 Si Valores(24) > 22 luego //nuevamente se cumple esta condición...
    Fin = (24-1) =23 // ahora el límite superior será 1 menos que el valor que ya hemos visto que era superior al buscado.

Siguiente ciclo:
Medio = (0 + 23)\2 = 11
 Si Valores(12) > 22 luego // esta vez no se cumple, pasamos a ala sigueinte condición
 Osi Valores(11) < 22 luego //si se cumple esta, luego inicio podrá ser ahora mayor que 0, toda vez que ehmos visto que el valor está más arriba que la posición 11.
    Ini = (medio +1) = 11+1 = 12 // es decir de existir, estará entre los índices 12 y 23

Siguiente ciclo:
Medio = (12+23)\2 = 17
 Si Valores(17) > 22 luego // no se cumple,
 Osi Valores(17) < 22 luego
    Ini = (medio+1) = 17+1=18

Siguiente ciclo:
Medio = (17+23)\2= 20
  Si Valores(20) > 22 luego // no se cumple,
  Osi Valores(20) < 22 luego
    Ini = (medio+1) = 20+1=21

Siguiente ciclo:
Medio= (21+23)\2= 22
  Si Valores(20) > 22 luego // no se cumple,
  Osi Valores(20) < 22 luego //Tampoco se cumple, se pasa el caso siguiente que es expresada como ninguno d elos previos:
    Devolver Medio // hallado, se devuelve el índice 22, porque contiene el valor 22
Recuerda que por comodidad pusimos en el array como valor el mismo valor numérico que es el índice, luego Valores(22) = 22, que es el valor buscado y está en el índice 22.

Si has seguido las explicaciones paso a paso, el -1, +1 debe quedarte claro, para que sirve en cada caso, para mover el límite al punto deseado (no revisar dos veces valores ya verificados). Seguirá funcionando si pones:
  Fin = medio -1
  Ini = medio +1
pero en general requerirá más ciclos y podría darse el caso de entrar en un bucle infinito si al hallar en el siguiente ciclo el punto medio, resultare ser nuevamente el mismo punto medio del ciclo previo, precisamente por no acotar los límites convenientemente.
 
4 - La última duda, son los símbolos matemáticos (que esto ya tiene tela, en la Universidad y aún no conocer los símbolos matemáticos "Mayor que y Menor que).
Menor que: <
Mayor que: >
Distinto de: <> //desigualdad,  no universalmente usado en todos los lenguajes pero matemáticamente es aceptado, gracias a que misteriosamente en el ASCII (cuando el American Standard..., creó la tabla), no se incluyó el símbolo "= tachado" para expresar desigualdad, distinto de...
La forma de no equivocarte es ver que en un extremo hay 2 'puntos'(de los 2 trazos) y en el otro solo 1 (donde comfluyen), luego puesto, escrito el símbolo considera que exige que adónde apuntan los 2 'puntos' se espera que sea mayor que adonde apuntan solo un 'punto'  A > B; C < D.

Creo que la idea de Bill Gates, sobre que los robots deban cotizar lo mismo que un trabajador lo hace, es de momento lo único al parecer, que podrá paliar el problema que se avecina.

En un futuro donde la tecnología podría llevar al ser humano a una etapa superior, donde la meta del ser humano, no tuviera que ser ya jamás perder el tiempo trabajando para poder sobrevivir, si no vivir para dedicarse a lo que uno pretenda como su meta, se augura, sin embargo como al final verbigracia a la avaricia de una minoría, la humanidad seguirá siendo esclava para servir a unos pocos...

Realmente la esclavitud de siglos o milenios atrás, no ha desaparecido, solo se ha transformado. Antes enjaulaban y forzaban a tu cuerpo ahora lo hacen con tu voluntad, lo que no ha cambiado es el cebo, sigue siendo la supervivencia.

En la sociedad ésta internacionalizada, falta un algo (llámese órgano, asociación o lo que sea) donde pedir responsabilidades a los que realmente están metidos en la toma de decisiones cuando estas cosas se ven venir desde lejos y no hacen nada al respecto, y que debieran comparecer y dar explicaciones...