Saludos tengo las siguientes tablas

BAR(id,nombre)
CERVEZA(id,nombre)
CLIENTE(id,nombre)
SIRVE(idBAR,idCERVEZA)
ASISTE(idCLIENTE,idBAR)
GUSTA(idCLIENTE,idCERVEZA)

y tengo la consulta que dice nombrar los nombres de las cervezas que no se sirven en el bar 'TARROS'

lo que llevo es esto:

SELECT c.nombre FROM BAR AS b, CERVEZA AS c, SIRVE AS s
WHERE c.id=s.idCERVEZA AND b.id=s.idBAR AND b.nombre='TARROS'

pero a partir de ahi ya no se como seguir

gracias

Saludos

tengo la siguientes tablas
CENTROS (Numero, Nombre, Direccion)
DEPARTAMENTOS (Numero, Centro, Director, Tipo_director, Presupesto, Depto_jefe, Nombre)
EMPLEADOS (Cod, Departamento, Telefono, Fecha_nacimiento, Fecha_ingreso, Salario, Comision,Num_hijos, Nombre)

y me pide que haga las siguientes consultas:

20. Obtener, por orden alfabético, los nombres y los salarios de los empleados cuyo salario coincide con la comisión de cualquier otro o la suya propia.

yo pense que seria algo como esto:

SELECT Nombre, Salario
FROM EMPLEADOS
WHERE Salario=Comision;

pero en el problema me dice que el salario puede coincidir con la comision de cualquier otro y esa es la parte que no se como hacerla.

otra es: 22. Para los departamentos cuyo salario medio supera al promedio de la empresa, hallar cuántas extensiones telefónicas tienen.

SELECT COUNT(Telefono)
FROM EMPLEADOS AS e, DEPARTAMENTOS AS d
WHERE AVG(e.salario) > AVG(salario);

pero no se como calcular el promedio del salario de toda la empresa

gracias

Saludos

Tengo la siguiente función que se llama crearArchivoTABSIM() la cual se encuentra dentro de un ciclo en el main, y cada vez que entra al ciclo se le asigna a la funcion una cadena que se llama etiqueta(char *etiqueta).

void crearArchivoTABSIM(char *etiqueta)
{
    FILE *tb;
    ETIQ *p = NULL;
    if((strcmp(etiqueta,"null")) != 0)
    {
        crearListaEtiquetas(&p,etiqueta);
        imprimirEtiquetas(p);
        if((tb = fopen("TABSIM.txt","a+")) != NULL)
        {
            fwrite(etiqueta,strlen(etiqueta),1,tb);
            fwrite("\n",1,1,tb);
        }
    }
}

y dentro de la función crearArchivoTABSIM() se encuentra la función crearListaEtiquetas() que me va a crear una lista simplemente ligada que tiene un campo char *etiqueta,y que cada vez que le envie una etiqueta me la va a insertar al principio, y después de esta esta la función imprimirEtiquetas() que me va a ir imprimiendo las etiquetas

void crearListaEtiquetas(ETIQ **p,char *etiqueta)
{
    ETIQ *nuevo;
    nuevo = crearEtiqueta(etiqueta);
    nuevo->sig = *p;
    *p = nuevo;
}
 
ETIQ *crearEtiqueta(char *etiqueta)
{
    ETIQ *x;
    int lon;
    lon = strlen(etiqueta);
    x = malloc(sizeof(ETIQ));
    x->Etiqueta = malloc((lon+1)*sizeof(char));
    strcpy(x->Etiqueta,etiqueta);
    return x;
}
 
void imprimirEtiquetas(ETIQ *p)
{
    ETIQ *ptr;
    for(ptr = p;ptr!=NULL;ptr = ptr->sig)
       printf("[%s]\n",ptr->Etiqueta);
}
 

como  por ejemplo:

Si le mando las etiquetas ET1, ET2,ET3,ET4

deberia imprimir

1) ET1
2)ET1    ET2
3)ET1   ET2    ET3
4)ET1   ET2    ET3     ET4

pero el problema que tengo es que solo me esta imprimiendo el primer nodo, o sea a donde apunte la cabeza de lista y no se que estoy haciendo mal, previamente ya habia hecho listas ligadas y no me habian dado ningun problema

