Necesito orientacion con planteamiento de codigo en C

[aguml]

Hola amigos, he estado viendo como se comprueban los motores de ventiladores de aires acondicionado y se me ocurrió crearme un código para hacerlo más rápido. El caso es que llevo parias horas y no doy con la tecla.
En un ventilador con 3 cables uno es el común al que van conectadas las dos bobinas, los otros dos son las otras puntas de las bobinas.
Si se mide la resistencia, entre los dos cables que de la mayor resistencia va un condensador.
Los dos que dan menor resistencia son los que están conectados a la bobina de arranque.
Los que quedan por probar son los que van conectados a la bobina de funcionamiento.
Por ejemplo, si tenemos un cable rojo, uno negro y uno blanco y:
-Entre rojo y negro hay 200.
-Entre rojo y blanco hay 450.
-Entre negro y blanco hay 250.
Por lo tanto el condensador va entre rojo y blanco porque es la mayor medida.
Las dos bobinas suman lo mismo que la medida mayor así que el común es el negro ya que para que me entiendan ahí va el signo de sumar jijiji.
El cable N va al común y el L va al cable que sea el de la bobina mayor que en este caso es el blanco.
La idea es que primero me pida los colores de los cables, luego me pida los valores entre los cables y me muestre entre cuales va el condensador, en cual va el N y en cual el L.
Tengo este código pero no soy capaz de que funcione correctamente:

Código C:

#include <stdio.h>
#define NCABLES 3
int main ()
{
    char cable [NCABLES][25];
    int i,j,n=0,mayor=0,menor;
    float valor [NCABLES];
    
    for (i=0;i <NCABLES;i++)
    {
        printf ("Introduce el color %d: ",i+1);
        scanf ("%s",cable [i]);
    }
    for (i=0;i<NCABLES-1;i++){
        for (j=i+1;j<NCABLES;j++){
            printf ("Introduce la resistencia entre el %s y el %s: ",cable[i], cable[j]);
            scanf ("%f",valor [n]);
        }
    }
    menor=valor[0];
 
    for (i=0;i<NCABLES;i++){
        if (valor [mayor]>valor [i]){
            mayor=i;
        }
        if (valor [menor]<valor [i]){
            menor=i;
        }
    }
    if (mayor ==0){
        printf ("El condensador va entre el %s y el %s",cable [mayor],cable [NCABLES-1]);
    }else {
        printf ("El condensador va entre el %s y el %s",cable [mayor],cable [mayor-1]);
    }
}
 

De aquí saque la idea: https://m.youtube.com/watch?v=RiBraC2-e9I
¿Podéis Ayudarme?

[Fw190]

Para empezar, en la línea 17, al leer valor[n], debes pasar su dirección:

scanf ("%f", &valor[n]);

Saludos,

[aguml]

Bueno, hice la corrección que me indicaba pero no consigo que me funcione como quiero.
Lo tengo así y aun me falta por indicar en cual iría el L o fase pero no se como hacerlo y además lo que tengo a veces falla y no se que hacer ya .

Código C:

#include <stdio.h>
#include <string.h>
#define NCABLES 3
 
int main ()
{
    char cable [NCABLES][25];
    char combinacion [NCABLES][50];
    int i,j,n=0,mayor=0,menor,trabajo,comun;
    float valor [NCABLES];
    
    for (i=0;i <NCABLES;i++)
    {
        printf ("Introduce el color %d: ",i+1);
        scanf ("%s",cable [i]);
    }
    for (i=0;i<NCABLES-1;i++){
        for (j=i+1;j<NCABLES;j++){
            sprintf (combinacion [n],"el %s y el %s",cable[i], cable[j]);
            printf ("Introduce la resistencia entre %s: ",combinacion [n]);
            scanf ("%f",&valor[n]);
            n++;
        }
    }
    menor=valor[0];
 
    for (i=0;i<NCABLES;i++){
        if (valor [mayor]<valor [i]){
            mayor=i;
        }
        if (valor [menor]>valor [i]){
            menor=i;
        }
        if (valor [i] < valor[mayor] && valor [i] > valor[menor]){
            trabajo=i;
        }
    }
    printf ("El condensador va entre %s\n",combinacion [mayor]);
    printf ("La bobina de arranque esta entre %s\n",combinacion [menor]);
    printf ("La bobina de trabajo esta entre %s\n",combinacion [trabajo ]);
    for (i=0;i <NCABLES;i++){
        if (strstr (combinacion[mayor],cable [i])==NULL){
            comun=i;
            break;
        }
    }
    printf ("El comun es el %s. Conecta el neutro en el\n",cable [comun]);
}
 

