Java 序列码中相邻的字母对

字母表按顺序排列的相邻对

接受仅包含小写字母的字符串S，并打印实例C的计数，其中在一对相邻字符中，右字符在原始字母顺序中紧靠左字符

边界条件：

---

1您只检查字母表中位于同一位置的字母

---

abcdefghij无论何时开发算法，都可以使用TDD。一步一步地实现功能，确保在添加新的生产代码后所有测试都通过。对于您的作业，我提出了以下代码（输入长度条件没有满足，因为我显然没有满足，但您可以自己实现）：

导入静态org.junit.Assert.assertEquals；
导入静态org.junit.Assert.fail；
公共类CharsTest{
私家车{
私有void validateInput（字符串输入）{
如果（！input.matches（“^[a-z]*$”）{
抛出新的IllegalArgumentException（“输入仅接受小写字母字符”）；
}
}
公共整数计数（字符串输入）{
验证输入（输入）；
int计数器=0；
对于（int i=0；i

请注意，我采用了一种完全不同的方法来检查两个字符是否构成有效对：我在字符串中取两个相邻的字符，比如

a

和

B

，并检查

a

是否正好比

B

小一个。由于

char

实际上是一个数值，因此您可以轻松确认字母字符的值构成一个数字序列。

简短

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

int main()
 {
char s[1002];
scanf("%s",s);
int ac=0;
int an = strlen(s);
for(int i=0;i<an-1;i++)
{
  if((s[i+1]-s[i])==1){
    ac+=1;
  }
}
printf("%d",ac);
}

#包括
#包括
int main（）
{
chars[1002]；
scanf（“%s”，s）；
int ac=0；
int an=strlen（s）；
对于（int i=0；i
if(t==(a[i]))
    {
        if(t1==(a[i+1]))
            {
                count++;
                continue;
            }
        continue;
    }

for(int j=0;j<(a.length()-1);j++)
    {
        if (t == a[j]){
            if(t1==(a[j+1]))
                {
                    count++;
                    break;
                }
            continue;
        }
    }

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;

public class CharsTest {

    private class Chars {

        private void validateInput(String input) {
            if (!input.matches("^[a-z]*$")) {
                throw new IllegalArgumentException("Input only accepts lowercase alphabetic characters.");
            }
        }

        public int count(String input) {
            validateInput(input);

            int counter = 0;

            for (int i = 0; i < input.length() - 1; ++i) {
                if (input.charAt(i) + 1 == input.charAt(i + 1)) {
                    counter++;
                }
            }

            return counter;
        }
    }

    private Chars chars = new Chars();

    @Test
    public void shouldReturnZeroOnEmptyString() {
        String input = "";
        int actual = chars.count(input);
        assertEquals(0, actual);
    }

    @Test
    public void shouldReturnZeroOnNonEmptyStringWithZeroSequences() {
        String input = "zyxcba";
        int actual = chars.count(input);
        assertEquals(0, actual);
    }

    @Test
    public void shouldRejectUppercaseAlpha() {
        try {
            chars.count("ABC");
            fail("Expected an exception.");
        } catch (IllegalArgumentException e) {
            // ok
        }
    }

    @Test
    public void shouldRejectNonAlpha() {
        try {
            chars.count("123 $%^");
            fail("Expected an exception.");
        } catch (IllegalArgumentException e) {
            // ok
        }
    }

    @Test
    public void shouldReturnOneWhenOneSequenceIsFound() {
        String input = "acdgix";
        int actual = chars.count(input);
        assertEquals(1, actual);
    }

    @Test
    public void shouldCorrectlyCountAllSequences() {
        String input = "abcehpqtyz"; // ab, bc, pq, yz
        int actual = chars.count(input);
        assertEquals(4, actual);
    }
}

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

int main()
 {
char s[1002];
scanf("%s",s);
int ac=0;
int an = strlen(s);
for(int i=0;i<an-1;i++)
{
  if((s[i+1]-s[i])==1){
    ac+=1;
  }
}
printf("%d",ac);
}