Consecutive Factors (20)

#include <iostream>
#include <cmath>
using namespace std;
int main(){
    long long n;
    cin>>n;
    long long sqr=(long long)sqrt(1.0*n);
    long long first=0,len=0;               //len为最长连续整数的长度，first是其中第一个
    for(long long i=2;i<=sqr;i++){         //遍历第一个整数
        long long temp=1,j;                //temp为当前连续整数的乘积
        for(j=i;;j++){
            temp*=j;
            if(n%temp!=0) break;           //j不断加1直到temp不能整除n
        }
        if(j-i>len){                       //更新最长长度与第一个整数
            len=j-i;
            first=i;
        }
    }
    if(len==0) cout<<1<<endl<<n;          //根号n范围内都无解，只能输出n本身（素数）
    else{
        cout<<len<<endl;
        for(long long i=0;i<len;i++){
            cout<<first+i;
            if(i<len-1) cout<<"*";
        }
    }
    return 0;
}

#include <cmath>
#include <iostream>
using namespace std;

int main()
{
	int n;
	cin >> n;
	int min_start = n;
	int max_len = 1;
	int start;
	for(start=2; start <= sqrt(n); start++){
		if(n % start == 0){
			int len = 1;
			int copy_n = n, copy_start = start;
			copy_n = copy_n / start;
			start += 1;
			while(copy_n % start == 0){
				copy_n /= start;
				start ++;
				len ++;
			}
			if(len > max_len){
				max_len = len;
				start = copy_start;
				min_start = start;
			}
			else if(len == max_len && min_start > start){
				start = copy_start;
				min_start = start;
			}
		}
	}
	cout << max_len << endl;
	cout << min_start;
	for(int i=1; i<max_len; i++)
		cout << "*" << ++min_start;
	cout << endl;
	return 0;
}

#include<iostream>
(720)#include<cstdio>
#include<math.h>
(865)#include<vector>
using namespace std;
int main(){
    int num=0;
    vector<int>myVector;
    int n,up;
    cin>>n;
    for(int i=2;i<=sqrt(n);i++){
        int j=i;
        int tempN=n;
        int tempNum=0;
        vector<int>tvector;
        while(tempN%j==0){
            tempNum++;
            tempN/=j;
            tvector.push_back(j);
            j++;
        }
        if(tempNum>num){
            num=tempNum;
            myVector.clear();
            myVector.assign(tvector.begin(),tvector.end());
        }
    }
    if(myVector.empty()){
        myVector.push_back(n);
        num=1;
    }
    printf("%d\n%d",num,myVector[0]);
    for(int i=1;i<myVector.size();i++){
        printf("*%d",myVector[i]);
    }
}

from math import sqrt
import sys
for s in sys.stdin:
    s=int(s)
    num=0
    a=[]
    for i in range(2,int(sqrt(s)+1)):
        temp=s
        n=0
        t=[]
        j=0
        p=1
        while True:
            if temp%(p*(i+j))==0:
                p*=(i+j)
                t.append(i+j)
                n+=1
                temp//(p*(i+j))
                j+=1
            else:
                break
        if n>num:
            num=n
            a=t
    cout=''
    if num>0:
        print(num)
        for i in range(num-1):
            cout+=str(a[i])
            cout+='*'
        cout+=str(a[-1])
        print(cout)
    else:
        print(1)
        print(s)

//思路：看到样例输出为长度和序列值，很容易想到枚举起始值，更新记录长度。
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
int main(){
    LL n;
    scanf("%lld",&n);
    int m=sqrt(n+10),anslen=0,ansstart;
    for(int l=2;l<=m;++l){
        LL product=l;int r=l; 
        while(n%product==0){
            product*=(++r);
        }
        if(r-l>anslen)
            anslen=r-l,ansstart=l;        
    }
    if(anslen==0) printf("%d\n%lld",1,n);
    else{
        printf("%d\n",anslen);
        for(int i=0;i<anslen;++i){
            if(i==0) printf("%d",ansstart+i);
            else printf("*%d",ansstart+i);
        }
    }    
    return 0;
} 

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int limit = (int)Math.sqrt(n);
		boolean flag = true;
		int maxlen = -1;
		int s = 0;
		for(int i = 2;i<=limit;i++){
			if(n%i==0){
				flag = false;
			}
			int start = i;
			int len = 0;
			double temp = n;
			while(temp%start==0){
				len++;
				temp /= start;
				start++;
			}
			if(len>maxlen){
				maxlen = len;
				s = i;
			}
		}
		if(flag){
			System.out.println(1);
			System.out.println(n);
		}else{
			System.out.println(maxlen);
			System.out.print(s++);
			for(int i = 1;i<maxlen;i++,s++)
				System.out.print("*"+s);
			System.out.println();
		}
	}
}

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
int main() {
	int N;
	while (cin >> N) {
		//初始状态假设为素数
		int min_start = N;
		int max = 1;
		int start=2;
		int sqrtn = sqrt(N);
		for (;start <= sqrtn;++start) {//只需要循环到sqrt(N),多了没必要，否则会运行超时
			if (N%start == 0) {
				//找到每一个可以被N除尽的start，然后计算连续多少个数的乘积可以被N整除
				int len = 1;
				int Ncopy = N;
				Ncopy /= start;
				while (Ncopy%(++start)==0) {//为了避免计算乘积越界，我才用了除的方式
					Ncopy /= start;
					++len;
				}
				if (len > max) {
					max = len;
					start = start - len;//每次都要重置start，从原起点开始
					min_start = start;
				}else if (len == max&&start < min_start) {//不是素数，但是只有一个数可以除尽
					start = start - len;
					min_start = start;
				}
			}
		}
		cout << max << endl;
		for (int i = 0;i < max-1;++i) {
			cout << min_start++ << "*";
		}
		cout << min_start << endl;
	}
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;

int main()
{     int n;     cin>>n;     int start_min = n, len_max = 1, start;     for(start=2;start<=sqrt(n);start++)     {         if(n%start==0)         {             int len = 1;             int x = n, t = start;             x /= start;             start++;             while(x%start == 0)             {                 x /= start;                 start++;                 len++;             }             if(len > len_max)             {                 len_max = len;                 start = t;                 start_min = start;             }else if(len==len_max && start_min>start){                 start = t;                 start_min = start;             }         }     }     cout<<len_max<<endl;     cout<<start_min;     for(int i=1;i<len_max;i++)         cout<<"*"<<start_min+i;     cout<<endl;     return 0;
}

	

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    public static void main(String[] args) {

        int N = Integer.parseInt(getLine());
        int maxNum = 0, maxIndex = 0;
        for (int i = 2; i < Math.sqrt(N); i++) {
            int len = getLen(N, i);
            if (maxNum < len) {
                maxNum = len;
                maxIndex = i;
            }
        }
        if (maxNum == 0) System.out.println(1 + "\n" + N);
        else {
            System.out.println(maxNum);
            for (int i = 0; i < maxNum; i++) {
                if (i != maxNum - 1) System.out.print((maxIndex + i) + "*");
                else System.out.println(maxIndex + i);
            }
        }
    }

    static int getLen(int n, int x) {
        int len = 0;
        for (; n % (x + len) == 0; n = n / (x + len++)) ;
        return len;
    }

    static String getLine() {
        String line = "";
        try {
            line = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return line;
    }
}

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;

int main(){
    ios::sync_with_stdio(0);
	LL n;
	cin>>n;
	LL m=(LL)sqrt(n*1.0),anslen=0,ansI=0;
	for(LL i=2;i<=m;i++){
		LL temp=1,j=i;
		while(1){
			temp*=j;
			if(n%temp!=0) break;
			if(j-i+1>anslen){
				ansI=i;
				anslen=j-i+1;
			}
			j++;
		}
	}
	if(!anslen){
		cout<<1<<endl<<n;
	}else{
		cout<<anslen<<endl;
		for(int i=0;i<anslen;i++){
			if(i>0) cout<<'*';
			cout<<ansI+i;
		}
	}
	return 0;
}

#include<iostream>
#include<math.h>
using namespace std;

//题目求由n的因子构成的最长的连续串，并且连续串是最小的；例如630=3*5*6*7 ，最长连续串就是5*6*7

int main(){
    int i,j,n,sum,loc=1;
    int max_count=0;//记录最大连续长度
    cin>>n;
    /*
    我的思路：
    从2~pow(i,2)【pow(i,2)<=n】 中
    第一次循环确定连续串的开始位置
    第二次循环找满足条件的连续串
 */
    for(i=2;i<=sqrt(n)&&pow(i,max_count+1)<=n;i++){
    	//找到开始位置是i的最长的比之前的max_count还要大的连续字串
        sum=1;
        //先找到比之前的max_count多一个的连续串
        for(j=0;j<=max_count;j++){
            sum = sum*(i+j);
            if(n%sum!=0) break;
        }
        
        //找到后，如果后续很能满足条件，我接着加
        if(j==max_count+1){
            max_count++; loc=i;
            for(;pow(i+j,2)<=n;j++){
                sum = sum*(i+j);
                if(n%sum!=0) break;
                max_count++;
            }
            //i = j-1;
        }  

    }
    
    if(loc==1){
        cout<<"1\n"<<n;
        //printf("1\n%d",n); 
        return 0;
    }
    
    cout<<max_count<<endl<<loc;
    for(i=1;i<max_count;i++)
        cout<<"*"<<i+loc;
}

#include<bits/stdc++.h>
using namespace std;
int main(){
    long long num,beg;
    cin>>num;
    int ma=0;
    for(long long i=2;i<=(sqrt(num));i++){
        int k=i,now=0,tp=num;
        while(tp%k==0){
            now++;tp=tp/k;k++;
        }
        if(now>ma){
            ma=now;beg=i;
        }
    }
    if(ma){
    cout<<ma<<endl;
    for(int i=beg;i<ma+beg-1;i++)
        cout<<i<<"*";
    cout<<ma+beg-1;}
    else{
        cout<<1<<endl;
        cout<<num;
    }
}

//dfs绝对会超时
//求因子数
//题目要求，先个数，再大小，因此我从小到大开始
//思路：试除法，在得到一个除数的时候，就证明这是至少有一个因子了，就可以开始了，接下来就要有更多
//     连续的因子才行，如果停止了，没有连续的因子了，就更新成最长的，从小到大保证了一定是最小
//     的连续因子。
//为了保证每个连续的因子都得到，因此需要两层循环
#include<iostream>
#include<vector>
using namespace std;

int a[2];  //由于连续，只需要存放头尾即可，这个好厉害，看别人的代码看到的
int reslen=-1;

int main(){
    int n;
    cin>>n;
    for(int i=2;i<=n/i;i++){
        if(n%i==0){
            int len=0;
            int temp=i;
            while(n%temp==0){
                len++;
                temp*=(i+len);
            }
            if(reslen<len){
                reslen=len;
                a[0]=i;
                a[1]=i+len-1;
            }
        }
    }
    if(reslen==-1){
        cout<<1<<endl;
        cout<<n;
    }
    else{
        cout<<reslen<<endl;
        for(int i=a[0];i<a[1];i++) cout<<i<<"*";
        cout<<a[1];
    }
    
    return 0;
}

/*    题目大意
一个整数可能存在很多个因数组合，试在所有因数组合中找出一个最大的连续序列。
*/
int maxLen=0;    //最大序列长度
int startPoint;    //答案序列起点
int target;    

//更新最大长度以及序列起点
void upData(int index){
    int sum = 1;
    int tmpLen = 0;
    int sub = 0;
    int tmpIndex = index;
    while (true){
        sum *= tmpIndex;
        if (sum>=target || target %sum != 0) break;
        tmpLen++;
        tmpIndex++;
        if (tmpLen > maxLen) {
            startPoint = index;
            maxLen = tmpLen;
        }
    }
    return;
}

int main(){
    cin >> target;
    for (int i = 2; i <= sqrt(target); i++){
        upData(i);
    }
    if (maxLen == 0) {
        cout << 1 << "\n" << target << endl;
        return 0;
    }
    cout << maxLen << endl;
    for (int i = 0; i < maxLen; i++){
        cout << startPoint + i;
        if (i != maxLen - 1) cout << "*";
    }
    cout << endl;
    return 0;
}
/*
笔记：
第一个循环里面，遍历的最大值到平方根即可，到target/2可能导致超时
失败原因记录：
1.出现长度相同的状况:没有输出起点最小的序列组合；
2.长度为0时:应输出长度为1，序列为taget本身；
*/