[enrieto]

Hola; espero que mi comentario no te resulte molesto, pero yo no consigo entender la "especificación funcional" del programa que estás intentando. El tema de la conexión de estos ventiladores puede ser que sea familiar para algunos, pero no para todo el mundo. En esos casos, creo que conviene tratar de ser lo más explícito posible, y que en "las especificaciones" no queden muchas cosas libradas a la interpretación.

A modo de ejemplo, voy a tomar una de tus primeras oraciones:

En un ventilador con 3 cables uno es el común al que van conectadas las dos bobinas, los otros dos son las otras puntas de las bobinas.

Yo me pregunto:
- De esos 3 cables que tiene el ventilador, dices que uno "es el común". ¿A qué te refieres? Uno de ellos es un cable común, como cualquier otro cable, mientras que los otros dos no? O aquí la palabra "común" tiene otro significado?

- "... al que van conectadas las dos bobinas..." ¿Cómo? ¿Qué dos bobinas? No has mencionado antes la existencia de bobinas.

- "... los otros dos son las otras puntas de las bobinas..." A ver si entiendo, ¿hay dos de esos cables que forman parte (son sus puntas) de las dos bobinas?

Yo creo que me llevo medianamente bien con la solución de problemas lógicos, y tengo algunos años de experiencia codificando en C, y me da la impresión de que el problema que planteas no es demasiado complejo, peor no consigo pasar de las primeras dos líneas de ese planteo.

[aguml]

En el enlace del video se explica mejor pero intentare explicarlo yo.
Un motor de ventilador de una sola velocidad y con condensador de arranque tiene dos bobinas. La bobina con menor resistencia es la que ayuda para el arranque del motor y la otra bobina es la de trabajo, o sea, lo que mantiene el motor girando.
Ambas bobinas están unidas por una punta y de esa unión sale un cable que se le dice el común porque esta conectado a ambas.
De la otra punta de cada bobina sale otro cable y con eso ya tenemos tres cables.
Si mides la resistencia entre las dos puntas de las bobinas, o sea entre los dos cables que no son el común, te dará como resistencia la suma de las dos resistencias ya que están en serie.
Bien, ente esos dos cables se coloca un condensador.
A la punta de la bobina con mayor resistencia se conecta la fase y al común se conecta el neutro.
Esperó que lo entiendas mejor.

[enrieto]

Tengo algo en C++ que para mí es más fácil, pero no calcula todo lo posible, sólo a) dónde va el condensador, b) cuál es el común y c) dónde conectar la línea.

Te quedaría completar lo que necesites y pasarlo a C, y yo controlaría la entrada de datos. Sobre todo porque vi en el video que parece fácil equivocarse en las mediciones, esos números no se quedan quietos y los cables se agarran con los deditos.

La criatura:

Código C++:

#include <iostream>
#include <algorithm>
#include <string>
#include <map>
#include <vector>
#include <utility>
 
using pair_string = std::pair<std::string, std::string>;
 
