被3整除

package com.shengxi.niuke;


import java.util.Scanner;

public class Day006 {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);


        int l = scan.nextInt();
        int r = scan.nextInt();
        int cnt = 0;
        for(int i=l;i<=r;i++) {
            if(i%3!=1) {
                cnt++;
            }
        }
        System.out.println(cnt);
    }


}

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int l = in.nextInt();
            int r = in.nextInt();
            if(r<l){
                throw new RuntimeException();
            }
            int count = 0;
            for(int i = l; i<=r; i++){
                long num = getNum((long)i);
                if(num % 3 == 0){
                    count++;
                }
            }
            System.out.println(count);
            
        }
    }
    
    private static long getNum(long num){
        String str = "";
        for(int i = 1; i<=num; i++){
            str = str+i;
        }
        long res = Integer.valueOf(str);
        return res;
    }
}

不太懂题的意思，我以为直接求两个数中可以整除3的个数和。写出来也通过了。看评论区发现自己想的有些简单

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
/**
left right 边界 里面能整除3的个数，只需要对边界值判断即可。
如果 left 可以整除3
   说明左边界包括一个 。 只需要right包括的3的个数 - left 包括的 + 1
如果左边界不是
     上式不用 + 1即可。
*/
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int l = sc.nextInt();
            int r = sc.nextInt();
            System.out.println(l % 3 == 0 ? r / 3 - l / 3 + 1 : r / 3 - l / 3);
        }
    }
}

找到这个数列的规律就可以了，就是1,2,3,4,5,6，7,8,9,10,11,12,13，14……字符串拼接，第几个数就拼接几次

import java.util.*;

public class Main
{
    public static void main(String [] args)
    {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNextInt())
        {
            int a=sc.nextInt();
            int b=sc.nextInt();
            System.out.println(getResult(a,b));
        }

    }

    public static int getResult(int a,int b)
        {
            int count=0;//计数器
            for(int i=a;i<=b;i++)
            {
                if(getNum(i)%3==0)
                {
                    count++;
                }
            }
            return count;          
        }

        public static long getNum(int index)
        {
            StringBuilder sb=new StringBuilder();
            for(int i=1;i<=index;i++)
            {
                sb.append(""+i);
            }
            String str=sb.toString();
            long num=Long.parseLong(str);
            return num;
        }
}

import java.util.Scanner;
// import java.math.BigInteger;

public class Main {
	public static void main(String[] args) {
		// 据观察，序列满足×√√×√√×√√×√√...
        // 该题right并不超过int类型，2^31 - 1 > 2*10^9
        // 如果超过整型范围，用BigInteger来计算
		Scanner scan = new Scanner(System.in); 
		int left = scan.nextInt();
		int right = scan.nextInt();
		if(left == 1)
			System.out.print(getNumbers(right));
		else
			System.out.print(getNumbers(right) - getNumbers(left - 1));
		scan.close();
	}

	public static int getNumbers(int x) {
        // 也就是求getNumbers(1, right) - getNumbers(1, left)
		return ((x/3) << 1) + (x % 3 > 1 ? 1 : 0);
	}
//	static BigInteger two =new BigInteger("2");
//	static BigInteger three =new BigInteger("3");
//	public static void main(String[] args) {
//		Scanner scan = new Scanner(System.in); 
//		BigInteger left = scan.nextBigInteger();
//		BigInteger right = scan.nextBigInteger();
//		if(left.compareTo(BigInteger.ONE) == 0 )
//			System.out.print(getNumbers(right));
//		else
//			System.out.print(getNumbers(right).subtract(getNumbers(left.subtract((BigInteger.ONE)))));
//		scan.close();
//	}
//
//	public static BigInteger getNumbers(BigInteger x) {
//        // 也就是求getNumbers(1, right) - getNumbers(1, left)
//		return ((x.divide(three)).multiply(two)).add(new BigInteger(String.valueOf((x.mod(three)).compareTo(BigInteger.ONE) > 0 ? 1 : 0)));
//	}
}

