C에서 문자열에 있는 문자의 발생 횟수 계산

C에서 문자열에 있는 문자의 발생 횟수 계산

나는 그 끈을 가지고 있습니다.str

char *str = "100.10b.100.100";

의 발생 횟수를 세고 싶습니다.'.'에str가급적 원라이너(가능한 경우 루프 없음)

내 접근 방식이 표준이 될 것입니다.strchr:

  int i = 0;
  char *pch=strchr(str,'.');
  while (pch!=NULL) {
    i++;
    pch=strchr(pch+1,'.');
  }

필요한 최소 변수 수는 다음과 같습니다.

for (i=0; s[i]; s[i]=='.' ? i++ : *s++);

좋아요, 비루프 구현(그리고 네, 농담으로 의미가 있습니다).

size_t CountChars(const char *s, char c)
{
  size_t nCount=0;
  if (s[0])
  {
    nCount += ( s[0]==c);
    if (s[1])
    {
      nCount += ( s[1]==c);
      if (s[2])
      {
        nCount += ( s[2]==c);
        if (s[3])
        {
          nCount += ( s[3]==c);
          if (s[4])
          {
            nCount += ( s[4]==c);
            if (s[5])
            {
              nCount += ( s[5]==c);
              if (s[6])
              {
                nCount += ( s[6]==c);
                if (s[7])
                {
                  nCount += ( s[7]==c);
                  if (s[8])
                  {
                    nCount += ( s[8]==c);
                    if (s[9])
                    {
                      nCount += ( s[9]==c);
                      if (s[10])
                      {
                        /* too long */
                        assert(0);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  return nCount;
}

봐요, 엄마, 루프는 안 돼요

int c = countChars( s, '.' );

int countChars( char* s, char c )
{
    return *s == '\0'
              ? 0
              : countChars( s + 1, c ) + (*s == c);
}

하지만, 저는 실제로 루프를 사용할 것입니다. 그것이 올바른 제어 구조이기 때문입니다.

루프가 없으면 이를 수행하는 표준 C 라이브러리 기능이 없기 때문에 어려울 것이고 모든 문자를 살펴봐야 합니다 :)

확실한 해결책을 찾겠습니다.

int i, count;
for (i=0, count=0; str[i]; i++)
  count += (str[i] == '.');

필요하다면 실제 코드의 두 줄을 하나로 자유롭게 짜세요 :)

만약 당신이 원라이너(글쎄요, 두 개-)를 원한다면:

size_t count = 0;
while(*str) if (*str++ == '.') ++count;

나는 여전히 이것을 함수에 던져서 검색할 소스 문자열과 문자를 매개 변수화합니다.

int count_characters(const char *str, char character)
{
    const char *p = str;
    int count = 0;

    do {
        if (*p == character)
            count++;
    } while (*(p++));

    return count;
}

//효과가 있어야 할 것 같습니다.한 줄에 루프가 없습니다.

int countChar(char *s, char letter) {
    return ((*s) ? (((*s++ == letter)? 1:0)) + countChar (s, letter)): 0);
}

루프가 없는 유일한 방법은 재귀입니다.다음은 재미로 포함되어 있지만 해결책으로 권장되지는 않습니다.

size_t CountChars(char* s, char c)
{
    return *s ? ((c==*s) + CountChars(s+1)) : 0;
}

나는 여전히 가는 것을 좋아하지 않습니다.

    int i=0,count=0;
    char *str = "100.10b.100.100";
    a:
    if(str[i]=='.')
        count++;
    i++;
    if(str[i])
    goto a;

당신이 이 코드를 실행할 때마다 베이비 다이크스트라가 울부짖습니다 :)

  1
  2
  3
  4 #include <ctype.h>
  5 #include <stdio.h>
  6 #include <stdlib.h>
  7 #include <string.h>
  8
  9
 10 size_t bytewise_pop_count(
 11     unsigned char * bp, size_t l
 12 ) {
 13     if ( (bp) && (l) ) {
 14         return bytewise_pop_count(bp+1, l-1) + (bp[0] ? 1 : 0);
 15     }
 16     return 0;
 17 }
 18
 19 void mercilessly_complement_bytes(
 20     unsigned char * bp, size_t l
 21 ) {
 22 /*
 23     transform
 24         0 -> 1
 25         !0 -> 0
 26 */
 27     if ( (bp) && (l) ) {
 28         bp[0] = bp[0] ? 0 : 1;
 29         mercilessly_complement_bytes(bp+1, l-1);
 30     }
 31 }
 32
 33 void xor_bytes(
 34     unsigned char * bp1, unsigned char * bp2, size_t l
 35 ) {
 36     /* stores result in bp2 */
 37     if ( (bp1) && (bp2) && (l) ) {
 38         bp2[0] ^= bp1[0];
 39         xor_bytes(bp1+1, bp2+1, l-1);
 40     }
 41 }
 42
 43
 44 int main(int argc, char * * argv) {
 45     char c;
 46     size_t count;
 47     size_t l;
 48     char * string;
 49     char * t;
 50
 51     if (argc < 3) {
 52         fprintf(stderr,
 53             "\n"
 54             "==> not enough arguments -- need char and string\n"
 55             "\n"
 56         );
 57         return EXIT_FAILURE;
 58     }
 59
 60     c = argv[1][0];
 61     string = argv[2];
 62
 63     if ( l = strlen(string) ) {
 64         t = malloc(l);
 65         memset(t, c, l);
 66         xor_bytes(string, t, l);
 67         mercilessly_complement_bytes(t, l);
 68         count = bytewise_pop_count(t, l);
 69         free(t);
 70     } else {
 71         count = 0;
 72     }
 73
 74     if ( isprint(c) ) {
 75         printf(
 76             "\n"
 77             "==> occurences of char ``%c'' in string ``%s'': %zu\n"
 78             "\n"
 79             , c, string ? string : "<NULL>", count
 80         );
 81     } else {
 82         printf(
 83             "\n"
 84             "==> occurences of char ``%hhu'' in string ``%s'': %zu\n"
 85             "\n"
 86             , c, string ? string : "<NULL>", count
 87         );
 88     }
 89     return EXIT_SUCCESS;
 90 }

만약 당신이 정말로 원라이너를 원한다면:

• 스트렐을 그대로 유지하기(나중에 사용하려는 경우를 위해)

  for(i = 0, c = 0; str[i] != '\0'; (str[i] == '.')? c++: 0, i++);

• 만약 당신이 str 변수에 관심이 없다면.

  for(c = 0; *str != '\0'; (*str == '.')? c++: 0, str++);

  • 또한 이전 스트렐렌을 빼서 다시 사용할 수 있습니다.

하지만 보시다시피 상당히 추악하기 때문에 다음과 같은 방법을 사용하는 것이 좋습니다.

for(i = 0; str[i] != '\0'; i++)
{
    if(str[i] == '.')
        ++c;
}

또는

for(c = 0; *str != '\0'; str++)
{
    if(*str == '.')
        ++c;
}

memchr 사용:

size_t nOccurrences(const char* buffer, const char character, size_t bufferLength) {
    size_t result = 0;
    size_t residualLength = bufferLength;
    
    do {
        void* start = (void*)(buffer + bufferLength - residualLength);
        void* occurrence = memchr(start, character, residualLength);
        if(NULL == occurrence) {
            break;
        }
        ++result;
        residualLength = bufferLength - ((char*)occurrence - buffer) - 1;
    } while(1);
    
    return result;
}

언급URL : https://stackoverflow.com/questions/4235519/counting-number-of-occurrences-of-a-char-in-a-string-in-c