pair_string calculaCapacitor(const std::map<pair_string, double>& medida)
{
    // determina el valor mayor de las tres mediciones y
    // devuelve el par de cables donde se obtuvo
    using mpartype = std::pair<pair_string, double>;
    auto maximo = std::max_element(medida.begin(), medida.end(),
    [](mpartype a, mpartype b) {
        return a.second < b.second;
    });
    return pair_string(maximo->first.first, maximo->first.second);
}
 
std::string calculaComun(const std::vector<std::string>& c, const pair_string& parCapacitor)
{
    // el cable común es donde no va conectado el capacitor
    for(size_t i = 0; i < 3; ++i) {
        if(parCapacitor.first != c[i] && parCapacitor.second != c[i]) {
            return c[i];
        }
    }
    return "";
}
 
std::string calculaLinea(const std::map<pair_string, double>& medidas,
                         const pair_string& parCapacitor,
                         const std::string& comun)
{
    // determina la medida intermedia (inmediata menor a la del capacitor)
    // y devuelve el cable que no es el común
    // -- el mayor, siempre que no sea ni esto ni aquello --
    double max = -1;
    std::string linea;
    for(const auto& par : medidas) {
        if(par.first == parCapacitor)
            continue;
        if(par.second > max) {
            max = par.second;
            if(par.first.first != comun)
                linea = par.first.first;
            else
                linea = par.first.second;
        }
    }
    return linea;
}
 
int main()
{
    std::map<pair_string, double> medidas;
    std::vector<std::string> c;
    c.resize(3);
    std::cout << "ingrese los tres colores: ";
    std::cin >> c[0] >> c[1] >> c[2];
 
    double m;
    auto parcolores = std::pair<std::string, std::string>(c[0], c[1]);
    std::cout << "ingrese la resistencia medida entre el " << c[0] << " y el " << c[1] << ": ";
    std::cin >> m;
    medidas[parcolores] = m;
 
    parcolores = std::pair<std::string, std::string>(c[0], c[2]);
    std::cout << "ingrese la resistencia medida entre " << c[0] << " y " << c[2] << ": ";
    std::cin >> m;
    medidas[parcolores] = m;
 
    parcolores = std::pair<std::string, std::string>(c[1], c[2]);
    std::cout << "ingrese la resistencia medida entre " << c[1] << " y " << c[2] << ": ";
    std::cin >> m;
    medidas[parcolores] = m;
 
    // faltaría controlar la forma y los valores.
 
    std::cout << '\n';
 
    // Capacitor
    pair_string parCapacitor = calculaCapacitor(medidas);
    std::cout << "el capacitor va entre el " << parCapacitor.first << " y el " << parCapacitor.second << '\n';
 
 
    // común
    std::string comun = calculaComun(c, parCapacitor);
    std::cout << "el comun es el " << comun << '\n';
 
 
    // linea
    std::cout << "la linea se conecta al " << calculaLinea(medidas, parCapacitor, comun) << '\n';
 
}
 

[dehm]

Aquí va mi solución (si no he entendido mal):

Código C++:

#include <stdio.h>
    #include <string.h>
    #define NCABLES 3
 
    int main ()
    {
        char cable[NCABLES][25];
        char combinacion [NCABLES][50];
        int i=0,indice_mayor=0,indice_trabajo,indice_menor=0,comun;
        int mayor=0;
        int menor=0;
        float valor [NCABLES];
 
 
        for (i=0;i <NCABLES;i++)
        {
            printf ("Introduce el color %d: ",i+1);
            scanf ("%s",cable[i]);
        }
        for (i=0;i<NCABLES;i++)
        {
            sprintf (combinacion[i],"el %s y el %s",cable[i], i<2?cable[i+1]:cable[0]);
            printf ("Introduce la resistencia entre %s: ",combinacion [i]);
            scanf ("%f",&valor[i]);
            if (i==0)
            {
                mayor=valor[i];
                menor=valor[i];
            }
            if (i>0)
            {
                if (valor[i]>mayor)
                {
                    indice_mayor=i;
                    mayor=valor[i];
                }
                if (valor[i]<menor)
                {
                    indice_menor=i;
                    menor=valor[i];
                }
            }
        }
        indice_trabajo=0;
        for (i=0;i<NCABLES;i++)
        {
            if (indice_trabajo==indice_menor || indice_trabajo==indice_mayor)
            {
                indice_trabajo++;
            }
        }
        printf ("El condensador va entre %s\n", combinacion[indice_mayor]);
        printf ("La bobina de arranque esta entre %s\n",combinacion[indice_menor]);
        printf ("La bobina de trabajo esta entre %s\n",combinacion[indice_trabajo]);
 
        for (i=0;i <NCABLES;i++){
            if (strstr (combinacion[mayor],cable [i])==NULL){
                comun=i;
                break;
            }
        }
        printf ("El comun es el %s. Conecta el neutro en el\n",cable[comun]);
    }
 