import java.util.Scanner;
//每连续三个数中必有两个数能被三整除，先算出一共有多少组3个数
//再分别判断余下的1或2个数中有几个3的倍数
//从1开始，分布规律为 NYYNYYNYY...
//N代表不是3的倍数，Y代表是3的倍数
public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        while(input.hasNext()){
            int l = input.nextInt();
            int r = input.nextInt();
            System.out.println(Solution(l, r));
        }
        input.close();        
    }
    public static int Solution(int l, int r) {
		if(l > r)
			return 0;
		else if((r + 1 - l)%3 == 0)
			return (r + 1 - l)/3 * 2;
		else if((r + 1 - l)%3 == 1)
			return (r + 1 - l)/3 * 2 + ((r%3 == 1) ? 0 : 1);
		else
			return (r + 1 - l)/3 * 2 + ((r%3 == 0) ? 2 : 1);  	
    }
}

import java.util.*;
public class Main{
    //参考一位大神的数学归纳法：在区间[1 , x]***有f(x) = (x+2)/3个不能被整除的，其余的全能被整除
    //那么区间[l , r]***有数字r-l+1个，其中存在不能整除的个数是f(r)-f(l-1)个
    //那么最后能被整除的个数就是 r-l+1-(f(r)-f(l-1))个
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int l = sc.nextInt();
        int r = sc.nextInt();
        System.out.println(r - l + 1 - (r + 2) / 3 + (l - 1 + 2) / 3);
    }
}

import java.util.Scanner;

public class Main {
	public static void main(String args[]){
		Scanner input=new Scanner(System.in);
		int l,r,count=0;
		l=input.nextInt();
		r=input.nextInt();
		int yushu=0;
		int value=0;
		StringBuffer str=new StringBuffer();
        //最左边的数是否是3的倍数
		for(int j=1;j<=l;j++){
			str.append(String.valueOf(j));
			value+=Integer.parseInt(str.substring(j-1, j));
		}
		yushu=value%3;
		if(yushu==0){
			count++;
		}
        //后面的数用前面的余数加此时最后一位数取余数判断是否是3的倍数
		for(int i=l+1;i<=r;i++){
			yushu=(i+yushu)%3;
			if(yushu==0){
				count++;
			}
		}
		System.out.println(count);
	}
}

import java.io.BufferedInputStream;
import java.util.Scanner;

public class Main {
    static int min =  Integer.MAX_VALUE;
    public static void main(String[] args) {
        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        int l = cin.nextInt();
        int r = cin.nextInt();
        System.out.println(r *2/3 - (l-1)*2/3);
    }
}

1-x 被3整除个数为x*2/3

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int l = sc.nextInt();
            int r = sc.nextInt();

            System.out.println(cal(r) - cal(l - 1));
        }
    }

    private static int cal(int n) {
        int sum = n / 3 * 2;
        if (n % 3 == 2)
            return sum + 1;
        else
            return sum;
    }


}

 for(int index = l;index<=r;index++){
     int num = 0;
     for(int i=1;i<=index;i++){//根据三的倍数的性质，如果各位相加能够整除3就是3的倍数。
         num = num+i;
     }
     System.out.println(num%3);
     //用这种方法先试着输出一下num%3的余数，可以发现从1-20分别按100100100...这种顺序
 }

import java.util.Scanner;
public class Main{
    public static void main(String[] arg){
        Scanner scan = new Scanner(System.in);
        int l = scan.nextInt();
        int r = scan.nextInt();
        if(l>=r){
            System.out.println(0);//判断左右区间是否合法
        }else{
            int count = 0;
        for(int index = l;index<=r;index++){
            if(index%3==2||index%3==0)
                count++;
        }
        System.out.println(count);
        }
        
    }
}

import java.util.Scanner;

public class Main  {
    public static int sum(int i){
        return i/3*2+(i%3==2?1:0);
    }
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int l = input.nextInt();
        int r = input.nextInt();
        System.out.println(sum(r) - sum(l-1));
    }
}

import java.util.*;
public class Main{
public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        //起始位置
        int l=in.nextInt();
        //结束位置
        int r=in.nextInt();
        //1 0 0 1 0 0 ....
        int sum=0;
        if(l>=1 && l<=r && r<=1e9){
            //根据规律进行判断，当l处于1 0 0中1号位与三号位时情况相同
            if (l%3==1 || l%3==0){
                sum=(r-l)-((r-l)/3);
            }
            //处于二号位时需要进行特殊的运算
            if (l%3==2){
                if (r-l==1){
                    sum=2;
                }else{
                    sum=(r-l)-((r-l-2)/3);
                }
            }
            System.out.println(sum);
        }else{
            System.out.println("输入错误");
        }

    }
}

//无需循环，只要找到相应规律即可