python – Algoritmo não converge, gradiente descendente

Alguém pode me ajudar nesse problema, o algoritmo não está convergindo e indo para um loop infinito.

      import numpy as np 
  import pandas as pd
  x1 = sym.Symbol('x1')
  x2 = sym.Symbol('x2') 
  z=(x1,x2)
  fun =  2*a + x1**2 + x2**2 - a*(sym.cos(2*sym.pi*x1)+sym.cos(2*sym.pi*x2))
  a = 10 
  grad_simb = gradiente_simbolico(fun,z) 
  hess_simb = hessiana_simbolico(grad_simb,z)
  x =(5.12,-5.12)
  x = np.array(x)
  g = eval_gradiente(grad_simb,z,x)
  print('Gradiente: ',g)
  H = eval_hessiana(hess_simb,z,x)
  print('Hessiana:', H)
  g1 = np.array(g)
     #Dataframe
  cols = ('i','x(i)','x(i+1)','G','Solução','Erro')
  df = pd.DataFrame((), columns=cols)
  i=1
  e=0.1
  tolerancia = 1e-3
  max_it = 100
  alpha = 0.01
  d = -1*g1
  #while (e > 1e-3):
  for i in range(max_it):
    sol=np.linalg.norm(g)
    row=pd.DataFrame(((i,x,x-sol,g,sol,e)),columns=cols)
    df = df.append(row, ignore_index=True)
    x = x - alpha * sol
    g = eval_gradiente(grad_simb,z,x)
    H = eval_hessiana(hess_simb,z,x)
    #Computação do erro
    e=g(0)*g(0)+g(1)*g(1)
    i+=1
  df

inserir a descrição da imagem aqui

python – Fiz este algoritmo para armazenar em uma lista as pessoas mais velhas e as mais novas e suas idades. Mas não sei o porque não armazena as mais novas

dados = ()
pessoas = ()
maior = 0
menor = 0
nome_maior = ''
nome_menor = ''
while True:
    dados.append(str(input('Seu nome: ')))
    dados.append(int(input('Sua idade: ')))
    pessoas.append(dados(:))
    for i in pessoas:
        if i == 0:
            maior = menor = i(1)
            nome_maior = nome_menor = i(0)
        else:
            if i(1) > maior:
                maior = i(1)
                nome_maior = i(0)
            if i(1) < menor:
                menor = i(1)
                nome_menor = i(0)
    dados.clear()
    continua = ' '
    while continua not in 'SsNn':
        continua = str(input('Deseja cotinuar? (S/N): ')).upper()
    if continua == 'N':
        break
print(pessoas)
print(f'A maior idade foi de {nome_maior}, {maior} anos.')
print(f'A menor idade foi de {nome_menor}, {menor} anos.')

Como melhorar o meu algoritmo para encontrar o índice de uma substring em uma string?

Por curiosidade, resolvi implementar um algoritmo para encontrar o índice da primeira ocorrência de uma substring dentro de uma string.

Cheguei nisto:

function find(str, substr) {
  let currentSubstr = '';

  for (let i = 0; i < str.length; i++) {
    let char = str(i);

    if (char === substr(currentSubstr.length)) {
      currentSubstr += char;
      if (currentSubstr.length === substr.length) {
        return i - substr.length + 1;
      }
    } else {
      currentSubstr = '';
    }
  }

  return -1;
}

Ele basicamente mantém uma variável, currentSubstr, que vai se ajustando de acordo com a substr a ser buscada conforme os caracteres da str forem ocorrendo. À medida que os caracteres vão coincidindo, currentSubstr vai ficando cada vez mais parecida com substr. Quando os comprimentos são iguais, a função termina.

Provavelmente não é a pior implementação possível, mas também penso não estar entre as melhores.

Gostaria de saber algumas coisas:

  • Essa função tem tempo de processamento O(n)?
  • Como poderia ser melhorada?

¿Es posible? Llamar a algoritmo principal desde subalgoritmo PSeInt

tengo un inconveniente y creería yo que es error de PSeInt, les comento lo que sucede…

