left, right = 0, len(arr) - 1
while left < right:
    total = arr[left] + arr[right]
    if total == target: return [left, right]
    elif total < target: left += 1
    else: right -= 1

Input:  nums = [-1, 0, 1, 2, -1, -4]
Output: [[-1, -1, 2], [-1, 0, 1]]

def threeSum(nums: list[int]) -> list[list[int]]:
    nums.sort()                           # [-4, -1, -1, 0, 1, 2]
    result = []
    
    for i in range(len(nums) - 2):        # fix the first element
        if nums[i] > 0:                   # sorted: if first > 0, no solution
            break
        if i > 0 and nums[i] == nums[i-1]:  # skip duplicates for i
            continue
        
        left, right = i + 1, len(nums) - 1  # two pointers for the rest
        
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            
            if total == 0:
                result.append([nums[i], nums[left], nums[right]])
                # skip duplicates for left and right
                while left < right and nums[left] == nums[left + 1]:
                    left += 1
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                left += 1
                right -= 1
            elif total < 0:
                left += 1   # need larger sum
            else:
                right -= 1  # need smaller sum
    
    return result

# Trace with nums = [-1, 0, 1, 2, -1, -4]:
# After sort: [-4, -1, -1, 0, 1, 2]
# i=0: nums[i]=-4, left=1(-1), right=5(2) → sum=-3 → left++
#       left=2(-1), right=5(2) → sum=-3 → left++
#       left=3(0),  right=5(2) → sum=-2 → left++
#       left=4(1),  right=5(2) → sum=-1 → left++
#       left>=right → stop
# i=1: nums[i]=-1, left=2(-1), right=5(2) → sum=0 ✅ append [-1,-1,2]
#       skip dups → left=3(0), right=4(1) → sum=0 ✅ append [-1,0,1]
#       left>=right → stop
# i=2: nums[i]=-1 == nums[i-1]=-1 → skip (duplicate!)
# i=3: nums[i]=0, left=4(1), right=5(2) → sum=3 → right--
#       left>=right → stop
# Result: [[-1,-1,2], [-1,0,1]] ✅

import { useRef } from 'react'

function VideoPlayer() {
  // Creates { current: null } — persists across renders
  const videoRef = useRef<HTMLVideoElement>(null)
  
  const handlePlay = () => {
    // Direct DOM access — no React state involved
    videoRef.current?.play()
  }
  
  const handleFocus = () => {
    videoRef.current?.focus()
  }
  
  return (
    <div>
      {/* Attach ref to DOM element via ref prop */}
      <video ref={videoRef} src="/demo.mp4" />
      <button onClick={handlePlay}>▶ Play</button>
      <button onClick={handleFocus}>Focus Video</button>
    </div>
  )
}

function RecordingTimer() {
  const [isRecording, setIsRecording] = useState(false)
  
  // Stores timer ID — changing it does NOT cause a re-render
  const timerIdRef = useRef<ReturnType<typeof setInterval> | null>(null)
  
  const startRecording = () => {
    setIsRecording(true)
    timerIdRef.current = setInterval(() => {
      console.log('Recording...')
    }, 1000)
  }
  
  const stopRecording = () => {
    setIsRecording(false)
    if (timerIdRef.current) {
      clearInterval(timerIdRef.current)
      timerIdRef.current = null
    }
  }
  
  return (
    <button onClick={isRecording ? stopRecording : startRecording}>
      {isRecording ? '⏹ Stop' : '⏺ Record'}
    </button>
  )
}

function Counter() {
  const [count, setCount] = useState(0)
  const renderCount = useRef(0)
  
  renderCount.current += 1  // increment on every render
  
  return (
    <div>
      <p>Count: {count}</p>
      <p>Renders: {renderCount.current}</p>
      <button onClick={() => setCount(c => c + 1)}>+1</button>
    </div>
  )
}
// After clicking +1 twice, what does "Renders" show?

// ❌ WRONG: Reading ref value during render to display in UI
function BadComponent() {
  const countRef = useRef(0)
  countRef.current += 1
  
  // BUG: React may batch renders or run effects multiple times
  // This count will be unreliable in React 18 Strict Mode (double-invokes)
  return <p>Rendered {countRef.current} times</p>
}

// ✅ RIGHT: Use useState for values that should be displayed in UI
function GoodComponent() {
  const [renderCount, setRenderCount] = useState(0)
  
  useEffect(() => {
    setRenderCount(c => c + 1)
  })
  
  return <p>Rendered {renderCount} times</p>
}

// ❌ WRONG: Accessing ref.current during render before it's assigned
function BadRef() {
  const inputRef = useRef<HTMLInputElement>(null)
  console.log(inputRef.current?.value)  // null on first render!
  return <input ref={inputRef} />
}

// ✅ RIGHT: Access ref.current inside effects or event handlers
function GoodRef() {
  const inputRef = useRef<HTMLInputElement>(null)
  
  useEffect(() => {
    // ref is assigned after DOM mounts
    console.log(inputRef.current?.value)
  }, [])
  
  return <input ref={inputRef} />
}

# Simplified PPO loop concept:
for prompt in training_prompts:
    response = policy_model.generate(prompt)    # current LLM
    reward = reward_model.score(response)        # RM gives score
    
    # Update policy to maximize reward,
    # but stay close to original (KL divergence penalty)
    loss = -reward + kl_penalty * kl(policy, reference)
    policy_model.update(loss)

# pip install trl transformers torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Simulate a reward model scoring responses
# (In real RLHF, this is trained on human preference data)
def simple_reward_model(response: str) -> float:
    """Score a response based on simple heuristics."""
    score = 0.0
    
    # Reward helpfulness signals
    if len(response) > 50: score += 0.3         # detailed enough
    if "because" in response.lower(): score += 0.2  # gives reasoning
    if "?" not in response: score += 0.1         # not evasive
    
    # Penalize harmful patterns  
    if "i can't help" in response.lower(): score -= 0.5
    if "kill" in response.lower(): score -= 1.0
    
    return score

# Test with example responses
responses = [
    "I can't help with that.",
    "Exercise regularly and maintain a balanced diet because consistent habits lead to sustainable weight loss.",
    "Just eat less."
]

for r in responses:
    print(f"Score: {simple_reward_model(r):.1f} | {r[:50]}...")
# Score: -0.5 | I can't help with that...
# Score:  0.6 | Exercise regularly and maintain a balanced...
# Score:  0.3 | Just eat less...