CompetitiveJava.js

export const competitiveJava = {
  difficulty: 'Intermediate',
  duration: '40 Live Lectures',
  level: 'Level 2',
  link: '/competitive-programming-using-java',
  domain: 'Interview Prepration',
  title: 'Competitive Programming using Java',
  upcoming: 'April 15th',
  language: 'Hindi',
  mentors: ['anuj', 'kunal', 'ekta'],
  default: 0,
  schedule: [
    {
      courseId: 'jcomp0121',
      dates: '15th Apr - 18th July',
      days: 'Sat, Sun, Wed, Fri',
      timing: '09:00 PM - 11:00 PM (IST)',
      link: '',
      priceCut: '₹ 12,000',
      price: '₹ 5,850',
      priceId: 'price_1I0Uz4LVU3L7vcSrx3vOaUdv',
      duration: '40 Live Lectures',
      active: true
    }
  ],
  projects: [
    {
      title: 'Automatic Sudoku Solver',
      img: '/static/images/courses/projects/sudoku.jpg'
    },
    {
      title: 'File Encryption and Compression',
      img: '/static/images/courses/projects/security.jpg'
    },
    {
      title: 'Splitwise Cashflow Minimization',
      img: '/static/images/courses/projects/split.png'
    },
    {
      title: 'Search routes like Google Maps',
      img: '/static/images/courses/projects/maps.png'
    },
    {
      title: 'Git Version Control Replica',
      img: '/static/images/courses/projects/git.png'
    }
  ],
  sections: [
    {
      title: 'Advance Competetive Algorithms',
      classes: 'Classes 01-20',
      topics: [
        {
          title: 'Revisiting Java Collection Framework',
          classes: 'Lectures 1-2',
          subtopics: [
            'In-built Data Structures',
            'Classes, Interfaces and Inheritance',
            'Best practices with Generics and Collections',
            'lurking over recursion problems'
          ]
        },
        {
          title: 'Understanding online platforms: Codeforces & Leetcode',
          classes: 'Lectures 3',
          subtopics: [
            'Start Competitive Programming on Codeforces',
            'Set up IntelliJ idea for Competitive Coding',
            'Create Template to save time in Competitive Coding'
          ]
        },
        {
          title: 'Bit Masking and Manipulation',
          classes: 'Lectures 4-5',
          subtopics: [
            'Get, Set, Clear and Update bits',
            'Fast Exponentiation using Bitmasking',
            'Generate Subsets using Bitmasking',
            'Decimal to Binary using Bitwise',
            'Inclusion Exclusion Concept + Implementation'
          ]
        },
        {
          title: 'Number theory & Computational Theory',
          classes: 'Lectures 6-7',
          subtopics: [
            'Binomial coefficients',
            'Matrix Exponentiation',
            'Catalan Series',
            'Fibonacci & other series facts',
            'Prime factorization',
            'Pigeonhole Principle',
            'Extended Euclids Algorithms',
            'Willsons Theorem',
            'Pollards rho Theorem'
          ]
        },
        {
          title: 'Divide & Conquer Algorithms',
          classes: 'Lectures 8',
          subtopics: [
            'Randomized Binary Search',
            'Merge sort & Quick sort',
            'Second largest element',
            'Painter partition problem',
            'Aggressive Cows',
            'Tilling problem'
          ]
        },
        {
          title: 'Recursion & Backtracking',
          classes: 'Lectures 10-12',
          subtopics: [
            'Recursive tree, Stack trace',
            'Generate all passwords from given character set',
            'Lockdown Game',
            'Its confidential problem',
            'Sudoku solver',
            'Optimal BST problem',
            'Subset sum',
            'M coloring problem',
            'Lexical permutation',
            'N-Queens & N-Knights'
          ]
        },
        {
          title: 'Dynamic Programming',
          classes: 'Lectures 13-15',
          subtopics: [
            'Understanding the concept in Dynamic Programming',
            'Understanding overlapping subproblems',
            'Memoization vs Tabulation',
            'Top down & bottom-up approach',
            '0-1 KnapSack problem',
            'Wildcard pattern problem',
            'Egg drop problem',
            'Matrix chain multiplication',
            'Wildcard Matching',
            'Longest Increasing Subsequence',
            'Maximum Subarray Sum'
          ]
        },
        {
          title: 'Greedy Algorithms',
          classes: 'Lectures 16-17',
          subtopics: [
            'Greedy Algorithm concept &  philosphy',
            'Pirates & Gold coins problem',
            'Activity selection & Job sequencing problem',
            'Policemen catch thieves',
            'Efficient Huffman encoding & decoding',
            'Assign mice to holes',
            'Minimum Spanning Tree',
            'Memory Management Algorithms'
          ]
        }
      ]
    },
    {
      title: 'Advanced non-linear data structures',
      classes: 'Classes 21-40',
      topics: [
        {
          title: 'Binary Tree',
          classes: 'Lectures 17-18',
          subtopics: [
            'Implementation of Binary Trees',
            'Tree traversal- inorder, preorder and postorder',
            'Searching Algorithms- DFS and BFS',
            'Calculate- height, depth, diameter of tree',
            'Implementation of Binary Search Tree',
            'AVL Trees & Rotations',
            'Interview problems on BT & BST'
          ]
        },
        {
          title: 'String Matching',
          classes: 'Lectures 19-20',
          subtopics: [
            'String Matching Algorithms',
            'String window problems',
            'String Hashing',
            'Rabin Karp Algorithm',
            'Knuth Morris Pratt Algorithm'
          ]
        },
        {
          title: 'Tries',
          classes: 'Lectures 21-22',
          subtopics: [
            'Trie as a Data Structure',
            'Implementation',
            'Max XOR pair',
            'Library Bookmarks',
            'Range XOR',
            'Trie Interview problem'
          ]
        },
        {
          title: 'Segment Tree',
          classes: 'Lectures 22-23',
          subtopics: [
            'Segment Tree: structure & concepts',
            'Build & update implementation',
            'Lazy Propagation',
            'Persistent Segment Tree',
            'XOR Sum problem',
            'Xenia & Bit operations[Codeforces]',
            'Alpha & his arrays',
            'Greatest common divisor',
            'Distinct Integers in range'
          ]
        },
        {
          title: 'Fenwick Tree',
          classes: 'Lectures 24-25',
          subtopics: [
            'Fenwick Tree concept',
            'Build & update implementation',
            'Range Sum query',
            'Inversion count',
            '2D Binary Indexed Tree',
            'No. of elements greater than K in [L,R] range',
            'Range Queries problems'
          ]
        },
        {
          title: 'Graphs',
          classes: 'Lectures 26-27',
          subtopics: [
            'Terminologies in Graph',
            'EdgeList implementation',
            'AdjacencyList implementation',
            'AdjacencyMap implementation',
            'Searching Algorithms- DFS and BFS',
            'Connected component, Cycle detection',
            'Bipartite Graph',
            "Kruskal's, Dijkstra's, Prim's Algorithms",
            "Kosaraju's Algorithm",
            'Dynamic Programming with Graphs'
          ]
        },
        {
          title: 'Advanced Mathematics',
          classes: 'Lectures 28-29',
          subtopics: [
            'Fast Fourier transform concepts',
            'FFT Implementation',
            'Discrete Fourier transform',
            'Inverse FFT',
            'Square Root Decompositions',
            'Segmented Sieve',
            'Modulo inverse',
            'Lucas Theorem'
          ]
        },
        {
          title: 'Game Theory',
          classes: 'Lectures 30',
          subtopics: [
            'Concept around Game theory',
            'Combinational Game theory',
            'Game of chocolates',
            'Robot problems'
          ]
        }
      ]
    }
  ],

  slides: [
    {
      heading: '',
      subheading: '',
      image: '/static/swipes/comp.png'
    }
  ],
  tags: [
    'Dynamic Programming',
    'Tree',
    'Graph',
    'Bitwise',
    'Pigeonhole Principle',
    'Number Theory',
    'Segment Tree',
    'Fenwick Tree',
    'Decompositions'
  ],
  overview: [
    'During the course, you’ll learn everything needed to participate in real competitions — that’s the main goal. Along the way you’ll also gain useful skills for which competitive programmers are so highly valued by employers: ability to write efficient, reliable, and compact code, manage your time well when it’s limited, apply basic algorithmic ideas to real problems, etc.',
    'We start from the very beginning by teaching you what competitions there are, what are their rules, what specifics problems have, how to read problem statements, how to organize your work, and what you should and shouldn’t do. So it’s fine if you’ve never taken part in programming competitions before.'
  ],
  faqs: [
    {
      title: 'Will this help me with my career path?',
      answer:
        'Yes. If you learn well, all that the course intends to teach, you’ll be able to impress quite a few interviewers across quite a few fine companies.'
    },
    {
      title: 'How your doubts will get resolved?',
      answer:
        'We have an army of TA’s who are available in different time slots to resolve all your doubts. You can also interact with faculty through Slack.'
    },
    {
      title: 'Is this course suitable for me?',
      answer:
        'Definitely! If you want to shift to software developer career path, then this course is perfect for you!'
    }
  ]
};