Como dice enrieto, una posible mejora sería verificar que la suma los dos valores menores sea igual al mayor (con alguna tolerancia) para evitar datos erróneos.
Un saludo...ya me dirás si era eso o no me he enterado de la idea

[aguml]

Iniciado por dehm

Aquí va mi solución (si no he entendido mal):

Código C++:

#include <stdio.h>
    #include <string.h>
    #define NCABLES 3
 
    int main ()
    {
        char cable[NCABLES][25];
        char combinacion [NCABLES][50];
        int i=0,indice_mayor=0,indice_trabajo,indice_menor=0,comun;
        int mayor=0;
        int menor=0;
        float valor [NCABLES];
 
 
        for (i=0;i <NCABLES;i++)
        {
            printf ("Introduce el color %d: ",i+1);
            scanf ("%s",cable[i]);
        }
        for (i=0;i<NCABLES;i++)
        {
            sprintf (combinacion[i],"el %s y el %s",cable[i], i<2?cable[i+1]:cable[0]);
            printf ("Introduce la resistencia entre %s: ",combinacion [i]);
            scanf ("%f",&valor[i]);
            if (i==0)
            {
                mayor=valor[i];
                menor=valor[i];
            }
            if (i>0)
            {
                if (valor[i]>mayor)
                {
                    indice_mayor=i;
                    mayor=valor[i];
                }
                if (valor[i]<menor)
                {
                    indice_menor=i;
                    menor=valor[i];
                }
            }
        }
        indice_trabajo=0;
        for (i=0;i<NCABLES;i++)
        {
            if (indice_trabajo==indice_menor || indice_trabajo==indice_mayor)
            {
                indice_trabajo++;
            }
        }
        printf ("El condensador va entre %s\n", combinacion[indice_mayor]);
        printf ("La bobina de arranque esta entre %s\n",combinacion[indice_menor]);
        printf ("La bobina de trabajo esta entre %s\n",combinacion[indice_trabajo]);
 
        for (i=0;i <NCABLES;i++){
            if (strstr (combinacion[mayor],cable [i])==NULL){
                comun=i;
                break;
            }
        }
        printf ("El comun es el %s. Conecta el neutro en el\n",cable[comun]);
    }
 

Como dice enrieto, una posible mejora sería verificar que la suma los dos valores menores sea igual al mayor (con alguna tolerancia) para evitar datos erróneos.
Un saludo...ya me dirás si era eso o no me he enterado de la idea

El código me da fallo de segmentación y creo que es por algún error al trabajar con los índices mayor y menor.
El código de en rito aun no lo pude probar porque estoy desde el movil usando c4ndroid y el móvil no me deja instalar gcc. En cuanto tenga un pc a mano lo probaré.
Ya digo que esta aplicación era por simple curiosidad y parece que era más complejo de lo que yo esperaba.

[dehm]

Iniciado por aguml

