配列論理エラー

Question

問題を解決するために次のコードを書きましたが、動作しません。質問へのリンクはhereです。

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

    boolean result = false; 

     if(inner.length == 0) 
      return true; 

     index: for(int x: inner) { 
        for(int y: outer) { 
         if(x==y) { 
          result = true; 
          break; 
         } 
         else { 
          result = false; 
          break index; 
         } 
        } 
       } 
     return result; 
    } 

Answer 1

問題は他の部分にあります。

if(x==y) { 
result = true; // ele present. 
break; 
} else { 
result = false; // can't conclude ele is absent..you might find it later. 
break index; 
} 

あなたが行う可能性があります。この問題を解決するには：あなたは、内側の配列ではないの要素がちょうど1つの比較がを失敗した場合と結論づけることはできないとして

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

     for(int x: inner) { 
       // assume x is absent. 
       boolean result = false; 
       for(int y: outer) { 
         // x found in outer. 
         if(x==y) { 
           // make result positive. 
           result = true; 
           // no need to look any further. 
           break; 
         } 
       } 
       // at this point not all elements of inner are 
       // tested for presence in outer. But one missing ele 
       // would mean we return false. 
       if(result == false) return false; 
     } 
     // all ele of inner are present in outer..return true. 
     return true; 
} 

Answer 2

あなたはしなければなりませんO（n）解では、あなたはO（n ）です。あなただけの3行を必要とする（OK、少し浮気）：

int j = 0; 
for (int in : inner) while (outer[j] != in) if (++j == outer.length) return false; 
return true; 

Answer 3

を複雑さはO（n）は、仮想的なコードである必要がある場合：

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

int in=0; 
    for(int i :outer){ 
     if(in==inner.length) return true; 
     if(inner[in]==i) 
      in++;} 
    if(in==inner.length)return true; 
    return false; 
} 

Answer 4

アイデアはループにあるアウターオーバーをし、外側の内側の内側をループする 途中でブレークが見られる場合は、ルールはすぐに偽を返します 最後にすべての配列にループされたインナーのインデックスがtrueを返します。

public boolean linearIn(int[] outer, int[] inner) { 
    int i, j; 
    // loop over the outer 
    for(i = 0, j =0; i < outer.length && j < inner.length; i++) { 
     // move to the last same value on the outer 
     while(i < outer.length-1 && outer[i] == outer[i+1]) { 
      i++; 
     } 
     // move to the last same value on the inner 
     while(j < inner.length-1 && inner[j] == inner[j+1]) { 
      j++; 
     } 
     // immediate false 
     if(inner[j] < outer[i]) { 
      return false; 
     } 
     // match - move to the next inner 
     if(inner[j] == outer[i]) { 
      j++; 
     } 
    } 
    if(j == inner.length) { 
     return true; 
    } 
    return false; 
}