He creado un algoritmo (algo extenso), prácticamente todo funciona ok, sin embargo encuentro un ligero fallo y es que al salir de un único condicionar (Validar si la base de datos está llena) en un único subproceso (ingresar()), PSeInt no se sale sino que después de la línea (FinSubProceso), continua dentro del mismo proceso y se devuelve 4 líneas arriba, quedando de ésta manera dentro de un ciclo “Repetir” donde indica la finalización de un proceso de registro. Cabe aclarar que al darle la opción correcta para salir a éste ciclo, entonces ahí si que sale del Subproceso y va al menú en el proceso principal.

Todos los demás subprocesos me funcionan correctamente incluso el mismo subproceso siempre y cuando no entra en la condicional que indica que la base de datos (Vector en este caso) está llena.

Si alguien puede revisarlo en su PSeInt y decirme si les pasa lo mismo y quizás si hay alguna manera de controlar este evento, se los agradezco muchísimo. Copiaré el código separado por subprocesos ya que es muy largo y el mismo depende de todos los subalgoritmos, es por ello que no copio tan solo la parte del error.

ALGORITMO PRINCIPAL

Algoritmo tiendaComercial
    Definir  opciones, cantRegistros Como Entero;
    
    Escribir "Defina cuantos registros que tendrá la base de datos.";
    Leer cantRegistros;
    
    Escribir "===== > Creando la base de datos. < =====";
    Escribir  "";
    Dimension documento(cantRegistros), nombres(cantRegistros), saldo(cantRegistros), activo(cantRegistros);    
    
    Repetir
        Limpiar Pantalla;
        Escribir "************* MENÚ PRINCIPAL *************";
        Escribir "===== > Seleccione una opción (Número). < =====";
        Escribir  "1. Consultar.";
        Escribir  "2. Ordenar de menor a mayor.";
        Escribir  "3. Eliminar.";
        Escribir  "4. Ingresar.";
        Escribir  "9. Terminar.";
        
        Leer opciones;
        
        Segun opciones
            1:
                consultar(documento, nombres, saldo, activo, cantRegistros);
            2:
                ordenar(documento, nombres, saldo, activo, cantRegistros);
            3:
                eliminar(documento, nombres, saldo, activo, cantRegistros);
            4:
                ingresar(documento, nombres, saldo, activo, cantRegistros);
            9:
                Escribir "Finalizando sesión...";               
            De Otro Modo:
                Limpiar Pantalla;
                Escribir "************* MENÚ PRINCIPAL *************";
                Escribir "Opción no válida!, ingrese una opción válida...";
                Esperar 2 Segundos;
        FinSegun        
    Hasta Que opciones = 9  
FinAlgoritmo

SUBALGORITMO PARA CONSULTA DE REGISTROS

