Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class LinearSearchConcept(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Scene title
        # 2. Main equation: MathTex - .shift(UP * 1.5) - Core problem statement
        # 3. Array visualization: Group of Rectangles + Text - .shift(LEFT * 2.5) - Visual array on left
        # 4. Secondary text: Text - .shift(DOWN * 1.5) - Explanation below

        # Elements creation:

        # 1. Title
        title = Text("Linear Search Algorithm").to_edge(UP, buff=0.5).set_color(BLUE)

        # 2. Main equation (problem statement)
        problem_text = MathTex(
            r"\text{Given a list of numbers and a target value,}",
            r" \text{how do we find if the target exists in the list?}"
        ).shift(UP * 1.5).set_color(WHITE)

        # 3. Array visualization on left side
        # Array: [3, 7, 1, 9, 5]
        array_vals = [3, 7, 1, 9, 5]
        rects = VGroup()
        nums = VGroup()
        for i, val in enumerate(array_vals):
            rect = Rectangle(width=1, height=1, stroke_color=WHITE)
            rect.shift(LEFT * 2.5 + RIGHT * i * 1.1)
            rects.add(rect)
            num = MathTex(str(val)).move_to(rect.get_center()).set_color(WHITE)
            nums.add(num)
        array_group = VGroup(rects, nums)

        # Highlighted target value on right side
        target_val = 9
        target_text = MathTex(r"\text{Target} = ", str(target_val)).set_color(RED).shift(RIGHT * 2.5)

        # 4. Secondary text (explanation)
        explanation_1 = Text(
            "Linear search checks each element one by one\n"
            "from the start until it finds the target or reaches the end."
        ).shift(DOWN * 1.5).set_color(WHITE)

        # Animation Sequence:

        # 1. Show title and problem statement
        self.play(Write(title), Write(problem_text), run_time=2)
        # Keep these visible, no fadeout here

        # 2. Show array on left and target on right with explanation below
        self.play(
            FadeIn(array_group),
            FadeIn(target_text),
            FadeIn(explanation_1),
            run_time=2
        )

        # 3. Step-by-step highlight moving through array elements
        # We'll highlight each rectangle with a SurroundingRectangle in YELLOW
        # Highlight each element for 0.8 seconds, fade out highlight before next
        for i, rect in enumerate(rects):
            highlight = SurroundingRectangle(rect, color=YELLOW, buff=0.1)
            self.play(Create(highlight), run_time=0.5)
            # Check if current element is target
            if array_vals[i] == target_val:
                found_text = Text("Target found!", color=GREEN).shift(DOWN * 1.5)
                self.play(Write(found_text), run_time=1)
                self.play(FadeOut(found_text))
                self.play(FadeOut(highlight))
                break
            else:
                self.play(FadeOut(highlight), run_time=0.3)

        # 4. Transition text about inefficiency and setup for next scene
        self.play(
            FadeOut(array_group),
            FadeOut(target_text),
            FadeOut(explanation_1),
            run_time=1
        )
        ineff_text = Text(
            "While linear search is straightforward, it can be inefficient\n"
            "for large lists. Let's understand how it works step-by-step."
        ).shift(DOWN * 1.5).set_color(WHITE)
        self.play(Write(ineff_text), run_time=3)

        # Final cleanup
        self.play(FadeOut(ineff_text), FadeOut(problem_text), FadeOut(title), run_time=1)
```
---

### Explanation of the plan:

**Layout Plan:**

1. Title: `Text("Linear Search Algorithm")` positioned `.to_edge(UP, buff=0.5)` at top edge.
2. Main equation: `MathTex` with problem statement, positioned `.shift(UP * 1.5)` (upper center).
3. Array visualization: 5 rectangles with numbers, grouped and shifted `.shift(LEFT * 2.5)` (left side).
4. Target value label: `MathTex` shifted `.shift(RIGHT * 2.5)` (right side).
5. Secondary text explanations: `Text` shifted `.shift(DOWN * 1.5)` (lower center).

**Animation Sequence:**

1. Write title and problem statement (2s).
2. FadeIn array, target, and explanation (2s).
3. Step progression highlight: SurroundingRectangle in YELLOW moves through each element, with a brief pause on each. On finding target, show "Target found!" in GREEN below, then fade out highlight.
4. Fade out all left/right elements and explanation, then write transition text about inefficiency (3s).
5. Final cleanup fades out all remaining elements.

**Cleanup:**

- Highlights fade out after each step.
- Old explanations fade out before new ones.
- Main equation and title remain visible until the transition text.
- Temporary elements cleared between sections.

**Colors used:** BLUE (title), RED (target label), GREEN (found text), YELLOW (highlight), WHITE (all other text and outlines).

**Positions strictly follow the given rules.**
PATTERN: step_progression

CRITICAL CONSTRAINTS:
1. Use ONLY these objects: Text, MathTex, Axes, Circle, Rectangle, Line, Arrow, Dot, SurroundingRectangle, VGroup
2. Use ONLY these animations: Write, Create, FadeIn, FadeOut 
3. Use ONLY these colors (no quotes): BLUE, RED, GREEN, YELLOW, WHITE, ORANGE, PURPLE
4. NO undefined objects like VideoFile, Slider, ImageMobject
5. NO Unicode characters - use LaTeX: \sqrt{} not √, \pm not ±

POSITIONING REQUIREMENTS (CRITICAL):
- Each element MUST have unique position within screen bounds
- SAFE positions only: .to_edge(UP), .shift(UP*1.5), .shift(DOWN*1.5), .shift(LEFT*2.5), .shift(RIGHT*2.5)
- NO extreme shifts: avoid UP*3, DOWN*3, LEFT*4, RIGHT*4 (goes off-screen)
- NO overlapping: if one element uses .shift(UP*1.5), others must use different positions
- Test positions: Title=top, Main=upper center, Secondary=lower center, Sides=left/right

TEMPLATE TO ADAPT:

        # Title at top
        title = Text("{title}").scale(0.8).to_edge(UP, buff=0.5)
        
        # Step equations positioned vertically
        step1 = MathTex(r"{step1}").shift(UP * 2)
        step2 = MathTex(r"{step2}").shift(UP * 0.5)  
        step3 = MathTex(r"{step3}").shift(DOWN * 1)
        
        # Step labels on the right
        label1 = Text("{label1}").scale(0.5).shift(RIGHT * 4 + UP * 2)
        label2 = Text("{label2}").scale(0.5).shift(RIGHT * 4 + UP * 0.5)
        label3 = Text("{label3}").scale(0.5).shift(RIGHT * 4 + DOWN * 1)
        
        # Progressive revelation
        self.play(Write(title))
        self.wait(1)
        self.play(Write(step1))
        self.wait(1)
        self.play(Write(label1))
        self.wait(1)
        self.play(Write(step2))
        self.wait(1)
        self.play(Write(label2))
        self.wait(1)
        self.play(Write(step3))
        self.wait(1)
        self.play(Write(label3))
        self.wait(2)
                

Replace placeholders with scene-specific values and ensure working Manim code.

Generate complete Python code: