karthickgm27
BAN USERfrom abc import ABC, abstractmethod
import copy
class Process(ABC):
@abstractmethod
def is_swap_required(self, sequences, index):
pass
@staticmethod
def checkStrictlyIncreasing(sequence):
try:
for i in range(0, len(sequence)-1):
if sequence[i] >= sequence[i+1]:
return False
return True
except IndexError:
return True
@staticmethod
def form_sequence_results_step(index, sequences, isSwapped, lookupIndex, swapCount, isSequenceOneIncreasing,
isSequenceTwoIncreasing):
return {
"index": index,
"sequences": sequences,
"is_swapped": isSwapped,
"lookup_index": lookupIndex,
"swap_count": swapCount,
"is_sequence_one_increasing": isSequenceOneIncreasing,
"is_sequence_two_increasing": isSequenceTwoIncreasing
}
@staticmethod
def sequence_results_steps_iteration(sequenceResultsSteps, index):
sequenceResultCurrentIndexSteps = []
sequenceStrictlyIncreasing = False
for step in sequenceResultsSteps:
sequences = copy.deepcopy(step["sequences"])
lookupIndex = copy.deepcopy(step["index"])
swapCount = copy.deepcopy(step["swap_count"])
swapRequiredWithPreviousIndexValues = False
swapRequiredWithNextIndexValues = False
if CompareWithPreviousIndex().is_swap_required(sequences, index):
swapRequiredWithPreviousIndexValues = True
if CompareWithNextIndex().is_swap_required(sequences, index):
swapRequiredWithNextIndexValues = True
if swapRequiredWithPreviousIndexValues and swapRequiredWithNextIndexValues:
temp = sequences[0][index]
sequences[0][index] = sequences[1][index]
sequences[1][index] = temp
isSequenceOneIncreasing = Process.checkStrictlyIncreasing(sequences[0])
isSequenceTwoIncreasing = Process.checkStrictlyIncreasing(sequences[1])
swapCount = swapCount + 1
sequenceResultCurrentIndexSteps \
.append(Process.form_sequence_results_step(index=0,
sequences=sequences,
isSwapped=True,
lookupIndex=lookupIndex,
swapCount=swapCount,
isSequenceOneIncreasing=isSequenceOneIncreasing,
isSequenceTwoIncreasing=isSequenceTwoIncreasing))
if isSequenceOneIncreasing and isSequenceTwoIncreasing:
sequenceStrictlyIncreasing = True
break
sequenceResultsSteps.extend(sequenceResultCurrentIndexSteps)
return sequenceResultsSteps, sequenceStrictlyIncreasing
@staticmethod
def process(sequences):
if len(sequences[0]) in [0, 1]:
return sequences, 0
sequenceResultsBaseStep = Process.form_sequence_results_step(index=0,
sequences=sequences,
isSwapped=False,
lookupIndex=None,
swapCount=0,
isSequenceOneIncreasing=Process.checkStrictlyIncreasing(sequences[0]),
isSequenceTwoIncreasing=Process.checkStrictlyIncreasing(sequences[1]))
if sequenceResultsBaseStep["is_sequence_one_increasing"] and \
sequenceResultsBaseStep["is_sequence_two_increasing"]:
return sequences, 0
sequenceResultsSteps = [sequenceResultsBaseStep]
for i in range(len(sequences[0])):
sequenceResultsSteps, isStrictlyIncreasing = Process.sequence_results_steps_iteration(sequenceResultsSteps=sequenceResultsSteps, index=i)
if isStrictlyIncreasing:
return sequenceResultsSteps[len(sequenceResultsSteps)-1]["sequences"], sequenceResultsSteps[len(sequenceResultsSteps)-1]["swap_count"]
return None, 0
class CompareWithPreviousIndex(Process):
def is_swap_required(self, sequences, index):
sequenceOne = sequences[0]
sequenceTwo = sequences[1]
swapRequired = False
try:
if index == len(sequenceOne) - 1:
if sequenceOne[index] <= sequenceOne[index-1]:
swapRequired = True
if sequenceTwo[index] <= sequenceTwo[index-1]:
swapRequired = swapRequired and True
if sequenceOne[index] > sequenceTwo[index-1]:
swapRequired = swapRequired and True
if sequenceTwo[index] > sequenceOne[index-1]:
swapRequired = swapRequired and True
return swapRequired
return True
except IndexError:
return True
class CompareWithNextIndex(Process):
def is_swap_required(self, sequences, index):
sequenceOne = sequences[0]
sequenceTwo = sequences[1]
swapRequired = False
try:
if index < len(sequenceOne) - 1:
if sequenceOne[index] >= sequenceOne[index + 1]:
swapRequired = True
if sequenceTwo[index] >= sequenceTwo[index + 1]:
swapRequired = True
if sequenceOne[index] < sequenceTwo[index + 1]:
swapRequired = swapRequired and True
if sequenceTwo[index] < sequenceOne[index + 1]:
swapRequired = swapRequired and True
return swapRequired
return True
except IndexError:
return True
class Create:
@staticmethod
def run(sequences):
result_sequence, total_swaps = Process.process(sequences)
if result_sequence is not None:
print("Strictly Increasing Array - ")
print(result_sequence)
print("Total minimal swaps took: " + str(total_swaps))
else:
print("Strictly Increasing Array is not possible")
Hi,
You can complete this problem by checking the value of index sum of all the repeating elements in the given string array.
public static boolean findSubsequent(String[] str ){
boolean result = false;
ArrayList<Integer> value_list = new ArrayList<Integer>();
ArrayList<Integer> sum_list = new ArrayList<Integer>();
int sum_val;
HashMap<String, List<Integer>> str_index = new HashMap<String, List<Integer>>();
int map_count = 0;
for(int i=0; i<str.length;i++){
if(str_index.containsKey(str[i])){
str_index.get(str[i]).add(i);
}
else
str_index.put(str[i], new ArrayList<Integer>(Arrays.asList(i)));
}
for(Map.Entry<String, List<Integer>> map_entry_check : str_index.entrySet()){
if(map_entry_check.getValue().size() >= 2){
map_count++;
}
}
if(map_count >= 2){
for(Map.Entry<String, List<Integer>> map_entry_check : str_index.entrySet()){
value_list.clear();
sum_val = 0;
value_list.addAll(map_entry_check.getValue());
for(int i=0; i<value_list.size();i++){
sum_val+=value_list.get(i);
}
sum_list.add(sum_val);
}
for(int i=0; i<sum_list.size()-1; i++){
if((sum_list.get(i+1) - sum_list.get(i)) > 0){
result = true;
break;
}
}
}
else
result = false;
return result;
}
You can run this code on Create.run().
- karthickgm27 June 16, 2022Test cases:
1. [5, 8, 8, 9, 10], [2, 7, 9, 10, 11]
2. [5, 3, 7, 7, 10], [1, 6, 6, 9, 9]
3. [1, 2, 3, 4, 5], [5, 6, 7, 8, 9]
4. [1, 8, 8, 11, 14, 17, 17, 19], [2, 3, 9, 9, 13, 15, 18, 20]
5. [1], [2]
6. [3, 2], [1, 4]