de antemano gracias

Saludos

tengo una duda de como hacer un procedimiento de conversión de un número decimal negativo a su hexadecimal, se que si el número fuera positivo con tan solo hacer divisiones sucesivas obtendría el resultado, pero cuál es el procedimiento para los negativos??

gracias

Saludos

tengo una duda a acerca de si el operador  ~ que se usa para obtener el complemento a 1 de un numero, puede usarse solo con números decimales o si tambien los puede usar con numeros binarios??

saludos, tengo una duda de como funciona el contador de localidades de un ensamblador cuando se tienen errores en una directiva por ejemplo si yo tengo

DB         300

aqui hay un error en el rango porque la directiva solo puede tener un valor del 0 al 255

DB         %11A

aqui hay otro error porque las bases binarias solo aceptan los digitos 1 y 0.

entonces en estos casos aumenta el contloc??? o se queda con el valor anterior??
gracias

Saludos

tengo un codigo que convierte un numero decimal en hexadecimal(siempre tiene que ser decimal-hexadecimal), el programa funciona bien el problema es que una vez que tengo el número hexa tengo que hacer que sea de dos bytes, o sea vendrían siendo 4 digitos como por ejemplo

numero decimal       hexadecimal      hexadecimal 2 bytes
33                               21                        0021

y no se como concatenarle los dos ceros al principio, pense en usar un strcat pero no funciono, creaba otra variable *cadena, y despues de asignarle memoria la inicializaba con: "0", y después le concatenaba la cadena "21" para que me quedara "021".

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
char convertirHexadecimal(int residuo);
 
int main()
{
    char num_hex,*cadena,c[2],*hexadecimal;
    int numero = 33,cociente,residuo,i;
    cadena = calloc(12,sizeof(char));
    for(cociente = numero;cociente > 0;cociente/=16)
    {
        residuo = cociente % 16;
        num_hex = convertirHexadecimal(residuo);
        sprintf(c,"%c",num_hex);
        strcat(cadena,c);
    }
    strrev(cadena);
    printf("[%s]\n",cadena);
    return 0;
}
 
char convertirHexadecimal(int residuo)
{
    char letra;
    switch(residuo)
    {
        case 10:
           letra = 'A';
           break;
        case 11:
           letra = 'B';
           break;
        case 12:
           letra = 'C';
           break;
        case 13:
           letra = 'D';
           break;
        case 14:
           letra = 'E';
           break;
        case 15:
           letra = 'F';
           break;
        default:
           letra = '0' + residuo;
    }
    return letra;
}
 

Saludos

Alguien conoce de algun metodo que no sea el de divisiones sucesivas el cual convierta un numero decimal a cualquiera de las otras 3 potencias,(binaria,octal,hexadecimal)????

gracias

Saludos, tengo el siguiente segmento de codigo dentro de un CASE '[' o
CASE INDEXADO_INDIRECTO, donde tengo que validar una cadena esta cadena que inicia con [, debe de tener o bien una D despues del corchete o un numero en base DECIMAL (tiene un rango especifico de valores para que sea valido)seguido por una , despues un registro que puede ser x,y,sp,pc  y por ultimo un corchete de cierre ]

por ejemplo si tengo:

