使用 C 中的三元运算符进行版本字符串比较答案

【问题标题】：Version string comparision using the ternary operator in C使用 C 中的三元运算符进行版本字符串比较
【发布时间】：2014-12-23 14:39:03
【问题描述】：

我需要比较两个“版本”字符串，它们可能以.0 结尾，也可能不以.0 结尾，以便（例如）10.3.8.9.2 和10.3.8.9.2.0 被认为是相等的。

#include <stdio.h>    
#include <string.h>

int main()    
{

   char str1[20];
   char str2[20];
   int ret;

   strcpy(str1, "10.3.8.9.2");
   strcpy(str2, "10.3.8.9.2.0");
   // strcpy(str2, "10.3.8.9.20.0");  This case are invalid case and need to handle properly inside ternary operator

   ret=(strlen(str1)> strlen(str2))? strncmp( str1,str2,strlen(str2)):(strncmp( str1,str2,strlen(str1))&&( strlen(str2)==strlen(str1)+2 ));

   //printf("ret=%d", ret);

   //ret=(strlen(str1)> strlen(str2))? strncmp( str1,str2,strlen(str2)):(strncmp( str1,str2,strlen(str1)));

   printf("ret_value=%d", ret);

   return 0;

}

上面的代码将10.3.8.9.2 和10.3.8.9.20.0 视为相等，这是不正确的。我尝试更新代码，如下所示，但由于strncmp() 在成功时返回0，它没有给出预期的结果。

似乎我没有在三元运算符中正确处理这种情况。可能将两个表达式的返回值存储在单独的变量中可以解决这个问题，但想知道如何使用三元运算符来实现。

【问题讨论】：

注意：你可能想要versionsort() [对BSD和linux标准库的扩展]
是的，你是对的，我想通过忽略 .0 来验证同样的结果
versionsort() 没有给出期望的结果。
剪掉所有尾随的".0"s 并进行比较。

标签： c ternary-operator

【解决方案1】：

你需要先比较str1和str2的最短公共子串，然后再检查每个字符串的余数。这是一个不使用三元运算符进行字符串比较的解决方案：

#include <stdio.h>
#include <string.h>

int compare_versions(const char *a, const char *b)
{

    size_t len1, len2, shortest;

    // Return a negative value for invalid inputs.
    if (!a || !b) { return -1; }

    //First, get the length of the shortest string.
    len1 = strlen(a);
    len2 = strlen(b);
    shortest = len1 < len2 ? len1 : len2;

    // If the first sections of the strings are different, they do not match.    
    if (strncmp(a, b, shortest) != 0) { return 0; }

    // Otherwise, check each string: if an "extension" exists, it must be ".0".
    if (a[shortest] && strcmp(&a[shortest], ".0") != 0) { return 0; }
    if (b[shortest] && strcmp(&b[shortest], ".0") != 0) { return 0; }

    // If both strings end with ".0" or nothing, they match.
    return 1;

}

int main(int argc, char *argv[])    
{
    printf("Return value: %d\n", compare_versions("10.3.8.9.2", "10.3.8.9.2"));
    printf("Return value: %d\n", compare_versions("10.3.8.9.2.0", "10.3.8.9.2.0"));
    printf("Return value: %d\n", compare_versions("10.3.8.9.2.0", "10.3.8.9.2"));
    printf("Return value: %d\n", compare_versions("10.3.8.9.2", "10.3.8.9.2.0"));
    printf("Return value: %d\n", compare_versions("10.3.8.9.20", "10.3.8.9.2"));
    return 0;
}

以上代码可以在线运行here。如果您确实需要使用三元运算符，可以重新组织字符串比较逻辑，尽管我不确定它是否具有可读性。

【讨论】：

str1 = "10.3.8.09.2" "str2 = 10.3.8.9.02.0" 不应该是 1 吗？
这在原始帖子中没有说明为要求，这就是为什么我给出的代码没有考虑到它。
前导 0 是有效的情况，因为单个数字可以表示前导单个 0 后跟单个数字。阿里的代码正确处理所有场景:)