El código me da fallo de segmentación y creo que es por algún error al trabajar con los índices mayor y menor.
El código de en rito aun no lo pude probar porque estoy desde el movil usando c4ndroid y el móvil no me deja instalar gcc. En cuanto tenga un pc a mano lo probaré.
Ya digo que esta aplicación era por simple curiosidad y parece que era más complejo de lo que yo esperaba.

Qué raro. He probado todas las combinaciones y siempre me muevo entre 0 y 2.
El código es bastante malo, pero creo que funciona....sí me he dado cuenta de que las variables mayor y menor deben ser float, pero no creo que eso cause un error de segmentación. En fin, dejo aquí la corrección con una impresión de los valores de los indices. Espero que alguien te dé una mejor respuesta...además de la de enrieto (pero él se mueve en otra liga )

Código C++:

#include <stdio.h>
    #include <string.h>
    #define NCABLES 3
 
    int main ()
    {
        char cable[NCABLES][25];
        char combinacion [NCABLES][50];
        int i=0,indice_mayor=0,indice_trabajo=0,indice_menor=0,comun;
        float valor[NCABLES];
        float mayor;
        float menor;
 
        for (i=0;i <NCABLES;i++)
        {
            printf ("Introduce el color %d: ",i+1);
            scanf ("%s",cable[i]);
        }
        for (i=0;i<NCABLES;i++)
        {
            sprintf (combinacion[i],"el %s y el %s",cable[i], i<2?cable[i+1]:cable[0]);
            printf ("Introduce la resistencia entre %s: ",combinacion [i]);
            scanf ("%f",&valor[i]);
            if (i==0)
            {
                mayor=valor[i];
                menor=valor[i];
            }
            if (i>0)
            {
                if (valor[i]>mayor)
                {
                    indice_mayor=i;
                    mayor=valor[i];
                }
                if (valor[i]<menor)
                {
                    indice_menor=i;
                    menor=valor[i];
                }
            }
        }
        indice_trabajo=0;
        for (i=0;i<NCABLES;i++)
        {
            if (indice_trabajo==indice_menor || indice_trabajo==indice_mayor)
            {
                indice_trabajo++;
            }
        }
        printf ("Mayor: %d\n",indice_mayor);
        printf ("Menor: %d\n",indice_menor);
        printf ("Trabajo: %d\n",indice_trabajo);
        printf ("El condensador va entre %s\n", combinacion[indice_mayor]);
        printf ("La bobina de arranque esta entre %s\n",combinacion[indice_menor]);
        printf ("La bobina de trabajo esta entre %s\n",combinacion[indice_trabajo]);
 
        for (i=0;i <NCABLES;i++){
            if (strstr (combinacion[indice_mayor],cable [i])==NULL){
                comun=i;
                break;
            }
        }
        printf ("El comun es el %s. Conecta el neutro en el\n",cable[comun]);
    }
 

[aguml]

Ahora parece que si funciona. Sólo falta por mostrar un dato y no se como plantearlo. Ya muestras donde va el neutro y el fase va en el otro extremo de la bobina de trabajo.
Por ejemplo, imaginemos estos datos:
Cables: rojo, blanco y negro
-Entre blanco y negro hay 250
-Entre rojo y negro hay 200
-Entre rojo y blanco hay 450
Con esos datos sabemos que:
-El condensador va entre el rojo y el blanco porque es la mayor medición y es la suma de ambas.
-El comun es el negro.
-El fase es el blanco porque es el otro extremo de la bobina de trabajo. O sea, la bobina de trabajo lleva el neutro en un extremo y el fase en el otro.
No se si lo explico bien.
No tiene que ser el código como yo lo estaba haciendo, simplemente es lo que se me ocurrió. Si hay un modo más limpio y correcto soy todo oidos jejeje.
Lo digo más que nada porque la idea es poder indicar el número de velocidades que tiene el motor ya que por ejemplo el motor del split de un aire acondicionado tiene tres bobinas de trabajo con diferentes resistencias y cada una para una velocidad del motor. Si de entrada este código empieza siendo un churro, lo que puede terminar saliendo puede ser una bomba. Jajaja.