//Creando Subproceso para consultar registros
SubProceso consultar (documento Por Referencia, nombres Por Referencia, saldo Por Referencia, activo Por Referencia, cantRegistros Por Valor)
    Definir option, registro Como Entero;   
    Definir respuesta Como Logico;
    Limpiar Pantalla;   
    
    Escribir "===== CONSULTANDO UN REGISTRO =====";
    Escribir "Seleccione 1. Consultar por documento.";
    Escribir "Seleccione 2. Listar todos los registros.";   
    Escribir "Seleccione 3. Salir.";    
    Leer option;
    Escribir "";
    
    Repetir     
        Segun option
            1:
                Escribir "Ingrese el documento a consultar";
                Leer registro;
                
                //Buscamos en los registros el documento ingresado
                Para i = 0 Hasta cantRegistros-1 Con Paso 1 Hacer
                    si registro = documento(i) Entonces
                        respuesta = Verdadero;              
                    FinSi
                FinPara
                
                // Verificamos si la búsqueda arrojó algun resultado
                si respuesta = Verdadero Entonces                   
                    // Si lo encontró mostramos la información del registro
                    Para i = 0 Hasta cantRegistros-1 Con Paso 1 Hacer
                        si registro = documento(i) Entonces
                            Limpiar Pantalla;
                            Escribir "";
                            Escribir "===== CONSULTANDO UN REGISTRO =====";
                            Escribir "Documento: ", documento(i);
                            Escribir "Nombres: ", nombres(i);
                            Escribir "Saldo: $", saldo(i);
                            
                            si activo(i) = "1" Entonces
                                Escribir "Activo: SI";
                            SiNo
                                Escribir "Activo: NO";
                            FinSi                           
                            Escribir "";
                            Escribir "Presione ENTER para regresar al menú principal";
                            Esperar Tecla;
                        FinSi
                    FinPara
                SiNo
                    Repetir
                        // Si el registro no existe, informamos que no se encontró
                        Limpiar Pantalla;                   
                        Escribir "===== CONSULTANDO UN REGISTRO =====";
                        Escribir "Ooops!! Registro no encontrado ¿Desea registrarlo?";
                        Escribir "1. Si";
                        Escribir "2. No";               
                        Leer option;
                        
                        Segun option
                            1:
                                ingresar(documento, nombres, saldo, activo, cantRegistros);                 
                            2:                              
                                Limpiar Pantalla;
                                Escribir "===== CONSULTANDO UN REGISTRO =====";
                                Escribir "Saliendo del proceso de consulta...";
                                Esperar 2 Segundos;
                            De Otro Modo:
                                Escribir "Opción incorrecta! elige una opción válida...";
                                Esperar 2 Segundos;
                        FinSegun
                    Hasta Que option = 2
                FinSi
                option = 3;
            2:
                // Verificamos posiciones llenas en el vector   
                cantReg = disponibilidad (documento, cantRegistros);
                
                si cantReg > 0 Entonces
                    Limpiar Pantalla;
                    Escribir "===== LISTANDO TODOS REGISTROS =====";
                    // Listamos todos los registros de la base datos
                    listar(documento, nombres, saldo, activo, cantReg);
                    Escribir "";
                    Escribir "Presione ENTER para continuar...";
                    Esperar Tecla;
                    option = 3;
                SiNo
                    Limpiar Pantalla;
                    Escribir "===== LISTANDO TODOS REGISTROS =====";
                    Escribir "La base de datos está vacía!";
                    Escribir "";
                    Esperar 2 Segundos;
                    option = 3;
                FinSi               
            3:
                Escribir "Regresando al menú principal...";
                Escribir "";
                Esperar 2 Segundos;
            De Otro Modo:
                Limpiar Pantalla;
                Escribir "===== LISTANDO TODOS REGISTROS =====";
                Escribir "Opción incorrecta!, elige una opción válida...";
                Escribir "";
                Esperar 2 Segundos;
                consultar(documento, nombres, saldo, activo, cantRegistros);
        FinSegun        
    Hasta Que option = 3
FinSubProceso

SUBALGORITMO PARA INGRESAR REGISTROS

//Creando Subproceso para ingresar registros
SubProceso ingresar (documento Por Referencia, nombres Por Referencia, saldo Por Referencia, activo Por Referencia, cantRegistros Por Valor)
    Definir option, indice, cantReg, nDocumento Como Entero;
    Definir detener, dupliDocumento, dupliNombre, continuar Como Logico;
    Definir nNombre Como Caracter;  
    
    continuar = Falso;
    
    // Verificamos posiciones llenas en el vector   
    cantReg = disponibilidad (documento, cantRegistros);
    
    si cantReg > 0 Entonces
        indice = (cantReg + 1)-1;
    SiNo
        indice = 0;
    FinSi       
    
    si cantReg = cantRegistros Entonces
        Repetir
            Limpiar Pantalla;
            Escribir "===== CREANDO NUEVO REGISTRO =====";
            Escribir "No hay espacios libres en la base de datos...";
            Escribir "=== > ¿Desea eliminar un registro?..  ";
            Escribir "1. Si";
            Escribir "2. No";
            Leer option;
            
            segun option
                1:
                    eliminar(documento, nombres, saldo, activo, cantRegistros);
                2:
                    Escribir "Regresando al menú principal...";
                    Esperar 2 Segundos;
                De Otro Modo:
                    Escribir "Opción no válida!, elige una opción válida...";
                    Esperar 2 Segundos;
            FinSegun
        Hasta Que option = 2;
    FinSi
    
    Si cantReg < cantRegistros Entonces
        Repetir
            Limpiar Pantalla;
            Escribir "===== CREANDO NUEVO REGISTRO =====";
            Repetir
                Escribir "Escriba documento a registrar...";
                Leer nDocumento;                
                dupliDocumento = validador(documento, nombres, cantRegistros, nDocumento, 1);
                
                si dupliDocumento = Verdadero Entonces
                    Escribir "Este documento ya existe!...";
                    Escribir "";
                    continuar = Falso;
                SiNo
                    Repetir
                        Escribir "Escriba el nombre del cliente...";
                        Leer nNombre;
                        dupliNombre = validador(documento, nombres, cantRegistros, nNombre, 2);
                        
                        Si dupliNombre = Verdadero Entonces
                            Escribir "";
                            Escribir "Nombre ya existe con documento diferente, ¿desea registrarlo?.";
                            Escribir "Escriba 1. Si quiero registrarlo";
                            Escribir "Escriba 2. No quiero elegir otro nombre";
                            Leer option;
                            
                            segun option
                                1:
                                    continuar = Verdadero;
                                De Otro Modo:
                                    continuar = Falso;                              
                            FinSegun
                        SiNo
                            continuar = Verdadero;
                        FinSi                       
                    Hasta Que continuar = Verdadero;
                FinSi               
            Hasta Que continuar = Verdadero;
            documento(indice) = nDocumento;
            nombres(indice) = nNombre;
            
            Escribir "Escriba el saldo del cliente...";
            Leer saldo(indice);
            Repetir
                Escribir "¿Cliente activo? 1= SI 2= NO...";
                Leer activo(indice);
            Hasta Que activo(indice) = "2" o activo(indice) = "1"
            
            ordenados(documento, nombres, saldo, activo, cantRegistros, 1);
            Repetir
                Limpiar Pantalla;
                Escribir "===== REGISTRO EXITOSO =====";
                Escribir "¿Desea agregar otro registro?.. 1 = SI, 2 = NO";
                Leer option;
                
                Segun option
                    1:
                        ingresar(documento, nombres, saldo, activo, cantRegistros);                                 
                    2:
                        detener = Verdadero;
                        Escribir "Regresando al menú principal...";
                        Esperar 2 Segundos;
                    De Otro Modo:                   
                        Escribir "Opción incorrecta!, regresando al menú principal...";
                        Esperar 2 Segundos; 
                FinSegun
            Hasta Que option =2;
        Hasta Que detener = Verdadero;
    FinSi
