Slice Traversal Adventure with Gloria the Bunny | CodeSignal Learn

Slice Traversal Adventure with Gloria the Bunny | CodeSignal Learn

Introduction

Welcome to an engaging lesson on slice traversal! Today, we invite you to join an endearing bunny named Gloria on an intricate quest. Gloria has a soft spot for number games, especially when they involve hopping between slices. Our goal on this exciting journey is to assist Gloria through her escapade and identify the maximum value she encounters along the way. Are you ready to embark on this adventure?

Task Statement

Gloria's quest unfolds with two slices, both full of non-negative integers. Starting at the first element of sliceA, she leaps to sliceB based on the index she discovers in sliceA . She then bounces back to sliceA according to the index she stumbles upon in sliceB . Gloria repeats these hops until she returns to where she started in sliceA . What an adventure! Your challenge is to craft a Go function that aids Gloria on her trip. The function will take two slices of integers as inputs, representing sliceA and sliceB . The objective is to find the highest value from sliceB that Gloria jumps to during her voyage. It is guaranteed that at some point, Gloria returns to the starting position. Example : If sliceA = []int{2, 4, 3, 1, 6} and sliceB = []int{4, 0, 3, 2, 0}, the output should be 3 . In this scenario, Gloria starts from the first element of sliceA, which is 2 . Then, she jumps to sliceB at index 2, where she discovers 3 . She then bounces back to sliceA at index 3, where she arrives at 1 . From there, she leaps back to sliceB at index 1, stumbling upon a 0 . Finally, she bounces back to sliceA at index 0, the location where she started her adventure. Hence, she stops here. During this journey, she encountered the highest value 3 from sliceB .

Step 1 - Initialization

Before we progress with our code, let's kickstart with the initialization of variables. Determine indexB : This represents Gloria's first landing spot in sliceB . It is determined by the first element in sliceA . This step sets the starting point for tracking Gloria's progress in sliceB . Set indexA : After reaching the first landing in sliceB, the value at this position dictates Gloria's next jump back to sliceA . This ensures continuity in her hopping path. Initialize maxValue : The value at indexB in sliceB serves as the initial maxValue . This setup allows us to monitor the highest value Gloria encounters during her adventure through the slices. Go indexB := sliceA[0] // Gloria's first landing spot in sliceB indexA := sliceB[indexB] // Next position in sliceA based on value found in sliceB at indexB maxValue := sliceB[indexB] // Initial highest value from the starting position in sliceB inSliceA := true // Tracks if Gloria is currently in sliceA

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Step 2 - Slice Hopping

Our assistant for Gloria’s hopping challenge will be a for loop! This keeps iterating until indexA returns to the starting position, which is 0 . Inside the loop, if Gloria is in sliceA, update indexB based on the value in sliceA at her current position and compare it to maxValue . If the value in sliceB at indexB is greater, update maxValue . Otherwise, if she is in sliceB, update indexA based on the value found in sliceB . Additionally, toggle inSliceA to track which slice Gloria is currently on. for indexA != 0 {if inSliceA {indexB = sliceA[indexA] if sliceB[indexB] > maxValue {maxValue = sliceB[indexB]}} else {indexA = sliceB[indexB]} inSliceA = !inSliceA}

Complete Solution

Collecting all the pieces together, along with the final return statement for maxValue, here's our ultimate function: package main import ("fmt") func solution(sliceA, sliceB []int) int {indexB := sliceA[0] indexA := sliceB[indexB] inSliceA := true maxValue := sliceB[indexB] for indexA != 0 {if inSliceA {indexB = sliceA[indexA] if sliceB[indexB] > maxValue {maxValue = sliceB[indexB]}} else {indexA = sliceB[indexB]} inSliceA = !inSliceA} return maxValue} func main() {sliceA := []int{2, 4, 3, 1, 6} sliceB := []int{4, 0, 3, 2, 0} fmt.Println("Maximum value encountered in sliceB:", solution(sliceA, sliceB))}

Go

for indexA != 0 {
    if inSliceA {
        indexB = sliceA[indexA]
        if sliceB[indexB] > maxValue {
            maxValue = sliceB[indexB]
        }
    } else {
        indexA = sliceB[indexB]
    }
    inSliceA = !inSliceA
}

Go

package main

import (
    "fmt"
)

func solution(sliceA, sliceB []int) int {
    indexB := sliceA[0]
    indexA := sliceB[indexB]
    inSliceA := true
    maxValue := sliceB[indexB]
    
    for indexA != 0 {
        if inSliceA {
            indexB = sliceA[indexA]
            if sliceB[indexB] > maxValue {
                maxValue = sliceB[indexB]
            }
        } else {
            indexA = sliceB[indexB]
        }
        inSliceA = !inSliceA
    }
    return maxValue
}

func main() {
    sliceA := []int{2, 4, 3, 1, 6}
    sliceB := []int{4, 0, 3, 2, 0}

    fmt.Println("Maximum value encountered in sliceB:", solution(sliceA, sliceB))
}