[aguml]

Bueno pues al final me puse a repensar el código que tenia y después de mucho me ha quedado asi:

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 typedef struct {
            char cable[2] [25];
            float resistencia;
}Combi;
 
long factorial(int n)
{
    int c;
    long result = 1;
    
    for (c = 1; c <= n; c++){
        result *= c;
    }
    return result;
} 
 
int main ()
{
    int nCombinaciones,nCables;
    char **cable;
    int n=0, j, i=0, indice_mayor=0, indice_trabajo=0, indice_menor=0, comun,fase;
    Combi *combinaciones;
    
    printf ("Introduce el numero de cables: ");
    scanf ("%d",&nCables);
    cable = malloc(sizeof(char*) * nCables);
 
    for (i=0;i <nCables;i++){
        cable [i]=malloc (sizeof (char)*25);
    }
    nCombinaciones=factorial (nCables)/(2*factorial(nCables-2));
    
    combinaciones=malloc (nCombinaciones*sizeof (Combi));
    
    for (i=0;i <nCables;i++)
    {
        printf ("Introduce el color %d: ",i+1);
        scanf ("%s",cable[i]);
    }
    for (i=0;i<nCables-1;i++)
    {
        for (j=i+1;j <nCables;j++)
        {
            strcpy (combinaciones[n].cable[0],cable [i]);
            strcpy (combinaciones[n].cable[1],cable [j]);
            printf ("Introduce la resistencia entre el %s y el %s: ",combinaciones [n].cable[0],combinaciones [n].cable[1]);
            scanf ("%f",&combinaciones[n].resistencia);
            n++;
        }
    }
    indice_menor=0;
    indice_mayor=0;
    for (i=0;i <nCombinaciones;i++)
    {
        if (combinaciones [indice_menor].resistencia >combinaciones [i].resistencia){
            indice_menor=i;
        }
        if (combinaciones [indice_mayor].resistencia<combinaciones [i].resistencia){
            indice_mayor=i;
        }
    }
    indice_trabajo=0;
    
    for (i=0;i<nCombinaciones;i++)
    {
        if (indice_trabajo==indice_menor || indice_trabajo==indice_mayor)
        {
            indice_trabajo++;
        }
    }
    printf ("El condensador va entre el %s y el %s\n", combinaciones[indice_mayor].cable[0],combinaciones [indice_mayor].cable[1]);
    printf ("La bobina de arranque esta entre el %s y el %s\n",combinaciones[indice_menor].cable[0],combinaciones [indice_menor].cable[1]);
    printf ("La bobina de trabajo esta entre el %s y el %s\n",combinaciones[indice_trabajo].cable[0],combinaciones [indice_trabajo].cable[1]);
 
    for (i=0;i <nCables;i++){
        if ( (strcmp(combinaciones[indice_mayor].cable[0],cable [i])!=0) && (strcmp (combinaciones [indice_mayor].cable[1],cable [i])!=0)){
            comun=i;
            break;
        }
    }
    printf ("El comun es el %s. Conecta el neutro en el\n",cable[comun]);
    if (strcmp(combinaciones[indice_trabajo].cable[0],cable [comun])!=0){
        fase=0;
    }else {
        fase=1;
    }
    printf ("El fase es el %s. Conecta el fase en el\n",combinaciones[indice_trabajo].cable [fase]);
    for (i=0;i <nCables;i++){
        free (cable [i]);
    }
    free (cable);
    free (combinaciones);
}
 

Funciona aunque aún queda mucho trabajo ya que tengo que controlar que los malloc funcionen correctamente, que el número de cables sea mayor que 2, y además para los motores de más de tres cables tengo que ver bien como va el cálculo para saber cómo programarlo y no se si será mejor crear funciones separadas. Como dije, aun queda curro.