[5,Sp -> error: le falta el ultimo corchete
[,x] -> no puede haber una instruccion vacia antes de la coma
[100,] ->no puede haber una instruccion vacia despues de la coma
[ ->despues del primer [ debe haber dos registros separados por una , y despues ]
[AD,sp]-> el primer registro tiene que ser la letra D

PERO cuando le pongo algo como:

[5A9,x] -> aqui me aparece que es un numero valido, pero para este caso en especial solo puede aceptar numeros decimales, y no se como corregir esto

case INDEXADO_INDIRECTO:
            i = 1;
            tam = strlen(operando);
            car = operando[i++];
            if(car == '\0')
               printf("Despues del primer [ debe haber dos registros separados por , y un corchete de cierre\n");
            else
            {
                if(operando[tam-1] != ']')
                   printf("Error: No se encontro corchete de cierre\n");
                else
                {
                    switch(car)
                    {
                        case ']':
                           printf("No pueden estar los corchetes vacios\n");
                           break;
                        case ',':
                           printf("No puede haber una instruccion vacia antes de la coma\n");
                           registro = obtenerRegistro(operando);
                           if((strcmp(registro,"\0")) == 0)
                              printf("No puede haber una instruccion vacia despues de la coma\n");
                              break;
                        case '0':
                        case '1':
                        case '2':
                        case '3':
                        case '4':
                        case '5':
                        case '6':
                        case '7':
                        case '8':
                        case '9':
                           if((ptr = strchr(operando,',')) == 0)
                              printf("Despues del primer corchete debe haber dos registros separados por una ,\n");
                           else
                           {
                               base = 10;
                               x = 1;
                               k = 0;
                               esIndexadoIndirecto16bits = 1;
                               instruccion = obtenerInstruccion(operando,x);
                               numero = obtenerNumero(instruccion,k,base);
                               registro = obtenerRegistro(operando);
                               registro = convertirMayusculas(registro);
                               if((strcmp(registro,"\0")) == 0)
                                  printf("No puede haber una instruccion vacia despues de la coma\n");
                               else
                               {
                                   if(!verificarRegistro(registro))
                                   {
                                       esIndexadoIndirecto16bits = 0;
                                       printf("Los registros validos de un direccionamiento Indexado indirecto de 16 bits son X,Y,SP,PC\n");
                                   }
                                   if(!verificarRangoIndexadoIndirecto(numero))
                                   {
                                       esIndexadoIndirecto16bits = 0;
                                       printf("El rango valido de un direccionamiento Indexado Indirecto de 16 bits es de 0 a 65535\n");
                                   }
                                   if(esIndexadoIndirecto16bits)
                                   {
                                       if((indice = buscarDireccionamiento(encontrado,direccionamiento[7]))!= -1)
                                          printf("Indexado Indirecto de 16 bits([IDX2]), de %s bytes\n",encontrado->total_bytes[indice]);
                                       else
                                          printf("el codop %s no acepta el direccionamiento indexado indirecto de 16 bits\n",encontrado->instruccion);
                                   }
                               }
                           }
                          break;
                       case '-':
                          if((ptr = strchr(operando,',')) == 0)
                             printf("Despues del primer corchete debe haber dos registros separados por una ,\n");
                          else
                          {
                              base = 10;
                              x = 0;
                              k = 1;
                              esIndexadoIndirecto16bits = 1;
                              instruccion = obtenerInstruccion(operando,x);
                              numero = obtenerNumero(instruccion,k,base);
                              registro = obtenerRegistro(operando);
                              registro = convertirMayusculas(registro);
                              if((strcmp(registro,"\0")) == 0)
                                 printf("No puede haber una instruccion vacia despues de la coma\n");
                              else
                              {
                                  if(!verificarRegistro(registro))
                                  {
                                      esIndexadoIndirecto16bits = 0;
                                      printf("Los registros validos de un direccionamiento Indexado indirecto de 16 bits son X,Y,SP,PC\n");
                                  }
                                  if(!verificarRangoIndexadoIndirecto(numero))
                                  {
                                      esIndexadoIndirecto16bits = 0;
                                      printf("El rango valido de un direccionamiento Indexado Indirecto de 16 bits es de 0 a 65535\n");
                                  }
                                  if(esIndexadoIndirecto16bits)
                                  {
                                      if((indice = buscarDireccionamiento(encontrado,direccionamiento[7]))!= -1)
                                         printf("Indexado Indirecto de 16 bits([IDX2]), de %s bytes\n",encontrado->total_bytes[indice]);
                                      else
                                         printf("el codop %s no acepta el direccionamiento indexado indirecto de 16 bits\n",encontrado->instruccion);
                                  }
                              }
                          }
                          break;
                       default:
                          x = 1;
                          esIndexadoIndirecto_Acumulador = 1;
                          instruccion = obtenerInstruccion(operando,x);
                          registro = obtenerRegistro(operando);
                          registro = convertirMayusculas(registro);
                          if(!indirectoAcumulador_D(instruccion))
                          {
                              printf("Error: El Acumulador valido de un Indexdo Indirecto de acumulador es D\n");
                              esIndexadoIndirecto_Acumulador = 0;
                          }
                          if(!verificarRegistro(registro))
                          {
                              printf("Los registros validos de un Indexado Indirecto de Acumulador son X,Y,SP,PC\n");
                              esIndexadoIndirecto_Acumulador = 0;
                          }
                          if(esIndexadoIndirecto_Acumulador)
                          {
                              if((indice = buscarDireccionamiento(encontrado,direccionamiento[6]))!= -1)
                                 printf("Indexado Indirecto de Acumulador D,([D,IDX]), de %s bytes\n",encontrado->total_bytes[indice]);
                              else
                                 printf("el codop %s no acepta el direccionamiento indexado indirecto de acumulador D\n",encontrado->instruccion);
                          }
                      }
                }
            }
            break;
 

y las demas funciones son estas, no puse todo el codigo porque son como 1700 lineas de codigo,se que tengo algunas malas practicas de programacion pero ahora lo importante es corregir ese bug.

char *obtenerRegistro(char *operando)
{
    int j,i = 0;
    char *cadena = NULL,c[2];
    cadena = calloc(2,sizeof(char));
    while(operando[i] != ',')
       i++;
    for(j = i+1;operando[j] != ']';j++)
    {
        sprintf(c,"%c",operando[j]);
        strcat(cadena,c);
    }
    return cadena;
}
char *obtenerInstruccion(char *operando,int x)
{
    int i;
    char *cadena = NULL,c[2],signo[] = {'\0',','};
    cadena = calloc(7,sizeof(char));
    for(i = x;operando[i] != ',';i++)
    {
        sprintf(c,"%c",operando[i]);
        strcat(cadena,c);
    }
    return cadena;
}
 
int obtenerNumero(char *operando,int x,int base)
{
    int i,potencia,num_decimal = 0,lon,entero = 0;
    lon = strlen(operando);
    for(i = lon-1,potencia = 1;i >= x;i--,potencia*=base)
    {
        if(esLetraBase16(operando[i]))
           entero = hexadecimal(operando[i]);
        else
           entero = operando[i]-'0';
        num_decimal+= potencia*entero;
    }
    if(operando[CERO] == '-')
       num_decimal*= -1;
    return num_decimal;
}
 
int hexadecimal(char caracter)
{
    int decimal;
    switch(caracter)
    {
        case 'A':case 'a':
           decimal = 10;
           break;
        case 'B':case 'b':
           decimal = 11;
           break;
        case 'C':case 'c':
           decimal = 12;
           break;
        case 'D':case 'd':
           decimal = 13;
           break;
        case 'E':case 'e':
           decimal = 14;
           break;
        case 'F':case 'f':
           decimal = 15;
           break;
        default:
           printf("!Error!\n");
    }
    return decimal;
}
 
char *convertirMayusculas(char *cadena)
{
    int i;
    for(i = 0;cadena[i];i++)
       cadena[i] = toupper(cadena[i]);
    return cadena;
}
 
int verificarRegistro(char *cadena)
{
    int i;
    char *registro[] = {"X","Y","SP","PC"};
    for(i = 0;i < 4;i++)
    {
        if((strcmp(cadena,registro[i])) == 0)
           return 1;
    }
    return 0;
}
 
int verificarRangoIndexadoIndirecto(int numero)
{
    if(numero >= CERO && numero <= MAX_IDX_INDIRECTO)
       return 1;
    else
       return 0;
}
 

de antemano gracias

Saludos, tengo dos tablas en postgres que son la siguientes:

partidas_pedidos con sus campos: id_pedido(Pk),fecha_pedido,cantidad,producto(fK),cliente(Fk)

y info_clientes: nombre,apellido,id_cliente(Pk)

y me piden que haga una consulta:

Mostrar IDs de los clientes, sin repetirse, que en algun pedido hayan comprado mas de dos ejemplares de un mismo producto(cantidad) durante 1999

SELECT DISTINCT id_cliente
FROM info_clientes
WHERE id_cliente=(SELECT cliente FROM partidas_pedidos WHERE cantidad > 2 AND fecha_pedido LIKE '1999%');

pero me aparece un error que dice: subconsulta utilizada como expresion retorno mas de un registro y no entiendo por qué me sale esto