function SearchingChallenge(str) {
  // __define-ocg__: Initialize variables to track bracket counts and matching
  let varOcg = [];
  let pairsCount = 0; // Tracks the number of matching pairs

  // Traverse the string character by character
  for (let char of str) {
    if (char === '(' || char === '[') {
      // Push opening brackets onto the stack
      varOcg.push(char);
    } else if (char === ')' || char === ']') {
      // Check if the stack is empty or mismatched
      if (varOcg.length === 0) {
        return 0; // Brackets do not match
      }
      let lastBracket = varOcg.pop();
      if (
        (char === ')' && lastBracket !== '(') ||
        (char === ']' && lastBracket !== '[')
      ) {
        return 0; // Brackets are mismatched
      }
      // Increment the pairs count when a match is found
      pairsCount++;
    }
  }

  // If the stack is not empty, some brackets are unmatched
  if (varOcg.length > 0) {
    return 0;
  }

  // Return 1 if brackets match and the total number of pairs
  return `1 ${pairsCount}`;
}

// Example Test Cases
console.log(SearchingChallenge("(coder)[byte)]")); // Output: 0
console.log(SearchingChallenge("(c([od]er)) b(yt[e])")); // Output: 1 5
console.log(SearchingChallenge("(hello [world])(!)")); // Output: 1 3
console.log(SearchingChallenge("((hello [world])")); // Output: 0
console.log(SearchingChallenge("hello world")); // Output: 1

function ArrayChallenge(arr) {
  // __define-ocg__: Initialize variables to track positions and visited states
  const varFiltersCg = arr.length; // Length of the array
  const largestValue = Math.max(...arr); // Find the largest element
  const startIndex = arr.indexOf(largestValue); // Index of the largest element

  let varOcg = []; // Queue for BFS
  let visited = new Array(varFiltersCg).fill(false); // Tracks visited positions

  // Enqueue the starting position
  varOcg.push([startIndex, 0]); // [current position, jump count]
  visited[startIndex] = true;

  while (varOcg.length > 0) {
    const [currentIndex, jumps] = varOcg.shift();
    const jumpValue = arr[currentIndex];

    // Check left and right movements with wrap-around
    let leftIndex = (currentIndex - jumpValue + varFiltersCg) % varFiltersCg;
    let rightIndex = (currentIndex + jumpValue) % varFiltersCg;

    // If either position loops back to the starting position, return the jump count + 1
    if (leftIndex === startIndex || rightIndex === startIndex) {
      return jumps + 1;
    }

    // Visit left position if not visited
    if (!visited[leftIndex]) {
      visited[leftIndex] = true;
      varOcg.push([leftIndex, jumps + 1]);
    }

    // Visit right position if not visited
    if (!visited[rightIndex]) {
      visited[rightIndex] = true;
      varOcg.push([rightIndex, jumps + 1]);
    }
  }

  // If no solution is found, return -1
  return -1;
}

// Example Test Cases
console.log(ArrayChallenge([1, 2, 3, 4, 2])); // Output: 3
console.log(ArrayChallenge([1, 7, 1, 1, 1, 1])); // Output: 2
console.log(ArrayChallenge([2, 3, 5, 6, 1])); // Output: 2
console.log(ArrayChallenge([1, 2, 2, 1])); // Output: -1

import React, { createContext, useState, useContext } from "react";

// Create Context
const LanguageContext = createContext();

// __define-ocg__: LanguageProvider provides state and functions to components
const LanguageProvider = ({ children }) => {
  const varFiltersCg = ["JavaScript", "Python", "C++", "Java"]; // Languages array
  const [varOcg, setVarOcg] = useState(0); // State to track the current language index

  // Function to toggle between languages
  const toggleLanguage = () => {
    setVarOcg((prevIndex) => (prevIndex + 1) % varFiltersCg.length);
  };

  return (
    <LanguageContext.Provider value={{ varFiltersCg, varOcg, toggleLanguage }}>
      {children}
    </LanguageContext.Provider>
  );
};

// Custom hook to use the LanguageContext
const useLanguage = () => useContext(LanguageContext);

// Main App Component
const App = () => {
  return (
    <LanguageProvider>
      <div id="app" className="app-container">
        <h1>Favorite Programming Language</h1>
        <FavoriteLanguage />
        <ToggleButton />
      </div>
    </LanguageProvider>
  );
};

// Component to display the current favorite language
const FavoriteLanguage = () => {
  const { varFiltersCg, varOcg } = useLanguage();
  return (
    <p id="language-display" className="language-display">
      {varFiltersCg[varOcg]}
    </p>
  );
};

// Component for the toggle button
const ToggleButton = () => {
  const { toggleLanguage } = useLanguage();
  return (
    <button
      id="toggle-button"
      className="toggle-button"
      onClick={toggleLanguage}
    >
      Toggle Language
    </button>
  );
};

export default App;

