特定のシーケンスで発生しない最小の正の整数を見つける
以下に提供されているCodilityの問題を解決しようとしていましたが、
関数を書く：
class Solution { public int solution(int[] A); }
n個の整数の配列Aが与えられると、Aで発生しない最小の正の整数（0より大きい）を返します。
たとえば、A = [1、3、6、4、1、2]の場合、関数は5を返します。
Given A = [1, 2, 3], the function should return 4.
Given A = [−1, −3], the function should return 1.
と仮定する：
Nは[1..100,000]の範囲内の整数です。配列Aの各要素は、[-1,000,000..1,000,000]の範囲内の整数です。複雑：
予想される最悪の場合の時間の複雑さはO（N）;予想される最悪の場合のスペースの複雑さは、O(N)（入力引数に必要なストレージをカウントしない）です。
パフォーマンスが低いソリューションを以下に記述しますが、バグを確認できません。
public static int solution(int[] A) {
Set<Integer> set = new TreeSet<>();
for (int a : A) {
set.add(a);
}
int N = set.size();
int[] C = new int[N];
int index = 0;
for (int a : set) {
C[index++] = a;
}
for (int i = 0; i < N; i++) {
if (C[i] > 0 && C[i] <= N) {
C[i] = 0;
}
}
for (int i = 0; i < N; i++) {
if (C[i] != 0) {
return (i + 1);
}
}
return (N + 1);
}
スコアはここにあります、
今後も調査を続けていきますが、よく見えたらお知らせください。
予想される実行時間が線形である必要がある場合、TreeSetを使用できません。これは入力をソートするため、O(NlogN)が必要です。したがって、HashSet要素を追加するにはO(N)時間を必要とするNを使用する必要があります。
さらに、4つのループは必要ありません。すべての正の入力要素をHashSetに追加して（最初のループ）、そのセットにない最初の正の整数を見つける（2番目のループ）だけで十分です。
int N = A.length;
Set<Integer> set = new HashSet<>();
for (int a : A) {
if (a > 0) {
set.add(a);
}
}
for (int i = 1; i <= N + 1; i++) {
if (!set.contains(i)) {
return i;
}
}
JavaScriptでの100％結果のソリューション：
function solution(A) {
// only positive values, sorted
A = A.filter(x => x >= 1).sort((a, b) => a - b)
let x = 1
for(let i = 0; i < A.length; i++) {
// if we find a smaller number no need to continue, cause the array is sorted
if(x < A[i]) {
return x
}
x = A[i] + 1
}
return x
}
何も保管する必要はありません。ハッシュセットは必要ありません。 （追加メモリ）、アレイを移動するときに実行できます。ただし、配列はソートする必要があります。そして、最小値は1であることを知っています。
import Java.util.Arrays;
class Solution {
public int solution(int[] A) {
Arrays.sort(A);
int min = 1;
int cap = A.length; //for efficiency — no need to calculate or access the array object’s length property per iteration
for (int i = 0; i < cap; i++){
if(A[i] == min){
min++;
}
}
//min = ( min <= 0 ) ? 1:min; //this means: if (min <= 0 ){min =1}else{min = min} you can also do: if min <1 for better efficiency/less jumps
return min;
}
}
ここに効率的なpythonソリューションがあります：
def solution(A):
m = max(A)
if m < 1:
return 1
A = set(A)
B = set(range(1, m + 1))
D = B - A
if len(D) == 0:
return m + 1
else:
return min(D)
Swift 4
func solution(_ A : [Int]) -> Int {
var positive = A.filter { $0 > 0 }.sorted()
var x = 1
for val in positive{
// if we find a smaller number no need to continue, cause the array is sorted
if(x < val) {
return x
}
x = val + 1
}
return x
}
これが私のPHPソリューション、100％のタスクスコア、100％の正確性、および100％のパフォーマンスです。最初に繰り返し、すべてのポジティブな要素を保存してから、それらが存在するかどうかを確認します。
function solution($A) {
$B = [];
foreach($A as $a){
if($a > 0) $B[] = $a;
}
$i = 1;
$last = 0;
sort($B);
foreach($B as $b){
if($last == $b) $i--; // Check for repeated elements
else if($i != $b) return $i;
$i++;
$last = $b;
}
return $i;
}
ここでは、その明確でシンプルな関数の1つであると思います。ロジックは他のすべての言語に適用できます。
私はPythonの以下の解決策でこれを100％達成しました：-
def solution(A):
a=frozenset(sorted(A))
m=max(a)
if m>0:
for i in range(1,m):
if i not in a:
return i
else:
return m+1
else:
return 1
あなたはやりすぎです。整数の順序セットであるTreeSetを作成し、それを配列に戻そうとしました。代わりに、リストを調べてすべての負の値をスキップし、正の値が見つかったらインデックスのカウントを開始します。インデックスが数値より大きい場合、セットは正の値をスキップしています。
int index = 1;
for(int a: set){
if(a>0){
if(a>index){
return index;
} else{
index++;
}
}
}
return index;
負の値に更新されました。
O(n)）である別のソリューションは、配列を使用することです。これはハッシュソリューションのようなものです。
int N = A.length;
int[] hashed = new int[N];
for( int i: A){
if(i>0 && i<=N){
hashed[i-1] = 1;
}
}
for(int i = 0; i<N; i++){
if(hash[i]==0){
return i+1;
}
}
return N+1;
これは、2番目のループの上限をカウントダウンしてさらに最適化できます。
<Java> Try this code-
private int solution(int[] A) {//Our original array
int m = Arrays.stream(A).max().getAsInt(); //Storing maximum value
if (m < 1) // In case all values in our array are negative
{
return 1;
}
if (A.length == 1) {
//If it contains only one element
if (A[0] == 1) {
return 2;
} else {
return 1;
}
}
int i = 0;
int[] l = new int[m];
for (i = 0; i < A.length; i++) {
if (A[i] > 0) {
if (l[A[i] - 1] != 1) //Changing the value status at the index of our list
{
l[A[i] - 1] = 1;
}
}
}
for (i = 0; i < l.length; i++) //Encountering first 0, i.e, the element with least value
{
if (l[i] == 0) {
return i + 1;
}
}
//In case all values are filled between 1 and m
return i+1;
}
Input: {1,-1,0} , o/p: 2
Input: {1,2,5,4,6}, o/p: 3
Input: {-1,0,-2}, o/p: 1
追加のストレージでそれを行う別の解決策を見つけました、
/*
* if A = [-1,2] the solution works fine
* */
public static int solution(int[] A) {
int N = A.length;
int[] C = new int[N];
/*
* Mark A[i] as visited by making A[A[i] - 1] negative
* */
for (int i = 0; i < N; i++) {
/*
* we need the absolute value for the duplicates
* */
int j = Math.abs(A[i]) - 1;
if (j >= 0 && j < N && A[j] > 0) {
C[j] = -A[j];
}
}
for (int i = 0; i < N; i++) {
if (C[i] == 0) {
return i + 1;
}
}
return N + 1;
}
私のJavaコードは100％でCodilityになります
import Java.util.*;
class Solution {
public int solution(int[] arr) {
int smallestInt = 1;
if(arr.length == 0) return smallestInt;
Arrays.sort(arr);
if(arr[0] > 1) return smallestInt;
if(arr[ arr.length - 1] <= 0 ) return smallestInt;
for(int i = 0; i < arr.length; i++){
if(arr[i] == smallestInt){
smallestInt++;}
}
return smallestInt;
}
}
//My recursive solution:
class Solution {
public int solution(int[] A) {
return next(1, A);
}
public int next(int b, int[] A) {
for (int a : A){
if (b==a)
return next(++b, A);
}
return b;
}
}
O(1)の空間の複雑さとO(N)の時間の複雑さの場合、配列を変更できる場合、次のようになります。
public int getFirstSmallestPositiveNumber(int[] arr) {
// set positions of non-positive or out of range elements as free (use 0 as marker)
for (int i = 0; i < arr.length; i++) {
if (arr[i] <= 0 || arr[i] > arr.length) {
arr[i] = 0;
}
}
//iterate through the whole array again mapping elements [1,n] to positions [0, n-1]
for (int i = 0; i < arr.length; i++) {
int prev = arr[i];
// while elements are not on their correct positions keep putting them there
while (prev > 0 && arr[prev - 1] != prev) {
int next = arr[prev - 1];
arr[prev - 1] = prev;
prev = next;
}
}
// now, the first unmapped position is the smallest element
for (int i = 0; i < arr.length; i++) {
if (arr[i] != i + 1) {
return i + 1;
}
}
return arr.length + 1;
}
@Test
public void testGetFirstSmallestPositiveNumber() {
int[][] arrays = new int[][]{{1,-1,-5,-3,3,4,2,8},
{5, 4, 3, 2, 1},
{0, 3, -2, -1, 1}};
for (int i = 0; i < arrays.length; i++) {
System.out.println(getFirstSmallestPositiveNumber(arrays[i]));
}
}
出力：
5
6
2
Rubyでの私の答え
def smallest_pos_integer(arr)
sorted_array = arr.select {|x| x >= 1}.sort
res = 1
for i in (0..sorted_array.length - 1)
if res < sorted_array[i]
return res
end
res = sorted_array[i] + 1
end
res
end
この答えは、Pythonでは100％です。最悪の場合の複雑度O（N）。
シーケンスAではなく最小の正の整数を見つけたいので、シーケンス内の負の数は気にしません。したがって、すべての負の数をゼロに設定し、一意の正の値のみを保持できます。次に、番号がシーケンスAの正の値のセットに含まれているかどうかを1から繰り返し確認します。
最悪のシナリオでは、シーケンスが一定の差1の算術的な進行であり、すべての要素を反復することになるため、O(N)複雑になります。
シーケンスのすべての要素が負である（つまり、最大が負である）極端なケースでは、最小の正の数としてすぐに1を返すことができます。
def solution(A):
max_A=max(A)
B=set([a if a>=0 else 0 for a in A ])
b=1
if max_A<=0:
return(1)
else:
while b in B:
b+=1
return(b)
JavaScriptでの私のソリューション、reduce（）メソッドを使用
function solution(A) {
// the smallest positive integer = 1
if (!A.includes(1)) return 1;
// greater than 1
return A.reduce((accumulator, current) => {
if (current <= 0) return accumulator
const min = current + 1
return !A.includes(min) && accumulator > min ? min : accumulator;
}, 1000000)
}
console.log(solution([1, 2, 3])) // 4
console.log(solution([5, 3, 2, 1, -1])) // 4
console.log(solution([-1, -3])) // 1
console.log(solution([2, 3, 4])) // 1
https://codesandbox.io/s/the-smallest-positive-integer-zu4s2
O(N)またはO（N * log（N））が時間の複雑さを検出して100％スコアを獲得したJavaScriptソリューションは次のとおりです。
function solution(A) {
let tmpArr = new Array(1);
for (const currNum of A) {
if (currNum > arr.length) {
tmpArr.length = currNum;
}
tmpArr[currNum - 1] = true;
}
return (tmpArr.findIndex((element) => element === undefined) + 1) || (tmpArr.length + 1);
}
これが私の解決策です。最初に1から始めて、配列をループし、配列の2つの要素と比較します。それが1ずつインクリメントした要素の1つと一致する場合は、プロセスを最初からやり直します。
private static int findSmallest(int max, int[] A) {
if (A == null || A.length == 0)
return max;
for (int i = 0; i < A.length; i++) {
if (i == A.length - 1) {
if (max != A[i])
return max;
else
return max + 1;
} else if (!checkIfUnique(max, A[i], A[i + 1]))
return findSmallest(max + 1, A);
}
return max;
}
private static boolean checkIfUnique(int number, int n1, int n2) {
return number != n1 && number != n2;
}
Objective-Cの例：
int solution(NSMutableArray *array) {
NSArray* sortedArray = [array sortedArrayUsingSelector: @selector(compare:)];
int x = 1;
for (NSNumber *number in sortedArray) {
if (number.intValue < 0) {
continue;
}
if (x < number.intValue){
return x;
}
x = number.intValue + 1;
}
return x;
}
これがC++での私の解決策です。 100％のスコア（100％の正確さ、100％のパフォーマンス）を獲得しました（複数回試行した後;））。これは、値を対応するインデックスと比較するという単純な原理に依存しています（ソートなどの少し前処理を行った後）。私はあなたの解決策がやりすぎていることに同意します。 4つのループは必要ありません。
私の解決策のステップは基本的に：
- 並べ替えて、重複を削除します。ここでは2つの方法が考えられます。最初の方法は_
std::sort_、_std::unique_、およびeraseを利用しますが、2番目の方法は_std::set_およびセットがソートするという事実を利用します自身は重複を許可しません - かなりの数のEdgeケースを処理します（私は最初にこれらを逃したため、最初はスコアがかなり低くなっています）。 3つのEdgeケースは次のとおりです。
- 元の配列のすべての整数は負でした
- 元の配列のすべてのintは正で1より大きい
- 元の配列には1つの要素しかありませんでした
- すべての要素について、その値！=そのインデックス+1かどうかを確認します。これが真である最初の要素は、最も小さい欠落している正の整数がある場所です。つまり
vec.at(i) != i+1の場合、vec.at(i-1)+1は、欠落している正の最小整数です。 vec.at(i) != i+1が配列のすべての要素に対してfalseの場合、配列のシーケンスに「ギャップ」はなく、最小の正のintはvec.back（）+ 1です（4番目のエッジの場合、意志）。
そしてコード：
_int solution(vector<int>& rawVec)
{
//Sort and remove duplicates: Method 1
std::sort(rawVec.begin(), rawVec.end());
rawVec.erase(std::unique(rawVec.begin(), rawVec.end()), rawVec.end());
//Sort and remove duplicates: Method 2
// std::set<int> s(rawVec.begin(), rawVec.end());
// rawVec.assign(s.begin(), s.end());
//Remove all ints < 1
vector<int> vec;
vec.reserve(rawVec.size());
for(const auto& el : rawVec)
{
if(el>0)
vec.Push_back(el);
}
//Edge case: All ints were < 1 or all ints were > 1
if(vec.size()==0 or vec.at(0) != 1)
return 1;
//Edge case: vector contains only one element
if(vec.size()==1)
return (vec.at(0)!=1 ? 1 : 2);
for(int i=0; i<vec.size(); ++i)
{
if(vec.at(i) != i+1)
return vec.at(i-1)+1;
}
return vec.back()+1;
}
_Swiftで100％の解決策を見つけました here 、それは私のアルゴより本当に美しいです...配列を順序どおりに回す必要はありません。代わりに辞書[Int: Bool]を使用して、肯定的な項目を確認するだけです。辞書で。
public func solution(_ A : inout [Int]) -> Int {
var counter = [Int: Bool]()
for i in A {
counter[i] = true
}
var i = 1
while true {
if counter[i] == nil {
return i
} else {
i += 1
}
}
}
％100スコアのKotlinでは、検出された時間の複雑さ：O(N)またはO（N * log（N））
fun solution(A: IntArray): Int {
var min = 1
val b = A.sortedArray()
for (i in 0 until b.size) {
if (b[i] == min) {
min++
}
}
return min
}
このソリューションはC＃にありますが、100％のスコアでテストを完了します
public int solution(int[] A) {
// write your code in C# 6.0 with .NET 4.5 (Mono)
var positives = A.Where(x => x > 0).Distinct().OrderBy(x => x).ToArray();
if(positives.Count() == 0) return 1;
int prev = 0;
for(int i =0; i < positives.Count(); i++){
if(positives[i] != prev + 1){
return prev + 1;
}
prev = positives[i];
}
return positives.Last() + 1;
}
.reduce()を使用したSwift
public func solution(_ A : inout [Int]) -> Int {
return A.filter { $0 > 0 }.sorted().reduce(1) { $0 < $1 ? $0 : $1 + 1}
}
会話への参加が遅い。に基づく：
https://codereview.stackexchange.com/a/179091/184415
実際、入力に重複した整数が含まれている場合でも、この問題にはO(n)複雑さの解があります。
solution(A)
Filter out non-positive values from A
For each int in filtered
Let a zero-based index be the absolute value of the int - 1
If the filtered range can be accessed by that index and filtered[index] is not negative
Make the value in filtered[index] negative
For each index in filtered
if filtered[index] is positive
return the index + 1 (to one-based)
If none of the elements in filtered is positive
return the length of filtered + 1 (to one-based)
So an array A = [1, 2, 3, 5, 6], would have the following transformations:
abs(A[0]) = 1, to_0idx = 0, A[0] = 1, make_negative(A[0]), A = [-1, 2, 3, 5, 6]
abs(A[1]) = 2, to_0idx = 1, A[1] = 2, make_negative(A[1]), A = [-1, -2, 3, 5, 6]
abs(A[2]) = 3, to_0idx = 2, A[2] = 3, make_negative(A[2]), A = [-1, -2, -3, 5, 6]
abs(A[3]) = 5, to_0idx = 4, A[4] = 6, make_negative(A[4]), A = [-1, -2, -3, 5, -6]
abs(A[4]) = 6, to_0idx = 5, A[5] is inaccessible, A = [-1, -2, -3, 5, -6]
A linear search for the first positive value returns an index of 3. Converting back to a one-based index results in solution(A)=3+1=4
以下は、C＃で推奨されているアルゴリズムの実装です（Java lingo-いくつかの一般的なたるみをカットしてください）に変換するのは簡単です）：
public int solution(int[] A)
{
var positivesOnlySet = A
.Where(x => x > 0)
.ToArray();
if (!positivesOnlySet.Any())
return 1;
var totalCount = positivesOnlySet.Length;
for (var i = 0; i < totalCount; i++) //O(n) complexity
{
var abs = Math.Abs(positivesOnlySet[i]) - 1;
if (abs < totalCount && positivesOnlySet[abs] > 0) //notice the greater than zero check
positivesOnlySet[abs] = -positivesOnlySet[abs];
}
for (var i = 0; i < totalCount; i++) //O(n) complexity
{
if (positivesOnlySet[i] > 0)
return i + 1;
}
return totalCount + 1;
}
これはあなたを助けるかもしれません、それはうまくいくはずです！
public static int sol(int[] A)
{
boolean flag =false;
for(int i=1; i<=1000000;i++ ) {
for(int j=0;j<A.length;j++) {
if(A[j]==i) {
flag = false;
break;
}else {
flag = true;
}
}
if(flag) {
return i;
}
}
return 1;
}
public int solution(int[] A) {
int res = 0;
HashSet<Integer> list = new HashSet<>();
for (int i : A) list.add(i);
for (int i = 1; i < 1000000; i++) {
if(!list.contains(i)){
res = i;
break;
}
}
return res;
}
package Consumer;
import Java.util.Arrays;
import Java.util.List;
import Java.util.stream.Collectors;
public class codility {
public static void main(String a[])
{
int[] A = {1,9,8,7,6,4,2,3};
int B[]= {-7,-5,-9};
int C[] ={1,-2,3};
int D[] ={1,2,3};
int E[] = {-1};
int F[] = {0};
int G[] = {-1000000};
System.out.println(getSmall(F));
}
public static int getSmall(int[] A)
{
int j=0;
if(A.length < 1 || A.length > 100000) return -1;
List<Integer> intList = Arrays.stream(A).boxed().sorted().collect(Collectors.toList());
if(intList.get(0) < -1000000 || intList.get(intList.size()-1) > 1000000) return -1;
if(intList.get(intList.size()-1) < 0) return 1;
int count=0;
for(int i=1; i<=intList.size();i++)
{
if(!intList.contains(i))return i;
count++;
}
if(count==intList.size()) return ++count;
return -1;
}
}
// you can also use imports, for example:
// import Java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(int[] A) {
int size=A.length;
int min=A[0];
for(int i=1;i<=size;i++){
boolean found=false;
for(int j=0;j<size;j++){
if(A[j]<min){min=A[j];}
if(i==A[j]){
found=true;
}
}
if(found==false){
return i;
}
}
if(min<0){return 1;}
return size+1;
}
}
私のシンプルで（時間）効率的なJavaソリューション：
import Java.util.*;
class Solution {
public int solution(int[] A) {
Set<Integer> set=new TreeSet<>();
for (int x:A) {
if (x>0) {
set.add(x);
}
}
int y=1;
Iterator<Integer> it=set.iterator();
while (it.hasNext()) {
int curr=it.next();
if (curr!=y) {
return y;
}
y++;
}
return y;
}
}
これはRubyシンプルで正確かつ効率的な方法で記述された私の解決策です
def solution(arr)
sorted = arr.uniq.sort
last = sorted.last
return 1 unless last > 0
i = 1
sorted.each do |num|
next unless num > 0
return i unless num == i
i += 1
end
i
end
Scala=での解決策は、すべてのテストケースを実行した場合：
Class Solution {
def smallestNumber(arrayOfNumbers: Array[Int]) = {
val filteredSet = arrayOfNumbers.foldLeft(HashSet.empty[Int]){(acc, next)
=> if(next > 0) acc.+(next) else acc}
getSmallestNumber(filteredSet)
}
@tailrec
private def getSmallestNumber(setOfNumbers: HashSet[Int], index: Int = 1):
Int = {
setOfNumbers match {
case emptySet if(emptySet.isEmpty) => index
case set => if(!set.contains(index)) index else getSmallestNumber(set,
index + 1)
}
}
}
このソリューションはO(N)複雑さで実行され、すべての主要なケースがカバーされています。
public int solution(int[] A) {
Arrays.sort(A);
//find the first positive integer
int i = 0, len = A.length;
while (i < len && A[i++] < 1) ;
--i;
//Check if minimum value 1 is present
if (A[i] != 1)
return 1;
//Find the missing element
int j = 1;
while (i < len - 1) {
if (j == A[i + 1]) i++;
else if (++j != A[i + 1])
return j;
}
// If we have reached the end of array, then increment out value
if (j == A[len - 1])
j++;
return j;
}
Java Solution-Inside de method solution
int N = A.length;
Set<Integer> set = new HashSet<>();
for (int a : A) {
if (a > 0) {
set.add(a);
}
}
if(set.size()==0) {
return N=1;
}
for (int i = 1; i <= N + 1; i++) {
if (!set.contains(i)) {
N= i;
break;
}
}
return N;
JavaScriptでの100％結果のソリューション：
function solution(A) {
let N,i=1;
A = [...new Set(A)]; // remove duplicated numbers form the Array
A = A.filter(x => x >= 1).sort((a, b) => a - b); // remove negative numbers & sort array
while(!N){ // do not stop untel N get a value
if(A[i-1] != i){N=i}
i++;
}
return N;
}
C＃では、バーの改善が必要です。
public int solution(int[] A) {
int retorno = 0;
for (int i = 0; i < A.Length; i++)
{
int ultimovalor = A[i] + 1;
if (!A.Contains(ultimovalor))
{
retorno = (ultimovalor);
if (retorno <= 0) retorno = 1;
}
}
return retorno;
}
JavaScriptの場合、次のようにします。
function solution(arr)
{
let minValue = 1;
arr.sort();
if (arr[arr.length - 1] > 0)
{
for (let i = 0; i < arr.length; i++)
{
if (arr[i] === minValue)
{
minValue = minValue + 1;
}
if (arr[i] > minValue)
{
break;
}
}
}
return minValue;
}
次のサンプルデータでテストしました。
console.log(solution([1, 3, 6, 4, 1, 2]));
console.log(solution([1, 2, 3]));
console.log(solution([-1, -3]));
100％の私のソリューションは、Swift 4。
func solution(_ A : [Int]) -> Int {
let positive = A.filter { $0 > 0 }.sorted()
var x = 1
for val in positive{
if(x < val) {
return x
}
x = val + 1
}
return x
}
public static int solution(int[] A) {
Arrays.sort(A);
int minNumber = 1;
int length = A.length - 1;
int max = A[length];
Set < Integer > set = new HashSet < > ();
for (int i: A) {
if (i > 0) {
set.add(i);
}
}
for (int j = 1; j <= max + 1; j++) {
if (!set.contains(j)) {
minNumber = j;
break;
}
}
return minNumber;
}
100％機能します。記載されているすべての条件でテストされています。
//MissingInteger
public int missingIntegerSolution(int[] A) {
Arrays.sort(A);
long sum = 0;
for(int i=0; i<=A[A.length-1]; i++) {
sum += i;
}
Set<Integer> mySet = Arrays.stream(A).boxed().collect(Collectors.toSet());
Integer[] B = mySet.toArray(new Integer[0]);
if(sum < 0)
return 1;
for(int i=0; i<B.length; i++) {
sum -= B[i];
}
if(sum == 0)
return A[A.length-1] + 1;
else
return Integer.parseInt(""+sum);
}
int[] j = {1, 3, 6, 4, 1, 2,5};
System.out.println("Missing Integer : "+obj.missingIntegerSolution(j));
出力不足整数：7
int[] j = {1, 3, 6, 4, 1, 2};
System.out.println("Missing Integer : "+obj.missingIntegerSolution(j));
出力不足整数：5
このコードはJava SE 8で記述されています
import Java.util.*;
public class Solution {
public int solution(int[] A) {
int smallestPositiveInt = 1;
if(A.length == 0) {
return smallestPositiveInt;
}
Arrays.sort(A);
if(A[0] > 1) {
return smallestPositiveInt;
}
if(A[A.length - 1] <= 0 ) {
return smallestPositiveInt;
}
for(int x = 0; x < A.length; x++) {
if(A[x] == smallestPositiveInt) {
smallestPositiveInt++;
}
}
return smallestPositiveInt;
}
}
これはpythonのコードで、コードを理解するためのコメントが付いています- Codility 100％Missing Integer
コード-
def solution(A):
"""
solution at https://app.codility.com/demo/results/trainingV4KX2W-3KS/
100%
idea is to take temp array of max length of array items
for all positive use item of array as index and mark in tem array as 1 ie. present item
traverse again temp array if first found value in tem array is zero that index is the smallest positive integer
:param A:
:return:
"""
max_value = max(A)
if max_value < 1:
# max is less than 1 ie. 1 is the smallest positive integer
return 1
if len(A) == 1:
# one element with 1 value
if A[0] == 1:
return 2
# one element other than 1 value
return 1
# take array of length max value
# this will work as set ie. using original array value as index for this array
temp_max_len_array = [0] * max_value
for i in range(len(A)):
# do only for positive items
if A[i] > 0:
# check at index for the value in A
if temp_max_len_array[A[i] - 1] != 1:
# set that as 1
temp_max_len_array[A[i] - 1] = 1
print(temp_max_len_array)
for i in range(len(temp_max_len_array)):
# first zero ie. this index is the smallest positive integer
if temp_max_len_array[i] == 0:
return i + 1
# if no value found between 1 to max then last value should be smallest one
return i + 2
arr = [2, 3, 6, 4, 1, 2]
result = solution(arr)
[〜＃〜] php [〜＃〜]のシンプルで高速なコードを次に示します。
- タスクスコア：100％
- 正しさ：100％
- パフォーマンス：100％
- 検出された時間の複雑さ：O(N) or O（N * log（N））
function solution($A) {
$x = 1;
sort($A);
foreach($A as $i){
if($i <=0) continue;
if($x < $i) return $x;
else $x = $i+1;
}
return $x;
}
Whileループを使用する最も簡単な方法：
fun solution(A: IntArray): Int {
var value = 1
var find = false
while(value < A.size) {
val iterator = A.iterator()
while (iterator.hasNext()) {
if (value == iterator.nextInt()) {
find = true
value++
}
}
if (!find) {
break
} else {
find = false
}
}
return value
}
これがJavaに対する私のアプローチです。この回答の時間の複雑さは2 * O（N）です。これは、アレイAを2回反復するためです。
import Java.util.HashMap;
public static final Integer solution(int[] A) {
HashMap<Integer, Integer> map = new HashMap<>(A.length); //O(n) space
for (int i : A) {
if (!map.containsKey(i)) {
map.put(i, i);
}
}
int minorPositive = 100000;
for (int i : A) {
if (!map.containsKey(i + 1)) {
if (i < minorPositive) {
minorPositive = i + 1;
}
}
}
if (minorPositive < 0){
minorPositive = 1;
}
return minorPositive;
}
私の解決策：
public int solution(int[] A) {
int N = A.length;
Set<Integer> set = new HashSet<>();
for (int a : A) {
if (a > 0) {
set.add(a);
}
}
for (int index = 1; index <= N; index++) {
if (!set.contains(index)) {
return index;
}
}
return N + 1;
}
最短PHPソリューション
function solution($A) {
// write your code in PHP7.0
$lastNum = 1;
while(in_array($lastNum, $A)) {
$lastNum++;
}
return $lastNum;
}
これを成し遂げる簡単な方法!!
public int findNearestPositive(int array[])
{
boolean isNegative=false;
int number=0;
int value=0;
if(array[0]<=0 && array[array.length-1]<0)
{
return 1;
}
for(int i=0;i<array.length;i++)
{
value=i+1;
isNegative=false;
for(int j=0;j<array.length;j++)
{
if(value==array[j])
{
isNegative=true;
}
}
if(isNegative!=true)
{
if(number==0){
number=value;
}else if(value<number){
number=value;
}
}
}
if(number==0)
{
number=value+1;
}
return number;
}
ソリューションのPython実装。配列のセットを取得-これにより、一意の要素のみが存在することが保証されます。次に、値がセットに存在しないまでチェックを続けます-次の値を出力として出力し、それを返します。
def solution(A):
# write your code in Python 3.6
a = set(A)
i = 1
while True:
if i in A:
i+=1
else:
return i
return i
pass
def solution(A):
A = sorted(filter(lambda x: x >= 0, A))
if A is []:
return 1
for i in range(1, 100000):
if i not in A:
return i
一意の値を格納するためのセットやディクテーションなどの構造を使用することは、O（N * N）の複雑さにつながるループ内の要素の検索を終了するか、欠落を確認するために別のループを使用するので、良い解決策ではないと思いますO(N)線形の複雑さを残しますが、1つのループよりも多くの時間を費やします。
配列に項目が1つしかない場合でも、最終的にメモリのMaxValueブロックを割り当てるため、カウンター配列構造の使用はストレージ領域に関して最適ではありません。
したがって、最良の解決策はforループを1つだけ使用して、構造を回避し、条件が実装されて不要になったときに反復を停止することです。
public int solution(int[] A) {
// write your code in Java SE 8
int len = A.length;
int min=1;
Arrays.sort(A);
if(A[len-1]>0)
for(int i=0; i<len; i++){
if(A[i]>0){
if(A[i]==min) min=min+1;
if(A[i]>min) break;
}
}
return min;
}
このようにして、O(N)またはO（N * log（N））の複雑さを得るので、より良いケースでは、O(N)の複雑さになります。
それが私のために働くこのコードを試してください
import Java.util.*;
class Solution {
public static int solution(int[] A) {
// write your code in Java SE 8
int m = Arrays.stream(A).max().getAsInt(); //Storing maximum value
if (m < 1) // In case all values in our array are negative
{
return 1;
}
if (A.length == 1) {
//If it contains only one element
if (A[0] == 1) {
return 2;
} else {
return 1;
}
}
int min = A[0];
int max= A[0];
int sm = 1;
HashSet<Integer> set = new HashSet<Integer>();
for(int i=0;i<A.length;i++){
set.add(A[i]);
if(A[i]<min){
min = A[i];
}
if(A[i]>max){
max = A[i];
}
}
if(min <= 0){
min = 1;
}
if(max <= 0){
max = 1;
}
boolean fnd = false;
for(int i=min;i<=max;i++){
if(i>0 && !set.contains(i)){
sm = i;
fnd = true;
break;
}
else continue;
}
if(fnd)
return sm;
else return max +1;
}
public static void main(String args[]){
Scanner s=new Scanner(System.in);
System.out.println("enter number of elements");
int n=s.nextInt();
int arr[]=new int[n];
System.out.println("enter elements");
for(int i=0;i<n;i++){//for reading array
arr[i]=s.nextInt();
}
int array[] = arr;
// Calling getMax() method for getting max value
int max = solution(array);
System.out.println("Maximum Value is: "+max);
}
}
最高のC++ではありませんが、スコアは100％です https://app.codility.com/demo/results/demoCNNMBE-B5W/
// you can use includes, for example:
#include <algorithm>
#include <iostream>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
template <class T>
bool allneg(const T start, const T end) {
T it;
for (it = start; it != end; it++) {
if (*it >= 0) return false;
}
return true;
}
int solution(vector<int> &A) {
if(A.empty()) throw std::invalid_argument("unexpected empty vector");
std::sort(A.begin(),A.end());
/*
for(size_t i = 0; i < A.size(); i++) {
std::cout << A[i] << ", ";
}*/
if(allneg(A.begin(),A.end())){
return 1;
}
int v = 1;
auto it = A.begin();
while(it!=A.end()){
if(std::binary_search(it,A.end(),v)){
v++;
} else {
return v;
}
it++;
}
return v;
}
整数のリストから欠落している最小の整数を見つける最速の方法 に基づいており、上記より少し高速です https://app.codility.com/demo/results/demoCJ7MDF-CDD/ =
int solution(vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
std::vector<bool> negative(1000000,false);
std::vector<bool> non_negative(1000000+1,false);
bool contain_negative = false;
bool contain_non_negative = false;
for(int a : A){
if(a<0) {
negative[-a] = true;
contain_negative = true;
} else {
non_negative[a] = true;
contain_non_negative = true;
}
}
int result = 1;
if(contain_negative && !contain_non_negative){
return result;
} else {
for(size_t i = 1; i < non_negative.size(); i++){
if(!non_negative[i]){
result = i;
break;
}
}
}
return result;
}
Linqを使用するC＃ソリューションはまだ見たことがありません...以下は、このテストで100％合格するための最も簡単な方法だと思います。
using System;
using System.Linq;
class Solution {
public int solution(int[] A) => Enumerable.Range(1, 100001).Except(A).Min();
}
ただし、上記は単純であり、テストで100％の合格になる一方で、最も効率的ではないことに注意してください。より効率的なLinqソリューションの場合、次のようなものがより適切に機能します。
using System;
using System.Collections.Generic;
public static int solution(int[] A)
{
var set = new HashSet<int>(A);
return Enumerable.Range(1, A.Length + 1).First(i => !set.Contains(i));
}
JavaScriptでのソリューション
function solution(A) {
let smallestInt = 1;
function existsInArray(val) {
return A.find((a) => a === val);
}
for (let index = smallestInt; index < 1000000; index++) {
if (existsInArray(index) && !existsInArray(index + 1) &&
existsInArray(smallestInt)) {
smallestInt = index + 1
}
}
return smallestInt;
}
function solution(A = []) {
return (A && A
.filter(num => num > 0)
.sort((a, b) => a - b)
.reduce((acc, curr, idx, arr) =>
!arr.includes(acc + 1) ? acc : curr, 0)
) + 1;
}
解決（）; // 1 solution（null）; // 1 solution（[]）; // 1ソリューション（[0、0、0]）; // 1