Solution for - CodeSignal - Reverse In Parentheses

gistfile1.txt

// 1. Find the pairs of parentheses
function getStartAndEndIndexes(inputString) {
  const regularExpression = /\([a-zA-Z]*?\)/;
  const execData = regularExpression.exec(inputString);
  if(!execData) {
    return null;
  }
  const startIndex = execData.index;
  const endIndex = execData.index + execData[0].length - 1;
  return {startIndex, endIndex}
}

// 2. Find the part of the string we need to reverse
function reverseParentheses(startIndex, endIndex, inputString) {
  // before the parenthesis
  const startSegmant = inputString.substring(0, startIndex);
  // the parenthesis
  const parenthesisSegmant = 
  inputString.substring(startIndex +1, endIndex);
  // after the parenthesis
  const endSegmant = 
  inputString.substring(endIndex + 1, inputString.length);
  return startSegmant + reverse(parenthesisSegmant) + endSegmant;
}

// 3. Reverse the string
function reverse(string) {
  return string.split('').reverse().join('');
}

// 4. Repeat until all parentheses are replaced
function reverseInParentheses(inputString) {
  let indexes = getStartAndEndIndexes(inputString);
  while(indexes) {
    const {startIndex, endIndex} = indexes; 
    const newString = 
    reverseParentheses(startIndex, endIndex, inputString);
    inputString = reverseInParentheses(newString);
    indexes = getStartAndEndIndexes(inputString);
  }
  return inputString;
}

What about this?

function solution(inputString) {
  let str = inputString
  const re = /\([A-Za-z]*\)/g
  
  while (re.test(str)) {
    str = str.replace(re, (substr) => substr.slice(1, substr.length - 1).split('').reverse().join(''))
  }
  
  return str
}

My solution in python

def solution(inputString):
    """
    loop through each letter
    define a list which will represent a stack of strs to reverse
    when ( add a new str to top of stack
    when ), pop the most recent str, reverse it and add it to the next str
    if there is no next str in the stack, append the str to the result str
    """
    result = ""
    stack = []
    for letter in inputString:
        if letter == "(":
            stack.append("")
        elif letter == ")":
            temp = stack.pop()[::-1]
            if stack:
                stack[-1] += temp
            else:
                result += temp
        elif stack:
            stack[-1] += letter
        else:
            result += letter
    return result

Solution For Kotlin

fun solution(inputString: String): String {
  val list = startAndEndIndices(inputString)
    var outputString = inputString
    for (pair in list) {
      val wordToReverse = outputString.substring(pair.first + 1, pair.second)
      outputString =
        outputString.replaceRange(pair.first + 1 until pair.second, wordToReverse.reversed())
    }
    return outputString.replace("(", "").replace(")", "")
}


private fun startAndEndIndices(inputString: String): List<Pair<Int, Int>> {
    val stackOfLeftBraces: Stack<Int> = Stack()
    val startEndIndexPair = mutableListOf<Pair<Int, Int>>()
    for (i in inputString.indices) {
      if (inputString[i] == '(') {
        stackOfLeftBraces.push(i)
      } else if (inputString[i] == ')') {
        startEndIndexPair.add(stackOfLeftBraces.pop() to i)
      }
    }
    return startEndIndexPair
  }

Solution For Kotlin

fun solution(inputString: String): String {
  val list = startAndEndIndices(inputString)
    var outputString = inputString
    for (pair in list) {
      val wordToReverse = outputString.substring(pair.first + 1, pair.second)
      outputString =
        outputString.replaceRange(pair.first + 1 until pair.second, wordToReverse.reversed())
    }
    return outputString.replace("(", "").replace(")", "")
}


private fun startAndEndIndices(inputString: String): List<Pair<Int, Int>> {
    val stackOfLeftBraces: Stack<Int> = Stack()
    val startEndIndexPair = mutableListOf<Pair<Int, Int>>()
    for (i in inputString.indices) {
      if (inputString[i] == '(') {
        stackOfLeftBraces.push(i)
      } else if (inputString[i] == ')') {
        startEndIndexPair.add(stackOfLeftBraces.pop() to i)
      }
    }
    return startEndIndexPair
  }

thank you @mahmed1987

Solution for Swift

func solution(inputString: String) -> String {
var result = ""
var stack = String
for letter in inputString {
if letter == "(" {
stack.append("")
} else if letter == ")" {
guard let last = stack.popLast() else { continue }
let reversedString = String(last.reversed())
if let lastStack = stack.last {
stack[stack.count - 1] = lastStack + reversedString
} else {
result += reversedString
}
} else if let lastStack = stack.last {
stack[stack.count - 1] += String(letter)
} else {
result += String(letter)
}
}
return result
}