【解决方案2】：

你可以试试这个：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main()
{
   int a[10],b[10];

   char str1[20];
   char str2[20];

   int kase;
   printf("Enter number of cases : ");
   scanf("%d",&kase);
   getchar();

   while(kase--)
   {
       // initialize array values to 0 if you have to do this checking more than once
       memset(a,0,sizeof(a));
       memset(b,0,sizeof(b));

       //strcpy(str1, "10.3.8.09.2.0");
       //strcpy(str2, "10.3.8.9.02.0");
       printf("Enter first string : ");
       gets(str1);
       printf("Enter second string : ");
       gets(str2);

       int ind1=0,ind2=0;

       char *token=strtok(str1,".");
       while(token!=NULL)
       {
           a[ind1++]=atoi(token); // separating the first string with respect to '.'
           token=strtok(NULL,".");
       }

       token=strtok(str2,".");
       while(token!=NULL)
       {
           b[ind2++]=atoi(token); // separating the 2nd string with respect to '.'
           token=strtok(NULL,".");
       }

       int same=1,n=ind1;
       if(ind2>n)  // selecting maximum values between str1 and str2
         n=ind2;
       for(int i=0;i<n;i++)
       {
           if(a[i]!=b[i])
           {
               same=0;
               break;
           }
       }

       if(same)
         printf("value = 1 . Strings are same\n");
       else
         printf("value = 0 . Strings not same\n");
   }
   return 0;
}

这里每个字符串值都被转换为整数，因此很容易在它们之间进行比较。

这也适用于这样的情况：

10.03.8.09.2.00
10.3.8.09.002

这就是数字可以有前导零的地方:)

【讨论】：