FinSubProceso

SUBALGORITMO PARA ELIMINAR REGISTROS

//Creando Subproceso para eliminar registros
SubProceso eliminar (documento Por Referencia, nombres Por Referencia, saldo Por Referencia, activo Por Referencia, cantRegistros Por Valor)
    Definir option, auxiliar, totalRegistros, cantReg Como Entero;
    
    // Verificamos posiciones llenas en el vector   
    cantReg = disponibilidad (documento, cantRegistros);    
    
    Escribir "===== ELIMINAR UN REGISTRO =====";
    Escribir "Actualmente estos son los registros de la base de datos, ¿Cual desea eliminar?...";   
    listar(documento, nombres, saldo, activo, cantReg); 
    Leer option;
    
    si option-1 >= cantReg Entonces
        Limpiar Pantalla;
        Escribir "===== ELIMINAR UN REGISTRO =====";
        Escribir "El registro a eliminar no existe!.. Regresando";
        Esperar 2 Segundos;
    SiNo
        auxiliar = option;
        
        Mientras auxiliar <= cantReg-1 Hacer
            // Eliminando el registro
            documento(option-1) = documento(auxiliar);
            nombres(option-1) = nombres(auxiliar);
            saldo(option-1) = saldo(auxiliar);
            activo(option-1) = activo(auxiliar);
            
            auxiliar = auxiliar+1;
        Fin Mientras
        
        documento(auxiliar-1) = 0;
        nombres(auxiliar-1) = "";
        saldo(auxiliar-1) = 0;
        activo(auxiliar-1) = "";        
        
        // Reordenamos la lista de la base de datos
        ordenados(documento, nombres, saldo, activo, cantRegistros, 1);
        // Verificamos posiciones llenas en el vector   
        cantReg = disponibilidad (documento, cantRegistros);    
        
        Limpiar Pantalla;
        // Mostramos los registros restantes
        Escribir "===== Registro eliminado con éxito. =====";   
        Si cantReg > 0 Entonces
            listar(documento, nombres, saldo, activo, cantReg);
            Escribir "";
            Escribir "Presione ENTER para salir";
            Esperar Tecla;
        SiNo
            Escribir "¡URRAAA!.. La base de datos ahora está vacía!";
            Escribir "";
            Escribir "Presione ENTER para regresar al menú Principal";
            Esperar Tecla;
        FinSi
    FinSi   
FinSubProceso

SUBALGORITMO PARA ESTABLECER UN ORDEN EN LOS REGISTROS

