一串连续字符被称作围栏当且仅当它由间隔的‘|’和‘-’组成。比如“|-|-|-|”或“-|-|”(引号仅供说明

cjl1166 2013-01-31 05:45:38
一个长度为n(0≤n≤50)的字符串s,s只包含‘| ’、‘-’字符。
Output
在一行中输出最长的围栏长度值。

#include<stdio.h>
int main()
{
char s[50],*p;
int a=1,b=0;
gets(s);
p=s;
for(;*p!='\0';p++)
{
if(*p!=*p+1)
a+=1;
else
{
if(a>b)
b=a;
a=0;
}
}
printf("%d",b);
return 0;
}
哪里错了啊
菜鸟求指导
...全文
245 7 打赏 收藏 转发到动态 举报
写回复
用AI写文章
7 条回复
切换为时间正序
请发表友善的回复…
发表回复
ForestDB 2013-02-18
  • 打赏
  • 举报
回复
学会自己考虑一些边界情况。
cjl1166 2013-02-10
  • 打赏
  • 举报
回复
楼上的大哥,,不想为难你的,,但是虽然电脑上过了但网上过不了 你再帮帮我吧 acm.cs.ecnu.edu.cn 2820题 谢啦
赵4老师 2013-02-04
  • 打赏
  • 举报
回复
//一个长度为n(0≤n≤50)的字符串s,s只包含‘| ’、‘-’字符。
//输出最长的由连续“|-”或连续“-|”组成的最长子串的长度。
#include <stdio.h>
#include <string.h>
#include <locale.h>
char s[51];
char s1[50],s2[50];
int i,L,L1,L2;
int main() {
    setlocale(LC_ALL,"chs");
    while (1) {
        printf("\n请输入一个最长50个字符且由|-组成的字符串(直接回车退出):");
        fflush(stdout);
        rewind(stdin);
        fgets(s,50,stdin);
        if ('\n'==s[0]) break;
        L=strlen(s);
        if ('\n'==s[L-1]) s[L-1]=0;
        s[50]=0;
        L=strlen(s);
        for (i=0;i<L;i++) {
            if (s[i]!='|' && s[i]!='-') break;
        }
        if (i>=L) {
            for (i=0;i<50;i+=2) {
                s1[i]='|';
                s1[i+1]='-';
                s2[i]='-';
                s2[i+1]='|';
            }
            for (L1=50;L1>=0;L1-=2) {
                s1[L1]=0;
                if (strstr(s,s1)) break;
            }
            for (L2=50;L2>=0;L2-=2) {
                s2[L2]=0;
                if (strstr(s,s2)) break;
            }
            L=L1;
            if (L<L2) L=L2;
            printf("其中最长的由连续“|-”或连续“-|”组成的最长子串的长度为%d",L);
        }
    }
    return 0;
}
//请输入一个最长50个字符且由|-组成的字符串(直接回车退出):-
//其中最长的由连续“|-”或连续“-|”组成的最长子串的长度为0
//请输入一个最长50个字符且由|-组成的字符串(直接回车退出):|
//其中最长的由连续“|-”或连续“-|”组成的最长子串的长度为0
//请输入一个最长50个字符且由|-组成的字符串(直接回车退出):|-
//其中最长的由连续“|-”或连续“-|”组成的最长子串的长度为2
//请输入一个最长50个字符且由|-组成的字符串(直接回车退出):-|
//其中最长的由连续“|-”或连续“-|”组成的最长子串的长度为2
//请输入一个最长50个字符且由|-组成的字符串(直接回车退出):-|-||-|-|-|
//其中最长的由连续“|-”或连续“-|”组成的最长子串的长度为6
//请输入一个最长50个字符且由|-组成的字符串(直接回车退出):
cjl1166 2013-02-02
  • 打赏
  • 举报
回复
希望有人能写出一个能运行的解决方案给我,,,郁闷死了
cjl1166 2013-02-01
  • 打赏
  • 举报
回复
哦,,,对了,,,谢谢
赵4老师 2013-02-01
  • 打赏
  • 举报
回复
//C++ Operators
//  Operators specify an evaluation to be performed on one of the following:
//    One operand (unary operator)
//    Two operands (binary operator)
//    Three operands (ternary operator)
//  The C++ language includes all C operators and adds several new operators.
//  Table 1.1 lists the operators available in Microsoft C++.
//  Operators follow a strict precedence which defines the evaluation order of
//expressions containing these operators.  Operators associate with either the
//expression on their left or the expression on their right;    this is called
//“associativity.” Operators in the same group have equal precedence and are
//evaluated left to right in an expression unless explicitly forced by a pair of
//parentheses, ( ).
//  Table 1.1 shows the precedence and associativity of C++ operators
//  (from highest to lowest precedence).
//
//Table 1.1   C++ Operator Precedence and Associativity
// The highest precedence level is at the top of the table.
//+------------------+-----------------------------------------+---------------+
//| Operator         | Name or Meaning                         | Associativity |
//+------------------+-----------------------------------------+---------------+
//| ::               | Scope resolution                        | None          |
//| ::               | Global                                  | None          |
//| [ ]              | Array subscript                         | Left to right |
//| ( )              | Function call                           | Left to right |
//| ( )              | Conversion                              | None          |
//| .                | Member selection (object)               | Left to right |
//| ->               | Member selection (pointer)              | Left to right |
//| ++               | Postfix increment                       | None          |
//| --               | Postfix decrement                       | None          |
//| new              | Allocate object                         | None          |
//| delete           | Deallocate object                       | None          |
//| delete[ ]        | Deallocate object                       | None          |
//| ++               | Prefix increment                        | None          |
//| --               | Prefix decrement                        | None          |
//| *                | Dereference                             | None          |
//| &                | Address-of                              | None          |
//| +                | Unary plus                              | None          |
//| -                | Arithmetic negation (unary)             | None          |
//| !                | Logical NOT                             | None          |
//| ~                | Bitwise complement                      | None          |
//| sizeof           | Size of object                          | None          |
//| sizeof ( )       | Size of type                            | None          |
//| typeid( )        | type name                               | None          |
//| (type)           | Type cast (conversion)                  | Right to left |
//| const_cast       | Type cast (conversion)                  | None          |
//| dynamic_cast     | Type cast (conversion)                  | None          |
//| reinterpret_cast | Type cast (conversion)                  | None          |
//| static_cast      | Type cast (conversion)                  | None          |
//| .*               | Apply pointer to class member (objects) | Left to right |
//| ->*              | Dereference pointer to class member     | Left to right |
//| *                | Multiplication                          | Left to right |
//| /                | Division                                | Left to right |
//| %                | Remainder (modulus)                     | Left to right |
//| +                | Addition                                | Left to right |
//| -                | Subtraction                             | Left to right |
//| <<               | Left shift                              | Left to right |
//| >>               | Right shift                             | Left to right |
//| <                | Less than                               | Left to right |
//| >                | Greater than                            | Left to right |
//| <=               | Less than or equal to                   | Left to right |
//| >=               | Greater than or equal to                | Left to right |
//| ==               | Equality                                | Left to right |
//| !=               | Inequality                              | Left to right |
//| &                | Bitwise AND                             | Left to right |
//| ^                | Bitwise exclusive OR                    | Left to right |
//| |                | Bitwise OR                              | Left to right |
//| &&               | Logical AND                             | Left to right |
//| ||               | Logical OR                              | Left to right |
//| e1?e2:e3         | Conditional                             | Right to left |
//| =                | Assignment                              | Right to left |
//| *=               | Multiplication assignment               | Right to left |
//| /=               | Division assignment                     | Right to left |
//| %=               | Modulus assignment                      | Right to left |
//| +=               | Addition assignment                     | Right to left |
//| -=               | Subtraction assignment                  | Right to left |
//| <<=              | Left-shift assignment                   | Right to left |
//| >>=              | Right-shift assignment                  | Right to left |
//| &=               | Bitwise AND assignment                  | Right to left |
//| |=               | Bitwise inclusive OR assignment         | Right to left |
//| ^=               | Bitwise exclusive OR assignment         | Right to left |
//| ,                | Comma                                   | Left to right |
//+------------------+-----------------------------------------+---------------+
rocktyt 2013-01-31
  • 打赏
  • 举报
回复
if(*p!=*p+1) 改成 if(*p!=*(p+1)) *优先级比+高

33,311

社区成员

发帖
与我相关
我的任务
社区描述
C/C++ 新手乐园
社区管理员
  • 新手乐园社区
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