var n = parseInt(readline())
var arr = readline().split(' ').map(function(item) {
	return item - 0
})
arr.sort(function(a, b) {
	return a - b
})
var diff = arr[1] - arr[0]
var flag = true
for (var i = 0; i < n - 1; i++) {
	if (arr[i + 1] - arr[i] != diff) {
		flag = false;
		break;
	}
}
if (flag) print("Possible")
else print("Impossible")

//输入一个数字表示数组的长度，再依次输入数组的每一个元素，采纳率最高的那个答案不全面，在测试用例的通过率只有80％

import java.util.Scanner;
import java.util.Arrays;

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        int[] arr = new int[num];
        for(int i = 0; i < num ;i++){
            arr[i] = in.nextInt();
        }
        Arrays.sort(arr);
        //需要定义一个布尔变量标记是否成功
        boolean flag = true;
        int d = arr[1] - arr[0];
        for(int i = 2;i<arr.length;i++){
            if(arr[i] - arr[i-1] != d){

                flag = false;
            }
        }
        if(flag){
            System.out.println("Possible");
        }else{
            System.out.println("Impossible");
        }

    }
}

/*
 *时间复杂度O(n),空间复杂度O(n)
 *1、找到等差数列的差值dif
 *2、判断每个数对应差值dif的倍数(arr-min)/dif
 */
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = Integer.valueOf(sc.nextLine());
		int[] arr = new int[n];
		int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
		String[] str = sc.nextLine().split(" ");
		for (int i = 0; i < n; i++) {
			arr[i] = Integer.valueOf(str[i]);
			min = arr[i] > min ? min : arr[i];
			max = arr[i] < max ? max : arr[i];
		}
		if (min == max) {
			System.out.println("Possible");
			return;
		}
		int dif = (max - min) / (n - 1);
		for (int i = 0; i < n; i++) {
			int tmp = (max - Math.abs(arr[i])) / dif;
			if (tmp < 0 || tmp >= n) {
				System.out.println("Impossible");
				return;
			}
			arr[tmp] = -Math.abs(arr[tmp]);
		}
		for (int i : arr) {
			if (i > 0) {
				System.out.println("Impossible");
				return;
			}
		}
		System.out.println("Possible");
	}

}

/*排序判断是否差值相同*/
#include <iostream>
#include<algorithm>
using namespace std;
int num[51];
int main()
{
    int n,i,flag=1;
    cin>>n;
    for(i=0;i<n;++i)
        cin>>num[i];
    sort(num,num+n);
    if(n<=2) cout<<"Possible";
    if(n>2)
    {
        for(i=0;i<n-2;++i)
          if(num[i]-num[i+1]!=num[i+1]-num[i+2]) {cout<<"Impossible";flag=0;break;}
        if(flag) cout<<"Possible";
    }
    return 0;
}

	

python两行

length, arr = int(input()), sorted(list(map(int, input().split())))
print("Possible" if len(set(map(lambda c: arr[c + 1] - arr[c], range(length - 1)))) == 1 else "Impossible")

思路：

1. 先对输入的数组进行排序。
2. 记录数组中两两相邻的差值，将差值放到一个数组里。
3. 如果是等差数列，那么这个差值全部为同一个数。既len(set(该数组)) == 1。

import java.util.Scanner;
 
public class Main {//两遍循环，时间复杂度0（n）  AC代码
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        String flag="Possible";
        int min=2147483646;
        int min2=2147483647;
        int []arr=new int[n];
        int []index=new int [n];//空间换时间
        int i=0;
        for(i=0;i<n;i++){//第一遍循环录入数据的同时取第一第二小数
            arr[i]=sc.nextInt();
            if(arr[i]<min){
                min2=min;
                min=arr[i];}
            else if(arr[i]<min2)min2=arr[i];
            if(i>0){if(arr[i]!=arr[i-1])flag="Impossible";}//所有数全等才直接possible
        }
        int d=min2-min;//获取等差值
        if(d!=0){
            for(i=0;i<n;i++){
            if((arr[i]-min)%d!=0)break;//不符合等差
            else if((arr[i]-min)/d>=n)break;//等差值超倍
            else if(index[(arr[i]-min)/d]==1)break;//数据存在重复
            else {index[(arr[i]-min)/d]=1;
                 if(i==n-1)flag="Possible";
                 }
            }
       }
        System.out.println(flag);
    }
}

给的样例极限长度是50 所以先排序是绝对不会超时的 nlog(n)的复杂度1s内大概能处理n < 10^6-10^7的数量级

#include<iostream>
#include<algorithm>

using namespace std;
const int maxn = 51;
int arr[maxn], n;

int main(){
    cin>>n;
    int flag = 1;
    for(int i=0;i<n;i++) scanf("%d", &arr[i]);
    sort(arr, arr+n);
    if(n > 2){
        int cha = arr[1] - arr[0];
        for(int i=2;i<n;i++){
            if(arr[i]-arr[i-1] != cha) {flag=0; break;}
        }
    }
    if(flag) cout<<"Possible"<<endl;
    else cout<<"Impossible"<<endl;
}

import java.util.*;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner (System.in);
		int n=cin.nextInt();//数组长度;
		int a[]=new int[n];
		for(int i=0;i<n;i++) {
			a[i]=cin.nextInt();
		}
		Arrays.sort(a);
		int left=1;
		int right=n-1;
		int temp=a[1]-a[0];
		int x=0;
		while (left<=right) {
			if(a[left]-a[left-1] !=temp || a[right]-a[right-1] !=temp) {
				x=1;
				break;
			}
			left++;
			right--;
			
		}
		if(x==0)System.out.print("Possible");
		else if(x==1)System.out.print("Impossible");

	}

}

import java.util.*;
public class Main{
    public static void main(String[] args){
        try(Scanner in = new Scanner(System.in)){
            int n = Integer.parseInt(in.nextLine()),i = 0;
            int[] a = new int[n];
            while(in.hasNextInt()){
                a[i++] = in.nextInt();
            }
            System.out.println(helper(a));
        }
    }
    public static String helper(int[] a){
        Arrays.sort(a);
        int d = a[1] - a[0],i = 2;
        while(i < a.length){
            if(a[i] - a[i - 1] != d) return "Impossible";
            i++;
        }
        return "Possible";
    }
}

#!/usr/bin/env python
#-*- coding:utf8 -*-
def isOK(n, nums):
    nums = sorted(nums)
    Max = nums[1] - nums[0]
    for i in range(1, n):
        if nums[i] - nums[i-1] != Max:
            return False
    return True
 
if __name__ == '__main__':
    n = input()
    nums = map(int, raw_input().split())
    if isOK(n, nums):
        print 'Possible'
    else:
        print 'Impossible'

java语言。先排序，然后判断相邻元素的差值是否相等。其中排序可以直接使用Arrays.sort()方法，
我这里顺便复习一下快排。有错误欢迎指正，非常感谢！

解法1：排序，两两比较
#include <iostream>
#include <vector>
#include <algorithm>

	
	

		using namespace std;
 
int main()
{
    int n,mid,num;
    vector<int> eql;
    cin>>n;
    num=n;
    if(n==2)
    {
        cout<<"Possible"<<endl;
        return 0;
    }
    while(n--)
    {
        cin>>mid;
        eql.push_back(mid);
    }
    sort(eql.begin(),eql.end());
 
    bool eq=true;
     
    for(int i=0;i<num-2;i++)
    {
        if(eql[i+2]-eql[i+1]!=eql[i+1]-eql[i])
        {
            eq=false;
            cout<<"Impossible"<<endl;
            break;
        }
    }
    if(eq==true)
    {
        cout<<"Possible"<<endl;
    }
    return 0;
}
解法2：
思路：1.先求出数列的最大，最小值 max min
	


2.判断max-min的差值对n-1取余是否为0
        若不为0，则不是等差数列
        若为0，则继续判断
      3.求出数列的差值eql=（max-min）/n-1
        若数列为等差数列，则每一项减去最小值对差值eql取余一定等于0
        
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    int n,mid,max=0,min=1000;
    cin>>n;
    vector<int> vec;
    for(int i=0;i<n;i++)
    {
        cin>>mid;
        vec.push_back(mid);
    }
    for(int i=0;i<n;i++)
    {
        
        if(vec[i]>max)
        {
            max=vec[i];
        }
        else if(vec[i]<min)
        {
            min=vec[i];
        }
    }
    if (max==min)
    {
        cout<<"Possible"<<endl ;
        return 0;
    }
    int eq=(max-min)%(n-1);
    if(eq!=0)
    {
        cout<<"Impossible"<<endl ;
        return 0;
    }

    int eql=(max-min)/(n-1);
    bool flag=true;
    for(int i=1;i<n;i++)
    {
        if((vec[i]-min)%eql!=0)
        {
             cout<<"Impossible"<<endl;
             flag=false;
             break;
        }
    }
    if(flag)
    {
         cout<<"Possible"<<endl;
    }
    return 0;
}

python 多行

mylen = int(input())
L = list(map(int,input().split()))
L.sort(reverse = True)

cha = L[1]-L[0]
flag = True
for i in range(1,mylen):
    if L[i]-L[i-1]!=cha:
        flag = False
        break
if flag:
    print("Possible")
else:
    print("Impossible")

##Python

n=int(input())
s=list(map(int,input().split()))
s.sort()
diff=[]
for i in range(n-1):
    diff.append(s[i+1]-s[i])
if len(set(diff))==1:
    print("Possible")
else:
    print("Impossible")

def grade(n, l):
    l = sorted(l)   # 先对序列排序
    t = l[0]-l[1]
    for i in range(1, n):
        if l[i-1] - l[i] != t:  # 相邻两个数的差不相同的话
            return 'Impossible'
    else:
        return 'Possible'

if __name__ == "__main__":
    n = int(input())
    l = list(map(int, input().split()))
    print(grade(n, l))

def pd(new_m,d):
    for j in range(n-1):
        if new_m[j]-new_m[j+1]!=d:
            return 0
    return 1

n=int(input());
m=[int(n) for n in input().split()];
new_m=sorted(m,reverse=True);
d=new_m[n-2]-new_m[n-1];
c=pd(new_m,d);
if c==1:
    print("Possible")
else:
    print("Impossible")

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main(int argc, char **argv)
{
    int n;
    cin >> n;
    vector<int> vec(n);
    for(int & c: vec)
        cin >> c;
    sort(vec.begin(), vec.end());
    int diff = vec[0]-vec[1];
    auto pos = adjacent_find(vec.begin(), vec.end(), [diff](int a, int b){return diff != (a-b);});
    if(pos != vec.end())
        cout << "Impossible" << endl;
    else
        cout << "Possible" << endl;
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

int main()
{     int n;     while(cin>>n){         int a[n];         for(int i=0;i<n;i++)             cin>>a[i];         sort(a,a+n);         bool flag = true;         for(int i=2,d=a[1]-a[0];i<n;i++)             if(a[i]-a[i-1]!=d){                 cout<<"Impossible"<<endl;                 flag = false;                 break;             }         if(flag)             cout<<"Possible"<<endl;     }     return 0;
}