请注意，如果您不确定输入是否一定包含数字，建议使用strtol 而不是atoi。
版本号总是包含数字
你怎么知道的？该操作没有说明他从哪里获取字符串 - 它们可能是用户输入的，或者是从文件名中提取的。
可能......没有冒犯:) 但如果它只包含数字并且可以包含前导 0，那么上述解决方案是完美的
我不知道你在做什么 :( 但是如果像你说的那样有多种情况，那么我编辑的代码肯定会工作......如果没有，那么给我示例示例，其中它失败了

【解决方案3】：

一种算术方法，也可以将版本验证为数字集。

每个字段可以是 0 到 9999，前导 0 可选。

int ValidateVersion(const char *src, unsigned long long *number) {
  unsigned u[5];
  int n4 = 0;
  int n5 = 0;
  sscanf(src,"%4u.%4u.%4u.%4u %n.%4u %n", 
    &u[0], &u[1], &u[2], &u[3], &n5, &u[4], &n5);

  if (n5 > 0) {
    if (src[n5] != '\0' || u[4] != 0) return -1; // invalid
  } else if (n4 != 0) {
    return -1; // invalid
  }  
  *number = u[0] * 1000000000000u + u[1] * 100000000u + u[2] * 10000u + u[3];
}

const char *sample() {
  const char *str1 = "10.3.8.9.2";
  unsigned long long n1;
  if (ValidateVersion(str1, &n1) return "1 Invalid";

  const char *str2 = "10.3.8.9.2.0";
  unsigned long long n2;
  if (ValidateVersion(str2, &n2) return "2 Invalid";

  if (n1 == n2) return "Equal";
  return "Different";
}

【讨论】：

请注意，u[0] * 1000000000000u 将产生如此大的数字，以至于它们需要超过 32 位来存储，因此在上面使用了 unsigned long long。但是，unsigned long long 在 C90 中不可用，这可能是您需要考虑的问题。
@GoBusto 早期的 C 不支持在此处和您的帖子中使用的原型 - 那么代码兼容性应该追溯到多远，为什么要停在 C89/90 上？使代码与 C99 之前的编译器兼容，虽然令人钦佩，但在 C 标准中已经超过了 2 代。
我之所以指出这一点，是因为最近有人向我寻求帮助，他的编译器（由于各种原因）无法将其代码编译为 C99，因此他们受到 C90 的限制。我并不是说您的答案在任何方面都是错误的 - 我只是指出需要 C99，以防 OP（或遇到此问题以寻找答案的任何其他人）同样受到限制。另外，我很确定 C90 确实支持原型（我的答案中的代码是在 C90 模式下使用 GCC 测试的），除非我误解了某些东西。

【解决方案4】：

天真的实现。注意：我使用strcmp() 相等字符串的标准返回值约定：返回值 = 零）

#include <stdio.h>
#include <string.h>

int compare_versions(const char *a, const char *b)
{
size_t lena, lenb, len;
int rc;

            /* handle NULL pointer arguments gracefully */
if (!a || !b) { return (a) ? 1 : (b) ? -1: 0; }

while(1) {
            /* find the length of the non-numerical prefix */
    lena = strcspn(a, "0123456789" );
    lenb = strcspn(b, "0123456789" );

    len = (lena <lenb) ? lena : lenb;
    rc = (len) ? memcmp(a,b, len): 0;
    if (rc) return rc;

            /* Skip leading zeros */
    for(a += lena; *a == '0'; a++) {;}
    for(b += lenb; *b == '0'; b++) {;}
    if (!*a || !*b) break;

            /* find the length of the numerical prefix */
    lena = strspn(a, "0123456789" );
    lenb = strspn(b, "0123456789" );
    if (lena != lenb) return lena-lenb;

    rc = (len) ? memcmp(a,b, lena): 0;
    if (rc) return rc;

    a += lena; b += lenb;
    }

return *a - *b;
}


struct pair {
    char *l;
    char *r;
    } pairs[] = {
    {"10.3.8.9.2", "10.3.8.9.2"},
    {"10.3.8.9.2.0", "10.3.8.9.2.0"},
    {"10.3.8.9.2.0", "10.3.8.9.2"},
    {"10.3.8.9.2", "10.3.8.9.2.0"},
    {"10.3.8.9.2", "10.3.8.9.02"},
    {"10.3.8.9.20", "10.3.8.9.2"},
    {"10.3.8.9.2", "10.3.8.9.03"},
    {"10.3.8.9.2", "10.3.8.9.01"},
    {"10.3.8.9.02", "10.3.8.9.3"},
    {"10.3.8.9.02", "10.3.8.9.1"},
    {"10.3.8.9.02", "10.3.8.9.03"},
    {"10.3.8.9.02", "10.3.8.9.01"},
        };

int main(int argc, char *argv[])
{
int ii;

for (ii=0; ii < 12; ii++) {
    int rc;
    rc = compare_versions(pairs[ii].l ,pairs[ii].r  );
    printf("(%s <-->> %s)  compare value= %d\n"
        , pairs[ii].l ,pairs[ii].r  , rc);
        }
return 0;
}

输出：

$ ./a.out
(10.3.8.9.2 <-->> 10.3.8.9.2)  compare value= 0
(10.3.8.9.2.0 <-->> 10.3.8.9.2.0)  compare value= 0
(10.3.8.9.2.0 <-->> 10.3.8.9.2)  compare value= 0
(10.3.8.9.2 <-->> 10.3.8.9.2.0)  compare value= 0
(10.3.8.9.2 <-->> 10.3.8.9.02)  compare value= 0
(10.3.8.9.20 <-->> 10.3.8.9.2)  compare value= 1
(10.3.8.9.2 <-->> 10.3.8.9.03)  compare value= -1
(10.3.8.9.2 <-->> 10.3.8.9.01)  compare value= 1
(10.3.8.9.02 <-->> 10.3.8.9.3)  compare value= -1
(10.3.8.9.02 <-->> 10.3.8.9.1)  compare value= 1
(10.3.8.9.02 <-->> 10.3.8.9.03)  compare value= -1
(10.3.8.9.02 <-->> 10.3.8.9.01)  compare value= 1

【讨论】：