[eferion]

Código C:

long factorial(int n)
{
    int c;
    long result = 1;
    
    for (c = 1; c <= n; c++){
        result *= c;
    }
    return result;
}
 

Desde C99 es posible declarar variables dentro de los for. Siempre es bueno acortar la vida de las variables lo máximo posible:

Código C:

long factorial(int n)
{
    long result = 1;
    
    for (int c = 1; c <= n; c++){
        result *= c;
    }
    return result;
}
 

Esto lo puedes (y lo deberías) utilizar en todos los bucles siempre que sea posible. ¿Por qué? Básicamente porque así evitas errores tontos. Imagínate que por error se borra una inicialización o se traspapela la variable... como la variable ya estaba declarada el programa compilará perfectamente y te dará errores rarísimos.

Un ejemplo que compila pero tiene errores:

Código C:

int i,j;
for( i=0; i<10; i++)
  printf("%d",i);
for( i=0; j<10;j++)
  printf("%d",j);
 

Un ejemplo que directamente no compila:

Código C:

for(int  i=0; i<10; i++)
  printf("%d",i);
for(int i=0; j<10;j++)
  printf("%d",j);
 

Por cierto, como nota adicional respecto a la función anterior, la variable c se puede eliminar con bastante facilidad:

Código C:

long factorial(int n)
{
    long result = 1;
    
    for( ; n>1; n--){
        result *= n;
    }
    return result;
}
 

Por otro lado, yo este bucle:

Código C:

for (i=0;i<nCables-1;i++)
{
    for (j=i+1;j <nCables;j++)
    {
        strcpy (combinaciones[n].cable[0],cable [i]);
        strcpy (combinaciones[n].cable[1],cable [j]);
        printf ("Introduce la resistencia entre el %s y el %s: ",combinaciones [n].cable[0],combinaciones [n].cable[1]);
        scanf ("%f",&combinaciones[n].resistencia);
        n++;
    }
}
 

lo dejaría tal que (con cambios adicionales):

Código C:

typedef struct {
            char* cable[2];
            float resistencia;
}Combinacion;
 
typedef struct
{
  Combinacion* lista;
  int nCombinaciones;
} Combinaciones;
 
Combinaciones GenerarCombinaciones(char** cables, int nCables)
{
  Combinaciones combinaciones;
  combinaciones.nCombinaciones = factorial(nCables)/(2*factorial(nCables-2));
  combinaciones.lista = (Combinacion*)malloc(combinaciones.nCombinaciones*sizeof(Combinacion));
 
  Combinacion* ptr = combinaciones.lista;
  for (int i=0;i<nCables-1;i++)
  {
    for (int j=i+1;j<nCables;j++,ptr++)
    {
      ptr->cable[0] = cables[i];
      ptr->cable[1] = cables[j];
    }
  }
 
  return combinaciones;  
}
 
// ...
 
Combinaciones combinaciones = GenerarCombinaciones(cable,nCables);
for(int n=0;n<combinaciones.nCombinaciones;n++)
{
    printf ("Introduce la resistencia entre el %s y el %s: ",combinaciones.lista [n].cable[0],combinaciones[n].cable[1]);
    scanf ("%f",&combinaciones.lista[n].resistencia);
}
 

No es obligatorio, ni mucho menos, pero creo que el código estaría mejor si estuviese un poco más compartimentado en funciones.

Por cierto, nota que en Combinaciones hago que los cables apunten al string original en vez de copiar los colores n veces. Dado que no se eliminan los strings originales copiarlos tantas veces es una tarea redundante.

Un saludo.

[aguml]

Muy interesante los cambios. Tengo que verlo más tranquilo en el pc.
Ahora estaba liado con el tema de poder hacerlo con más cables pero no se porque con 3 cables va correcto pero si le pongo por ejemplo 5 da resultados erróneos. No termino de dar con el modo. Actualmente lo tenia asi: (queda pendiente los cambios sugeridos):

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 typedef struct {
            char cable[2] [25];
            float resistencia;
}Combi;
 
