0

我刚刚尝试了一个在线编程小测验，要求我尽快解决这个问题。我得到了正确的答案，但我知道它并不漂亮。我正在努力成为一名更好的程序员并编写更清洁、更高效的代码，所以请给我一些提示。我已经包含了下面的描述。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 中（除了缺少整数的点）。

输出格式一个数字，它是系列中缺少的整数。

样本输入 5 1 3 5 9 11

样本输出 7

4

7 回答 7

3

我认为这段代码可以稍微简化。首先，输入。没有太大不同，除了我使用raw_input（或input在 Python 3 中），我立即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

现在是有趣的部分：请注意（假设列表格式正确）数字之间可能只有两个差异：正确的差异或该差异的两倍。我使用列表推导来创建一个元组列表(difference, at index)。现在我可以简单地使用内置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)
于 2013-10-17T13:01:02.867 回答
1

效劳于

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 是存储字符串中的数字数组的位置。

长度是您提供的数字数量。

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

于 2013-12-10T15:01:02.110 回答
0 
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);
于 2014-01-10T08:52:40.150 回答
0

它非常简单，查看下面的代码，如果您删除了空白行，它将正好是 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
于 2013-11-13T23:29:03.880 回答
0 
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

输入：

 5
 1 21 31 51 61

输出：

 41
于 2015-07-30T04:59:59.890 回答
0

这是我的代码，适用于正差和负差...

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])
于 2016-06-29T22:22:01.243 回答
-1

2 For Loops 用于解决诸如此类的简单问题！上面的解决方案的行为是二次的！

这是一种 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;
}
于 2014-02-04T03:29:17.063 回答