Question

我刚尝试了一个小小的在线编程测验，要求我尽快解决这个问题。我得到了正确的答案，但我知道它不漂亮。我正在努力成为一名更好的程序员并编写更清晰，更高效的代码，所以请给我一些提示。我已经包括下面的描述。 PS我认为这个算法在N = 3

的情况下失败了

# Enter your code here. Read input from STDIN. Print output to STDOUT
import sys
N= int(sys.stdin.readline())
stringdata =  sys.stdin.readline()
array = stringdata.split(' ')
diff1=[0]*(N-1)
diff2 = [0]*(N-2)
index = 0
diff = 0
for i in  range(0,len(array)-1):
    first_diff[i] = int(array[i+1])-int(array[i])
for i in   range(0,len(diff1)-1):
    second_diff[i] = first_diff[i+1]-first_diff[i]
    if second_diff[i] == 0:
        diff = first_diff[i]
    else:
        index = i
print(int(array[index])+diff)

任务：在算术级数中找到缺失的术语。

算术级数定义为给定系列数的连续项之间存在恒定差异的算术级数。您将获得算术级数的连续元素。然而有一个障碍：原始系列中的一个术语从给出的数字集中缺失。给定系列的其余部分与原始AP相同。找到缺少的术语。

输入格式第一行包含一个整数N，它是将作为输入提供的术语数。接下来是N个连续的整数，每对整数之间有一个空格。所有这些都在一行上，并且它们在AP中（除了缺少整数的点之外）。

输出格式一个数字是该系列中缺失的整数。

示例输入五 1 3 5 9 11

示例输出 7

Answer 1

我认为这段代码可以稍微简化一下。一，输入。差别不大，除了我在{3}中使用raw_input（或input），我立即map将数字int。

n = int(raw_input("Number of Numbers: "))
s = raw_input("List of Numbers, space-separated: ")
nums = map(int, s.split())
assert n == len(nums) and n > 2

现在有趣的部分：注意（假设列表格式正确）数字之间可能只有两个差异：正确的差异，或两倍的差异。我使用列表推导来创建元组列表（差异，索引）。现在我可以简单地使用内置max函数来找到具有两倍正确差异和相应索引（d2, index）的函数，并计算丢失的数字。

diffs = [(nums[i+1] - nums[i], i) for i in range(n-1)]
(d2, index) = max(diffs)
print nums[index] + d2 / 2

但问题是编码风格，而不是算法，所以这是我的想法：

在您的计划的逻辑块之间添加一些空行和注释（例如# read input）
map数组到int一次，而不是每次需要时都输出数字
您可以使用列表推导来创建diff1（又名first_diff），如我的示例所示
您根本不需要diff2 ;只需写下if diff1[i+1] - diff1[i] == 0:
简明扼要：range(0,len(array)-1)与range(N-1)

Answer 2

适用于

1）N的任何值（在示例中给出5）

2）术语之间的任何差异（在示例中给出2）

3）差异可以是+以及 - （例如：11 5 2 -1 -4）

int diff[]= new int[length-1];
for(int i = 0; i<length-1;i++){
    diff[i] = n1[i+1]-n1[i];
    //System.out.println(diff[i]);
    if(i!=0){
        if(diff[i]<diff[i-1]){
            if(diff[i]<0)
                System.out.println(n1[i]+diff[i-1]);
            else
                System.out.println(n1[i-1]+diff[i]);
            break;
        }
        if(diff[i]>diff[i-1]){
            if(diff[i]<0)
                System.out.println(n1[i-1]+diff[i]);
            else
                System.out.println(n1[i]+diff[i-1]);
            break;
        }
    }
}

n1是从String存储数字数组的地方。

长度是您提供的数字。

这是优化的，如果你错过前两个数字之间的数字，那么无论你给出了多少数字，它只会循环3次

Answer 3

非常简单，请查看下面的代码，如果删除了空白行，它将正好是8行我希望这个答案对你来说很清楚

import re
N = int(raw_input())        #Number of Terms
I = raw_input()             #The Series of Numbers received as a String

I =  re.findall(r'\d+',I)   #Extract items from the string 

I = [int(s) for s in I]     #I is a list with Series of Integers

for x in range(N-1):

    if (I[x]+2 != I[x+1]):
    print I[x]+2

Answer 4

int a[]={1,3,5,7,11};
int i=0,n=5,fd,sd;
printf("output:\n");
do
{
    fd=0;sd=0;
    fd=a[i+1]-a[i];
    sd=a[i+2]-a[i+1];
    if(fd<sd)
    {
        printf("missing term is %d",fd+a[i+1]);
    }
    else if(fd>sd){
       printf("missing term is %d",a[i]+sd);}
    else{
       i++;}
}while((fd==sd)&&i<n-2);

Answer 5

N = input()
max_num = range(N)
s = raw_input()
AP = map(int,s.split())
comm_dif = AP[1]-AP[0]
length = len(AP)
for i in range(N):
    if i != length-1:
        if AP[i+1]-AP[i] != comm_dif:
            print AP[i]+comm_dif

INPUT：

 5
 1 21 31 51 61

输出：

Answer 6

这是我的代码，兼顾正面差异和负面差异......

def find_arith(aplist):
   idiff=[]
   flag=0
   for j in range(0, len(aplist)-1):
      diff1 = aplist[j+1] - aplist[j]
      if diff1 < 0:
         flag=1
      idiff.append(abs(diff1))
   if flag==1:
     final_diff=-1*min(idiff)
   else:
     final_diff=min(idiff)
   print(idiff)
   print("final diff:", final_diff)
   for i in range(aplist[0],aplist[len(aplist)-1]+1,final_diff):
      if i not in aplist:
         print(i)

if __name__ == "__main__":

   print("First Result")
   find_arith([13,21,25,33,37,45])
   print("Second Result")
   find_arith([-10,-6,-4,-2])
   print("3rd Result")
   find_arith([-5, -1, 3, 11])
   print("4th Result")
   find_arith([1, 5, 13, 17, 21])

   print("5th Result")
   find_arith([-2, -8, -11, -14, -17, -20, -23, -29])

Answer 7

2对于像这样的简单问题的循环!!以上解决方案的行为是二次方!!

这是一个解决方案，对于最坏情况行为的O（N），其中项目索引1缺失，并且对于索引1之后缺少的任何项目，解决方案优于线性。

此方法的算术级数（输入数组），用适当的返回替换SYSOUT。

解决方案：

 public static int findMissingNumberInAP(int[] ipArr)
{
    // ipArr will always be more than 3 elements in size.
    int maxDiff = ipArr[1] - ipArr[0];
    int i=0;
    while(i<ipArr.length-1)
    {
        if((ipArr[i+1] - ipArr[i]) > maxDiff)
        break;
        i++;
    }
    // This means the 2nd element or i=1 was missing so add ip[0] to
    // any random difference you are good to go.
    if(i == ipArr.length - 1) 
    System.out.println(ipArr[0] + (ipArr[ipArr.length-1]-ipArr[ipArr.length-2]));
    else System.out.println(ipArr[i] + maxDiff);
    // Else just add the maxDiff you got from first step to the position 
    // of i you broke the loop at.
    return -1;
}

缺少术语算术级数 - 清理我的代码

7 个答案: