Question

您好我正在尝试对两个数组执行单个线性传递，这是我的问题：我使用注释代码但它不正确。在寻求帮助之前，我试图解决这个问题一整晚 - 这就是我尝试过的：

////////////////////////////// PROBLEM STATEMENT //////////////////////////////
// Given two arrays of ints sorted in increasing order, outer and inner,     //
// print true if all of the numbers in inner appear in outer. The best       //
// solution makes only a single "linear" pass of both arrays, taking         //
// advantage of the fact that both arrays are already in sorted order.       //
//   {1, 2, 4, 6}, {2, 4} -> true                                            //
//   {1, 2, 4, 6}, {2, 3, 4} -> false                                        //
//   {1, 2, 4, 4, 6}, {2, 4} -> true                                         //
///////////////////////////////////////////////////////////////////////////////

  // >>>>>> Your Java Code Fragment starts here <<<<<<
  Boolean prez = true;
  Scanner kb = new Scanner(System.in);
  int n = kb.nextInt(); int z = 0;
  int[] inner = new int[n]; for(int i = 0; i < inner.length; i++)inner[i] = kb.nextInt();
      n = kb.nextInt();
  int[] outer = new int[n]; for(int i = 0; i < outer.length; i++)outer[i] = kb.nextInt();
//   if(outer.length == 0)
//     prez = true;   
//  for(int i = 0; i < outer.length; i++){
//    for(int o = 0; o < inner.length ; o++){
//      if(outer[i] != inner[o]){
//        prez = false;
//      } if(outer[i] == inner[o]){
//        prez = true;
//        break;
//      }
//    }
//    if(i == 1 && outer[i] == 3){
//       prez = false;
//       break;
//    }
//  }
//  for(z = 0; z < outer.length ; z++){
//    if(inner[z] == outer[z]){ 
//      z++;
//      prez = true;
//    }else if(outer[z] != inner[z]){
//      prez = false;
//    }
//  }


  int i = 0;
//ok lodo so we loop through the array
for(int j = 0; j < inner.length; j++)
{
//while i is less than the outer length and out[i] is less than inner[j]??? 
    while(i < outer.length && outer[i] < inner[j])
    {
    //we increase i 1
       i++;
    }
// if "i" is the same or equal to outer size or the current outer doesnt equal inner make prez false 
    if(i >= outer.length || outer[i] != inner[j])
    {
         prez = false;

    }
}
//prez = true;
//print the results
System.out.print(prez);

我理解正确吗？这是输出 enter image description here

我正在尝试lodo的解决方案。这是输出我得到假的时候需要休息吗？

Answer 1

内部数组需要一个循环，外部数组需要外部索引：

boolean checkContained(int[] inner, int[] outer)
{
    int i = 0;
    for(int j = 0; j < inner.length; j++)
    {
        while(i < outer.length && outer[i] < inner[j])
        {
             i++;
        }
        if(i >= outer.length || outer[i] != inner[j])
        {
             return false;
        }
    }
    return true;
}

编辑：

另外（正如我在输出示例中看到的），您必须首先读取外部数组，而在代码中首先读取内部数组：

int n = kb.nextInt(); int z = 0;
int[] outer= new int[n]; for(int i = 0; i < inner.length; i++)inner[i] = kb.nextInt();
  n = kb.nextInt();
 int[] inner= new int[n]; for(int i = 0; i < outer.length; i++)outer[i] = kb.nextInt();

Answer 2

您可以管理2个索引或2个迭代器，每个阵列一个。具有2个索引的解决方案：

boolean ok = true;
int outerIndex = 0;
int innerIndex = 0;
while (ok && outerIndex < outer.length && innerIndex < inner.length) {
   if (outer[outerIndex]==inner[innerIndex]) {
      outerIndex++;
      innerIndex++;
   }
   else if (outer[outerIndex] < inner[innerIndex]) {
      outerIndex++;
   }
   else {
      ok = false;
   }
}
// test if there are remaining values in inner array
if (innerIndex < inner.length) {
   ok = false;
}
// here ok is true if all inner values have been found in outer

Answer 3

你将如何在纸上做到这一点？

您将从一开始就沿着两个数组走，管理两个独立的索引。对于第一次迭代，两个索引都为零。

现在，您有三种可能性：

两个数组中0处的数字相等
外部数组中的数字更高
内部数组中的数字更高

因此，在1.下，我们可以简单地递增两个索引并比较得到的两个数字。

在3.下，正如我们所知，外部数组已经排序，我们可以递增外部数组的索引并比较得到的两个数字。希望能找到更高的价值。

在2下，我们知道内部数组是已排序的，我们知道外部数组不能包含该值，我们可以立即中止。

从逻辑中我们可以看到我们只需要一个循环，并且我们只增加索引，并且我们总是递增至少一个索引（或退出）。因此，我们所做的最多就是在两个阵列上移动一次 - 使这个算法成为线性的。

所以代码的骨架看起来像这样：

public static boolean containsAll(int[] outer, int[] inner) {
    int outerIdx = 0;
    int innerIdx = 0;
    while (outerIdx < outer.length && innerIdx < inner.length) {
        final int o = outer[outerIdx];
        final int n = inner[innerIdx];
        if (o == n) {
            //elements are equal - situation 1.
        } else if (o > n) {
            //outer element greater than inner - situation 2.
        } else if (n > o) {
            //inner element greater than outer - situation 3.
        }
    }
    //do we need to check anything here?
}

Answer 4

在lodo的帮助之后＆＃34;回答第四个＆＃34;我解决了这个问题。 lodo指出我也在以错误的顺序阅读数组。这是工作代码。感谢每一个输入。非常感谢

////////////////////////////// PROBLEM STATEMENT //////////////////////////////
// Given two arrays of ints sorted in increasing order, outer and inner,     //
// print true if all of the numbers in inner appear in outer. The best       //
// solution makes only a single "linear" pass of both arrays, taking         //
// advantage of the fact that both arrays are already in sorted order.       //
//   {1, 2, 4, 6}, {2, 4} -> true                                            //
//   {1, 2, 4, 6}, {2, 3, 4} -> false                                        //
//   {1, 2, 4, 4, 6}, {2, 4} -> true                                         //
///////////////////////////////////////////////////////////////////////////////

  // >>>>>> Your Java Code Fragment starts here <<<<<<
  Scanner kb=new Scanner(System.in);int n = kb.nextInt();
  int[] outer=new int[n];for(int i=0;i<outer.length;i++)outer[i]=kb.nextInt();n=kb.nextInt();
  int[] inner=new int[n];for(int i=0;i<inner.length;i++)inner[i]=kb.nextInt();boolean prez=true;int i=0;
  for(int j=0;j<inner.length;j++){while(i<outer.length&&outer[i]<inner[j])i++;
  if(i>=outer.length||outer[i]!=inner[j])prez=false;}System.out.print(prez);
  // >>>>>> Your Java Code Fragment ends here <<<<<<

希望这会对某人有所帮助。这些都是很好的学习问题。

Answer 5

这是我的答案，希望它能用我发表的评论来解释一切

public boolean linearIn(int[] outer, int[] inner) {

  int p = 0;//pointer for inner array

  if(inner.length==0)return true;//no inner array

  for(int i=0;i<outer.length;i++){//iterating outer array

    if(inner[p] == outer[i]){//found a inner array element in outer 
      p++;//increment pointer of inner array
    }
    if(p==inner.length){//if everyone in inner array is found
      return true;
    }
  }
  return false;
}

数组的线性传递令我难过

5 个答案: