awesome-repositories.com
Blog
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoAcerca deCómo clasificamosPrensaServidor MCP
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
gyoogle avatar

gyoogle/tech-interview-for-developer

0
View on GitHub↗
17,417 estrellas·3,732 forks·Java·MIT·9 vistasgyoogle.dev↗

Tech Interview For Developer

This project is a comprehensive technical interview preparation resource and computer science interview guide. It serves as an educational reference for developers to study core software engineering fundamentals and common coding patterns required for employment screenings.

The repository provides detailed guides and references covering data structures and algorithms, networking and security, operating systems, and web development. It specifically focuses on the implementation and complexity analysis of sorting, searching, and graph algorithms.

The material encompasses a wide breadth of computer science domains, including software engineering principles like SOLID and design patterns, language fundamentals across Java, C, and C++, and system architecture. It also covers database design and scaling, concurrency and multithreading, and frontend development lifecycles.

The project is primarily written in Java and is structured as a knowledge base for mastering technical interviews.

Features

  • Computer Science Fundamentals - Reviewing essential knowledge across operating systems, networking, database theory, and computer architecture.
  • Computer Science Interview Guides - A comprehensive collection of technical questions and answers covering core software engineering and computer science fundamentals.
  • Technical Interview Preparation - Studying core computer science concepts and common coding patterns to pass developer employment screenings.
  • Concurrency and Multithreading - Provides comprehensive guides on the execution of concurrent tasks and multithreading fundamentals.

Búsqueda con IA

Explora más repositorios increíbles

Describe lo que necesitas en lenguaje sencillo: la IA clasifica miles de proyectos open-source curados por relevancia.

Start searching with AI
Web Document Parsing - Outlines how lexical and syntactic analysis convert raw web code into structured trees.
  • Hash Data Structures - Provides an implementation for mapping arbitrary data to fixed-length values for constant-time retrieval.
  • Hash Tables - Implements custom hash tables using arrays to map keys to values.
  • Collision Resolution Strategies - Explains how to resolve hash mapping conflicts using chaining and open addressing.
  • Database Indexes - Explains the implementation of B-Trees and Hash Tables to accelerate database retrieval speeds.
  • Source Code Analysis - Provides educational exercises for manually analyzing source code to identify logical errors and standard violations.
  • Algorithm and Data Structure Guides - A guide to implementing and analyzing common sorting, searching, and graph algorithms with a focus on time and space complexity.
  • Browser Architecture Tutorials - Provides educational content explaining how browsers request resources via URIs and render content.
  • Hardware Cache Mapping - Compares direct-mapped, fully associative, and set-associative hardware cache structures.
  • Data Structures and Algorithms - Implementing and analyzing the time and space complexity of common sorting, searching, and graph traversal methods.
  • Data Structure Analysis - Provides a pedagogical analysis of performance trade-offs between arrays and linked lists.
  • Data Structure Implementations - Includes educational code examples demonstrating the implementation of linear data structures like linked lists.
  • Queues - Provides implementations of queue structures using linear, circular, and linked lists.
  • Database Normalization Theory - Provides an educational breakdown of database anomalies to explain the necessity of normalization.
  • Depth-First Search Implementations - Details the branch-first traversal and backtracking implementation for graph exploration.
  • Dynamic Programming - Teaches algorithmic strategies for solving complex optimization problems using overlapping subproblems and memoization.
  • Bit Manipulation Algorithms - Covers fundamental bitwise logic operations including AND, OR, XOR, and shift operators.
  • Breadth-First Search - Explains the level-by-level traversal strategy for searching tree and graph data structures.
  • Stack Structures - Provides educational material on the implementation and operation of Last-In-First-Out stack structures.
  • Functional Programming Concepts - The use of pure functions and immutability to implement declarative programming.
  • Technical Primers - A detailed exploration of browser architecture, rendering processes, REST APIs and frontend and backend integration.
  • Networking and Security Guides - An overview of the OSI model, TCP/IP stack, HTTP protocols and common web security vulnerabilities like XSS and CSRF.
  • Operating Systems Reference - A reference for core system concepts including process management, memory allocation, concurrency and file systems.
  • Software Engineering Principles - Applying SOLID design principles, architectural patterns, and agile methodologies to build maintainable software.
  • HTTP Methods - Provides semantic definitions and use cases for standard HTTP request methods.
  • Tree Data Structures - Explains fundamental tree properties and the architectural distinction between trees and graphs.
  • Web Development Fundamentals - Covers foundational web concepts including browser behaviors, session management, and server architectures.
  • Client Side Rendering - Explains the process of generating content and rendering HTML entirely within the user's browser using JSON data.
  • HTTP Status Codes - Provides a categorized reference of standard HTTP response codes and their meanings.
  • Computer Architecture - Provides an overview of the Von Neumann architecture and its sequential processing limitations.
  • RISC Architectures - Analyzes ARM processor architecture and RISC design principles for technical interview preparation.
  • Process and Memory Management - Provides an overview of core OS fundamentals including process management and memory allocation.
  • Binary Search Trees - Provides the core structural properties and operations for binary search trees.
  • Heaps - Implements heap-based structures to enable efficient priority queue operations.
  • Linked Lists - Provides fundamental educational content on the structure and trade-offs of linked lists.
  • Bitsets - Explains the use of bitsets for memory-efficient storage and management of boolean collections.
  • Binary Search Algorithms - Provides the fundamental range-halving search logic for locating values in sorted datasets.
  • Bit Manipulation Techniques - Provides detailed techniques for manipulating data at the individual bit level for interview preparation.
  • Shortest Path Algorithms - Provides algorithms to calculate the most efficient path between nodes in a graph.
  • DOM Construction - Describes the process of transforming HTML tags into a hierarchical tree-like object model.
  • Web Session Management - Compares cookies and sessions for persisting client state across multiple HTTP requests.
  • Concurrency Synchronization Primitives - Implements and explains the use of mutexes and critical sections to synchronize shared resources.
  • Design Patterns - Offers comprehensive analysis of structural, creational, and behavioral design patterns.
  • Dynamic Arrays - Implements resizable array structures with automated memory allocation and capacity management.
  • Priority Queue Operations - Details the processes for inserting and deleting elements within heaps to maintain order.
  • Spring MVC Implementations - Explains how a central dispatcher coordinates requests between handlers and view resolvers in Spring MVC.
  • Principle Implementations - Provides practical implementations of inheritance, polymorphism, and encapsulation for creating modular code.
  • Refactoring Guides - Offers educational resources on structural improvements to code, such as simplifying long functions and large classes.
  • Software Design Principles - Teaches the application of SOLID principles and identifies design smells for decoupled code.
  • Software Engineering Study Guides - A resource for learning SOLID principles, design patterns, agile methodologies and version control workflows for developers.
  • Counting Sorts - Implements frequency-based counting sort algorithms for efficient integer sorting.
  • Heap Sorts - Implements sorting algorithms that utilize binary max-heaps to achieve logarithmic time complexity.
  • Merge Sorts - Implements divide-and-conquer sorting logic that recursively splits and merges sequences.
  • Quick Sorts - Implements quick sort algorithms that partition elements around a pivot for recursive sorting.
  • Radix Sorts - Implements non-comparative sorting that processes individual digits or bits for integers and strings.
  • Tree Traversal Algorithms - Implements pre-order, in-order, post-order, and level-order tree traversal sequences.
  • Trie Data Structures - Explains the use of tree-based structures for prefix-based string storage and retrieval.
  • Test-Driven Development Resources - Includes structured guides and materials on the Test-Driven Development methodology of writing tests before implementation.
  • Browser Rendering Pipelines - Details the sequence of parsing HTML/CSS, constructing DOM/Render Trees, and painting.
  • Fundamentals - Exploring browser rendering engines, HTTP protocols, REST APIs, and the differences between client-side and server-side rendering.
  • Server-Side Rendering - Explains generating static pages on the server before sending them to the client to improve load speed.
  • Density-Based Clustering - Details clustering methods that group data points based on local density reachability.
  • Memory Allocation Strategies - Details the allocation of main memory using continuous and non-continuous methods, including paging.
  • Clean Code Foundations - Provides educational principles for writing readable, maintainable, and clean code.
  • Public Key Cryptography - Explains the cryptographic handshake process involving public keys and certificates in HTTPS.
  • Cycle Management - Details the execution of Scrum cycles through product backlogs, sprints, and meetings.
  • Team Synchronization Rituals - Describes the use of daily standups and retrospectives to synchronize agile teams.
  • Lazy Evaluation Techniques - The use of lazy evaluations and internal iterations to filter and aggregate data sequences.
  • Data Sharding - Describes strategies for partitioning large datasets into smaller shards to distribute load and improve scalability.
  • Database Normalization - Explains the formal process of organizing database tables to reduce redundancy and improve data integrity.
  • Database Object Synchronizations - Describes the process of detecting changes in managed objects and synchronizing them with the database.
  • Database Query Joins - Details methods for retrieving records from multiple tables using various relational join types.
  • Database Replication Strategies - Explains the architectural pattern of splitting database operations into primary and secondary roles for read traffic distribution.
  • Primary Keys - Provides educational content on defining primary and candidate keys for unique tuple identification in databases.
  • Entity CRUD Management - Explains how to manage database CRUD operations and schema updates by modifying entity classes.
  • Dynamic Resizing Mechanisms - Explains the use of load factors to trigger dynamic bucket expansion and rehashing.
  • Stateless Web Scaling - Describes removing session state from application servers to enable horizontal scaling via shared databases.
  • In-Memory Caches - Covers the use of memory-based stores to accelerate access to frequently used data.
  • In-Memory Databases - Provides an overview of Redis and its use of main memory for low-latency data storage.
  • Object-Relational Mapping - Covers the mapping of programming language objects to database tables to enable SQL-free data manipulation.
  • Query Caching Strategies - Explains mechanisms for storing and retrieving database query results to reduce latency and server load.
  • B-Tree - Analyzes the B-Tree structure to optimize random and sequential data access.
  • Stored Procedures - Explains how to group complex SQL queries into reusable server-side stored procedures.
  • Transaction Management - Covers mechanisms for managing transaction isolation levels and shared locks to balance concurrency and integrity.
  • Transaction Recovery Logs - Explains how UNDO and REDO logs are used to restore data integrity during transaction failures.
  • Commit Standards - Provides standards for formatting commit messages to ensure a consistent and readable project history.
  • Compilation Sequence Analysis - An explanation of the preprocessing, compiling, assembling, and linking sequence.
  • Iterative Frameworks - Guides the application of iterative development focusing on collaboration and flexible responses.
  • CI Workflow Automations - Provides guidelines for integrating automated test suites into continuous integration pipelines.
  • Version Control and Management - Covers the use of commit conventions and collaboration flows for managing shared version control repositories.
  • Cache Optimization Studies - Provides educational content on hardware-level cache optimization techniques and the principle of locality.
  • Cache Performance Analysis - Provides a detailed study of cache miss causes and the performance trade-offs regarding cache size and speed.
  • Competitive Programming Problems - Provides solutions for complex array rotation and weighted sum calculations typical of technical interviews.
  • Database Architecture Comparisons - Analyzes the trade-offs between relational and non-relational systems regarding schema flexibility and performance.
  • Database Selection Strategies - Provides a decision process for selecting relational or non-relational stores based on data volatility.
  • Database Transaction Principles - Offers educational resources explaining the fundamental ACID properties and principles of database transactions.
  • File System Fundamentals - Covers foundational concepts of data storage management, file operations, and metadata for developers.
  • Inter-Thread Coordination - Explains the coordination of threads through lock release and notification mechanisms.
  • Language Specifications - Comparing memory management, concurrency models, and syntax specifics across Java, C, C++, and JavaScript.
  • Lock Reentrancy Concepts - Explains the mechanism of lock reentrancy and its application in synchronized block execution.
  • Locking Mechanism Comparisons - Provides a comparative analysis of structured locks versus explicit reentrant locks.
  • Memory Visibility Theory - Explains the fundamental concepts of memory visibility in multithreaded environments and the role of locks.
  • Mutual Exclusion Algorithms - Implements and explains Dekker, Peterson, and Bakery algorithms to ensure single-process critical section execution.
  • Numerical Representation Theory - Explains the theoretical differences and precision trade-offs between fixed-point and floating-point numerical representations.
  • Process and Threading Models - Analyzes the stability and overhead trade-offs between multi-processing and multi-threading models.
  • Distributed Database Scaling - Compares vertical scaling for performance against horizontal scaling for distribution within a system design context.
  • System Programming Concepts - Provides educational explanations of deadlock concepts and the four necessary conditions for their occurrence.
  • Thread State Management - Covers the management of thread states and execution flow using fundamental synchronization methods.
  • TLS Handshake Tutorials - Provides educational resources explaining how clients and servers establish secure TLS/SSL connections.
  • UDP Protocol Fundamentals - Provides detailed explanations of the connectionless nature and speed advantages of UDP for technical interview preparation.
  • Network Protocols - Provides analysis of network protocols, including File Transfer Protocol and its secure alternatives.
  • Protocol Comparisons - Compares reliable connection-oriented transmission with fast unreliable datagram protocols.
  • Error Detection Codes - Implements redundant bit techniques to detect data corruption during transmission.
  • DNS Resolution - Analyzes DNS resolution logic, including the use of UDP for small requests and TCP for larger payloads.
  • Network Flow Control - Describes the synchronization of data transmission speeds using sliding window mechanisms.
  • Congestion Controllers - Explains network congestion control algorithms such as Slow Start and Fast Recovery.
  • TCP Connection Lifecycles - Analyzes the packet sequence for TCP connection establishment and termination handshakes.
  • Traffic Distribution - Explains algorithms for distributing network traffic across multiple servers to prevent overloading.
  • Cross-Data Center Routing - Explains the routing of users to the nearest operational data center and traffic redirection during outages.
  • UDP Protocol Analysis - Describes the UDP header structure, including ports, length, and checksum fields.
  • CPU Architectures - An explanation of the internal components and operational cycle of a central processing unit.
  • Deadlock Prevention and Avoidance - Covers strategies to prevent deadlocks by breaking necessary conditions or using avoidance algorithms.
  • Hardware Bus Architectures - An explanation of how data, address, and control buses facilitate communication between hardware components.
  • Interrupt Handling - Explains how the system pauses tasks to execute priority service routines in response to hardware signals.
  • Paging and Context Switching - Explains the mechanism for saving and restoring process states to switch between tasks within a kernel.
  • Dynamic Memory Allocation - The allocation and initialization of heap memory during runtime and its subsequent release.
  • Heap Allocation Strategies - The allocation and initialization of memory in the heap during runtime to prevent leaks.
  • Process Lifecycle Managers - Explains the coordination of multiple processes using metadata and scheduling to maintain efficiency.
  • Process Address Space Analysis - Analyzes the division of memory into code, data, and stack segments to optimize resource sharing.
  • Kernel Deadlock Detection - Discusses detecting deadlocks via allocation graphs and recovering by terminating processes.
  • Page Replacement Algorithms - Explains strategies for selecting victim pages for eviction when memory is full, such as LRU.
  • Synchronization Primitives - Explains the use of low-level synchronization primitives like semaphores and mutexes to restrict shared resource access.
  • File System Access Patterns - Compares sequential, direct, and indexed file access patterns and their respective use cases.
  • Directory Operations - Explains the organization of files through directory structures, including links and cycles.
  • Virtual Memory Management - Covers system-level virtual memory and swap space allocation for handling page faults.
  • Asynchronous Programming Patterns - The handling of tasks using promises and async/await patterns to avoid nested callbacks.
  • Destructuring Assignments - Describes the syntax for unpacking values from arrays or objects into variables.
  • Constant String Referencing - Covers technical details of string literal referencing and memory optimization via constant pools.
  • I/O Optimizations - Describes reducing execution time for C++ standard streams by disabling synchronization.
  • String Data Types - Discusses the implementation and trade-offs between mutable and immutable string data types.
  • Language Memory Specifications - Documentation of memory management and compilation processes for Java, C, and C++.
  • Object Literal Enhancements - Covers shorthand syntax for methods, property values, and computed property names in object literals.
  • Primitive Type Conversion - Explains boxing and unboxing for conversion between primitive types and wrapper classes.
  • Prototype-Based Inheritance - Explains how prototype-based inheritance works through property and method delegation chains.
  • Longest Increasing Subsequence Calculations - Implements algorithms for calculating the maximum length of a strictly increasing subsequence.
  • Runtime Memory Partitioning - Provides an analysis of how memory is partitioned into regions like the heap and stack.
  • Bytecode Generation - The transformation of source code into bytecode for execution by a virtual machine.
  • Template Literals - Explains the use of backticks for embedding expressions directly into strings.
  • Type Conversion and Casting - Covers implicit upcasting and explicit downcasting between different data types.
  • Variable Scope Controls - Discusses the difference between block-scoped and function-scoped declarations to prevent hoisting.
  • Scope Chain Management - Covers the access of variables across local, outer, and global scopes in nested functions.
  • Virtual Functions - Explains the use of virtual keywords to ensure correct derived class method calls via base pointers.
  • Error Correction Codes - Provides methods to identify and reverse flipped bits in a data stream.
  • Structure Analysis - Explains how JSON Web Tokens encode headers and payloads to securely transmit identity claims.
  • Rotation Strategies - Explains the security mechanism of pairing short-lived access tokens with long-lived refresh tokens.
  • API Key Management - Describes systems for issuing and managing unique API keys to maintain independence between services.
  • API Access Restrictions - Implements filter-based mechanisms to enforce role-based access and identity verification for API endpoints.
  • File System Permissions - Explains how to identify owners, groups, and read/write/execute permissions from Linux file system listings.
  • Authorization Flows - Describes standardized protocols for allowing third-party applications to access user data securely.
  • Stateless Verifications - Provides technical guidance on implementing stateless identity verification using signed tokens.
  • Claim Analysis - Discusses the use of registered and private claims to store identity and expiration data within security tokens.
  • OAuth Authentication - Provides an overview of OAuth roles, token types, and the delegated authorization standard.
  • Permission Systems - Describes mechanisms for defining and enforcing access control policies for public and restricted API endpoints.
  • Secure Network Communication - Covers techniques for preventing eavesdropping and tampering through encryption and certificate authentication.
  • Linux Access Control Models - Provides educational content on discretionary, mandatory, and role-based access control models for securing Linux directories.
  • Social Login Integrations - Explains the implementation of authentication flows using social platform providers via popup windows.
  • SQL Injection Prevention - Details the use of prepared statements and input validation to prevent SQL injection attacks.
  • Token-Based Authentication - Covers the implementation of security tokens to verify identity and permissions in distributed systems.
  • User Account Management - Details the processes and security considerations for registering new user accounts.
  • User Authentication Systems - Provides a comprehensive guide on verifying user identities using email and password credentials.
  • Adapter Patterns - Implements the Adapter pattern using wrapper classes to enable compatibility between incompatible interfaces.
  • Closures - Describes how closures maintain access to lexical environments and outer scopes.
  • Closure Bug Prevention - Details methods to prevent common closure bugs in loops using block-scoped declarations.
  • Private Method Emulation - Explains how to hide variables and functions from the global scope using closures.
  • Template Method Patterns - Details the Template Method pattern for defining algorithm skeletons in base classes.
  • Pointer Memory Management - Explains how pointers reference memory addresses to modify variables across function scopes.
  • Code Refactoring Guidelines - Provides guidelines for improving code structure via conditional simplification and data encapsulation.
  • Collaborative Workflows - Discusses the design of commit conventions and branching strategies for effective team collaboration.
  • Common Ancestor Algorithms - Implements the algorithm to find the first shared parent node of two vertices in a tree.
  • Composite Patterns - Implements the Composite pattern to represent object hierarchies and treat individual objects and compositions uniformly.
  • Factory Method Patterns - Provides educational material and implementation examples for Factory Method design patterns.
  • Singleton Patterns - Explains and implements the Singleton pattern to ensure single-instance class restriction.
  • Thread-Safe Implementations - Provides strategies for implementing thread-safe Singletons using techniques like double-checked locking.
  • Design Pattern Implementations - Provides practical code examples and implementations of various structural and behavioral software design patterns.
  • Development Methodologies - Compares predictive, iterative, and agile development methodologies based on requirement handling.
  • Coding Standards - Outlines naming conventions and resource management standards for writing maintainable code.
  • Arrow Function Expressions - Explains the use of arrow functions for concise syntax and lexical this binding.
  • Software Development Lifecycle - Covers theoretical frameworks and task sequences for managing the full software development lifecycle.
  • Manifesto Principles - Analyzes the core principles of the Agile Manifesto, prioritizing individuals and working software.
  • Functional Pipelines - The chaining of intermediate operations like filtering and mapping with a terminal operation.
  • High Availability Patterns - Details architectural strategies for redundancy and load balancing to ensure high availability.
  • Microservices Architectures - Covers the decomposition of applications into independent, scalable service units to avoid monolithic architectures.
  • Network Layering Concepts - Details the roles and functions of the OSI network layers from physical to application.
  • Observer Patterns - Implements the Observer pattern to demonstrate one-to-many dependency and notification systems.
  • Optional Value Types - Discusses using optional types to represent absent values and prevent null-pointer errors.
  • Standardized Metadata Templates - Details the use of markdown templates for issues and pull requests to standardize team communication.
  • Project Progress Tracking - Explains how to use visual tools like burn down charts to track project progress against estimates.
  • Requirement Tracking Tools - Describes the use of issue tracking to define and manage project requirements and goals.
  • Software Development Processes - Describes the organization of development processes using Scrum roles, backlogs, and sprints.
  • Composition Over Inheritance - Explains the design principle of favoring object composition over inheritance for flexibility.
  • SOLID Principles - Provides guidance on using SOLID principles to build maintainable class hierarchies.
  • Kernel Schedulers - Details kernel-level process scheduling algorithms using preemptive and non-preemptive methods.
  • Automated Test Suites - Provides guides on writing and running automated test suites to verify functional requirements.
  • Code Quality and Review - Discusses improving software quality through static analysis and iterative test refinement.
  • Unit Testing - Includes implementation guides for writing automated unit tests to verify API endpoints.
  • Effect Synchronization - The execution of logic or synchronization tasks after a component renders or dependencies update.
  • Component Lifecycle Management - The execution of logic during specific stages from initial creation to final destruction.
  • Fullstack Integrations - The connection of a React frontend to a Spring Boot backend using Webpack for bundling.
  • Frontend Development Guides - Conceptual knowledge and implementation guides for modern JavaScript libraries and their lifecycles.
  • Component State Management - The tracking and updating of dynamic data within components to trigger UI re-renders.
  • Progressive Web Apps - Reviews Progressive Web App architecture, including responsive design and offline functionality via service workers.
  • Reactivity Patterns - A comparison of computed properties for derived state against watchers for asynchronous operations.
  • Identity Provider Integration - Explains the integration of external identity providers for user authentication and sign-up.
  • Search Engine Optimization - The provision of server-side rendered content to ensure single-page applications are discoverable.
  • Server-Side Rendered SEO - Analyzes how server-side rendering improves search engine visibility and initial load times.

    • Historial de estrellas

    Gráfico del historial de estrellas de gyoogle/tech-interview-for-developerGráfico del historial de estrellas de gyoogle/tech-interview-for-developer

    Preguntas frecuentes

    ¿Qué hace gyoogle/tech-interview-for-developer?

    This project is a comprehensive technical interview preparation resource and computer science interview guide. It serves as an educational reference for developers to study core software engineering fundamentals and common coding patterns required for employment screenings.

    ¿Cuáles son las características principales de gyoogle/tech-interview-for-developer?

    Las características principales de gyoogle/tech-interview-for-developer son: Computer Science Fundamentals, Computer Science Interview Guides, Technical Interview Preparation, Concurrency and Multithreading, Web Document Parsing, Hash Data Structures, Hash Tables, Collision Resolution Strategies.

    ¿Qué alternativas de código abierto existen para gyoogle/tech-interview-for-developer?

    Las alternativas de código abierto para gyoogle/tech-interview-for-developer incluyen: chefyuan/algorithm-base — algorithm-base is an educational library and study guide designed for simulating algorithms and studying data… oi-wiki/oi-wiki — This project is a comprehensive, community-maintained knowledge base and toolkit designed for competitive programming.… junh0328/prepare_frontend_interview — This project is a comprehensive technical interview study resource designed to help developers prepare for engineering… greyireland/algorithm-pattern — This project is an algorithm template library and coding interview study guide providing reusable code patterns for… hit-alibaba/interview — This project is a comprehensive technical interview preparation guide and computer science knowledge base. It serves… geekxh/hello-algorithm — This project is a comprehensive technical knowledge base and study guide focused on data structures, algorithms, and…

    Alternativas open-source a Tech Interview For Developer

    Proyectos open-source similares, clasificados según cuántas características comparten con Tech Interview For Developer.
    • chefyuan/algorithm-baseAvatar de chefyuan

      chefyuan/algorithm-base

      10,702Ver en GitHub↗

      algorithm-base is an educational library and study guide designed for simulating algorithms and studying data structures. It functions as an execution visualizer that renders step-by-step state changes and pointer updates through animated simulations to illustrate how data movement works. The project distinguishes itself by mapping conceptual logic directly to multi-language source code implementations. It utilizes a comparative analysis framework to evaluate different algorithmic strategies based on stability, time complexity, and space complexity, while organizing problems by underlying mec

      algorithmsbaseinterview-practice
      Ver en GitHub↗10,702
    • oi-wiki/oi-wikiAvatar de OI-wiki

      OI-wiki/OI-wiki

      26,176Ver en GitHub↗

      This project is a comprehensive, community-maintained knowledge base and toolkit designed for competitive programming. It serves as a centralized repository for algorithmic theory, data structures, and mathematical techniques, providing a structured reference for informatics and collegiate programming competitions. The project distinguishes itself by integrating educational content with a robust suite of automation utilities. It provides a complete workflow for competitive programming, including tools for automated test case generation, solution verification, and direct interaction with onlin

      TypeScriptacm-icpcacm-icpc-handbookalgorithms
      Ver en GitHub↗26,176
    • junh0328/prepare_frontend_interviewAvatar de junh0328

      junh0328/prepare_frontend_interview

      1,725Ver en GitHub↗

      This project is a comprehensive technical interview study resource designed to help developers prepare for engineering job assessments. It functions as a structured guide that curates essential computer science fundamentals, web development standards, and programming language concepts into a format optimized for professional evaluation. The repository distinguishes itself by providing strategic guidance on architectural decision-making and professional communication. Beyond simple question-and-answer pairs, it offers frameworks for articulating experience during interviews and suggests profes

      JavaScriptfrontendhandbook
      Ver en GitHub↗1,725
  • greyireland/algorithm-patternAvatar de greyireland

    greyireland/algorithm-pattern

    15,465Ver en GitHub↗

    This project is an algorithm template library and coding interview study guide providing reusable code patterns for common data structures and algorithms. It serves as a reference for optimized strategies and a structured learning path to build proficiency in algorithmic problem solving and competitive programming. The library focuses on standardized implementations of key algorithmic patterns, including sliding windows, backtracking, dynamic programming, and binary search. It provides specific templates for managing binary search trees, searching rotated sorted arrays, and executing divide-a

    Goalgoalgorithmleetcode
    Ver en GitHub↗15,465
    • Ver las 30 alternativas a Tech Interview For Developer→