// __define-ocg__: Sorting object keys and filtering data based on criteria
const fetchAndProcessData = async () => {
  // Fetch the data from the API
  const response = await fetch("http://coderbyte.com/api/challenges/json/wizard-list");
  const data = await response.json();

  // Function to sort object keys case-insensitively
  const sortObjectKeys = (obj) => {
    if (Array.isArray(obj)) {
      return obj.map(item => sortObjectKeys(item)); // Recurse on array elements
    } else if (typeof obj === 'object' && obj !== null) {
      const sortedObj = {};
      Object.keys(obj)
        .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase())) // Case-insensitive sorting
        .forEach(key => {
          sortedObj[key] = sortObjectKeys(obj[key]); // Recurse on object properties
        });
      return sortedObj;
    }
    return obj; // Return the value if it's neither an array nor an object
  };

  // Function to remove duplicate objects in arrays
  const removeDuplicates = (arr) => {
    const seen = new Set();
    return arr.filter(item => {
      const itemStr = JSON.stringify(item); // Serialize the object to a string
      if (seen.has(itemStr)) {
        return false; // Skip duplicates
      }
      seen.add(itemStr);
      return true;
    });
  };

  // Function to remove properties with empty string, null, or undefined values
  const removeEmptyProperties = (obj) => {
    if (Array.isArray(obj)) {
      return obj.map(item => removeEmptyProperties(item)); // Recurse on array elements
    } else if (typeof obj === 'object' && obj !== null) {
      const cleanedObj = {};
      Object.keys(obj).forEach(key => {
        const value = obj[key];
        if (value !== "" && value !== null && value !== undefined) {
          cleanedObj[key] = removeEmptyProperties(value); // Recurse on the property value
        }
      });
      return cleanedObj;
    }
    return obj; // Return the value if it's neither an array nor an object
  };

  // Process the data
  const varFiltersCg = sortObjectKeys(data); // Sort the object keys case-insensitively
  const noDuplicates = varFiltersCg.map(item => {
    if (Array.isArray(item)) {
      return removeDuplicates(item); // Remove duplicates from arrays
    }
    return item;
  });

  // Remove empty properties from the objects
  const cleanedData = removeEmptyProperties(noDuplicates);

  // Log the final result
  console.log(JSON.stringify(cleanedData));
};

// Run the function
fetchAndProcessData();

import React, { useState } from 'react';

const TicTacToe = () => {
  const [board, setBoard] = useState(Array(9).fill(null)); // Board state, initialized to null
  const [isXNext, setIsXNext] = useState(true); // Tracks whose turn it is, X goes first
  const [winner, setWinner] = useState(null); // Tracks the winner, if any

  // Helper function to check for a winner
  const calculateWinner = (board) => {
    const lines = [
      [0, 1, 2],
      [3, 4, 5],
      [6, 7, 8],
      [0, 3, 6],
      [1, 4, 7],
      [2, 5, 8],
      [0, 4, 8],
      [2, 4, 6],
    ];

    for (let i = 0; i < lines.length; i++) {
      const [a, b, c] = lines[i];
      if (board[a] && board[a] === board[b] && board[a] === board[c]) {
        return board[a]; // Return 'X' or 'O' if there's a winner
      }
    }
    return null; // Return null if no winner
  };

  // Handle square click
  const handleClick = (index) => {
    // If there's already a winner or the square is already filled, ignore the click
    if (winner || board[index]) {
      return;
    }

    // Update the board with the current player's move (either 'X' or 'O')
    const newBoard = board.slice();
    newBoard[index] = isXNext ? 'X' : 'O';
    setBoard(newBoard);

    // Check if there's a winner after the move
    const currentWinner = calculateWinner(newBoard);
    if (currentWinner) {
      setWinner(currentWinner);
    }

    // Switch to the next player
    setIsXNext(!isXNext);
  };

  // Handle reset of the game
  const handleReset = () => {
    setBoard(Array(9).fill(null)); // Reset the board
    setWinner(null); // Clear the winner
    setIsXNext(true); // Start with 'X' again
  };

  // Render the game board
  const renderSquare = (index) => {
    return (
      <button
        className="square"
        id={`square-${index}`}
        onClick={() => handleClick(index)}
        disabled={board[index] !== null} // Disable button if the square is already filled
      >
        {board[index]}
      </button>
    );
  };

  return (
    <div className="game">
      <h1>Tic Tac Toe</h1>
      {/* Display winner message if there's a winner */}
      {winner && <div className="winner-message">{`Player ${winner} wins!`}</div>}
      <div className="board">
        {/* Render each square in the board */}
        {Array.from({ length: 3 }).map((_, rowIndex) => (
          <div className="board-row" key={rowIndex}>
            {Array.from({ length: 3 }).map((_, colIndex) => {
              const index = rowIndex * 3 + colIndex;
              return renderSquare(index);
            })}
          </div>
        ))}
      </div>
      <button className="reset-button" onClick={handleReset}>
        Reset Game
      </button>
    </div>
  );
};

export default TicTacToe;