//Creando Subproceso para ordenar los registros
SubProceso ordenar (documento Por Referencia, nombres Por Referencia, saldo Por Referencia, activo Por Referencia, cantRegistros Por Valor)
    Definir orden, cantReg Como Entero;
    
    // Verificamos posiciones llenas en el vector   
    cantReg = disponibilidad (documento, cantRegistros);
    
    Si cantReg > 1 Entonces
        Repetir
            Limpiar Pantalla;
            Escribir "===== Orden actual de la base de datos =====";
            listar(documento, nombres, saldo, activo, cantReg);
            
            Escribir "";
            Escribir "Seleccione 1. Para ordenar de MENOR a MAYOR por Documento";
            Escribir "Seleccione 2. Para ordenar de MAYOR a MENOR por Documento";
            Leer orden;
            
            Si orden < 1 o orden > 2 Entonces
                Escribir "";
                Escribir "Opción incorrecta!, elige una opción válida...";
                Esperar 2 Segundos;
            FinSi
        Hasta Que orden <= 2
        
        ordenados(documento, nombres, saldo, activo, cantRegistros, orden);
        
        Escribir "";
        Escribir "===== Base de datos Ordenada  =====";
        listar(documento, nombres, saldo, activo, cantReg);
        Escribir "";
        Escribir "Presione ENTER para volver al menú principal...";
        Esperar Tecla;
    SiNo
        Si cantReg = 1 Entonces
            Limpiar Pantalla;
            Escribir "===== ORDENAR BASE DE DATOS =====";
            listar(documento, nombres, saldo, activo, cantReg);
            Escribir "";
            Escribir "No hay suficientes registros para ordenar.";
            Escribir "Presione ENTER para regresar al menú princial...";
            Esperar Tecla;
        SiNo
            Limpiar Pantalla;
            Escribir "===== ORDENAR BASE DE DATOS =====";
            Escribir "Esta base de datos no tiene registros para ordenar...";
            Esperar 2 Segundos;
        FinSi
    FinSi   
FinSubProceso

SUBALGORITMO PARA ORDENAR REGISTROS SEGUN ORDEN ENVIADO

// Estableciendo orden general
SubProceso ordenados (documento Por Referencia, nombres Por Referencia, saldo Por Referencia, activo Por Referencia, cantRegistros Por Valor, nOrden Por Valor)
    Definir cantReg Como Entero;
    
    Segun nOrden        
        1:          
            // Ordeno de Mayor a menor segun la cantidad total de cupos
            Para i=0 Hasta cantRegistros-1 Con Paso 1 Hacer
                Para j=i+1 Hasta cantRegistros-1 Con Paso 1 Hacer
                    si documento(i) < documento(j) Entonces
                        //Ordenando los documentos
                        tmpDocumento = documento(i);
                        documento(i) = documento(j);
                        documento(j) = tmpDocumento;
                        
                        //Ordenando los nombres
                        tmpNombre = nombres(i);
                        nombres(i) = nombres(j);
                        nombres(j) = tmpNombre;
                        
                        //Ordenando los saldos
                        tmpSaldo = saldo(i);
                        saldo(i) = saldo(j);
                        saldo(j) = tmpSaldo;
                        
                        //Ordenando los activos
                        tmpActivo = activo(i);
                        activo(i) = activo(j);
                        activo(j) = tmpActivo;                          
                    FinSi
                FinPara
            FinPara
            
            // Verifico cuantos cupos hay llenos 
            cantReg = disponibilidad (documento, cantRegistros);
            
            // Ordeno de Menor a Mayor unicamente los cupos que contienen datos en el vector
            Para i=0 Hasta cantReg-1 Con Paso 1 Hacer
                Para j=i+1 Hasta cantReg-1 Con Paso 1 Hacer
                    si documento(i) > documento(j) Entonces
                        //Ordenando los documentos
                        tmpDocumento = documento(i);
                        documento(i) = documento(j);
                        documento(j) = tmpDocumento;
                        
                        //Ordenando los nombres
                        tmpNombre = nombres(i);
                        nombres(i) = nombres(j);
                        nombres(j) = tmpNombre;
                        
                        //Ordenando los saldos
                        tmpSaldo = saldo(i);
                        saldo(i) = saldo(j);
                        saldo(j) = tmpSaldo;
                        
                        //Ordenando los activos
                        tmpActivo = activo(i);
                        activo(i) = activo(j);
                        activo(j) = tmpActivo;                          
                    FinSi
                FinPara
            FinPara
        2:
            // Ordeno de Mayor a menor segun la cantidad total de cupos
            Para i=0 Hasta cantRegistros-1 Con Paso 1 Hacer
                Para j=i+1 Hasta cantRegistros-1 Con Paso 1 Hacer
                    si documento(i) < documento(j) Entonces
                        //Ordenando los documentos
                        tmpDocumento = documento(i);
                        documento(i) = documento(j);
                        documento(j) = tmpDocumento;
                        
                        //Ordenando los nombres
                        tmpNombre = nombres(i);
                        nombres(i) = nombres(j);
                        nombres(j) = tmpNombre;
                        
                        //Ordenando los saldos
                        tmpSaldo = saldo(i);
                        saldo(i) = saldo(j);
                        saldo(j) = tmpSaldo;
                        
                        //Ordenando los activos
                        tmpActivo = activo(i);
                        activo(i) = activo(j);
                        activo(j) = tmpActivo;                          
                    FinSi
                FinPara
            FinPara     
    FinSegun    
