Goal Parser Interpretation

🏠 ⬅️ ➡️

You own a Goal Parser that can interpret a string command. The command consists of an alphabet of "G ", "() " and/or "(al) " in some order. The Goal Parser will interpret "G " as the string "G ", "() " as the string "o ", and "(al) " as the string "al ". The interpreted strings are then concatenated in the original order.

Given the string command, return the Goal Parser's interpretation of command.

Example 1:

Input: command = "G()(al) " Output: "Goal " Explanation: The Goal Parser interprets the command as follows: G -> G () -> o (al) -> al The final concatenated result is "Goal ".

Example 2:

Input: command = "G()()()()(al) " Output: "Gooooal "

Example 3:

Input: command = "(al)G(al)()()G " Output: "alGalooG "

Constraints:

  • 1 <= command.length <= 100
  • command consists of "G ", "() ", and/or "(al) " in some order.
Note: This problem is from LeetCode.
✅ Compiled
✅ Executed
❌ Correct 
program main
    implicit none

    character(len=100) :: command
    character(len=100) :: result

    ! Example 1
    command = "G()(al) "
    result = goalParser(command)
    write (*,*) trim(result)

    ! Example 2
    command = "G()()()()(al) "
    result = goalParser(command)
    write (*,*) trim(result)

    ! Example 3
    command = "(al)G(al)()()G "
    result = goalParser(command)
    write (*,*) trim(result)

contains

    function goalParser(command) result(result)
        implicit none
        character(len=*), intent(in) :: command
        character(len=100) :: result

        integer :: i
        logical :: found_g

        result = ""
        found_g = .false.

        do i = 1, len(command)
            select case (command(i:i))
                case ("G")
                    if (.not. found_g) then
                        result = trim(result) // "G"
                        found_g = .true.
                    end if
                case ("()")
                    result = trim(result) // "o"
                case ("(al)")
                    result = trim(result) // "al"
            end select
        end do

    end function goalParser

end program main
✅ Compiled
✅ Executed
❌ Correct 
program main
      implicit none

      character(len=100) :: command
      character(len=100) :: result

      command = "G()(al) "
      result = goal_parser(command)
      write (*,*) "Interpretation of ", command, " is ", result

      command = "G()()()()(al) "
      result = goal_parser(command)
      write (*,*) "Interpretation of ", command, " is ", result

      command = "(al)G(al)()()G "
      result = goal_parser(command)
      write (*,*) "Interpretation of ", command, " is ", result

      contains

      function goal_parser(command) result(result)
      implicit none

      character(len=*), intent(in) :: command
      character(len=100) :: result

      integer :: i
      integer :: j

      result = ""

      do i = 1, len(command)
        if (command(i:i+1) == "G ") then
          result = result // "G "
        else if (command(i:i+1) == "() ") then
          result = result // "o "
        else if (command(i:i+2) == "(al) ") then
          result = result // "al "
        end if
      end do

      end function goal_parser
      end program main
🌐 Data from online sources 
def num_ways(s: str) -> int:
    number_of_ones = s.count('1')
    if number_of_ones % 3 != 0:
        return 0

    target = number_of_ones // 3
    if target == 0:
        n = len(s)
        return ((n - 1) * (n - 2) // 2) % 1000000007

    ones_so_far1, ones_so_far2 = 0, 0
    way1, way2 = 0, 0
    for c in s:
        if c == '1':
            ones_so_far1 += 1
            if ones_so_far1 == target:
                way1 += 1
                ones_so_far1 = 0

            ones_so_far2 += 1
            if ones_so_far2 == target * 2:
                way2 += 1
                ones_so_far2 = 0

    return (way1 * way2) % 1000000007

First, count the number of ones in the binary string s. If the number of ones is not divisible by three, there is no valid way to split s. If the number of ones is zero, calculate the result as the number of ways to pick two positions out of (s.length() - 1) positions to insert separator. In other cases, we iterate through the string and count ones. If the count reaches target ones, we accumulate the result for s1 and clear the count. Similarly for s2, we accumulate the result based on the count reaching target * 2. Finally, we calculate the result as (way1 * way2) % 1000000007.
🌐 Data from online sources 
#include <string>
using namespace std;

int numWays(string s) {
    int numberOfOnes = 0;
    for (char c : s) {
        if (c == '1') numberOfOnes++;
    }
    if (numberOfOnes % 3 != 0) return 0;

    int target = numberOfOnes / 3;
    if (target == 0) {
        long n = s.length();
        return ((n - 1) * (n - 2) / 2) % 1000000007;
    }

    int onesSoFar1 = 0, onesSoFar2 = 0;
    long way1 = 0, way2 = 0;
    for (char c : s) {
        if (c == '1') {
            onesSoFar1++;
            if (onesSoFar1 == target) {
                way1++;
                onesSoFar1 = 0;
            }

            onesSoFar2++;
            if (onesSoFar2 == target * 2) {
                way2++;
                onesSoFar2 = 0;
            }
        }
    }

    return (way1 * way2) % 1000000007;
}

First, count the number of ones in the binary string s. If the number of ones is not divisible by three, there is no valid way to split s. If the number of ones is zero, calculate the result as the number of ways to pick two positions out of (s.length() - 1) positions to insert separator. In other cases, we iterate through the string and count ones. If the count reaches target ones, we accumulate the result for s1 and clear the count. Similarly for s2, we accumulate the result based on the count reaching target * 2. Finally, we calculate the result as (way1 * way2) % 1000000007.