long factorial(int n)
{
    int c;
    long result = 1;
    
    for (c = 1; c <= n; c++){
        result *= c;
    }
    return result;
} 
 
int main ()
{
    int nCombinaciones,nCables;
    char **cable;
    int n=0, j, i=0, comun,fase;
    Combi *combinaciones,combinacion_aux;
    do {
        printf ("Introduce el numero de cables: ");
        scanf ("%d",&nCables);
        if (nCables <3){
            printf ("Tiene que tener al menos 3 cables\n");
        }
    }while (nCables  <3);
    
    cable = malloc(sizeof(char*) * nCables);
 
    for (i=0;i <nCables;i++){
        cable [i]=malloc (sizeof (char)*25);
    }
    nCombinaciones=factorial (nCables)/(2*factorial(nCables-2));
    
    combinaciones=malloc (nCombinaciones*sizeof (Combi));
    
    for (i=0;i <nCables;i++)
    {
        printf ("Introduce el color %d: ",i+1);
        scanf ("%s",cable[i]);
    }
    for (i=0;i<nCables-1;i++)
    {
        for (j=i+1;j <nCables;j++)
        {
            strcpy (combinaciones[n].cable[0],cable [i]);
            strcpy (combinaciones[n].cable[1],cable [j]);
            printf ("Introduce la resistencia entre el %s y el %s: ",combinaciones [n].cable[0],combinaciones [n].cable[1]);
            scanf ("%f",&combinaciones[n].resistencia);
            n++;
        }
    }
    for (i=0;i<nCombinaciones-1;i++)
    {
        for (j=i+1;j <nCombinaciones;j++)
        {
            if (combinaciones [i].resistencia > combinaciones [j].resistencia)
            {
                combinacion_aux = combinaciones [i];
                combinaciones [i] = combinaciones [j];
                combinaciones [j] = combinacion_aux;
            }
        }
    }
 
    printf ("El condensador va entre el %s y el %s\n", combinaciones[nCombinaciones-1].cable[0],combinaciones [nCombinaciones-1].cable[1]);
    printf ("La bobina de arranque esta entre el %s y el %s\n",combinaciones[0].cable[0],combinaciones [0].cable[1]);
    
    for (i=0;i <nCables;i++){
        if ( (strcmp(combinaciones[nCombinaciones-1].cable[0],cable [i])!=0) && (strcmp (combinaciones [nCombinaciones-1].cable[1],cable [i])!=0)){
            comun=i;
            break;
        }
    }
    printf ("El comun es el %s. Conecta el neutro en el\n",cable[comun]);
    
    for (i=1,j=0;i<nCombinaciones-1;i++)
    {
        if (strcmp (cable [comun],combinaciones [i].cable [0])==0){
            j++;
            printf ("La bobina de trabajo %d esta entre el %s y el %s\n",j, combinaciones[i].cable[0],combinaciones [i].cable[1]);
            printf ("El fase es el %s. Conecta el fase en el\n",combinaciones[i].cable [1]);
        }else if (strcmp (cable [comun],combinaciones [i].cable [1])==0){
            j++;
            printf ("La bobina de trabajo %d esta entre el %s y el %s\n",j, combinaciones[i].cable[0],combinaciones [i].cable[1]);
            printf ("El fase es el %s. Conecta el fase en el\n",combinaciones[i].cable [0]);
        }
    }
    
    for (i=0;i <nCables;i++){
        free (cable [i]);
    }
    free (cable);
    free (combinaciones);
}
 

Os pongo un enlace a un video donde lo hace a mano para un motor de 5 cables con 3 velocidades: https://youtu.be/8g0vUVi3uvU
A ver si podéis echarme otro cable para saber como hacerlo.