FinSubProceso

SUBALGORITMO PARA CONTAR REGISTROS EN EL VECTOR

// Creamos función para contar las posiciones llenas en el vector
Funcion totalRegistros <- disponibilidad (documento Por Referencia, cantRegistros Por Valor)
    // Verificamos posiciones llenas en el vector
    Para i=0 hasta cantRegistros-1 Con Paso 1 Hacer
        si documento(i) <> 0 Entonces
            totalRegistros = totalRegistros+1;
        FinSi
    FinPara 
FinFuncion

SUBALGORITMO PARA LISTAR LOS REGISTROS DE LOS VECTORES

// Proceso para listar todos los registros de la base de datos
SubProceso listar (documento Por Referencia, nombres Por Referencia, saldo Por Referencia, activo Por Referencia, cantRegistros Por Valor)
    
    Para  i=0 Hasta cantRegistros-1 Con Paso 1 Hacer        
        si activo(i) = "1" Entonces         
            Escribir i+1,". Documento: ", documento(i), ", Nombre: ", nombres(i), ", Saldo: ", saldo(i), ", ¿Activo?: SI";
        SiNo            
            Escribir i+1,". Documento: ", documento(i), ", Nombre: ", nombres(i), ", Saldo: ", saldo(i), ", ¿Activo?: NO";
        FinSi
    FinPara
FinSubProceso

SUBALGORITMO PARA VALIDAR REGISTROS DUPLICADOS

Funcion duplicado <- validador (documento Por Referencia, nombres Por Referencia, cantRegistros Por Valor, regValidar Por Valor, vectorValidar Por Valor)
    
    Segun vectorValidar
        1:
            Para  i=0 Hasta cantRegistros-1 Con Paso 1 Hacer
                si regValidar = documento(i) Entonces
                    duplicado = Verdadero;
                FinSi
            FinPara
        2:
            Para  i=0 Hasta cantRegistros-1 Con Paso 1 Hacer
                si regValidar = nombres(i) Entonces
                    duplicado = Verdadero;
                FinSi
            FinPara
    FinSegun        
FinFuncion

Desde ya, gracias por tomarte el tiempo de revisarlo y decirme si te sucede el mismo fallo que me presenta.

RECUERDA: El fallo es cuando intentas hacer un nuevo registro estando los vectores llenos, puedes establecer un tamaño de vector de 1 elementos, registrarlo e intentar registrar de nuevo otro, te dirá que la base de datos está llena y te pregunta si quieres eliminar 1 registro, al indicar la opción 2, justo ahí es cuando no se sale del subproceso y se devuelve a la línea que indico al inicio de la pregunta.

Adjunto algunas capturas que describen la falla.

1.Muestra cuando llega al final del Subproceso
Muestra cuando llega al final del Subproceso

2.Muestra la línea a la que salta sin salir del subproceso
Muestra la línea a la que salta sin salir del subproceso

3.Muestra el ciclo en el que queda luego de fallar la salida del subproceso
Muestra el ciclo en el que queda luego de fallar la salida del subproceso

Como o kernel do sistema operacional é acordado para executar o algoritmo de escalonamento Shortest Job First preemptivo?

Nos livros de sistemas operacionais, nos capítulos de algoritmos de escalonamento, há a descrição do Shortest Job First preemptivo (SRTF). Em todos os livros que li e videoaulas no youtube que assisti, é dito que a chegada de um novo processo na fila dos prontos, que possua tempo de CPU inferior ao processo atual em execução irá causar a sua preempção. Mas como o kernel é acordado para colocar o escalonador em execução e consequentemente fazer a escolha do menor processo? Não há menção a time-slice, quantum ou interrupção do timer. Obrigado.

Fiz um algoritmo de uma f(x), pelo método de Newton-Raphson, a parte condicional e de exibição de resultados não esta executando, alguém pode ajudar?

Var
// Seção de Declarações das variáveis
   f, daf, erro, xb, x1, x0: real
   k_esp, k: inteiro
funcao f(x: real):real

Inicio
  retorne ((x)^2+(x)-6)
fimfuncao
funcao daf(x: real):real
Inicio
  retorne ((2*(x))+1)
fimfuncao
Inicio
escreval("escreva o valor da  estimativa inicial: ")
leia(x0)
escreva ("digite o erro desejado: ")
leia(erro)
escreval ("Digite um numero máximo de iterações do caso específico: ")
leia(k_esp)
k <- 1
enquanto abs(f(x0))> erro faca
x1 <- x0 - (f(x0)/daf(x0))
se(abs (f(x1))< erro) ou (abs(x0-x1)< erro) entao
xb <- x1
interrompa
fimse
x0 <- x1
se k > K_esp entao
interrompa
senao
k <- k + 1
fimse
fimenquanto
se k > K_esp entao
escreval("o numero de iterações específicas utilizado foi: ",k_esp,)
escreval("o valor aproximado da raiz é: ",xb,)
fimse

Fimalgoritmo

Alguem pode me ajudar a fazer esse esse algoritmo?

Dada uma sequência de números inteiros, pretende-se uma função que crie uma
lista de elementos repetidos a partir dessa sequência e criar outra função que crie
uma lista sem os elementos repetidos.
Nota: Podes usar um só ciclo (use dicionário);

  • Permita ao utilizador inserir frases e só termina quando se escreve “end”. O
    programa vai colocar cada inicial de cada frase em maiúsculas e verifica se no final da
    frase se coloca ponto final, ponto de exclamação, ponto de interrogação. No final
    mostra todas as frases inseridas com a inicial em maiúscula e o tipo de fim de frase.

algoritmo – Preciso fazer um app q faz sorteio no Instagram usando python

Preciso fazer um sorteio de comentário no Instagram usando python e com o Tkinter ou qualquer outra GUi.
Alguém por favor me ajude

Algoritmo em python

1- Escreva um algoritmo que solicite um número ao usuário. Caso seja digitado um valor entre 0 e 9, mostre: “valor correto”, caso contrário mostre: “valor incorreto”.

lógica – dúvida em como montar o algoritmo no VisuALG

é um algoritmo que deve retornar o dia da semana segundo o número correspondente, eu tentei escrever o algoritmo, porém ainda não entendi muito bem onde colocar o leia(mes), leia(ano), leia(dia).

//
//
// Descrição   : retorna o dia da semana
// Autor(a)    : Ana
// Data atual  : 07/03/2021
Var
   A, B, C, D, Ei, F, G, H, I, J : inteiro
   mes, ano, dia : inteiro

Inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...


   escreval ("alguma coisa aqui")
   A <- o int ((12 - mes) ÷ 10)
   leia(mes)
   B <- ano - A
   leia(ano)
   C <- mes + (12 x A)
   D <- o int  (B ÷ 100)
   Ei <- o int (D ÷ 4)
   F <- 2 - D + Ei
   G <- o int (365,25 x B)
   H <- o int  (30,6001 x (C + 1))
   I <- F + G + H + dia + 5
   leia(dia)
   J <- o resto (I ÷ 7)

   switch (j)
   caso 0:
   escolha "Sábado"
   caso 1:
   escolha "Domingo"
   caso 2:
   escolha "Segunda"
   caso 3:
   escolha "Terça"
   caso 4:
   escolha "Quarta"
   caso 5:
   escolha "Quinta"
   caso 6:
   escolha "Sexta"
   senao :
   escolha "Erro ao tentar retornar o dia da semana";





Fimalgoritmo
Fimescolha