diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml deleted file mode 100644 index f344b865..00000000 --- a/.github/FUNDING.yml +++ /dev/null @@ -1,12 +0,0 @@ -# These are supported funding model platforms - -github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2] -patreon: rampatra # Replace with a single Patreon username -open_collective: jbot # Replace with a single Open Collective username -ko_fi: # Replace with a single Ko-fi username -tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel -community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry -liberapay: # Replace with a single Liberapay username -issuehunt: # Replace with a single IssueHunt username -otechie: # Replace with a single Otechie username -custom: https://www.paypal.me/ramswaroop # Replace with a single custom sponsorship URL diff --git a/.gitignore b/.gitignore index 236a7c71..b9284dea 100644 --- a/.gitignore +++ b/.gitignore @@ -1,53 +1,105 @@ -# Do not version control these files +# Created by .ignore support plugin (hsz.mobi) +### Java template *.class -*.log -*.ctxt + +# Mobile Tools for Java (J2ME) .mtj.tmp/ + +# Package Files # *.jar *.war -*.nar *.ear -*.zip -*.tar.gz -*.rar + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* -.DS_Store -.AppleDouble -.LSOverride -Icon -._* -.DocumentRevisions-V100 -.fseventsd -.Spotlight-V100 -.TemporaryItems -.Trashes -.VolumeIcon.icns -.com.apple.timemachine.donotpresent -.AppleDB -.AppleDesktop -Network Trash Folder -Temporary Items -.apdisk + + +### JetBrains template +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm + +*.iml + +## Directory-based project format: .idea/ -cmake-build-debug/ -cmake-build-release/ +# if you remove the above rule, at least ignore the following: + +# User-specific stuff: +# .idea/workspace.xml +# .idea/tasks.xml +# .idea/dictionaries + +# Sensitive or high-churn files: +# .idea/dataSources.ids +# .idea/dataSources.xml +# .idea/sqlDataSources.xml +# .idea/dynamic.xml +# .idea/uiDesigner.xml + +# Gradle: +# .idea/gradle.xml +# .idea/libraries + +# Mongo Explorer plugin: +# .idea/mongoSettings.xml + +## File-based project format: +*.ipr *.iws -*.iml + +## Plugin-specific files: + +# IntelliJ out/ + +# mpeltonen/sbt-idea plugin .idea_modules/ + +# JIRA plugin atlassian-ide-plugin.xml + +# Crashlytics plugin (for Android Studio and IntelliJ) com_crashlytics_export_strings.xml crashlytics.properties crashlytics-build.properties -fabric.properties -target/ -pom.xml.tag -pom.xml.releaseBackup -pom.xml.versionsBackup -pom.xml.next -release.properties -dependency-reduced-pom.xml -buildNumber.properties -.mvn/timing.properties -!/.mvn/wrapper/maven-wrapper.jar -*_Practice.java + + + +### Eclipse template +*.pydevproject +.metadata +.gradle +bin/ +tmp/ +*.tmp +*.bak +*.swp +*~.nib +local.properties +.settings/ +.loadpath + +# Eclipse Core +.project + +# External tool builders +.externalToolBuilders/ + +# Locally stored "Eclipse launch configurations" +*.launch + +# CDT-specific +.cproject + +# JDT-specific (Eclipse Java Development Tools) +.classpath + +# PDT-specific +.buildpath + +# sbteclipse plugin +.target + +# TeXlipse plugin +.texlipse + + diff --git a/LICENSE b/LICENSE index f288702d..cf421538 100644 --- a/LICENSE +++ b/LICENSE @@ -1,674 +1,22 @@ - GNU GENERAL PUBLIC LICENSE - Version 3, 29 June 2007 +The MIT License (MIT) - Copyright (C) 2007 Free Software Foundation, Inc. - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. +Copyright (c) 2015 Ram swaroop - Preamble +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: - The GNU General Public License is a free, copyleft license for -software and other kinds of works. +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. - The licenses for most software and other practical works are designed -to take away your freedom to share and change the works. By contrast, -the GNU General Public License is intended to guarantee your freedom to -share and change all versions of a program--to make sure it remains free -software for all its users. We, the Free Software Foundation, use the -GNU General Public License for most of our software; it applies also to -any other work released this way by its authors. You can apply it to -your programs, too. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -them if you wish), that you receive source code or can get it if you -want it, that you can change the software or use pieces of it in new -free programs, and that you know you can do these things. - - To protect your rights, we need to prevent others from denying you -these rights or asking you to surrender the rights. Therefore, you have -certain responsibilities if you distribute copies of the software, or if -you modify it: responsibilities to respect the freedom of others. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must pass on to the recipients the same -freedoms that you received. You must make sure that they, too, receive -or can get the source code. And you must show them these terms so they -know their rights. - - Developers that use the GNU GPL protect your rights with two steps: -(1) assert copyright on the software, and (2) offer you this License -giving you legal permission to copy, distribute and/or modify it. - - For the developers' and authors' protection, the GPL clearly explains -that there is no warranty for this free software. For both users' and -authors' sake, the GPL requires that modified versions be marked as -changed, so that their problems will not be attributed erroneously to -authors of previous versions. - - Some devices are designed to deny users access to install or run -modified versions of the software inside them, although the manufacturer -can do so. This is fundamentally incompatible with the aim of -protecting users' freedom to change the software. The systematic -pattern of such abuse occurs in the area of products for individuals to -use, which is precisely where it is most unacceptable. Therefore, we -have designed this version of the GPL to prohibit the practice for those -products. If such problems arise substantially in other domains, we -stand ready to extend this provision to those domains in future versions -of the GPL, as needed to protect the freedom of users. - - Finally, every program is threatened constantly by software patents. -States should not allow patents to restrict development and use of -software on general-purpose computers, but in those that do, we wish to -avoid the special danger that patents applied to a free program could -make it effectively proprietary. To prevent this, the GPL assures that -patents cannot be used to render the program non-free. - - The precise terms and conditions for copying, distribution and -modification follow. - - TERMS AND CONDITIONS - - 0. Definitions. - - "This License" refers to version 3 of the GNU General Public License. - - "Copyright" also means copyright-like laws that apply to other kinds of -works, such as semiconductor masks. - - "The Program" refers to any copyrightable work licensed under this -License. Each licensee is addressed as "you". "Licensees" and -"recipients" may be individuals or organizations. - - To "modify" a work means to copy from or adapt all or part of the work -in a fashion requiring copyright permission, other than the making of an -exact copy. The resulting work is called a "modified version" of the -earlier work or a work "based on" the earlier work. - - A "covered work" means either the unmodified Program or a work based -on the Program. - - To "propagate" a work means to do anything with it that, without -permission, would make you directly or secondarily liable for -infringement under applicable copyright law, except executing it on a -computer or modifying a private copy. Propagation includes copying, -distribution (with or without modification), making available to the -public, and in some countries other activities as well. - - To "convey" a work means any kind of propagation that enables other -parties to make or receive copies. Mere interaction with a user through -a computer network, with no transfer of a copy, is not conveying. - - An interactive user interface displays "Appropriate Legal Notices" -to the extent that it includes a convenient and prominently visible -feature that (1) displays an appropriate copyright notice, and (2) -tells the user that there is no warranty for the work (except to the -extent that warranties are provided), that licensees may convey the -work under this License, and how to view a copy of this License. If -the interface presents a list of user commands or options, such as a -menu, a prominent item in the list meets this criterion. - - 1. Source Code. - - The "source code" for a work means the preferred form of the work -for making modifications to it. "Object code" means any non-source -form of a work. - - A "Standard Interface" means an interface that either is an official -standard defined by a recognized standards body, or, in the case of -interfaces specified for a particular programming language, one that -is widely used among developers working in that language. - - The "System Libraries" of an executable work include anything, other -than the work as a whole, that (a) is included in the normal form of -packaging a Major Component, but which is not part of that Major -Component, and (b) serves only to enable use of the work with that -Major Component, or to implement a Standard Interface for which an -implementation is available to the public in source code form. A -"Major Component", in this context, means a major essential component -(kernel, window system, and so on) of the specific operating system -(if any) on which the executable work runs, or a compiler used to -produce the work, or an object code interpreter used to run it. - - The "Corresponding Source" for a work in object code form means all -the source code needed to generate, install, and (for an executable -work) run the object code and to modify the work, including scripts to -control those activities. However, it does not include the work's -System Libraries, or general-purpose tools or generally available free -programs which are used unmodified in performing those activities but -which are not part of the work. For example, Corresponding Source -includes interface definition files associated with source files for -the work, and the source code for shared libraries and dynamically -linked subprograms that the work is specifically designed to require, -such as by intimate data communication or control flow between those -subprograms and other parts of the work. - - The Corresponding Source need not include anything that users -can regenerate automatically from other parts of the Corresponding -Source. - - The Corresponding Source for a work in source code form is that -same work. - - 2. Basic Permissions. - - All rights granted under this License are granted for the term of -copyright on the Program, and are irrevocable provided the stated -conditions are met. This License explicitly affirms your unlimited -permission to run the unmodified Program. The output from running a -covered work is covered by this License only if the output, given its -content, constitutes a covered work. This License acknowledges your -rights of fair use or other equivalent, as provided by copyright law. - - You may make, run and propagate covered works that you do not -convey, without conditions so long as your license otherwise remains -in force. You may convey covered works to others for the sole purpose -of having them make modifications exclusively for you, or provide you -with facilities for running those works, provided that you comply with -the terms of this License in conveying all material for which you do -not control copyright. Those thus making or running the covered works -for you must do so exclusively on your behalf, under your direction -and control, on terms that prohibit them from making any copies of -your copyrighted material outside their relationship with you. - - Conveying under any other circumstances is permitted solely under -the conditions stated below. Sublicensing is not allowed; section 10 -makes it unnecessary. - - 3. Protecting Users' Legal Rights From Anti-Circumvention Law. - - No covered work shall be deemed part of an effective technological -measure under any applicable law fulfilling obligations under article -11 of the WIPO copyright treaty adopted on 20 December 1996, or -similar laws prohibiting or restricting circumvention of such -measures. - - When you convey a covered work, you waive any legal power to forbid -circumvention of technological measures to the extent such circumvention -is effected by exercising rights under this License with respect to -the covered work, and you disclaim any intention to limit operation or -modification of the work as a means of enforcing, against the work's -users, your or third parties' legal rights to forbid circumvention of -technological measures. - - 4. Conveying Verbatim Copies. - - You may convey verbatim copies of the Program's source code as you -receive it, in any medium, provided that you conspicuously and -appropriately publish on each copy an appropriate copyright notice; -keep intact all notices stating that this License and any -non-permissive terms added in accord with section 7 apply to the code; -keep intact all notices of the absence of any warranty; and give all -recipients a copy of this License along with the Program. - - You may charge any price or no price for each copy that you convey, -and you may offer support or warranty protection for a fee. - - 5. Conveying Modified Source Versions. - - You may convey a work based on the Program, or the modifications to -produce it from the Program, in the form of source code under the -terms of section 4, provided that you also meet all of these conditions: - - a) The work must carry prominent notices stating that you modified - it, and giving a relevant date. - - b) The work must carry prominent notices stating that it is - released under this License and any conditions added under section - 7. This requirement modifies the requirement in section 4 to - "keep intact all notices". - - c) You must license the entire work, as a whole, under this - License to anyone who comes into possession of a copy. This - License will therefore apply, along with any applicable section 7 - additional terms, to the whole of the work, and all its parts, - regardless of how they are packaged. This License gives no - permission to license the work in any other way, but it does not - invalidate such permission if you have separately received it. - - d) If the work has interactive user interfaces, each must display - Appropriate Legal Notices; however, if the Program has interactive - interfaces that do not display Appropriate Legal Notices, your - work need not make them do so. - - A compilation of a covered work with other separate and independent -works, which are not by their nature extensions of the covered work, -and which are not combined with it such as to form a larger program, -in or on a volume of a storage or distribution medium, is called an -"aggregate" if the compilation and its resulting copyright are not -used to limit the access or legal rights of the compilation's users -beyond what the individual works permit. Inclusion of a covered work -in an aggregate does not cause this License to apply to the other -parts of the aggregate. - - 6. Conveying Non-Source Forms. - - You may convey a covered work in object code form under the terms -of sections 4 and 5, provided that you also convey the -machine-readable Corresponding Source under the terms of this License, -in one of these ways: - - a) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by the - Corresponding Source fixed on a durable physical medium - customarily used for software interchange. - - b) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by a - written offer, valid for at least three years and valid for as - long as you offer spare parts or customer support for that product - model, to give anyone who possesses the object code either (1) a - copy of the Corresponding Source for all the software in the - product that is covered by this License, on a durable physical - medium customarily used for software interchange, for a price no - more than your reasonable cost of physically performing this - conveying of source, or (2) access to copy the - Corresponding Source from a network server at no charge. - - c) Convey individual copies of the object code with a copy of the - written offer to provide the Corresponding Source. This - alternative is allowed only occasionally and noncommercially, and - only if you received the object code with such an offer, in accord - with subsection 6b. - - d) Convey the object code by offering access from a designated - place (gratis or for a charge), and offer equivalent access to the - Corresponding Source in the same way through the same place at no - further charge. You need not require recipients to copy the - Corresponding Source along with the object code. If the place to - copy the object code is a network server, the Corresponding Source - may be on a different server (operated by you or a third party) - that supports equivalent copying facilities, provided you maintain - clear directions next to the object code saying where to find the - Corresponding Source. Regardless of what server hosts the - Corresponding Source, you remain obligated to ensure that it is - available for as long as needed to satisfy these requirements. - - e) Convey the object code using peer-to-peer transmission, provided - you inform other peers where the object code and Corresponding - Source of the work are being offered to the general public at no - charge under subsection 6d. - - A separable portion of the object code, whose source code is excluded -from the Corresponding Source as a System Library, need not be -included in conveying the object code work. - - A "User Product" is either (1) a "consumer product", which means any -tangible personal property which is normally used for personal, family, -or household purposes, or (2) anything designed or sold for incorporation -into a dwelling. In determining whether a product is a consumer product, -doubtful cases shall be resolved in favor of coverage. For a particular -product received by a particular user, "normally used" refers to a -typical or common use of that class of product, regardless of the status -of the particular user or of the way in which the particular user -actually uses, or expects or is expected to use, the product. A product -is a consumer product regardless of whether the product has substantial -commercial, industrial or non-consumer uses, unless such uses represent -the only significant mode of use of the product. - - "Installation Information" for a User Product means any methods, -procedures, authorization keys, or other information required to install -and execute modified versions of a covered work in that User Product from -a modified version of its Corresponding Source. The information must -suffice to ensure that the continued functioning of the modified object -code is in no case prevented or interfered with solely because -modification has been made. - - If you convey an object code work under this section in, or with, or -specifically for use in, a User Product, and the conveying occurs as -part of a transaction in which the right of possession and use of the -User Product is transferred to the recipient in perpetuity or for a -fixed term (regardless of how the transaction is characterized), the -Corresponding Source conveyed under this section must be accompanied -by the Installation Information. But this requirement does not apply -if neither you nor any third party retains the ability to install -modified object code on the User Product (for example, the work has -been installed in ROM). - - The requirement to provide Installation Information does not include a -requirement to continue to provide support service, warranty, or updates -for a work that has been modified or installed by the recipient, or for -the User Product in which it has been modified or installed. Access to a -network may be denied when the modification itself materially and -adversely affects the operation of the network or violates the rules and -protocols for communication across the network. - - Corresponding Source conveyed, and Installation Information provided, -in accord with this section must be in a format that is publicly -documented (and with an implementation available to the public in -source code form), and must require no special password or key for -unpacking, reading or copying. - - 7. Additional Terms. - - "Additional permissions" are terms that supplement the terms of this -License by making exceptions from one or more of its conditions. -Additional permissions that are applicable to the entire Program shall -be treated as though they were included in this License, to the extent -that they are valid under applicable law. If additional permissions -apply only to part of the Program, that part may be used separately -under those permissions, but the entire Program remains governed by -this License without regard to the additional permissions. - - When you convey a copy of a covered work, you may at your option -remove any additional permissions from that copy, or from any part of -it. (Additional permissions may be written to require their own -removal in certain cases when you modify the work.) You may place -additional permissions on material, added by you to a covered work, -for which you have or can give appropriate copyright permission. - - Notwithstanding any other provision of this License, for material you -add to a covered work, you may (if authorized by the copyright holders of -that material) supplement the terms of this License with terms: - - a) Disclaiming warranty or limiting liability differently from the - terms of sections 15 and 16 of this License; or - - b) Requiring preservation of specified reasonable legal notices or - author attributions in that material or in the Appropriate Legal - Notices displayed by works containing it; or - - c) Prohibiting misrepresentation of the origin of that material, or - requiring that modified versions of such material be marked in - reasonable ways as different from the original version; or - - d) Limiting the use for publicity purposes of names of licensors or - authors of the material; or - - e) Declining to grant rights under trademark law for use of some - trade names, trademarks, or service marks; or - - f) Requiring indemnification of licensors and authors of that - material by anyone who conveys the material (or modified versions of - it) with contractual assumptions of liability to the recipient, for - any liability that these contractual assumptions directly impose on - those licensors and authors. - - All other non-permissive additional terms are considered "further -restrictions" within the meaning of section 10. If the Program as you -received it, or any part of it, contains a notice stating that it is -governed by this License along with a term that is a further -restriction, you may remove that term. If a license document contains -a further restriction but permits relicensing or conveying under this -License, you may add to a covered work material governed by the terms -of that license document, provided that the further restriction does -not survive such relicensing or conveying. - - If you add terms to a covered work in accord with this section, you -must place, in the relevant source files, a statement of the -additional terms that apply to those files, or a notice indicating -where to find the applicable terms. - - Additional terms, permissive or non-permissive, may be stated in the -form of a separately written license, or stated as exceptions; -the above requirements apply either way. - - 8. Termination. - - You may not propagate or modify a covered work except as expressly -provided under this License. Any attempt otherwise to propagate or -modify it is void, and will automatically terminate your rights under -this License (including any patent licenses granted under the third -paragraph of section 11). - - However, if you cease all violation of this License, then your -license from a particular copyright holder is reinstated (a) -provisionally, unless and until the copyright holder explicitly and -finally terminates your license, and (b) permanently, if the copyright -holder fails to notify you of the violation by some reasonable means -prior to 60 days after the cessation. - - Moreover, your license from a particular copyright holder is -reinstated permanently if the copyright holder notifies you of the -violation by some reasonable means, this is the first time you have -received notice of violation of this License (for any work) from that -copyright holder, and you cure the violation prior to 30 days after -your receipt of the notice. - - Termination of your rights under this section does not terminate the -licenses of parties who have received copies or rights from you under -this License. If your rights have been terminated and not permanently -reinstated, you do not qualify to receive new licenses for the same -material under section 10. - - 9. Acceptance Not Required for Having Copies. - - You are not required to accept this License in order to receive or -run a copy of the Program. Ancillary propagation of a covered work -occurring solely as a consequence of using peer-to-peer transmission -to receive a copy likewise does not require acceptance. However, -nothing other than this License grants you permission to propagate or -modify any covered work. These actions infringe copyright if you do -not accept this License. Therefore, by modifying or propagating a -covered work, you indicate your acceptance of this License to do so. - - 10. Automatic Licensing of Downstream Recipients. - - Each time you convey a covered work, the recipient automatically -receives a license from the original licensors, to run, modify and -propagate that work, subject to this License. You are not responsible -for enforcing compliance by third parties with this License. - - An "entity transaction" is a transaction transferring control of an -organization, or substantially all assets of one, or subdividing an -organization, or merging organizations. If propagation of a covered -work results from an entity transaction, each party to that -transaction who receives a copy of the work also receives whatever -licenses to the work the party's predecessor in interest had or could -give under the previous paragraph, plus a right to possession of the -Corresponding Source of the work from the predecessor in interest, if -the predecessor has it or can get it with reasonable efforts. - - You may not impose any further restrictions on the exercise of the -rights granted or affirmed under this License. For example, you may -not impose a license fee, royalty, or other charge for exercise of -rights granted under this License, and you may not initiate litigation -(including a cross-claim or counterclaim in a lawsuit) alleging that -any patent claim is infringed by making, using, selling, offering for -sale, or importing the Program or any portion of it. - - 11. Patents. - - A "contributor" is a copyright holder who authorizes use under this -License of the Program or a work on which the Program is based. The -work thus licensed is called the contributor's "contributor version". - - A contributor's "essential patent claims" are all patent claims -owned or controlled by the contributor, whether already acquired or -hereafter acquired, that would be infringed by some manner, permitted -by this License, of making, using, or selling its contributor version, -but do not include claims that would be infringed only as a -consequence of further modification of the contributor version. For -purposes of this definition, "control" includes the right to grant -patent sublicenses in a manner consistent with the requirements of -this License. - - Each contributor grants you a non-exclusive, worldwide, royalty-free -patent license under the contributor's essential patent claims, to -make, use, sell, offer for sale, import and otherwise run, modify and -propagate the contents of its contributor version. - - In the following three paragraphs, a "patent license" is any express -agreement or commitment, however denominated, not to enforce a patent -(such as an express permission to practice a patent or covenant not to -sue for patent infringement). To "grant" such a patent license to a -party means to make such an agreement or commitment not to enforce a -patent against the party. - - If you convey a covered work, knowingly relying on a patent license, -and the Corresponding Source of the work is not available for anyone -to copy, free of charge and under the terms of this License, through a -publicly available network server or other readily accessible means, -then you must either (1) cause the Corresponding Source to be so -available, or (2) arrange to deprive yourself of the benefit of the -patent license for this particular work, or (3) arrange, in a manner -consistent with the requirements of this License, to extend the patent -license to downstream recipients. "Knowingly relying" means you have -actual knowledge that, but for the patent license, your conveying the -covered work in a country, or your recipient's use of the covered work -in a country, would infringe one or more identifiable patents in that -country that you have reason to believe are valid. - - If, pursuant to or in connection with a single transaction or -arrangement, you convey, or propagate by procuring conveyance of, a -covered work, and grant a patent license to some of the parties -receiving the covered work authorizing them to use, propagate, modify -or convey a specific copy of the covered work, then the patent license -you grant is automatically extended to all recipients of the covered -work and works based on it. - - A patent license is "discriminatory" if it does not include within -the scope of its coverage, prohibits the exercise of, or is -conditioned on the non-exercise of one or more of the rights that are -specifically granted under this License. You may not convey a covered -work if you are a party to an arrangement with a third party that is -in the business of distributing software, under which you make payment -to the third party based on the extent of your activity of conveying -the work, and under which the third party grants, to any of the -parties who would receive the covered work from you, a discriminatory -patent license (a) in connection with copies of the covered work -conveyed by you (or copies made from those copies), or (b) primarily -for and in connection with specific products or compilations that -contain the covered work, unless you entered into that arrangement, -or that patent license was granted, prior to 28 March 2007. - - Nothing in this License shall be construed as excluding or limiting -any implied license or other defenses to infringement that may -otherwise be available to you under applicable patent law. - - 12. No Surrender of Others' Freedom. - - If conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot convey a -covered work so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you may -not convey it at all. For example, if you agree to terms that obligate you -to collect a royalty for further conveying from those to whom you convey -the Program, the only way you could satisfy both those terms and this -License would be to refrain entirely from conveying the Program. - - 13. Use with the GNU Affero General Public License. - - Notwithstanding any other provision of this License, you have -permission to link or combine any covered work with a work licensed -under version 3 of the GNU Affero General Public License into a single -combined work, and to convey the resulting work. The terms of this -License will continue to apply to the part which is the covered work, -but the special requirements of the GNU Affero General Public License, -section 13, concerning interaction through a network will apply to the -combination as such. - - 14. Revised Versions of this License. - - The Free Software Foundation may publish revised and/or new versions of -the GNU General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - - Each version is given a distinguishing version number. If the -Program specifies that a certain numbered version of the GNU General -Public License "or any later version" applies to it, you have the -option of following the terms and conditions either of that numbered -version or of any later version published by the Free Software -Foundation. If the Program does not specify a version number of the -GNU General Public License, you may choose any version ever published -by the Free Software Foundation. - - If the Program specifies that a proxy can decide which future -versions of the GNU General Public License can be used, that proxy's -public statement of acceptance of a version permanently authorizes you -to choose that version for the Program. - - Later license versions may give you additional or different -permissions. However, no additional obligations are imposed on any -author or copyright holder as a result of your choosing to follow a -later version. - - 15. Disclaimer of Warranty. - - THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY -APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT -HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY -OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, -THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM -IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF -ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. Limitation of Liability. - - IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS -THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY -GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE -USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF -DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD -PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), -EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF -SUCH DAMAGES. - - 17. Interpretation of Sections 15 and 16. - - If the disclaimer of warranty and limitation of liability provided -above cannot be given local legal effect according to their terms, -reviewing courts shall apply local law that most closely approximates -an absolute waiver of all civil liability in connection with the -Program, unless a warranty or assumption of liability accompanies a -copy of the Program in return for a fee. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -state the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . - -Also add information on how to contact you by electronic and paper mail. - - If the program does terminal interaction, make it output a short -notice like this when it starts in an interactive mode: - - Copyright (C) - This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, your program's commands -might be different; for a GUI interface, you would use an "about box". - - You should also get your employer (if you work as a programmer) or school, -if any, to sign a "copyright disclaimer" for the program, if necessary. -For more information on this, and how to apply and follow the GNU GPL, see -. - - The GNU General Public License does not permit incorporating your program -into proprietary programs. If your program is a subroutine library, you -may consider it more useful to permit linking proprietary applications with -the library. If this is what you want to do, use the GNU Lesser General -Public License instead of this License. But first, please read -. diff --git a/README.md b/README.md index 33b68334..b22c5cff 100644 --- a/README.md +++ b/README.md @@ -1,56 +1,21 @@ # Algorithms and Data Structures in Java -The repo consists of solutions to numerous problems using different data structures and algorithms, all coded in Java. It also -contains solutions to HackerRank problems which I have solved so far and questions from Cracking the Coding Interview -Book _(6th Edition)_. - -You can also refer to my [Java Notes](http://blog.rampatra.com/category/java) for a quick refresh on the Java concepts or if you want a break from coding then can read about my [interview experiences](https://blog.rampatra.com/category/interview/) at various companies. Lastly, feel free to connect with me on [Twitter](https://twitter.com/ram__patra) for any queries or concerns. All the best! - -## Contents - -1. [Basic Practice](/src/main/java/com/rampatra/): - 1. [Arrays](/src/main/java/com/rampatra/arrays) - 2. [Backtracking](/src/main/java/com/rampatra/backtracking) - 3. [Bits](/src/main/java/com/rampatra/bits) - 4. [Blockchain Demo](/src/main/java/com/rampatra/blockchain) - 5. [Dynamic Programming](/src/main/java/com/rampatra/dynamicprogramming) - 6. [Graphs](/src/main/java/com/rampatra/graphs) - 7. [Java 8](/src/main/java/com/rampatra/java8) - 8. [Linked Lists](/src/main/java/com/rampatra/linkedlists) - 9. [Miscellaneous](/src/main/java/com/rampatra/misc) - 10. [Permutations](/src/main/java/com/rampatra/permutations) - 11. [Searching](/src/main/java/com/rampatra/searching) - 12. [Sorting](/src/main/java/com/rampatra/sorting) - 13. [Stacks](/src/main/java/com/rampatra/stacks) - 14. [Strings](/src/main/java/com/rampatra/strings) - 15. [Threads](/src/main/java/com/rampatra/threads) - 16. [Trees](/src/main/java/com/rampatra/trees) -2. [Cracking the Coding Interview](/src/main/java/com/ctci): - 1. [Arrays and Strings](/src/main/java/com/ctci/arraysandstrings) - 2. [Linked Lists](/src/main/java/com/ctci/linkedlists) - 3. [Stacks and Queues](/src/main/java/com/ctci/stacksandqueues) - 4. [Trees and Graphs](/src/main/java/com/ctci/treesandgraphs) - 5. [Bit Manipulation](/src/main/java/com/ctci/bitmanipulation) - 6. [Recursion and DP](/src/main/java/com/ctci/recursionanddp) -3. [LeetCode](/src/main/java/com/leetcode). -4. [HackerRank](/src/main/java/com/hackerrank). +The repo consists of solutions to numerous problems using different data structures and algorithms, where all solutions are coded purely in Java. It also contains solutions to HackerRank problems which I have solved so far. +You can also refer my [Java Notes](http://java.ramswaroop.me) for a quick refresh on the Java concepts. ## Environment ### Java Version -Java version 1.8.0_172 -Java(TM) SE Runtime Environment (build 1.8.0_172-b11) -Java HotSpot(TM) 64-Bit Server VM (build 25.172-b11, mixed mode) +java version "1.8.0_74" +Java(TM) SE Runtime Environment (build 1.8.0_74-b02) +Java HotSpot(TM) 64-Bit Server VM (build 25.74-b02, mixed mode) ### IDE -IntelliJ IDEA 2018.1.4 (Ultimate Edition) +IntelliJ IDEA 16 ### Machine -MacBook Pro -2.5 GHz Intel Core i7 -16 GB 1600 MHz DDR3 - ---- - -_P.S. For any queries or concerns, you can reach out to me on [Twitter](https://twitter.com/rampatra_). I'll try my best to help 🙏. And, if you're keen to know what I'm currently working on then check out [Presentify](https://presentifyapp.com), [FaceScreen](https://facescreenapp.com/), [ToDoBar](https://todobarapp.com/), [SimpleFill](https://simplefillapp.com/), and [Apps.Deals](https://www.apps.deals)._ +__MacBook Pro (Retina, 15-inch, Mid 2015)__ +__Processor__ 2.5 GHz Intel Core i7 +__Memory__ 16 GB 1600 MHz DDR3 +__Graphics__ AMD Radeon R9 M370X 2048 MB diff --git a/pom.xml b/pom.xml deleted file mode 100644 index 4db680c0..00000000 --- a/pom.xml +++ /dev/null @@ -1,132 +0,0 @@ - - - 4.0.0 - - com.rampatra.adsj - adsj - 1.0.1-SNAPSHOT - pom - - Algorithms and Data Structures in Java - My solutions to some of the algorithm and data structure questions in Java - https://github.com/rampatra/Algorithms-and-Data-Structures-in-Java - - - - ram - Ram Patra - hi at rampatra.com - RamPatra.com - http://www.rampatra.com - - - - - - GPL-3.0 - https://opensource.org/licenses/GPL-3.0 - - - - - https://github.com/rampatra/Algorithms-and-Data-Structures-in-Java - scm:git:git://github.com/rampatra/Algorithms-and-Data-Structures-in-Java.git - scm:git:ssh://git@github.com/rampatra/Algorithms-and-Data-Structures-in-Java.git - HEAD - - - - - ossrh - https://oss.sonatype.org/content/repositories/snapshots - - - ossrh - https://oss.sonatype.org/service/local/staging/deploy/maven2 - - - - - UTF-8 - 1.8 - ${java.version} - ${java.version} - - - - - - org.junit.jupiter - junit-jupiter-api - 5.5.1 - - - - - - release - - - - org.apache.maven.plugins - maven-source-plugin - 2.2.1 - - - attach-sources - - jar-no-fork - - - - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.9.1 - - - attach-javadocs - - jar - - - - - - org.apache.maven.plugins - maven-gpg-plugin - 1.5 - - - sign-artifacts - verify - - sign - - - - - - - - - - - - - org.apache.maven.plugins - maven-release-plugin - 2.5 - - true - false - release - deploy - - - - - - - \ No newline at end of file diff --git a/src/main/java/com/hackerrank/algorithms/arraysandsorting/InsertionSort1.java b/src/com/hackerrank/algorithms/arraysandsorting/InsertionSort1.java similarity index 98% rename from src/main/java/com/hackerrank/algorithms/arraysandsorting/InsertionSort1.java rename to src/com/hackerrank/algorithms/arraysandsorting/InsertionSort1.java index 6fd03542..7dadb554 100644 --- a/src/main/java/com/hackerrank/algorithms/arraysandsorting/InsertionSort1.java +++ b/src/com/hackerrank/algorithms/arraysandsorting/InsertionSort1.java @@ -4,7 +4,7 @@ /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/1/15 * Time: 8:58 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/hackerrank/algorithms/arraysandsorting/InsertionSort2.java b/src/com/hackerrank/algorithms/arraysandsorting/InsertionSort2.java similarity index 98% rename from src/main/java/com/hackerrank/algorithms/arraysandsorting/InsertionSort2.java rename to src/com/hackerrank/algorithms/arraysandsorting/InsertionSort2.java index cd710eb9..93ee48a3 100644 --- a/src/main/java/com/hackerrank/algorithms/arraysandsorting/InsertionSort2.java +++ b/src/com/hackerrank/algorithms/arraysandsorting/InsertionSort2.java @@ -4,7 +4,7 @@ /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/1/15 * Time: 9:42 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/hackerrank/algorithms/arraysandsorting/IntroTutorial.java b/src/com/hackerrank/algorithms/arraysandsorting/IntroTutorial.java similarity index 93% rename from src/main/java/com/hackerrank/algorithms/arraysandsorting/IntroTutorial.java rename to src/com/hackerrank/algorithms/arraysandsorting/IntroTutorial.java index aeb8ea5f..aac8e479 100644 --- a/src/main/java/com/hackerrank/algorithms/arraysandsorting/IntroTutorial.java +++ b/src/com/hackerrank/algorithms/arraysandsorting/IntroTutorial.java @@ -5,7 +5,7 @@ /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/1/15 * Time: 3:38 PM * To change this template go to Preferences | IDE Settings | File and Code Templates @@ -15,7 +15,7 @@ static int search(int searchVal, int[] arr) { return Arrays.binarySearch(arr, searchVal); } - public static void main(String[] args) { + public static void main(String[] a) { Scanner in = new Scanner(System.in); int searchVal = in.nextInt(); diff --git a/src/main/java/com/hackerrank/algorithms/arraysandsorting/LoopInvariant.java b/src/com/hackerrank/algorithms/arraysandsorting/LoopInvariant.java similarity index 98% rename from src/main/java/com/hackerrank/algorithms/arraysandsorting/LoopInvariant.java rename to src/com/hackerrank/algorithms/arraysandsorting/LoopInvariant.java index dd12ee7e..2b8613e9 100644 --- a/src/main/java/com/hackerrank/algorithms/arraysandsorting/LoopInvariant.java +++ b/src/com/hackerrank/algorithms/arraysandsorting/LoopInvariant.java @@ -4,7 +4,7 @@ /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/2/15 * Time: 3:26 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/hackerrank/algorithms/arraysandsorting/QuickSort1.java b/src/com/hackerrank/algorithms/arraysandsorting/QuickSort1.java similarity index 98% rename from src/main/java/com/hackerrank/algorithms/arraysandsorting/QuickSort1.java rename to src/com/hackerrank/algorithms/arraysandsorting/QuickSort1.java index 0753f812..7e14ca9b 100644 --- a/src/main/java/com/hackerrank/algorithms/arraysandsorting/QuickSort1.java +++ b/src/com/hackerrank/algorithms/arraysandsorting/QuickSort1.java @@ -4,7 +4,7 @@ /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/2/15 * Time: 5:13 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/hackerrank/algorithms/arraysandsorting/QuickSort2.java b/src/com/hackerrank/algorithms/arraysandsorting/QuickSort2.java similarity index 98% rename from src/main/java/com/hackerrank/algorithms/arraysandsorting/QuickSort2.java rename to src/com/hackerrank/algorithms/arraysandsorting/QuickSort2.java index b9b1dcba..a366da37 100644 --- a/src/main/java/com/hackerrank/algorithms/arraysandsorting/QuickSort2.java +++ b/src/com/hackerrank/algorithms/arraysandsorting/QuickSort2.java @@ -4,7 +4,7 @@ /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/3/15 * Time: 1:05 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/hackerrank/algorithms/arraysandsorting/RunningTime.java b/src/com/hackerrank/algorithms/arraysandsorting/RunningTime.java similarity index 98% rename from src/main/java/com/hackerrank/algorithms/arraysandsorting/RunningTime.java rename to src/com/hackerrank/algorithms/arraysandsorting/RunningTime.java index 27a0bd77..36a55877 100644 --- a/src/main/java/com/hackerrank/algorithms/arraysandsorting/RunningTime.java +++ b/src/com/hackerrank/algorithms/arraysandsorting/RunningTime.java @@ -4,7 +4,7 @@ /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/2/15 * Time: 5:02 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/hackerrank/algorithms/implementation/CavityMap.java b/src/com/hackerrank/algorithms/implementation/CavityMap.java similarity index 96% rename from src/main/java/com/hackerrank/algorithms/implementation/CavityMap.java rename to src/com/hackerrank/algorithms/implementation/CavityMap.java index 0bc4a052..8ead43c8 100644 --- a/src/main/java/com/hackerrank/algorithms/implementation/CavityMap.java +++ b/src/com/hackerrank/algorithms/implementation/CavityMap.java @@ -3,7 +3,7 @@ import java.util.Scanner; /** - * Created by rampatra on 08/05/2016. + * Created by ramswaroop on 08/05/2016. */ public class CavityMap { public static void main(String[] args) { diff --git a/src/main/java/com/hackerrank/algorithms/implementation/ExtraLongFactorials.java b/src/com/hackerrank/algorithms/implementation/ExtraLongFactorials.java similarity index 91% rename from src/main/java/com/hackerrank/algorithms/implementation/ExtraLongFactorials.java rename to src/com/hackerrank/algorithms/implementation/ExtraLongFactorials.java index 230a18aa..d4e340b7 100644 --- a/src/main/java/com/hackerrank/algorithms/implementation/ExtraLongFactorials.java +++ b/src/com/hackerrank/algorithms/implementation/ExtraLongFactorials.java @@ -4,7 +4,7 @@ import java.util.Scanner; /** - * Created by rampatra on 29/05/2016. + * Created by ramswaroop on 29/05/2016. */ public class ExtraLongFactorials { public static void main(String[] args) { diff --git a/src/main/java/com/hackerrank/algorithms/implementation/GridSearch.java b/src/com/hackerrank/algorithms/implementation/GridSearch.java similarity index 98% rename from src/main/java/com/hackerrank/algorithms/implementation/GridSearch.java rename to src/com/hackerrank/algorithms/implementation/GridSearch.java index a317913c..6fb2251d 100644 --- a/src/main/java/com/hackerrank/algorithms/implementation/GridSearch.java +++ b/src/com/hackerrank/algorithms/implementation/GridSearch.java @@ -3,7 +3,7 @@ import java.util.Scanner; /** - * Created by rampatra on 02/05/2016. + * Created by ramswaroop on 02/05/2016. */ public class GridSearch { diff --git a/src/main/java/com/hackerrank/algorithms/implementation/TheTimeInWords.java b/src/com/hackerrank/algorithms/implementation/TheTimeInWords.java similarity index 97% rename from src/main/java/com/hackerrank/algorithms/implementation/TheTimeInWords.java rename to src/com/hackerrank/algorithms/implementation/TheTimeInWords.java index 4915014b..0b747ce5 100644 --- a/src/main/java/com/hackerrank/algorithms/implementation/TheTimeInWords.java +++ b/src/com/hackerrank/algorithms/implementation/TheTimeInWords.java @@ -3,7 +3,7 @@ import java.util.Scanner; /** - * Created by rampatra on 29/05/2016. + * Created by ramswaroop on 29/05/2016. */ public class TheTimeInWords { public static void main(String[] args) { diff --git a/src/main/java/com/hackerrank/algorithms/strings/AlternatingCharacters.java b/src/com/hackerrank/algorithms/strings/AlternatingCharacters.java similarity index 95% rename from src/main/java/com/hackerrank/algorithms/strings/AlternatingCharacters.java rename to src/com/hackerrank/algorithms/strings/AlternatingCharacters.java index c81f5c22..823f1e61 100644 --- a/src/main/java/com/hackerrank/algorithms/strings/AlternatingCharacters.java +++ b/src/com/hackerrank/algorithms/strings/AlternatingCharacters.java @@ -5,8 +5,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/22/15 + * @author: ramswaroop + * @date: 10/22/15 * @time: 9:24 AM */ public class AlternatingCharacters { diff --git a/src/main/java/com/hackerrank/algorithms/strings/PalindromeIndex.java b/src/com/hackerrank/algorithms/strings/PalindromeIndex.java similarity index 95% rename from src/main/java/com/hackerrank/algorithms/strings/PalindromeIndex.java rename to src/com/hackerrank/algorithms/strings/PalindromeIndex.java index 294c4dd2..b9d76784 100644 --- a/src/main/java/com/hackerrank/algorithms/strings/PalindromeIndex.java +++ b/src/com/hackerrank/algorithms/strings/PalindromeIndex.java @@ -4,7 +4,7 @@ /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/18/15 * Time: 12:27 PM * To change this template go to Preferences | IDE Settings | File and Code Templates @@ -37,7 +37,7 @@ static boolean isPalindrome(String s) { return true; } - public static void main(String[] args) { + public static void main(String[] a) { Scanner in = new Scanner(System.in); int t = in.nextInt(); diff --git a/src/main/java/com/hackerrank/algorithms/strings/Pangram.java b/src/com/hackerrank/algorithms/strings/Pangram.java similarity index 95% rename from src/main/java/com/hackerrank/algorithms/strings/Pangram.java rename to src/com/hackerrank/algorithms/strings/Pangram.java index fa98b4fd..27fffa88 100644 --- a/src/main/java/com/hackerrank/algorithms/strings/Pangram.java +++ b/src/com/hackerrank/algorithms/strings/Pangram.java @@ -5,8 +5,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/22/15 + * @author: ramswaroop + * @date: 10/22/15 * @time: 8:47 AM */ public class Pangram { diff --git a/src/main/java/com/hackerrank/algorithms/strings/TwoStrings.java b/src/com/hackerrank/algorithms/strings/TwoStrings.java similarity index 92% rename from src/main/java/com/hackerrank/algorithms/strings/TwoStrings.java rename to src/com/hackerrank/algorithms/strings/TwoStrings.java index 779a148b..f2b0ea1f 100644 --- a/src/main/java/com/hackerrank/algorithms/strings/TwoStrings.java +++ b/src/com/hackerrank/algorithms/strings/TwoStrings.java @@ -5,8 +5,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/22/15 + * @author: ramswaroop + * @date: 10/22/15 * @time: 10:08 AM */ public class TwoStrings { @@ -22,7 +22,7 @@ public static String isSubstringInBoth(String[] a) { return "NO"; } - public static void main(String[] args) { + public static void main(String a[]) { Scanner in = new Scanner(System.in); int t = Integer.parseInt(in.nextLine()); diff --git a/src/main/java/com/hackerrank/algorithms/warmup/FlippingBits.java b/src/com/hackerrank/algorithms/warmup/FlippingBits.java similarity index 91% rename from src/main/java/com/hackerrank/algorithms/warmup/FlippingBits.java rename to src/com/hackerrank/algorithms/warmup/FlippingBits.java index e335efe1..9db5f21c 100644 --- a/src/main/java/com/hackerrank/algorithms/warmup/FlippingBits.java +++ b/src/com/hackerrank/algorithms/warmup/FlippingBits.java @@ -1,10 +1,10 @@ -package com.hackerrank.algorithms.warmup; +package me.ramswaroop.algorithms.warmup; import java.util.Scanner; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 2/28/15 * Time: 12:41 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/hackerrank/algorithms/warmup/LonelyInteger.java b/src/com/hackerrank/algorithms/warmup/LonelyInteger.java similarity index 95% rename from src/main/java/com/hackerrank/algorithms/warmup/LonelyInteger.java rename to src/com/hackerrank/algorithms/warmup/LonelyInteger.java index 666b3fa0..b60b695c 100644 --- a/src/main/java/com/hackerrank/algorithms/warmup/LonelyInteger.java +++ b/src/com/hackerrank/algorithms/warmup/LonelyInteger.java @@ -1,4 +1,4 @@ -package com.hackerrank.algorithms.warmup; +package me.ramswaroop.algorithms.warmup; import java.util.HashMap; import java.util.Map; @@ -6,7 +6,7 @@ /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 2/28/15 * Time: 12:16 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/hackerrank/algorithms/warmup/LoveLetterMystery.java b/src/com/hackerrank/algorithms/warmup/LoveLetterMystery.java similarity index 89% rename from src/main/java/com/hackerrank/algorithms/warmup/LoveLetterMystery.java rename to src/com/hackerrank/algorithms/warmup/LoveLetterMystery.java index 8855498c..b0588dfd 100644 --- a/src/main/java/com/hackerrank/algorithms/warmup/LoveLetterMystery.java +++ b/src/com/hackerrank/algorithms/warmup/LoveLetterMystery.java @@ -1,10 +1,10 @@ -package com.hackerrank.algorithms.warmup; +package me.ramswaroop.algorithms.warmup; import java.util.Scanner; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/17/15 * Time: 3:22 PM * To change this template go to Preferences | IDE Settings | File and Code Templates @@ -20,7 +20,7 @@ static int calcPalindromeSteps(String s) { return steps; } - public static void main(String[] args) { + public static void main(String[] a) { Scanner in = new Scanner(System.in); int t = in.nextInt(); diff --git a/src/main/java/com/hackerrank/algorithms/warmup/MaximizingXor.java b/src/com/hackerrank/algorithms/warmup/MaximizingXor.java similarity index 92% rename from src/main/java/com/hackerrank/algorithms/warmup/MaximizingXor.java rename to src/com/hackerrank/algorithms/warmup/MaximizingXor.java index 2b0cc0ab..78865aa2 100644 --- a/src/main/java/com/hackerrank/algorithms/warmup/MaximizingXor.java +++ b/src/com/hackerrank/algorithms/warmup/MaximizingXor.java @@ -1,11 +1,11 @@ -package com.hackerrank.algorithms.warmup; +package me.ramswaroop.algorithms.warmup; import java.util.Scanner; import java.util.TreeSet; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/7/15 * Time: 11:07 AM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/hackerrank/algorithms/warmup/UtopianTree.java b/src/com/hackerrank/algorithms/warmup/UtopianTree.java similarity index 87% rename from src/main/java/com/hackerrank/algorithms/warmup/UtopianTree.java rename to src/com/hackerrank/algorithms/warmup/UtopianTree.java index 43e455c2..ca0d5556 100644 --- a/src/main/java/com/hackerrank/algorithms/warmup/UtopianTree.java +++ b/src/com/hackerrank/algorithms/warmup/UtopianTree.java @@ -1,10 +1,10 @@ -package com.hackerrank.algorithms.warmup; +package me.ramswaroop.algorithms.warmup; import java.util.Scanner; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/1/15 * Time: 3:07 PM * To change this template go to Preferences | IDE Settings | File and Code Templates @@ -23,7 +23,7 @@ static int calcHeight(int growthCycles) { return h; } - public static void main(String[] args) { + public static void main(String[] a) { Scanner in = new Scanner(System.in); int t = in.nextInt(); diff --git a/src/main/java/com/hackerrank/bitmanipulation/CounterGame.java b/src/com/hackerrank/bitmanipulation/CounterGame.java similarity index 94% rename from src/main/java/com/hackerrank/bitmanipulation/CounterGame.java rename to src/com/hackerrank/bitmanipulation/CounterGame.java index b2a03e21..c319fc38 100644 --- a/src/main/java/com/hackerrank/bitmanipulation/CounterGame.java +++ b/src/com/hackerrank/bitmanipulation/CounterGame.java @@ -6,8 +6,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/24/15 + * @author: ramswaroop + * @date: 6/24/15 * @time: 12:03 PM */ public class CounterGame { @@ -37,7 +37,7 @@ public static String computeWinner(BigInteger n) { return (louiseTurn) ? "Richard" : "Louise"; } - public static void main(String[] args) { + public static void main(String a[]) { Scanner in = new Scanner(System.in); int t = Integer.parseInt(in.nextLine()); diff --git a/src/main/java/com/hackerrank/bitmanipulation/Solution.java b/src/com/hackerrank/bitmanipulation/Solution.java similarity index 97% rename from src/main/java/com/hackerrank/bitmanipulation/Solution.java rename to src/com/hackerrank/bitmanipulation/Solution.java index d07b9f37..618b9120 100644 --- a/src/main/java/com/hackerrank/bitmanipulation/Solution.java +++ b/src/com/hackerrank/bitmanipulation/Solution.java @@ -7,8 +7,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/24/15 + * @author: ramswaroop + * @date: 6/24/15 * @time: 10:25 PM */ public class Solution { diff --git a/src/main/java/com/hackerrank/bitmanipulation/TwosCompliment.java b/src/com/hackerrank/bitmanipulation/TwosCompliment.java similarity index 90% rename from src/main/java/com/hackerrank/bitmanipulation/TwosCompliment.java rename to src/com/hackerrank/bitmanipulation/TwosCompliment.java index 0bfdc29f..37fb21ae 100644 --- a/src/main/java/com/hackerrank/bitmanipulation/TwosCompliment.java +++ b/src/com/hackerrank/bitmanipulation/TwosCompliment.java @@ -5,8 +5,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/24/15 + * @author: ramswaroop + * @date: 6/24/15 * @time: 10:25 PM */ public class TwosCompliment { @@ -19,7 +19,7 @@ public static long countSetBitsInRange(int start, int end) { return count; } - public static void main(String[] args) { + public static void main(String a[]) { Scanner in = new Scanner(System.in); int t = Integer.parseInt(in.nextLine()); diff --git a/src/main/java/com/hackerrank/java/oops/JavaInheritance.java b/src/com/hackerrank/java/oops/JavaInheritance.java similarity index 68% rename from src/main/java/com/hackerrank/java/oops/JavaInheritance.java rename to src/com/hackerrank/java/oops/JavaInheritance.java index b8d0d9e4..d12db5c0 100644 --- a/src/main/java/com/hackerrank/java/oops/JavaInheritance.java +++ b/src/com/hackerrank/java/oops/JavaInheritance.java @@ -1,10 +1,10 @@ -package com.hackerrank.java.oops; +package me.ramswaroop.java.oops; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/19/15 + * @author: ramswaroop + * @date: 7/19/15 * @time: 3:36 PM */ public class JavaInheritance { @@ -13,7 +13,7 @@ public void JavaInheritance() { } - public static void main(String[] args) { + public static void main(String a[]) { } } diff --git a/src/main/java/com/hackerrank/projecteuler/MultiplesOf3and5.java b/src/com/hackerrank/projecteuler/MultiplesOf3and5.java similarity index 72% rename from src/main/java/com/hackerrank/projecteuler/MultiplesOf3and5.java rename to src/com/hackerrank/projecteuler/MultiplesOf3and5.java index f56da78e..fcbc341b 100644 --- a/src/main/java/com/hackerrank/projecteuler/MultiplesOf3and5.java +++ b/src/com/hackerrank/projecteuler/MultiplesOf3and5.java @@ -5,16 +5,16 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 1/1/16 + * @author: ramswaroop + * @date: 1/1/16 * @time: 8:48 AM */ public class MultiplesOf3and5 { - public static void main(String[] args) { + public static void main(String a[]) { Scanner in = new Scanner(System.in); - + int t = Integer.parseInt(in.nextLine()); - + } } diff --git a/src/main/java/com/ctci/arraysandstrings/CheckPermutation.java b/src/main/java/com/ctci/arraysandstrings/CheckPermutation.java deleted file mode 100644 index dbf7c795..00000000 --- a/src/main/java/com/ctci/arraysandstrings/CheckPermutation.java +++ /dev/null @@ -1,67 +0,0 @@ -package com.ctci.arraysandstrings; - -import java.util.Arrays; - -/** - * @author rampatra - * @since 19/11/2018 - */ -public class CheckPermutation { - - /** - * Checks if {@code s1} is a permutation of {@code s2}. - * - * @param s1 - * @param s2 - * @return - */ - private static boolean isOnePermutationOfOther(String s1, String s2) { - if (s1.length() != s2.length()) { - return false; - } - - char[] c1 = s1.toCharArray(); - char[] c2 = s2.toCharArray(); - Arrays.sort(c1); - Arrays.sort(c2); - - return Arrays.equals(c1, c2); - } - - /** - * Checks if {@code s1} is a permutation of {@code s2}. - * - * @param s1 - * @param s2 - * @return - */ - private static boolean isOnePermutationOfOtherGivenThatStringsContainOnlyAscii(String s1, String s2) { - if (s1.length() != s2.length()) { - return false; - } - - int[] chars = new int[128]; // assuming strings contain only ASCII characters - - for (int i = 0; i < s1.length(); i++) { - chars[s1.charAt(i)]++; - } - - for (int i = 0; i < s2.length(); i++) { - chars[s2.charAt(i)]--; - if (chars[s2.charAt(i)] < 0) { - return false; - } - } - return true; - } - - public static void main(String[] args) { - System.out.println(isOnePermutationOfOther("ram", "mar")); - System.out.println(isOnePermutationOfOther("rama", "mar")); - System.out.println(isOnePermutationOfOther("rama", "marA")); - System.out.println("-------"); - System.out.println(isOnePermutationOfOtherGivenThatStringsContainOnlyAscii("ram", "mar")); - System.out.println(isOnePermutationOfOtherGivenThatStringsContainOnlyAscii("rama", "mar")); - System.out.println(isOnePermutationOfOtherGivenThatStringsContainOnlyAscii("rama", "marA")); - } -} diff --git a/src/main/java/com/ctci/arraysandstrings/IsUnique.java b/src/main/java/com/ctci/arraysandstrings/IsUnique.java deleted file mode 100644 index 895d16b3..00000000 --- a/src/main/java/com/ctci/arraysandstrings/IsUnique.java +++ /dev/null @@ -1,51 +0,0 @@ -package com.ctci.arraysandstrings; - -/** - * @author rampatra - * @since 18/11/2018 - */ -public class IsUnique { - - private static boolean hasAllUniqueCharacters(String str) { - if (str == null || str.length() > 128) return false; - - boolean[] charSet = new boolean[128]; // assuming the string contains only ASCII characters - for (int i = 0; i < str.length(); i++) { - int charVal = str.charAt(i); - if (charSet[charVal]) { - return false; - } - charSet[charVal] = true; - } - return true; - } - - private static boolean hasAllUniqueCharactersWhenStringContainsAllLowercase(String s) { - int checker = 0; - for (int i = 0; i < s.length(); i++) { - int charValue = s.charAt(i) - 'a'; - if ((checker & (1 << charValue)) > 0) { - return false; - } - checker |= (1 << charValue); - } - return true; - } - - public static void main(String[] args) { - String s = "ram"; - System.out.println(hasAllUniqueCharacters(s)); - s = "rama"; - System.out.println(hasAllUniqueCharacters(s)); - s = "ramA"; - System.out.println(hasAllUniqueCharacters(s)); - System.out.println("-------"); - s = "ram"; - System.out.println(hasAllUniqueCharactersWhenStringContainsAllLowercase(s)); - s = "rama"; - System.out.println(hasAllUniqueCharactersWhenStringContainsAllLowercase(s)); - // not working as the input contains different cases - s = "ramA"; - System.out.println(hasAllUniqueCharactersWhenStringContainsAllLowercase(s)); - } -} diff --git a/src/main/java/com/ctci/arraysandstrings/OneAway.java b/src/main/java/com/ctci/arraysandstrings/OneAway.java deleted file mode 100644 index f5345ed7..00000000 --- a/src/main/java/com/ctci/arraysandstrings/OneAway.java +++ /dev/null @@ -1,70 +0,0 @@ -package com.ctci.arraysandstrings; - -/** - * @author rampatra - * @since 24/11/2018 - */ -public class OneAway { - - /** - * Checks if two strings are only one edit away, that is, by inserting, deleting, or editing - * at max one character in {@code s1} it becomes same as {@code s2}. - * - * @param s1 - * @param s2 - * @return - */ - private static boolean isOneEditAway(String s1, String s2) { - if (s1.length() == s2.length()) { - return isOneCharacterDiffAtMax(s1, s2); - } else if (s1.length() < s2.length()) { - return checkForMaxOneInsertOrDeleteInS1(s1, s2); - } else { - return checkForMaxOneInsertOrDeleteInS1(s1, s2); - } - } - - private static boolean isOneCharacterDiffAtMax(String s1, String s2) { - boolean foundDiff = false; - for (int i = 0; i < s1.length(); i++) { - if (s1.charAt(i) != s2.charAt(i)) { - if (foundDiff) { - return false; // means we already found a difference earlier - } - foundDiff = true; - } - } - return true; - } - - private static boolean checkForMaxOneInsertOrDeleteInS1(String s1, String s2) { - int i = 0; - int j = 0; - int s1Len = s1.length(); - int s2Len = s2.length(); - if (Math.abs(s1Len - s2Len) > 1) return false; - - while (i < s1Len && j < s2Len) { - if (s1.charAt(i) != s2.charAt(j)) { - if (s1Len > s2Len) { - i++; - } else { - j++; - } - continue; - } - i++; - j++; - } - return Math.abs(i - j) <= 1; // check whether difference in two strings is not more than 1 - } - - public static void main(String[] args) { - System.out.println("pale, ple: " + isOneEditAway("pale", "ple")); - System.out.println("pales,pale: " + isOneEditAway("pales", "pale")); - System.out.println("pale, bale: " + isOneEditAway("pale", "bale")); - System.out.println("pale, bake: " + isOneEditAway("pale", "bake")); - System.out.println("ram, rama: " + isOneEditAway("ram", "rama")); - System.out.println("ram, ramaaaaaaa: " + isOneEditAway("ram", "ramaaaaaaa")); - } -} diff --git a/src/main/java/com/ctci/arraysandstrings/PalindromePermutation.java b/src/main/java/com/ctci/arraysandstrings/PalindromePermutation.java deleted file mode 100644 index 0ab21095..00000000 --- a/src/main/java/com/ctci/arraysandstrings/PalindromePermutation.java +++ /dev/null @@ -1,103 +0,0 @@ -package com.ctci.arraysandstrings; - -import java.util.HashMap; -import java.util.Map; - -/** - * @author rampatra - * @since 21/11/2018 - */ -public class PalindromePermutation { - - /** - * This method exploits the fact that a palindrome will contain at most - * one character with odd counts. All other characters should be of even - * counts. - * - * @param str input string - * @return {@code true} if {@code str} is a permutation of a palindrome - */ - private static boolean isPermutationOfPalindrome(String str) { - Map charCounts = new HashMap<>(); - Integer freq; - int oddCounts = 0; // keep count of odds so that we don't have to loop through the hashmap the second time - for (int i = 0; i < str.length(); i++) { - char c = str.charAt(i); - if (c != 32) { - freq = charCounts.get(c) == null ? 0 : charCounts.get(c); - if ((freq + 1) % 2 == 1) { - oddCounts++; - } else { - oddCounts--; - } - charCounts.put(c, freq + 1); - } - } - return oddCounts <= 1; - } - - - /** - * This approach sets a bit in a number based on the character in the string and - * then un-sets the bit if it sees the character again. Finally, checks if the - * bitVector has at most one bit set only. - * - * @param str input string - * @return {@code true} if {@code str} is a permutation of a palindrome - */ - private static boolean isPermutationOfPalindromeViaBits(String str) { - int bitVector = 0; - int index; - - for (int i = 0; i < str.length(); i++) { - index = getIndex(str.charAt(i)); - if (index != -1) { - bitVector = toggleBitAt(bitVector, index); - } - } - return (bitVector & (bitVector - 1)) == 0; - } - - /** - * Calculates the index to set the bit according to the character {@code c}. - * - * @param c - * @return the index to set the bit as per the character {@code c} - */ - private static int getIndex(char c) { - char a = 'a'; - char z = 'z'; - - // assuming string contains only lowercase characters - if (c < a || c > z) { - return -1; - } - - return c - a; - } - - /** - * Toggles the bit at index {@code index} in {@code bitVector}. - * - * @param bitVector - * @param index - * @return the resulting {@code bitVector} after toggling the bit - */ - private static int toggleBitAt(int bitVector, int index) { - return bitVector ^ (1 << index); - } - - public static void main(String[] args) { - System.out.println(isPermutationOfPalindrome("tactc oapapa")); - System.out.println(isPermutationOfPalindrome("maam")); - System.out.println(isPermutationOfPalindrome("maa m")); - System.out.println(isPermutationOfPalindrome("rammmar")); - System.out.println(isPermutationOfPalindrome("rammmara")); - System.out.println("---------"); - System.out.println(isPermutationOfPalindromeViaBits("tactc oapapa")); - System.out.println(isPermutationOfPalindromeViaBits("maam")); - System.out.println(isPermutationOfPalindromeViaBits("maa m")); - System.out.println(isPermutationOfPalindromeViaBits("rammmar")); - System.out.println(isPermutationOfPalindromeViaBits("rammmara")); - } -} diff --git a/src/main/java/com/ctci/arraysandstrings/RotateMatrix.java b/src/main/java/com/ctci/arraysandstrings/RotateMatrix.java deleted file mode 100644 index de43c56b..00000000 --- a/src/main/java/com/ctci/arraysandstrings/RotateMatrix.java +++ /dev/null @@ -1,16 +0,0 @@ -package com.ctci.arraysandstrings; - -/** - * @author rampatra - * @since 2019-01-20 - */ -public class RotateMatrix { - - public static void rotateImage(int[][] pixels) { - - } - - public static void main(String[] args) { - - } -} diff --git a/src/main/java/com/ctci/arraysandstrings/StringCompression.java b/src/main/java/com/ctci/arraysandstrings/StringCompression.java deleted file mode 100644 index 5c2df955..00000000 --- a/src/main/java/com/ctci/arraysandstrings/StringCompression.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.ctci.arraysandstrings; - -/** - * @author rampatra - * @since 24/11/2018 - */ -public class StringCompression { - - /** - * Compresses the string {@code s} such that a string {@code aabccccaaa} becomes {@code a2b1c4a3}. - * Also, if the compressed string is not shorter than the original, returns the original string. - * - * @param str input string containing only a-z characters, both cases - * @return which ever is the shorter string - */ - private static String compressString(String str) { - StringBuilder compressedSb = new StringBuilder(); - int countConsecutive = 0; - for (int i = 0; i < str.length(); i++) { - countConsecutive++; - - /* If next character is different than current, append this char to result. */ - if (i + 1 >= str.length() || str.charAt(i) != str.charAt(i + 1)) { - compressedSb.append(str.charAt(i)); - compressedSb.append(countConsecutive); - countConsecutive = 0; - } - } - return compressedSb.length() < str.length() ? compressedSb.toString() : str; - } - - public static void main(String[] args) { - System.out.println("aabccccaaa: " + compressString("aabccccaaa")); - System.out.println("aabccccAAAA: " + compressString("aabccccAAAA")); - System.out.println("abcd: " + compressString("abcd")); - System.out.println("a: " + compressString("a")); - System.out.println("aabcccccccccccccccccccccccccaaa: " + compressString("aabcccccccccccccccccccccccccaaa")); - } -} diff --git a/src/main/java/com/ctci/arraysandstrings/StringRotation.java b/src/main/java/com/ctci/arraysandstrings/StringRotation.java deleted file mode 100644 index 0c03e94f..00000000 --- a/src/main/java/com/ctci/arraysandstrings/StringRotation.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.ctci.arraysandstrings; - -/** - * Assume you have a method isSubString which checks if one word is a substring of another. Given two - * strings, S1 and S2, write code to check if S2 is a rotation of S1 using only one call to isSubString - * (e.g., "waterbottle" is a rotation of" erbottlewat"). - * - * @author rampatra - * @since 2019-01-22 - */ -public class StringRotation { - - private static boolean isStringRotation(String s1, String s2) { - if (s1.length() != s2.length()) { - return false; - } - s2 = s2 + s2; - return isSubString(s1, s2); - } - - /** - * Given method in question. - * - * @param s1 first string - * @param s2 second string - * @return {@code true} if s1 is a substring of s2 or else {@code false} - */ - private static boolean isSubString(String s1, String s2) { - return s2.contains(s1); - } - - public static void main(String[] args) { - System.out.println(isStringRotation("waterbottle", "erbottlewat")); // true - System.out.println(isStringRotation("rampatra", "atraramp")); // true - System.out.println(isStringRotation("rampatra", "arampata")); // false - System.out.println(isStringRotation("rampatra", "arampat")); // false - System.out.println(isStringRotation("", "")); // true - } -} diff --git a/src/main/java/com/ctci/arraysandstrings/URLify.java b/src/main/java/com/ctci/arraysandstrings/URLify.java deleted file mode 100644 index 712829ac..00000000 --- a/src/main/java/com/ctci/arraysandstrings/URLify.java +++ /dev/null @@ -1,43 +0,0 @@ -package com.ctci.arraysandstrings; - -/** - * @author rampatra - * @since 19/11/2018 - */ -public class URLify { - - /** - * We space encode the string such that all spaces in the string are replaced with '%20'. The string {@code str} - * contains extra spaces to accommodate the extra characters. - * - * @param str string with spaces - * @return string with spaces replaced with %20 - */ - private static String urlify(String str) { - char[] chars = str.toCharArray(); - int curr = chars.length - 1; // we will start backwards so that we don't have to worry about characters we overwrite - int insertIndex = curr; - - // move the curr pointer to the last character which isn't a space - while (chars[curr] == 32) { - curr--; - } - - while (curr >= 0) { - if (chars[curr] == 32) { - chars[insertIndex--] = '0'; - chars[insertIndex--] = '2'; - chars[insertIndex--] = '%'; - } else { - chars[insertIndex--] = chars[curr]; - } - curr--; - } - return String.valueOf(chars); - } - - public static void main(String[] args) { - System.out.println(urlify("Mr John Smith ")); - System.out.println(urlify("Mr Ram Patra ")); - } -} diff --git a/src/main/java/com/ctci/arraysandstrings/ZeroMatrix.java b/src/main/java/com/ctci/arraysandstrings/ZeroMatrix.java deleted file mode 100644 index f73d8760..00000000 --- a/src/main/java/com/ctci/arraysandstrings/ZeroMatrix.java +++ /dev/null @@ -1,78 +0,0 @@ -package com.ctci.arraysandstrings; - -import java.util.ArrayList; -import java.util.List; - -/** - * Write an algorithm such that if an element in an MxN matrix is 0, its entire row - * and column are set to 0. - * - * @author rampatra - * @since 2019-01-20 - */ -public class ZeroMatrix { - - private static void zeroMatrix(int[][] matrix) { - // keep count of which rows and columns have a number zero - List rowsToZero = new ArrayList<>(); - List colsToZero = new ArrayList<>(); - - for (int i = 0; i < matrix.length; i++) { - for (int j = 0; j < matrix[0].length; j++) { - if (matrix[i][j] == 0) { - rowsToZero.add(i); - colsToZero.add(j); - } - } - } - - makeRowColumnZero(matrix, rowsToZero, colsToZero); - } - - private static void makeRowColumnZero(int[][] matrix, List rows, List cols) { - for (int row : rows) { - // make entire row zero - for (int c = 0; c < matrix[0].length; c++) { - matrix[row][c] = 0; - } - } - for (int col : cols) { - // make entire column zero - for (int r = 0; r < matrix.length; r++) { - matrix[r][col] = 0; - } - } - } - - private static void printMatrix(int[][] matrix) { - for (int i = 0; i < matrix.length; i++) { - for (int j = 0; j < matrix[0].length; j++) { - System.out.print(matrix[i][j]); - if (j + 1 >= matrix[0].length) { - System.out.println(); - } - } - } - } - - public static void main(String[] args) { - int[][] m = new int[][]{{0, 1, 2}, {3, 4, 5}, {6, 7, 8}}; - printMatrix(m); - zeroMatrix(m); - System.out.println("---"); - printMatrix(m); - System.out.println("---"); - m = new int[][]{{1, 0, 2}, {3, 4, 5}, {6, 7, 8}}; - printMatrix(m); - zeroMatrix(m); - System.out.println("---"); - printMatrix(m); - System.out.println("---"); - m = new int[][]{{1, 2, 0}, {3, 4, 5}, {6, 7, 8}}; - printMatrix(m); - zeroMatrix(m); - System.out.println("---"); - printMatrix(m); - System.out.println("---"); - } -} diff --git a/src/main/java/com/ctci/bitmanipulation/BinaryToString.java b/src/main/java/com/ctci/bitmanipulation/BinaryToString.java deleted file mode 100644 index 895c354a..00000000 --- a/src/main/java/com/ctci/bitmanipulation/BinaryToString.java +++ /dev/null @@ -1,48 +0,0 @@ -package com.ctci.bitmanipulation; - -/** - * @author rampatra - * @since 2019-03-16 - */ -public class BinaryToString { - - /** - * Given a real number between 0 and 1 (e.g., 0.72) that is passed in as a double, print the binary representation. - * If the number cannot be represented accurately in binary with at most 32 characters, print "ERROR." - * - * @param realNum a real number between 0 and 1 (for ex. 0.75) - * @return binary string of the real number - * @see how to convert decimal fraction to binary - */ - private static String decimalFractionToBinaryString(double realNum) { - if (realNum <= 0 || realNum >= 1) { - return "ERROR"; - } - - int binaryBit; - StringBuilder sb = new StringBuilder(); - sb.append("0."); - - while (realNum > 0) { - if (sb.length() == 32) { - return "ERROR"; - } - realNum = realNum * 2; - // the binary bit is the whole number part (left to the decimal) - binaryBit = (int) realNum; - // we only have to take the part after the decimal (right to the decimal) for the next iteration - if (binaryBit == 1) { - realNum -= 1; - } - sb.append(binaryBit); - } - return sb.toString(); - } - - public static void main(String[] args) { - System.out.println(decimalFractionToBinaryString(0.625)); - System.out.println(decimalFractionToBinaryString(0.75)); - System.out.println(decimalFractionToBinaryString(0.72)); - System.out.println(decimalFractionToBinaryString(0.10)); - } -} diff --git a/src/main/java/com/ctci/bitmanipulation/Conversion.java b/src/main/java/com/ctci/bitmanipulation/Conversion.java deleted file mode 100644 index 5a4c7575..00000000 --- a/src/main/java/com/ctci/bitmanipulation/Conversion.java +++ /dev/null @@ -1,63 +0,0 @@ -package com.ctci.bitmanipulation; - -/** - * @author rampatra - * @since 2019-03-17 - */ -public class Conversion { - - /** - * Write a function to determine the number of bits you would need to flip to convert - * integer A to integer B. - * Example: - * Input: 29 (or: 11101), 15 (or: 01111) - * Output: 2 - * - * @param a - * @param b - * @return the number of bits to flip - */ - private static int getNoOfBitsToFlipToConvertAToB(int a, int b) { - return countSetBits(a ^ b); - } - - private static int countSetBits(int n) { - int count = 0; - while (n > 0) { - if ((n & 1) == 1) { - count++; - } - n >>>= 1; - } - return count; - } - - /** - * In this approach, we first take the xor of both the integers (which sets the bits at positions where the bits - * in a and b are different). We then unset the least significant bit in each iteration (c & (c - 1)) and count the - * number of iterations to find the bits to flip. - * - * @param a - * @param b - * @return the number of bits to flip - */ - private static int getNoOfBitsToFlipToConvertAToBWithoutRightShift(int a, int b) { - int count = 0; - for (int c = a ^ b; c != 0; c = c & (c - 1)) { - count++; - } - return count; - } - - public static void main(String[] args) { - System.out.println(getNoOfBitsToFlipToConvertAToB(5, 7)); - System.out.println(getNoOfBitsToFlipToConvertAToB(5, 5)); - System.out.println(getNoOfBitsToFlipToConvertAToB(29, 15)); - - System.out.println("---"); - - System.out.println(getNoOfBitsToFlipToConvertAToBWithoutRightShift(5, 7)); - System.out.println(getNoOfBitsToFlipToConvertAToBWithoutRightShift(5, 5)); - System.out.println(getNoOfBitsToFlipToConvertAToBWithoutRightShift(29, 15)); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/bitmanipulation/Debugger.java b/src/main/java/com/ctci/bitmanipulation/Debugger.java deleted file mode 100644 index 6782036b..00000000 --- a/src/main/java/com/ctci/bitmanipulation/Debugger.java +++ /dev/null @@ -1,30 +0,0 @@ -package com.ctci.bitmanipulation; - -/** - * @author rampatra - * @since 2019-03-17 - */ -public class Debugger { - - /** - * If after un-setting the least significant bit in n, it becomes 0 then it implies that it has only set bit. This - * can also imply that n is a power of 2. - * - * @param n input integer - * @return {@code true} if n has only set bit, {@code false} otherwise. - */ - private static boolean hasOneSetBit(int n) { - // edge case - if (n == 0) { - return false; - } - return (n & (n - 1)) == 0; // (n & (n - 1)) un-sets the least significant bit - } - - public static void main(String[] args) { - System.out.println(hasOneSetBit(0)); - System.out.println(hasOneSetBit(2)); - System.out.println(hasOneSetBit(16)); - System.out.println(hasOneSetBit(10)); - } -} diff --git a/src/main/java/com/ctci/bitmanipulation/DrawLine.java b/src/main/java/com/ctci/bitmanipulation/DrawLine.java deleted file mode 100644 index 3eb2be0c..00000000 --- a/src/main/java/com/ctci/bitmanipulation/DrawLine.java +++ /dev/null @@ -1,109 +0,0 @@ -package com.ctci.bitmanipulation; - -import java.util.Arrays; - -/** - * @author rampatra - * @since 2019-03-21 - */ -public class DrawLine { - - /** - * A monochrome screen is stored as a single array of bytes, allowing eight consecutive pixels to be stored - * in one byte. The screen has width w, where w is divisible by 8 (that is, no byte will be split across rows). - * The height of the screen, of course, can be derived from the length of the array and the width. Implement a - * function that draws a horizontal line from (xl, y) to ( x2, y). - *

- * The method signature should look something like: - * {@code drawline(byte[] screen, int width, int xl, int x2, int y)} - *

- * Approach: - * First, find the numbers in which all bits has to be set. Next, find the starting number and apply the mask - * created from the starting offset. Do the same with the ending number. - * - * @param screen - * @param width - * @param x1 - * @param x2 - * @param y - */ - private static void drawLine(byte[] screen, int width, int x1, int x2, int y) { - int startOffset = x1 % 8; - int startFullByte = x1 / 8; - if (startOffset != 0) { - startFullByte++; - } - int endOffset = x2 % 8; - int endFullByte = x2 / 8; - if (endOffset != 7) { - endFullByte--; - } - - // all bits have to be set in in-between numbers - for (int i = startFullByte; i <= endFullByte; i++) { - screen[width / 8 * y + i] |= (byte) 0xff; - } - - /* 0xff is an integer literal which is like 000...11111111 (32 bits) but when we - cast it to a byte, we get rid of the initial 24 bits */ - byte startByteMask = (byte) (0xff >> startOffset); - byte endByteMask = (byte) ~(0xff >> endOffset + 1); - - if (x1 / 8 == x2 / 8) { // if starting and ending both lie in the same byte - screen[width / 8 * y + (x1 / 8)] |= (startByteMask & endByteMask); - } else { - screen[width / 8 * y + (startFullByte - 1)] |= startByteMask; // only specific bits set in the starting number - screen[width / 8 * y + (endFullByte + 1)] |= endByteMask; // only specific bits set in the ending number - } - } - - public static void main(String[] args) { - /* - Consider the below screen with width 32 as an example: - - byte[] screen = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - - This screen has a width of 32 so you can assume the screen would be looking like: - - 9 10 11 12 - 5 6 7 8 - 1 2 3 4 - - x-axis is 5-20 (5th position to 20th position) - y-axis is 1 - - which means our line would lie in numbers 5, 6, and 7 - - so if you visualize these numbers in bits, it would be like: - - 00000101 00000110 00000111 - ^ ^ - and after drawing the line, the bits would become: - - 00000111 11111111 11111111 - - and in the output we would see: - - 7, -1, -1 instead of 5, 6, 7 - */ - byte[] screen = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - System.out.println("Input: " + Arrays.toString(screen)); - drawLine(screen, 32, 5, 20, 1); - System.out.println("Output: " + Arrays.toString(screen)); - System.out.println("---"); - screen = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - System.out.println("Input: " + Arrays.toString(screen)); - drawLine(screen, 32, 0, 5, 1); - System.out.println("Output: " + Arrays.toString(screen)); - System.out.println("---"); - screen = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - System.out.println("Input: " + Arrays.toString(screen)); - drawLine(screen, 32, 3, 7, 1); - System.out.println("Output: " + Arrays.toString(screen)); - System.out.println("---"); - screen = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - System.out.println("Input: " + Arrays.toString(screen)); - drawLine(screen, 16, 0, 7, 0); - System.out.println("Output: " + Arrays.toString(screen)); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/bitmanipulation/FlipBitToWin.java b/src/main/java/com/ctci/bitmanipulation/FlipBitToWin.java deleted file mode 100644 index 4424f7ab..00000000 --- a/src/main/java/com/ctci/bitmanipulation/FlipBitToWin.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.ctci.bitmanipulation; - -/** - * @author rampatra - * @since 2019-03-16 - */ -public class FlipBitToWin { - - /** - * You have an integer and you can flip exactly one bit from a O to a 1. Write code to find the length of the - * longest sequence of 1s you could create. - * Example: - * Input: 1775 (or: 11011101111) - * Output: 8 - *

- * Approach: - * We just walk through the integer tracking the current 1s sequence length and the previous 1s sequence length. - * When we see a zero, update previous length as follows: - * - If the next bit is a 1, previous Length should be set to current Length. - * - If the next bit is a 0, then we can't merge these sequences together. So, set previous Length to 0. - * - * @param n an integer - * @return the longest sequence of set bits in {@code n} by flipping only one zero bit - */ - private static int findLongestSequence(int n) { - // if all bits are set, return the total number of bits in an integer - if (n == ~0) { - return Integer.BYTES * 8; - } - - int prevOnesLen = 0; - int currOnesLen = 0; - int maxOnesLen = 0; - - while (n > 0) { - // if the current bit is 0, reset the currOnesLen - if ((n & 1) == 0) { - prevOnesLen = (n & 2) == 0 ? 0 : currOnesLen; // if the next bit is also 0, set prevOnesLen to 0 - currOnesLen = 0; - } else { - currOnesLen++; - } - n >>>= 1; - maxOnesLen = Math.max(maxOnesLen, prevOnesLen + 1 + currOnesLen); - } - return maxOnesLen; - } - - public static void main(String[] args) { - System.out.println("Longest seq in " + Integer.toBinaryString(125) + " is " + findLongestSequence(125)); - System.out.println("Longest seq in " + Integer.toBinaryString(1275) + " is " + findLongestSequence(1275)); - } -} diff --git a/src/main/java/com/ctci/bitmanipulation/Insertion.java b/src/main/java/com/ctci/bitmanipulation/Insertion.java deleted file mode 100644 index 3230d86f..00000000 --- a/src/main/java/com/ctci/bitmanipulation/Insertion.java +++ /dev/null @@ -1,49 +0,0 @@ -package com.ctci.bitmanipulation; - -/** - * @author rampatra - * @since 2019-03-14 - */ -public class Insertion { - - /** - * You are given two 32-bit numbers, N and M, and two bit positions, startIndex and endIndex. Write a method to - * insert M into N such that M starts at bit startIndex and ends at bit endIndex. You can assume that the bits - * startIndex through endIndex have enough space to fit all of M. That is, if M = 10011, you can assume that there - * are at least 5 bits between j and i. You would not, for example, have startIndex = 3 and endIndex = 2, because - * M could not fully fit between bit 3 and bit 2. - *

- * EXAMPLE - * Input: N = 10000000000, M = 10011, startIndex = 6, endIndex = 2 - * Output: 10001001100 - * - * @param n - * @param m - * @param startIndex - * @param endIndex - * @return - */ - private static int insertMIntoN(int n, int m, int startIndex, int endIndex) { - // create a mask with only one bit set - int mask = 1; - // shift the set bit so that it starts with endIndex - mask <<= endIndex; - - // unset the bits in 'n' from endIndex to startIndex - for (int i = endIndex; i <= startIndex; i++) { - n = n & ~mask; // ~mask will make the bit at ith index 0 but the rest of the bits will be 1 - mask <<= 1; - } - - // shift 'm' so that it lines up with bits from startIndex to endIndex - m <<= endIndex; - - // finally, return the xor of both as we know that 0 ^ a = a - return n ^ m; - } - - public static void main(String[] args) { - System.out.println(Integer.toBinaryString(insertMIntoN(Integer.parseInt("10000000000", 2), Integer.parseInt("10011", 2), 6, 2))); - System.out.println(Integer.toBinaryString(insertMIntoN(Integer.parseInt("10110110111", 2), Integer.parseInt("11101", 2), 7, 3))); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/bitmanipulation/NextNumber.java b/src/main/java/com/ctci/bitmanipulation/NextNumber.java deleted file mode 100644 index ec817c13..00000000 --- a/src/main/java/com/ctci/bitmanipulation/NextNumber.java +++ /dev/null @@ -1,124 +0,0 @@ -package com.ctci.bitmanipulation; - -/** - * @author rampatra - * @since 2019-03-17 - */ -public class NextNumber { - - private static class NextLargerAndSmallerNumber { - int nextLarger; - int nextSmaller; - } - - /** - * Given a positive integer, print the next smallest and the next largest number that have the same number of - * 1 bits in their binary representation. - * - * @param n a positive integer. - * @return an object containing the next larger and next smaller number containing the identical set bits. - */ - private static NextLargerAndSmallerNumber getNextLargerAndSmallerNumber(int n) { - NextLargerAndSmallerNumber result = new NextLargerAndSmallerNumber(); - result.nextLarger = getNextLarger(n); - result.nextSmaller = getNextSmaller(n); - return result; - } - - private static int getNextLarger(int n) { - int rightmostNonTrailingZero = 0; - int noOfZeros = 0; - int noOfOnes = 0; - int temp = n; - - /* Count the number of zeros and ones until the rightmost non-trailing zero - For example, see below: - - n = 10110110011110 - ^ - */ - while ((temp & 1) == 0 && temp != 0) { - noOfZeros++; - temp >>>= 1; - } - - while ((temp & 1) == 1 && temp != 0) { - noOfOnes++; - temp >>>= 1; - } - - if (noOfZeros + noOfOnes == 31 || noOfZeros + noOfOnes == 0) { - return -1; - } - - /* Flip the bit and then shift all the 1s to the right end and then fill with 0s until the bit pattern '01. - For example, consider the above number: - n = 10110110011110 (original) - ^ - n = 10110110111110 (after flip bit) - ^ - next larger = 10110110100111 (the 1s are shifted to the right end and 0s to the left but before the rightmostNonTrailingZero) - ^ - */ - rightmostNonTrailingZero = noOfOnes + noOfZeros; - n |= 1 << rightmostNonTrailingZero; // set the rightmost non-trailing zero - n &= ~((1 << rightmostNonTrailingZero) - 1); // unset all bits until rightmost non-trailing zero - n |= (1 << noOfOnes - 1) - 1; // set (noOfOnes - 1) bits from the right - - return n; - } - - private static int getNextSmaller(int n) { - int rightmostNonTrailingOne = 0; - int noOfZeros = 0; - int noOfOnes = 0; - int temp = n; - - while ((temp & 1) == 1 && temp != 0) { - noOfOnes++; - temp >>>= 1; - } - - if (temp == 0) { - return -1; - } - - while ((temp & 1) == 0 && temp != 0) { - noOfZeros++; - temp >>>= 1; - } - - rightmostNonTrailingOne = noOfZeros + noOfOnes; - n &= ~(1 << rightmostNonTrailingOne); // unset the rightmost non-trailing one - n |= (1 << rightmostNonTrailingOne - 1); // set all the bits until rightmost non-trailing one - n &= ~((1 << noOfZeros - 1) - 1); // unset (noOfZeros - 1) bits from the right - - return n; - } - - public static void main(String[] args) { - NextLargerAndSmallerNumber of0 = getNextLargerAndSmallerNumber(0); - System.out.println("Next larger of 0: " + of0.nextLarger); - System.out.println("Next smaller of 0: " + of0.nextSmaller); - - NextLargerAndSmallerNumber of2 = getNextLargerAndSmallerNumber(2); - System.out.println("Next larger of 2: " + of2.nextLarger); - System.out.println("Next smaller of 2: " + of2.nextSmaller); - - NextLargerAndSmallerNumber of5 = getNextLargerAndSmallerNumber(5); - System.out.println("Next larger of 5: " + of5.nextLarger); - System.out.println("Next smaller of 5: " + of5.nextSmaller); - - NextLargerAndSmallerNumber of7 = getNextLargerAndSmallerNumber(7); - System.out.println("Next larger of 7: " + of7.nextLarger); - System.out.println("Next smaller of 7: " + of7.nextSmaller); - - NextLargerAndSmallerNumber of8 = getNextLargerAndSmallerNumber(8); - System.out.println("Next larger of 8: " + of8.nextLarger); - System.out.println("Next smaller of 8: " + of8.nextSmaller); - - NextLargerAndSmallerNumber of15 = getNextLargerAndSmallerNumber(15); - System.out.println("Next larger of 15: " + of15.nextLarger); - System.out.println("Next smaller of 15: " + of15.nextSmaller); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/bitmanipulation/PairwiseSwap.java b/src/main/java/com/ctci/bitmanipulation/PairwiseSwap.java deleted file mode 100644 index a1219d47..00000000 --- a/src/main/java/com/ctci/bitmanipulation/PairwiseSwap.java +++ /dev/null @@ -1,40 +0,0 @@ -package com.ctci.bitmanipulation; - -/** - * @author rampatra - * @since 2019-03-18 - */ -public class PairwiseSwap { - - /** - * Write a program to swap odd and even bits in an integer with as few instructions as - * possible (e.g., bit O and bit 1 are swapped, bit 2 and bit 3 are swapped, and so on). - * - * Approach: - * Shift the odd bits to the left, shift the even bits to the right, and finally, OR both the results. - * Note: You can operate on only odd bits or only even bits by using the appropriate masks, for e.g., - * 0x55555555 for odd bits and 0xaaaaaaaa for even bits. - * - * @param n an input integer. - * @return an integer with even and odd bits swapped. - */ - private static int swapBits(int n) { - return ((n & 0x55555555) << 1) | ((n & 0xaaaaaaaa) >>> 1); - } - - public static void main(String[] args) { - System.out.println("Input: " + Integer.toBinaryString(1569) + - "\nOutput: " + Integer.toBinaryString(swapBits(1569))); - - assert Integer.toBinaryString(swapBits(1569)).equals("100100010010"); - - System.out.println("Input: " + Integer.toBinaryString(2680) + - "\nOutput: " + Integer.toBinaryString(swapBits(2680))); - - assert Integer.toBinaryString(swapBits(2680)).equals("10110110100"); - - // fyi - System.out.println(Integer.toBinaryString(0x55555555)); - System.out.println(Integer.toBinaryString(0xaaaaaaaa)); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/linkedlists/DeleteMiddleNode.java b/src/main/java/com/ctci/linkedlists/DeleteMiddleNode.java deleted file mode 100644 index c4b4052e..00000000 --- a/src/main/java/com/ctci/linkedlists/DeleteMiddleNode.java +++ /dev/null @@ -1,65 +0,0 @@ -package com.ctci.linkedlists; - -/** - * @author rampatra - * @since 2019-01-27 - */ -public class DeleteMiddleNode { - - /** - * Implement an algorithm to delete a node in the middle (i.e., any node but the first and last node, not - * necessarily the exact middle) of a singly linked list, given only access to that node. - *

- * EXAMPLE - * Input: the node c from the linked list a->b->c->d->e->f - * Result: nothing is returned, but the new linked list looks like a->b->d->e->f - * - * @param middle the node to be deleted - */ - private static void deleteMiddleNode(Node middle) { - if (middle == null || middle.next == null) { - return; - } - // copy the data from the next node over to the middle node, and then to delete the next node - Node next = middle.next; - middle.val = next.val; - middle.next = next.next; - } - - public static void main(String[] args) { - Node l1 = new Node(1); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.next.next.next = new Node(4); - l1.next.next.next.next = new Node(5); - l1.next.next.next.next.next = new Node(6); - l1.print(); - deleteMiddleNode(l1.next.next); - l1.print(); - - System.out.println("----"); - - l1 = new Node(1); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.print(); - deleteMiddleNode(l1.next); - l1.print(); - - System.out.println("----"); - - l1 = new Node(1); - l1.next = new Node(3); - l1.print(); - deleteMiddleNode(l1); - l1.print(); - - System.out.println("----"); - - l1 = new Node(1); - l1.next = new Node(3); - l1.print(); - deleteMiddleNode(l1.next); - l1.print(); - } -} diff --git a/src/main/java/com/ctci/linkedlists/Intersection.java b/src/main/java/com/ctci/linkedlists/Intersection.java deleted file mode 100644 index 4665fe43..00000000 --- a/src/main/java/com/ctci/linkedlists/Intersection.java +++ /dev/null @@ -1,104 +0,0 @@ -package com.ctci.linkedlists; - -/** - * @author rampatra - * @since 2019-02-02 - */ -public class Intersection { - - /** - * Given two (singly) linked lists, determine if the two lists intersect. Return the intersecting node. Note that - * the intersection is defined based on reference, not value. That is, if the kth node of the first linked list is - * the exact same node (by reference) as the jth node of the second linked list, then they are intersecting. - * - * @param n1 - * @param n2 - * @return the intersecting node, {@code null} otherwise. - */ - private static Node findIntersectingNode(Node n1, Node n2) { - Node curr1 = n1; - Node curr2 = n2; - int len1 = 1; - int len2 = 1; - - /* Calculate the length of both linked lists */ - while (curr1 != null && curr1.next != null) { - len1++; - curr1 = curr1.next; - } - while (curr2 != null && curr2.next != null) { - len2++; - curr2 = curr2.next; - } - - // if different tail nodes, they don't intersect - if (curr1 != curr2) { - return null; - } - - curr1 = n1; - curr2 = n2; - - /* Get rid of the extra nodes from the longer list */ - if (len1 > len2) { - for (int i = 0; i < len1 - len2; i++) { - curr1 = curr1.next; - } - } - if (len2 > len1) { - for (int i = 0; i < len2 - len1; i++) { - curr2 = curr2.next; - } - } - - // move both pointers until you have a collision - while (curr1 != curr2) { - curr1 = curr1.next; - curr2 = curr2.next; - } - - // return either - return curr1; - } - - public static void main(String[] args) { - Node l1 = new Node(1); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.next.next.next = new Node(4); - l1.next.next.next.next = new Node(5); - l1.next.next.next.next.next = new Node(5); - Node l2 = new Node(1); - l2.next = new Node(4); - l2.next.next = new Node(2); - l2.next.next.next = new Node(3); - l2.next.next.next.next = l1.next.next.next; - l1.print(); - l2.print(); - System.out.println(findIntersectingNode(l1, l2).val); // may throw NPE, not handling for the sake of simplicity - - System.out.println("----"); - - l1 = new Node(1); - l2 = l1; - l1.print(); - l2.print(); - System.out.println(findIntersectingNode(l1, l2).val); // may throw NPE, not handling for the sake of simplicity - - System.out.println("----"); - - l1 = new Node(1); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.next.next.next = new Node(4); - l1.next.next.next.next = new Node(5); - l1.next.next.next.next.next = new Node(5); - l2 = new Node(1); - l2.next = new Node(4); - l2.next.next = new Node(2); - l2.next.next.next = new Node(3); - l1.print(); - l2.print(); - System.out.println(findIntersectingNode(l1, l2)); - } -} diff --git a/src/main/java/com/ctci/linkedlists/KthToLastElement.java b/src/main/java/com/ctci/linkedlists/KthToLastElement.java deleted file mode 100644 index 8fff3f9d..00000000 --- a/src/main/java/com/ctci/linkedlists/KthToLastElement.java +++ /dev/null @@ -1,88 +0,0 @@ -package com.ctci.linkedlists; - -/** - * @author rampatra - * @since 21/11/2018 - */ -public class KthToLastElement { - - /** - * Finds the kth node from the end in a linked list. - * - * @param head is the reference to the head of the linked list - * @param k is the position of element from the end - * @return the Kth node from the end - */ - private static Node getKthToLastElement(Node head, int k) { - Node slow = head; - Node fast = head; - int i = 0; - - // forward the fast reference k times - while (i < k) { - if (fast == null) return null; // k is out of bounds - fast = fast.next; - i++; - } - - while (fast != null) { - slow = slow.next; - fast = fast.next; - } - return slow; - } - - /** - * This approach is recursive and it just prints the kth to last node instead - * of returning the node. - * - * @param head starting node of the linklist - * @param k kth to last node to print - * @return the index of the kth to last node - */ - private static int printKthToLastElement(Node head, int k) { - if (head == null) { - return 0; - } - int index = printKthToLastElement(head.next, k) + 1; - if (index == k) { - System.out.println(head.val); - } - return index; - } - - public static void main(String[] args) { - Node l1 = new Node(1); - l1.next = new Node(6); - l1.next.next = new Node(3); - l1.next.next.next = new Node(4); - l1.next.next.next.next = new Node(5); - l1.next.next.next.next.next = new Node(7); - l1.print(); - System.out.println("k=2: " + getKthToLastElement(l1, 2).val); // NPE check is omitted intentionally to keep it simple - System.out.print("k=2: "); - printKthToLastElement(l1, 2); - - Node l2 = new Node(1); - l2.next = new Node(6); - l2.next.next = new Node(2); - l2.next.next.next = new Node(3); - l2.next.next.next.next = new Node(4); - l2.next.next.next.next.next = new Node(7); - l2.print(); - System.out.println("k=1: " + getKthToLastElement(l2, 1).val); - System.out.print("k=1: "); - printKthToLastElement(l2, 1); - - Node l3 = new Node(1); - l3.next = new Node(6); - l3.next.next = new Node(3); - l3.next.next.next = new Node(3); - l3.next.next.next.next = new Node(4); - l3.next.next.next.next.next = new Node(7); - l3.print(); - System.out.println("k=6: " + getKthToLastElement(l3, 6).val); - System.out.print("k=6: "); - printKthToLastElement(l3, 6); - } -} diff --git a/src/main/java/com/ctci/linkedlists/LoopDetection.java b/src/main/java/com/ctci/linkedlists/LoopDetection.java deleted file mode 100644 index d0a9a110..00000000 --- a/src/main/java/com/ctci/linkedlists/LoopDetection.java +++ /dev/null @@ -1,67 +0,0 @@ -package com.ctci.linkedlists; - -/** - * @author rampatra - * @since 2019-02-03 - */ -public class LoopDetection { - - /** - * Given a circular linked list, implement an algorithm that returns the node at the beginning of the loop. - * DEFINITION - * Circular linked list: A (corrupt) linked list in which a node's next pointer points to an earlier node, so - * as to make a loop in the linked list. - * EXAMPLE - * Input: A -> B -> C -> D -> E -> C [the same C as earlier] - * Output: C - *

- * See {@link com.rampatra.linkedlists.DetectAndRemoveLoop} for a slightly more complex problem. - * - * @param head the starting node of the linked list - * @return the {@code Node} where the loop starts, {@code null} otherwise. - */ - private static Node findLoopStartNode(Node head) { - Node slow = head; - Node fast = head; - - while (fast != null && fast.next != null) { - slow = slow.next; - fast = fast.next.next; - if (slow == fast) { - break; - } - } - - /* Error check - no meeting point, and therefore no loop */ - if (fast == null || fast.next == null) { - return null; - } - - /* Move slow to Head. Keep fast at Meeting Point. Each are k steps from the - * Loop Start. If they move at the same pace, they must meet at Loop Start. */ - slow = head; - while (slow != fast) { - slow = slow.next; - fast = fast.next; - } - - /* You can return either as now both point to the start of the loop */ - return fast; - } - - public static void main(String[] args) { - /* - * 1 -> 2 -> 3 -> 4 -> 5 -> 6 - * ^ | - * |_________| - */ - Node l1 = new Node(1); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.next.next.next = new Node(4); - l1.next.next.next.next = new Node(5); - l1.next.next.next.next.next = new Node(6); - l1.next.next.next.next.next.next = l1.next.next.next; - System.out.println(findLoopStartNode(l1).val); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/linkedlists/Node.java b/src/main/java/com/ctci/linkedlists/Node.java deleted file mode 100644 index 5c0d1ec3..00000000 --- a/src/main/java/com/ctci/linkedlists/Node.java +++ /dev/null @@ -1,23 +0,0 @@ -package com.ctci.linkedlists; - -/** - * @author rampatra - * @since 21/11/2018 - */ -class Node { - int val; - Node next; - - Node(int val) { - this.val = val; - } - - public void print() { - Node curr = this; - while (curr.next != null) { - System.out.print(curr.val + "->"); - curr = curr.next; - } - System.out.println(curr.val); - } -} diff --git a/src/main/java/com/ctci/linkedlists/Palindrome.java b/src/main/java/com/ctci/linkedlists/Palindrome.java deleted file mode 100644 index 57bb184d..00000000 --- a/src/main/java/com/ctci/linkedlists/Palindrome.java +++ /dev/null @@ -1,107 +0,0 @@ -package com.ctci.linkedlists; - -import java.util.Stack; - -/** - * @author rampatra - * @since 2019-02-02 - */ -public class Palindrome { - - /** - * Checks whether a Linked List is palindrome by using a stack. - * - * @param head starting node of the linked list. - * @return {@code true} if linked list palindrome, {@code false} otherwise. - */ - private static boolean isPalindrome(Node head) { - Node curr = head; - Stack stack = new Stack<>(); - // pop all elements into stack - while (curr != null) { - stack.push(curr.val); - curr = curr.next; - } - curr = head; - // as stack contains the elements in reverse order, pop and compare with the list one by one - while (curr != null) { - if (curr.val != stack.pop()) { - return false; - } - curr = curr.next; - } - return true; - } - - /** - * This is a similar approach like above but a bit faster as we are not iterating the entire list twice. - * - * @param head starting node of the linked list. - * @return {@code true} if linked list palindrome, {@code false} otherwise. - */ - private static boolean isPalindromeOptimized(Node head) { - Node slow = head; - Node fast = head; - Stack stack = new Stack<>(); - - // push half of the elements into the stack - while (fast != null && fast.next != null) { - stack.push(slow.val); - slow = slow.next; - fast = fast.next.next; - } - - // linked list has odd number of elements, so forward the slow reference by one - if (fast != null) { - slow = slow.next; - } - - while (slow != null) { - if (slow.val != stack.pop()) { - return false; - } - slow = slow.next; - } - return true; - } - - public static void main(String[] args) { - - Node l1 = new Node(1); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.next.next.next = new Node(3); - l1.next.next.next.next = new Node(2); - l1.next.next.next.next.next = new Node(1); - l1.print(); - System.out.println(isPalindrome(l1)); - System.out.println(isPalindromeOptimized(l1)); - System.out.println("------"); - - l1 = new Node(1); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.next.next.next = new Node(2); - l1.next.next.next.next = new Node(1); - l1.print(); - System.out.println(isPalindrome(l1)); - System.out.println(isPalindromeOptimized(l1)); - System.out.println("------"); - - l1 = new Node(0); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.next.next.next = new Node(3); - l1.next.next.next.next = new Node(0); - l1.print(); - System.out.println(isPalindrome(l1)); - System.out.println(isPalindromeOptimized(l1)); - System.out.println("------"); - - l1 = new Node(1); - l1.print(); - System.out.println(isPalindrome(l1)); - System.out.println(isPalindromeOptimized(l1)); - - } -} diff --git a/src/main/java/com/ctci/linkedlists/Partition.java b/src/main/java/com/ctci/linkedlists/Partition.java deleted file mode 100644 index 8876a424..00000000 --- a/src/main/java/com/ctci/linkedlists/Partition.java +++ /dev/null @@ -1,93 +0,0 @@ -package com.ctci.linkedlists; - -/** - * Write code to partition a linked list around a value x, such that all nodes less than x come before all - * nodes greater than or equal to x. If x is contained within the list, the values of x only need to be - * after the elements less than x (see below). The partition element x can appear anywhere in the "right - * partition"; it does not need to appear between the left and right partitions. - *

- * EXAMPLE: - * Input: 3 -> 5 -> 8 -> 5 -> 10 -> 2 -> 1 [partition=5] - * Output: 3 -> 1 -> 2 -> 10 -> 5 -> 5 -> 8 - * - * @author rampatra - * @since 2019-01-28 - */ -public class Partition { - - private static Node partition(Node head, int x) { - Node leftPartitionHead = null; - Node leftPartitionCurr = null; - Node rightPartitionHead = null; - Node rightPartitionCurr = null; - Node curr = head; - - while (curr != null) { - if (curr.val < x) { - if (leftPartitionHead == null) { - leftPartitionHead = curr; - leftPartitionCurr = curr; - } else { - leftPartitionCurr.next = curr; - leftPartitionCurr = leftPartitionCurr.next; - } - } else { - if (rightPartitionHead == null) { - rightPartitionHead = curr; - rightPartitionCurr = curr; - } else { - rightPartitionCurr.next = curr; - rightPartitionCurr = rightPartitionCurr.next; - } - } - curr = curr.next; - } - - if (leftPartitionCurr != null) leftPartitionCurr.next = rightPartitionHead; - if (rightPartitionCurr != null) rightPartitionCurr.next = null; - - return leftPartitionHead; - } - - public static void main(String[] args) { - Node l1 = new Node(3); - l1.next = new Node(5); - l1.next.next = new Node(8); - l1.next.next.next = new Node(5); - l1.next.next.next.next = new Node(10); - l1.next.next.next.next.next = new Node(2); - l1.next.next.next.next.next.next = new Node(1); - l1.print(); - l1.print(); - - System.out.println("----"); - - l1 = new Node(1); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.print(); - l1.print(); - - System.out.println("----"); - - l1 = new Node(3); - l1.next = new Node(2); - l1.next.next = new Node(1); - l1.print(); - l1.print(); - - System.out.println("----"); - - l1 = new Node(1); - l1.print(); - l1.print(); - - System.out.println("----"); - - l1 = null; - l1.print(); - l1.print(); - - System.out.println("----"); - } -} diff --git a/src/main/java/com/ctci/linkedlists/RemoveDuplicates.java b/src/main/java/com/ctci/linkedlists/RemoveDuplicates.java deleted file mode 100644 index 31029188..00000000 --- a/src/main/java/com/ctci/linkedlists/RemoveDuplicates.java +++ /dev/null @@ -1,88 +0,0 @@ -package com.ctci.linkedlists; - -import java.util.HashSet; -import java.util.Set; - -/** - * @author rampatra - * @since 21/11/2018 - */ -public class RemoveDuplicates { - - /** - * Removes duplicates in an unsorted linked list by using additional memory - * and two references. - *

- * If asked not to use any additional memory then you can - * loop through the list for each node and check for repeated elements but bear - * in mind that the time complexity of this would be O(n^2) where n is the number - * of nodes in the linked list. - * - * @param head reference to the head of the linked list - */ - private static void removeDuplicatesFromUnsortedList(Node head) { - Set valuesInList = new HashSet<>(); - Node curr = head; - Node prev = curr; - while (curr != null) { - if (valuesInList.contains(curr.val)) { - prev.next = curr.next; - } - valuesInList.add(curr.val); - prev = curr; - curr = curr.next; - } - } - - public static void main(String[] args) { - Node l1 = new Node(1); - l1.next = new Node(2); - l1.next.next = new Node(3); - l1.next.next.next = new Node(4); - l1.next.next.next.next = new Node(5); - l1.next.next.next.next.next = new Node(5); - System.out.print("With dups: "); - l1.print(); - removeDuplicatesFromUnsortedList(l1); - System.out.print("Without dups: "); - l1.print(); - - Node l2 = new Node(1); - l2.next = new Node(1); - l2.next.next = new Node(2); - l2.next.next.next = new Node(3); - l2.next.next.next.next = new Node(4); - l2.next.next.next.next.next = new Node(5); - System.out.print("\nWith dups: "); - l2.print(); - removeDuplicatesFromUnsortedList(l2); - System.out.print("Without dups: "); - l2.print(); - - Node l3 = new Node(1); - l3.next = new Node(2); - l3.next.next = new Node(3); - l3.next.next.next = new Node(3); - l3.next.next.next.next = new Node(4); - l3.next.next.next.next.next = new Node(5); - System.out.print("\nWith dups: "); - l3.print(); - removeDuplicatesFromUnsortedList(l3); - System.out.print("Without dups: "); - l3.print(); - - Node l4 = new Node(1); - System.out.print("\nWith dups: "); - l4.print(); - removeDuplicatesFromUnsortedList(l4); - System.out.print("Without dups: "); - l4.print(); - - Node l5 = null; - System.out.print("\nWith dups: "); - l5.print(); - removeDuplicatesFromUnsortedList(l5); - System.out.print("Without dups: "); - l5.print(); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/linkedlists/SumLists.java b/src/main/java/com/ctci/linkedlists/SumLists.java deleted file mode 100644 index befdfc3e..00000000 --- a/src/main/java/com/ctci/linkedlists/SumLists.java +++ /dev/null @@ -1,86 +0,0 @@ -package com.ctci.linkedlists; - -/** - * @author rampatra - * @since 2019-01-31 - */ -public class SumLists { - - /** - * You have two numbers represented by a linked list, where each node contains a single digit. The digits are - * stored in reverse order, such that the 1's digit is at the head of the list (or in other words, the least - * significant digit is stored at the head of the list). Write a function that adds the two numbers and returns - * the sum as a linked list. - *

- * EXAMPLE - * Input: (7-> 1 -> 6) + (5 -> 9 -> 2).That is, 617 + 295. - * Output: 2 -> 1 -> 9. That is, 912. - * - * @param num1 - * @param num2 - * @return - */ - private static Node sumLists(Node num1, Node num2) { - int carry = 0; - int sum; - Node sumList = null, curr = null; - while (num1 != null || num2 != null) { - sum = ((num1 == null) ? 0 : num1.val) + ((num2 == null) ? 0 : num2.val) + carry; - carry = sum / 10; - if (sumList == null) { - sumList = new Node(sum % 10); - curr = sumList; - } else { - curr.next = new Node(sum % 10); - curr = curr.next; - } - if (num1 != null) num1 = num1.next; - if (num2 != null) num2 = num2.next; - } - if (carry != 0) { - curr.next = new Node(carry); - } - return sumList; - } - - // TODO: After doing reverseListRecursive - private static Node sumListsWithMostSignificantDigitAtHead(Node n1, Node n2) { - return null; - } - - public static void main(String[] args) { - Node l1 = new Node(9); - l1.next = new Node(9); - l1.next.next = new Node(9); - - Node l2 = new Node(9); - l2.next = new Node(9); - l2.next.next = new Node(9); - - l1.print(); - l2.print(); - sumLists(l1, l2).print(); - System.out.println("-----------"); - - l1 = new Node(9); - l1.next = new Node(9); - - l2 = new Node(9); - l2.next = new Node(9); - l2.next.next = new Node(9); - - l1.print(); - l2.print(); - sumLists(l1, l2).print(); - System.out.println("-----------"); - - l1 = null; - l2 = new Node(9); - l2.next = new Node(9); - l2.next.next = new Node(8); - - l1.print(); - l2.print(); - sumLists(l1, l2).print(); - } -} diff --git a/src/main/java/com/ctci/recursionanddp/FibonacciNumber.java b/src/main/java/com/ctci/recursionanddp/FibonacciNumber.java deleted file mode 100644 index caa4d095..00000000 --- a/src/main/java/com/ctci/recursionanddp/FibonacciNumber.java +++ /dev/null @@ -1,64 +0,0 @@ -package com.ctci.recursionanddp; - -/** - * The fabled fibonacci numbers problem with three different solutions. - * The {@link FibonacciNumber#fibonacciBottomUpOptimized(int)} version is the most optimized among all w.r.t space - * and time. See {@link com.rampatra.dynamicprogramming.FibonacciNumbers} for Fibonacci series. - * - * @author rampatra - * @since 2019-02-26 - */ -public class FibonacciNumber { - - private static int fibonacciTopDown(int n, int[] memo) { - if (n == 0 || n == 1) return n; - - if (memo[n] != 0) { - return memo[n]; - } else { - memo[n] = fibonacciTopDown(n - 1, memo) + fibonacciTopDown(n - 2, memo); - return memo[n]; - } - } - - private static int fibonacciBottomUp(int n) { - if (n == 0 || n == 1) return n; - - int[] memo = new int[n + 1]; - memo[1] = 1; - for (int i = 2; i <= n; i++) { - memo[i] = memo[i - 1] + memo[i - 2]; - } - return memo[n]; - } - - private static int fibonacciBottomUpOptimized(int n) { - if (n == 0 || n == 1) return n; - - int a = 0; - int b = 1; - int res = a + b; - - for (int i = 2; i <= n; i++) { - res = a + b; - a = b; - b = res; - } - - return res; - } - - public static void main(String[] args) { - System.out.println(fibonacciTopDown(4, new int[5])); - System.out.println(fibonacciBottomUp(4)); - System.out.println(fibonacciBottomUpOptimized(4)); - System.out.println("---"); - System.out.println(fibonacciTopDown(5, new int[6])); - System.out.println(fibonacciBottomUp(5)); - System.out.println(fibonacciBottomUpOptimized(5)); - System.out.println("---"); - System.out.println(fibonacciTopDown(10, new int[11])); - System.out.println(fibonacciBottomUp(10)); - System.out.println(fibonacciBottomUpOptimized(10)); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/stacksandqueues/QueueViaStacks.java b/src/main/java/com/ctci/stacksandqueues/QueueViaStacks.java deleted file mode 100644 index 271fd8e4..00000000 --- a/src/main/java/com/ctci/stacksandqueues/QueueViaStacks.java +++ /dev/null @@ -1,61 +0,0 @@ -package com.ctci.stacksandqueues; - -import java.util.NoSuchElementException; -import java.util.Stack; - -/** - * Implement a queue using two stacks. No other data structures to be used. - * - * @author rampatra - * @since 2019-02-06 - */ -public class QueueViaStacks { - - private Stack stackFront = new Stack<>(); - private Stack stackRear = new Stack<>(); - - private T add(T item) { - return stackRear.push(item); - } - - private T remove() { - if (stackFront.empty() && stackRear.empty()) { - throw new NoSuchElementException(); - } else if (!stackFront.empty()) { - return stackFront.pop(); - } else { - while (!stackRear.empty()) { - stackFront.push(stackRear.pop()); - } - return stackFront.pop(); - } - } - - private void print() { - Stack tempStack = new Stack<>(); - while (!stackFront.empty()) { - tempStack.push(stackFront.pop()); - } - System.out.print("["); - tempStack.forEach(item -> System.out.print(item + ",")); - stackRear.forEach(item -> System.out.print(item + ",")); - System.out.println("]"); - while (!tempStack.empty()) { - stackFront.push(tempStack.pop()); - } - } - - public static void main(String[] args) { - QueueViaStacks queue = new QueueViaStacks<>(); - queue.add(1); - queue.add(2); - queue.add(3); - queue.print(); - queue.remove(); - queue.print(); - queue.remove(); - queue.print(); - queue.remove(); - queue.print(); - } -} diff --git a/src/main/java/com/ctci/stacksandqueues/SortStack.java b/src/main/java/com/ctci/stacksandqueues/SortStack.java deleted file mode 100644 index b94c68fb..00000000 --- a/src/main/java/com/ctci/stacksandqueues/SortStack.java +++ /dev/null @@ -1,48 +0,0 @@ -package com.ctci.stacksandqueues; - -import java.util.Arrays; -import java.util.Stack; - -/** - * Write a program to sort a stack such that the smallest items are on the top. You can use an additional temporary - * stack, but you may not copy the elements into any other data structure (such as an array). The stack supports the - * following operations: push, pop, peek, and isEmpty. - * - * @author rampatra - * @since 2019-02-08 - */ -public class SortStack { - - private static void sortStack(Stack stack) { - Stack tempStack = new Stack<>(); - while (!stack.empty()) { - tempStack.push(stack.pop()); - } - while (!tempStack.empty()) { - Integer item = tempStack.pop(); - if (stack.empty()) { - stack.push(item); - } else { - while (!stack.empty() && item > stack.peek()) { - tempStack.push(stack.pop()); - } - stack.push(item); - } - } - } - - private static void printStack(Stack stack) { - System.out.println(Arrays.toString(stack.toArray())); - } - - public static void main(String[] args) { - Stack unsortedStack = new Stack<>(); - unsortedStack.push(2); - unsortedStack.push(5); - unsortedStack.push(1); - unsortedStack.push(3); - printStack(unsortedStack); - sortStack(unsortedStack); - printStack(unsortedStack); - } -} diff --git a/src/main/java/com/ctci/stacksandqueues/StackMin.java b/src/main/java/com/ctci/stacksandqueues/StackMin.java deleted file mode 100644 index 0a5d2d59..00000000 --- a/src/main/java/com/ctci/stacksandqueues/StackMin.java +++ /dev/null @@ -1,62 +0,0 @@ -package com.ctci.stacksandqueues; - -import com.sun.tools.javac.util.Assert; - -import java.util.Stack; - -/** - * How would you design a stack which, in addition to push and pop, has a function min - * which returns the minimum element? Push, pop and min should all operate in 0(1) time. - * - * @author rampatra - * @since 2019-02-04 - */ -public class StackMin { - - // the main stack to do push, pop, and min operations - private static Stack stack = new Stack<>(); - // another stack to store the mins (needed to make min() call O(1)) - private static Stack minStack = new Stack<>(); - - private static int push(int item) { - minPush(item); - return stack.push(item); - } - - private static int pop() { - minPop(stack.peek()); - return stack.pop(); - } - - private static int min() { - return minStack.peek(); - } - - private static void minPush(int item) { - if (minStack.empty() || item <= minStack.peek()) { - minStack.push(item); - } - } - - private static void minPop(int item) { - if (item == minStack.peek()) { - minStack.pop(); - } - } - - public static void main(String[] args) { - push(2); - push(5); - push(1); - push(1); - push(6); - push(8); - Assert.check(min() == 1); - pop(); - pop(); - pop(); - Assert.check(min() == 1); - pop(); - Assert.check(min() == 2); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/stacksandqueues/StackOfPlates.java b/src/main/java/com/ctci/stacksandqueues/StackOfPlates.java deleted file mode 100644 index f001c4e4..00000000 --- a/src/main/java/com/ctci/stacksandqueues/StackOfPlates.java +++ /dev/null @@ -1,80 +0,0 @@ -package com.ctci.stacksandqueues; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.EmptyStackException; -import java.util.List; -import java.util.Stack; - -/** - * Imagine a (literal) stack of plates. If the stack gets too high, it might topple. Therefore, in real life, we - * would likely start a new stack when the previous stack exceeds some threshold. Implement a data structure - * SetOfStacks that mimics this. SetOfStacks should be composed of several stacks and should create a new stack once - * the previous one exceeds capacity. SetOfStacks.push() and SetOfStacks. pop() should behave identically to a single - * stack (that is, pop() should return the same values as it would if there were just a single stack). - * - * @author rampatra - * @since 2019-02-08 - */ -public class StackOfPlates { - - private static final int capacity = 3; - private static List> stackList = new ArrayList<>(); - - private static int push(int item) { - return getLastStack().push(item); - } - - private static int pop() { - Stack lastStack = stackList.get(stackList.size() - 1); - if (lastStack == null || (stackList.size() == 1 && lastStack.empty())) { - throw new EmptyStackException(); - } else if (lastStack.empty()) { - stackList.remove(stackList.size() - 1); - return pop(); - } else { - return lastStack.pop(); - } - } - - private static Stack getLastStack() { - if (stackList.size() == 0 || isFull(stackList.get(stackList.size() - 1))) { - stackList.add(new Stack<>()); - } - return stackList.get(stackList.size() - 1); - } - - private static boolean isFull(Stack stack) { - return stack.size() >= capacity; - } - - private static void print() { - System.out.print("["); - stackList.stream().flatMap(Collection::stream).forEach(System.out::print); - System.out.println("]"); - } - - public static void main(String[] args) { - push(1); - push(2); - print(); - push(3); - print(); - push(4); - push(5); - print(); - push(6); - push(7); - print(); - pop(); - print(); - pop(); - pop(); - pop(); - print(); - pop(); - pop(); - pop(); - print(); - } -} diff --git a/src/main/java/com/ctci/treesandgraphs/BuildOrder.java b/src/main/java/com/ctci/treesandgraphs/BuildOrder.java deleted file mode 100644 index 6d64e48a..00000000 --- a/src/main/java/com/ctci/treesandgraphs/BuildOrder.java +++ /dev/null @@ -1,144 +0,0 @@ -package com.ctci.treesandgraphs; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.HashSet; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.stream.Stream; - -/** - * You are given a list of projects and a list of dependencies (which is a list of pairs of projects, where the second - * project is dependent on the first project). All of a project's dependencies must be built before the project is. Find - * a build order that will allow the projects to be built. If there is no valid build order, return an error. - * EXAMPLE - * Input: projects: a, b, c, d, e, f and dependencies: (a, d), (f, b), (b, d), (f, a), (d, c) - * Output: f, e, a, b, d, c - * - * @author rampatra - * @since 2019-02-21 - */ -public class BuildOrder { - - private class Project { - String name; - Set dependencies = new HashSet<>(); - - Project(String name) { - this.name = name; - } - - @Override - public String toString() { - return name; - } - } - - private final Map projects = new HashMap<>(); - - private void addProjects(Stream projectNames) { - projectNames.forEach(name -> projects.put(name, new Project(name))); - } - - /** - * Adds a directed edge from {@code projectName2} to {@code ProjectName1}. This means {@code projectName2} is - * dependent on {@code projectName1}, i.e, {@code projectName1} has to be built before {@code projectName2}. - * - * @param projectName1 name of project 1 - * @param projectName2 name of project 2 - */ - private void addDependency(String projectName1, String projectName2) { - Project p1 = projects.get(projectName1); - Project p2 = projects.get(projectName2); - - if (p1 == null) { - p1 = new Project(projectName1); - projects.put(projectName1, p1); - } - if (p2 == null) { - p2 = new Project(projectName2); - projects.put(projectName2, p2); - } - - p2.dependencies.add(p1); - } - - /** - * Determines the order in which the projects need to be built. - * Time complexity: TODO - * - * @return a list of projects in the order they should be built, the first project should be built first and so on. - */ - private List getBuildOrder() { - Map projectsBuilt = new LinkedHashMap<>(); // linked hashmap is needed to maintain the insertion order - - while (projectsBuilt.size() != projects.size()) { - // find the projects which are not dependent on any project - Set nextProjectsToBuild = getProjectsWithNoDependencies(projectsBuilt); - - // if there are no further independent projects to build, then we can't proceed further - if (nextProjectsToBuild.size() == 0) { - throw new IllegalStateException("Error: Projects can't be built."); - } - nextProjectsToBuild.forEach(p -> projectsBuilt.put(p.name, p)); - - // once a project is built, remove the dependencies from all other projects dependent on this - removeDependency(nextProjectsToBuild); - } - - return new ArrayList<>(projectsBuilt.values()); - } - - private Set getProjectsWithNoDependencies(Map alreadyBuildProjects) { - Set unBuiltProjectsWithZeroDependencies = new HashSet<>(); - - for (Map.Entry entry : projects.entrySet()) { - if (entry.getValue().dependencies.size() == 0 && alreadyBuildProjects.get(entry.getKey()) == null) { - unBuiltProjectsWithZeroDependencies.add(entry.getValue()); - } - } - - return unBuiltProjectsWithZeroDependencies; - } - - private void removeDependency(Set newlyBuiltProjects) { - projects.forEach((n, p) -> p.dependencies.removeAll(newlyBuiltProjects)); - } - - - public static void main(String[] args) { - /* test case 1 - - ––––––––––– b - | ↑ - ↓ | - f <–– a <–– d <–– c - - Note: Project "a" is dependent on "f", and project "d" is dependent on "a", and so on. - - */ - BuildOrder buildOrder = new BuildOrder(); - buildOrder.addProjects(Stream.of("a", "b", "c", "d", "e", "f")); - buildOrder.addDependency("a", "d"); - buildOrder.addDependency("f", "b"); - buildOrder.addDependency("b", "d"); - buildOrder.addDependency("f", "a"); - buildOrder.addDependency("d", "c"); - System.out.println(buildOrder.getBuildOrder()); - - // test case 2 - buildOrder = new BuildOrder(); - buildOrder.addProjects(Stream.of("a", "b", "c", "d", "e", "f", "g")); - buildOrder.addDependency("d", "g"); - buildOrder.addDependency("f", "b"); - buildOrder.addDependency("f", "c"); - buildOrder.addDependency("f", "a"); - buildOrder.addDependency("c", "a"); - buildOrder.addDependency("b", "a"); - buildOrder.addDependency("b", "e"); - buildOrder.addDependency("a", "e"); - System.out.println(buildOrder.getBuildOrder()); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/treesandgraphs/CheckBalanced.java b/src/main/java/com/ctci/treesandgraphs/CheckBalanced.java deleted file mode 100644 index d7658cd8..00000000 --- a/src/main/java/com/ctci/treesandgraphs/CheckBalanced.java +++ /dev/null @@ -1,81 +0,0 @@ -package com.ctci.treesandgraphs; - -/** - * Implement a function to check if a binary tree is balanced. For the purposes of this question, a balanced - * tree is defined to be a tree such that the heights of the two subtrees of any node never differ by more than one. - * - * @author rampatra - * @since 2019-02-16 - */ -public class CheckBalanced { - - /** - * Checks whether its left and right child are balanced, if yes then continues down the - * tree or else stops and returns {@code false}. Time complexity: O(n log n) since each - * node is touched once per node above it. Space complexity: O(h) where, h is the height - * of the tree. - * - * @param node reference to the node for which the balanced property needs to be checked - * @return {@code true} if balanced, {@code false} otherwise - */ - private static boolean isBalanced(TreeNode node) { - if (node == null) return true; - - boolean isBalanced = (height(node.left) - height(node.right)) <= 1; - - /* Note: isBalanced is first checked below as there is no point is checking the left and right child - if the current node itself is not balanced. And, as '&&' is a short circuit operator, it won't evaluate - the rest of the conditions if the first condition is false. */ - return isBalanced && isBalanced(node.left) && isBalanced(node.right); - } - - private static int height(TreeNode node) { - if (node == null) return -1; - - return Math.max(height(node.left), height(node.right)) + 1; - } - - /** - * This approach is a slight modification to the above {@link CheckBalanced#height(TreeNode)} method where - * while calculating the height we also check whether the difference between the left and right child heights - * is more than 1. If yes, we return an error code, which in this case, is {@code Integer.MIN_VALUE}. - * Time complexity: O(n). Space complexity: O(h) where, h is the height of the tree. - * - * @param node reference to the node for which the balanced property needs to be checked - * @return the height of the tree if it's balance, {@code Integer.MIN_VALUE} otherwise - */ - private static int checkHeightAndBalance(TreeNode node) { - if (node == null) return -1; - - int leftHeight = checkHeightAndBalance(node.left); - int rightHeight = checkHeightAndBalance(node.right); - - if (leftHeight == Integer.MIN_VALUE || rightHeight == Integer.MIN_VALUE || !(leftHeight - rightHeight <= 1)) { - return Integer.MIN_VALUE; - } - - return Math.max(leftHeight, rightHeight) + 1; - } - - public static boolean isBalancedOptimized(TreeNode node) { - return checkHeightAndBalance(node) != Integer.MIN_VALUE; - } - - public static void main(String[] args) { - TreeNode treeRoot = new TreeNode(1); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(3); - System.out.println("Height: " + height(treeRoot)); - System.out.println("Is Balance: " + isBalanced(treeRoot)); - System.out.println("Is Balance Optimized: " + isBalancedOptimized(treeRoot)); - - treeRoot = new TreeNode(1); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(3); - treeRoot.left.left = new TreeNode(4); - treeRoot.left.left.left = new TreeNode(5); - System.out.println("Height: " + height(treeRoot)); - System.out.println("Is Balance: " + isBalanced(treeRoot)); - System.out.println("Is Balance Optimized: " + isBalancedOptimized(treeRoot)); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/treesandgraphs/CheckSubtree.java b/src/main/java/com/ctci/treesandgraphs/CheckSubtree.java deleted file mode 100644 index a49f1b74..00000000 --- a/src/main/java/com/ctci/treesandgraphs/CheckSubtree.java +++ /dev/null @@ -1,96 +0,0 @@ -package com.ctci.treesandgraphs; - -/** - * @author rampatra - * @since 2019-02-24 - */ -public class CheckSubtree { - - private static boolean isT2SubtreeOfT1(TreeNode t1, TreeNode t2) { - if (t1 == null) { - return false; - } else if (t2 == null) { - return true; - } - - if (t1.val == t2.val) { - if (matchTree(t1, t2)) { - return true; - } - } - return isT2SubtreeOfT1(t1.left, t2) || isT2SubtreeOfT1(t1.right, t2); - } - - private static boolean matchTree(TreeNode a, TreeNode b) { - if (a == null && b == null) { - return true; - } else if (a == null) { - return false; - } else if (b == null) { - return true; - } else if (a.val != b.val) { - return false; - } else { - return matchTree(a.left, b.left) && matchTree(a.right, b.right); - } - } - - public static void main(String[] args) { - /* - The BST looks like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - / - 0 - - */ - TreeNode treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(8); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(3); - treeRoot.left.left.left = new TreeNode(0); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - System.out.println(isT2SubtreeOfT1(treeRoot, treeRoot)); - System.out.println(isT2SubtreeOfT1(treeRoot, treeRoot.left)); - System.out.println(isT2SubtreeOfT1(treeRoot, treeRoot.right)); - - /* - The sub-tree: - - 8 - / - 6 - */ - TreeNode treeRoot2 = new TreeNode(8); - treeRoot2.left = new TreeNode(6); - System.out.println(isT2SubtreeOfT1(treeRoot, treeRoot2)); - - /* - The sub-tree: - - 2 - / - 1 - */ - TreeNode treeRoot3 = new TreeNode(2); - treeRoot3.left = new TreeNode(1); - System.out.println(isT2SubtreeOfT1(treeRoot, treeRoot3)); - - /* - The sub-tree: - - 8 - / - 9 - */ - TreeNode treeRoot4 = new TreeNode(8); - treeRoot4.left = new TreeNode(9); - System.out.println(isT2SubtreeOfT1(treeRoot, treeRoot4)); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/treesandgraphs/FirstCommonAncestor.java b/src/main/java/com/ctci/treesandgraphs/FirstCommonAncestor.java deleted file mode 100644 index 38977be3..00000000 --- a/src/main/java/com/ctci/treesandgraphs/FirstCommonAncestor.java +++ /dev/null @@ -1,103 +0,0 @@ -package com.ctci.treesandgraphs; - -/** - * Design an algorithm and write code to find the first common ancestor of two nodes in a binary - * tree. Avoid storing additional nodes in a data structure. Also, for this question, the tree node - * does NOT have access to its parent node. NOTE: This is not necessarily a binary search tree. - * - * First Common Ancestor or the Least/Lowest Common Ancestor of two nodes is a node which is the - * closest to both of the nodes. - * - * @author rampatra - * @since 2019-02-24 - */ -public class FirstCommonAncestor { - - /** - * We recurse through the entire tree with a function called findFCA(TreeNode root, TreeNode TreeNode a, TreeNode b). - * This function returns values as follows: - * - Returns p, if root's subtree includes p (and not q). - * - Returns q, if root's subtree includes q (and not p). - * - Returns null, if neither p nor q are in root's subtree. - * - Else, returns the common ancestor of p and q. - *

- * See {@link com.rampatra.trees.LeastCommonAncestorInBT} for a better answer. - * - * @param root - * @param a - * @param b - * @return the least common ancestor node - */ - private static TreeNode findFCA(TreeNode root, TreeNode a, TreeNode b) { - if (root == null) { // validation - return null; - } - if (root == a && root == b) { // optimization - return root; - } - - TreeNode left = findFCA(root.left, a, b); - if (left != null && left != a && left != b) { - return left; - } - - TreeNode right = findFCA(root.right, a, b); - if (right != null && right != a && right != b) { - return right; - } - - /* One node is found on the left subtree and other on the - right one. This means current node is the ancestor. */ - if (left != null && right != null) { - return root; - } else if (root == a || root == b) { - return root; - } else { - return left == null ? right : left; - } - } - - private static class TreeNode { - int val; - TreeNode left; - TreeNode right; - - TreeNode(int val) { - this.val = val; - } - } - - public static void main(String[] args) { - /* - The binary tree looks like: - - 4 - / \ - 5 8 - / \ / \ - 1 3 2 9 - / \ - 0 7 - - */ - TreeNode treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(5); - treeRoot.right = new TreeNode(8); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(3); - treeRoot.left.left.left = new TreeNode(0); - treeRoot.right.left = new TreeNode(2); - treeRoot.right.right = new TreeNode(9); - treeRoot.right.left.right = new TreeNode(7); - - System.out.println("FCA of 0 and 7 is: " + findFCA(treeRoot, treeRoot.left.left.left, treeRoot.right.left.right).val); - System.out.println("FCA of 0 and 9 is: " + findFCA(treeRoot, treeRoot.left.left.left, treeRoot.right.right).val); - System.out.println("FCA of 0 and 1 is: " + findFCA(treeRoot, treeRoot.left.left.left, treeRoot.left.left).val); - System.out.println("FCA of 1 and 2 is: " + findFCA(treeRoot, treeRoot.left.left, treeRoot.right.left).val); - System.out.println("FCA of 1 and 7 is: " + findFCA(treeRoot, treeRoot.left.left, treeRoot.right.left.right).val); - System.out.println("FCA of 4 and 7 is: " + findFCA(treeRoot, treeRoot, treeRoot.right.left.right).val); - System.out.println("FCA of 5 and 2 is: " + findFCA(treeRoot, treeRoot.left, treeRoot.right.left).val); - System.out.println("FCA of 7 and 9 is: " + findFCA(treeRoot, treeRoot.right.left.right, treeRoot.right.right).val); - System.out.println("FCA of 7 and 10 is: " + findFCA(treeRoot, treeRoot.right.left.right, new TreeNode(10)).val); // this use case does not work with the above algorithm - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/treesandgraphs/FirstCommonAncestorWithParentAccess.java b/src/main/java/com/ctci/treesandgraphs/FirstCommonAncestorWithParentAccess.java deleted file mode 100644 index 5aa453cf..00000000 --- a/src/main/java/com/ctci/treesandgraphs/FirstCommonAncestorWithParentAccess.java +++ /dev/null @@ -1,115 +0,0 @@ -package com.ctci.treesandgraphs; - -/** - * Design an algorithm and write code to find the first common ancestor of two nodes in a binary - * tree. Avoid storing additional nodes in a data structure. Also, for this question, the tree node - * has access to its parent node. NOTE: This is not necessarily a binary search tree. - * - * @author rampatra - * @since 2019-02-23 - */ -public class FirstCommonAncestorWithParentAccess { - - /** - * This is a simple approach where we start with two references, one pointing to {@code node a} and another - * pointing to {@code node b}. We move the reference pointing to the deeper node upwards, if required, so that - * both the references are at the same depth from root. After both the references are at same depth, we simply - * move both the references upwards until they merge. The node at which they merge is our LCA. - * - * @param a - * @param b - * @return the least common ancestor node - */ - private static TreeNode findLCA(TreeNode a, TreeNode b) { - if (a == null || b == null) { - return null; - } - - int depthA = depth(a); - int depthB = depth(b); - /* be little careful when both nodes are at same depth, have the checks such that - shallow and deeper references point to different nodes */ - TreeNode shallowNode = depthA < depthB ? a : b; - TreeNode deeperNode = depthB > depthA ? b : a; - - // move deeper node reference upwards so that both the references are at same depth - deeperNode = goUpBy(deeperNode, Math.abs(depthA - depthB)); - - while (shallowNode != deeperNode && shallowNode != null && deeperNode != null) { - shallowNode = shallowNode.parent; - deeperNode = deeperNode.parent; - } - - return shallowNode; - } - - private static int depth(TreeNode node) { - int d = 0; - while (node != null && node.parent != null) { - d++; - node = node.parent; - } - return d; - } - - private static TreeNode goUpBy(TreeNode node, int levelsUp) { - int c = 0; - while (node != null && c < levelsUp) { - node = node.parent; - c++; - } - return node; - } - - private static class TreeNode { - int val; - TreeNode parent; - TreeNode left; - TreeNode right; - - TreeNode(int val) { - this.val = val; - } - } - - public static void main(String[] args) { - /* - The binary tree looks like: - - 4 - / \ - 5 8 - / \ / \ - 1 3 2 9 - / \ - 0 7 - - */ - TreeNode treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(5); - treeRoot.left.parent = treeRoot; - treeRoot.right = new TreeNode(8); - treeRoot.right.parent = treeRoot; - treeRoot.left.left = new TreeNode(1); - treeRoot.left.left.parent = treeRoot.left; - treeRoot.left.right = new TreeNode(3); - treeRoot.left.right.parent = treeRoot.left; - treeRoot.left.left.left = new TreeNode(0); - treeRoot.left.left.left.parent = treeRoot.left.left; - treeRoot.right.left = new TreeNode(2); - treeRoot.right.left.parent = treeRoot.right; - treeRoot.right.right = new TreeNode(9); - treeRoot.right.right.parent = treeRoot.right; - treeRoot.right.left.right = new TreeNode(7); - treeRoot.right.left.right.parent = treeRoot.right.left; - - System.out.println("FCA of 0 and 7 is: " + findLCA(treeRoot.left.left.left, treeRoot.right.left.right).val); - System.out.println("FCA of 0 and 9 is: " + findLCA(treeRoot.left.left.left, treeRoot.right.right).val); - System.out.println("FCA of 0 and 1 is: " + findLCA(treeRoot.left.left.left, treeRoot.left.left).val); - System.out.println("FCA of 1 and 2 is: " + findLCA(treeRoot.left.left, treeRoot.right.left).val); - System.out.println("FCA of 1 and 7 is: " + findLCA(treeRoot.left.left, treeRoot.right.left.right).val); - System.out.println("FCA of 4 and 7 is: " + findLCA(treeRoot, treeRoot.right.left.right).val); - System.out.println("FCA of 5 and 2 is: " + findLCA(treeRoot.left, treeRoot.right.left).val); - System.out.println("FCA of 7 and 9 is: " + findLCA(treeRoot.right.left.right, treeRoot.right.right).val); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/treesandgraphs/GraphNode.java b/src/main/java/com/ctci/treesandgraphs/GraphNode.java deleted file mode 100644 index 573cccf3..00000000 --- a/src/main/java/com/ctci/treesandgraphs/GraphNode.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.ctci.treesandgraphs; - -import java.util.HashSet; -import java.util.Set; - -/** - * @author rampatra - * @since 2019-03-21 - */ -public class GraphNode { - int value; - Set adjacent = new HashSet<>(); - - GraphNode(int value) { - this.value = value; - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/treesandgraphs/ListOfDepths.java b/src/main/java/com/ctci/treesandgraphs/ListOfDepths.java deleted file mode 100644 index fd5287dc..00000000 --- a/src/main/java/com/ctci/treesandgraphs/ListOfDepths.java +++ /dev/null @@ -1,99 +0,0 @@ -package com.ctci.treesandgraphs; - -import java.util.ArrayList; -import java.util.List; - -/** - * Given a binary tree, design an algorithm which creates a linked list of all the nodes - * at each depth (e.g., if you have a tree with depth D, you'll have D linked lists). - * - * @author rampatra - * @since 2019-02-16 - */ -public class ListOfDepths { - - /** - * This approach visits the root node, adds all its children to a list, then iterates - * that list, and repeats the same process until all nodes are visited. - * - * @param root the root node of the tree - * @return list of nodes at each depth, where depth starts from 0 - */ - private static List> listOfDepths(TreeNode root) { - List> listOfDepths = new ArrayList<>(); - List listOfNodesAtCurrentDepth = new ArrayList<>(); - - if (root != null) { - listOfNodesAtCurrentDepth.add(root); - } - - while (listOfNodesAtCurrentDepth.size() > 0) { - listOfDepths.add(listOfNodesAtCurrentDepth); // add current depth - List listOfNodesAtPreviousDepth = listOfNodesAtCurrentDepth; // make current depth as previous - /* make current depth as the new depth to be processed considering - the nodes from the previous depth as parents */ - listOfNodesAtCurrentDepth = new ArrayList<>(); - - for (TreeNode node : listOfNodesAtPreviousDepth) { - if (node.left != null) { - listOfNodesAtCurrentDepth.add(node.left); - } - if (node.right != null) { - listOfNodesAtCurrentDepth.add(node.right); - } - } - } - - return listOfDepths; - } - - /** - * This is a recursive approach where we pass the depth of each node in the call. We use a - * list {@code listOfDepths} to keep track of all the depths. - * - * @param node - * @param depth - * @param listOfDepths - * @return list of nodes at each depth, where depth starts from 0 - */ - private static List> listOfDepths(TreeNode node, int depth, List> listOfDepths) { - if (node == null) return null; - - List listOfNodesAtDepth; - if (depth == listOfDepths.size()) { - listOfNodesAtDepth = new ArrayList<>(); - listOfDepths.add(listOfNodesAtDepth); - } else { - listOfNodesAtDepth = listOfDepths.get(depth); - } - - listOfNodesAtDepth.add(node); - - listOfDepths(node.left, depth + 1, listOfDepths); - listOfDepths(node.right, depth + 1, listOfDepths); - - return listOfDepths; - } - - private static void printAllDepths(List> listOfDepths) { - for (int i = 0; i < listOfDepths.size(); i++) { - System.out.print("Depth " + i + ": "); - listOfDepths.get(i).forEach(node -> System.out.print("->" + node.val)); - System.out.println(); - } - } - - public static void main(String[] args) { - TreeNode treeRoot = new TreeNode(1); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(3); - treeRoot.left.left = new TreeNode(4); - treeRoot.left.right = new TreeNode(5); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(7); - - printAllDepths(listOfDepths(treeRoot)); - System.out.println("-----"); - printAllDepths(listOfDepths(treeRoot, 0, new ArrayList<>())); - } -} diff --git a/src/main/java/com/ctci/treesandgraphs/MinimalTree.java b/src/main/java/com/ctci/treesandgraphs/MinimalTree.java deleted file mode 100644 index 4d18faf7..00000000 --- a/src/main/java/com/ctci/treesandgraphs/MinimalTree.java +++ /dev/null @@ -1,43 +0,0 @@ -package com.ctci.treesandgraphs; - -/** - * Given a sorted (increasing order) array with unique integer elements, write - * an algorithm to create a binary search tree with minimal height. - * - * @author rampatra - * @since 2019-02-15 - */ -public class MinimalTree { - - private static TreeNode constructBSTWithMinimalHeight(int[] arr, int start, int end) { - if (start > end) return null; - - int mid = (start + end) / 2; - TreeNode root = new TreeNode(arr[mid]); - root.left = constructBSTWithMinimalHeight(arr, start, mid - 1); - root.right = constructBSTWithMinimalHeight(arr, mid + 1, end); - return root; - } - - private static void inOrderTraversal(TreeNode node) { - if (node == null) return; - - inOrderTraversal(node.left); - System.out.print("->" + node.val); - inOrderTraversal(node.right); - } - - public static void main(String[] args) { - TreeNode root = constructBSTWithMinimalHeight(new int[]{1, 2, 3, 4, 5, 6, 7}, 0, 6); - inOrderTraversal(root); - System.out.println(); - root = constructBSTWithMinimalHeight(new int[]{1, 2, 3, 4, 5, 6, 7, 8}, 0, 7); - inOrderTraversal(root); - System.out.println(); - root = constructBSTWithMinimalHeight(new int[]{1, 2}, 0, 1); - inOrderTraversal(root); - System.out.println(); - root = constructBSTWithMinimalHeight(new int[]{1}, 0, 0); - inOrderTraversal(root); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/treesandgraphs/RouteBetweenNodes.java b/src/main/java/com/ctci/treesandgraphs/RouteBetweenNodes.java deleted file mode 100644 index b849b8c8..00000000 --- a/src/main/java/com/ctci/treesandgraphs/RouteBetweenNodes.java +++ /dev/null @@ -1,94 +0,0 @@ -package com.ctci.treesandgraphs; - -import java.util.ArrayDeque; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Queue; -import java.util.Set; - -/** - * @author rampatra - * @since 2019-03-21 - */ -public class RouteBetweenNodes { - - class Graph { - - private final Map nodes = new HashMap<>(); - - /** - * Adds an edge from a node with value {@code v1} to another node with value {@code v2}. - * Note: This code doesn't work for nodes having duplicate values. - * - * @param v1 - * @param v2 - */ - void addEdge(int v1, int v2) { - GraphNode n1 = nodes.get(v1); - GraphNode n2 = nodes.get(v2); - - if (n1 == null) { - n1 = new GraphNode(v1); - nodes.put(v1, n1); - } - if (n2 == null) { - n2 = new GraphNode(v2); - nodes.put(v2, n2); - } - - n1.adjacent.add(n2); // as it is a directed graph - } - - /** - * Checks for a path from a node with value {@code v1} to another node with value {@code v2} in a breadth-first - * manner. Note: This code doesn't work for nodes having duplicate values. - * - * @param v1 the value of the first node or starting node. - * @param v2 the value of the ending node. - * @return {@code true} if path exists, {@code false} otherwise. - */ - boolean isRoutePresent(int v1, int v2) { - Queue queue = new ArrayDeque<>(); - Set visited = new HashSet<>(); - - GraphNode n1 = nodes.get(v1); - GraphNode n2 = nodes.get(v2); - - if (n1 == null || n2 == null) { - return false; - } - - queue.add(n1); - - while (!queue.isEmpty()) { - GraphNode n = queue.poll(); - - if (visited.contains(n)) { - continue; - } - if (n.adjacent.contains(n2)) { - return true; - } - queue.addAll(n.adjacent); - visited.add(n); - } - - return false; - } - } - - public static void main(String[] args) { - Graph g = new RouteBetweenNodes().new Graph(); - g.addEdge(1, 2); - g.addEdge(2, 3); - g.addEdge(4, 5); - g.addEdge(5, 6); - System.out.println("Route exists from 1 to 2: " + g.isRoutePresent(1, 2)); - System.out.println("Route exists from 2 to 5: " + g.isRoutePresent(2, 5)); - System.out.println("Route exists from 1 to 3: " + g.isRoutePresent(1, 3)); - System.out.println("Route exists from 4 to 6: " + g.isRoutePresent(4, 6)); - System.out.println("Route exists from 6 to 4: " + g.isRoutePresent(6, 4)); - System.out.println("Route exists from 6 to 5: " + g.isRoutePresent(6, 5)); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/treesandgraphs/Successor.java b/src/main/java/com/ctci/treesandgraphs/Successor.java deleted file mode 100644 index d37488bd..00000000 --- a/src/main/java/com/ctci/treesandgraphs/Successor.java +++ /dev/null @@ -1,98 +0,0 @@ -package com.ctci.treesandgraphs; - -/** - * Write an algorithm to find the "next" node (i.e., in-order successor) of a given node - * in a binary search tree. You may assume that each node has a link to its parent. - * - * @author rampatra - * @since 2019-02-17 - */ -public class Successor { - - /** - * To get the inorder successor what this method does is that it checks if the right child of the input node - * is null and if not, gets the leftmost child of the right child. And, if the right child of the input - * node is null, it checks all the parents until it finds the next successor. - * - * @param node - * @return - */ - private static TreeNode getInOrderSuccessor(TreeNode node) { - if (node == null) return null; - - if (node.right != null) { - return getLeftmostNode(node.right); - } else { - TreeNode curr = node; - - while (curr != null) { - if (curr.parent != null && curr.parent.left == curr) { - return curr.parent; - } - curr = curr.parent; - } - } - return null; - } - - private static TreeNode getLeftmostNode(TreeNode node) { - TreeNode curr = node; - while (curr != null && curr.left != null) { - curr = curr.left; - } - return curr; - } - - private static class TreeNode { - int val; - TreeNode parent; - TreeNode left; - TreeNode right; - - TreeNode(int val) { - this.val = val; - } - } - - public static void main(String[] args) { - /* - The binary search tree looks like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - / \ - 0 7 - - */ - TreeNode treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.left.parent = treeRoot; - treeRoot.right = new TreeNode(8); - treeRoot.right.parent = treeRoot; - treeRoot.left.left = new TreeNode(1); - treeRoot.left.left.parent = treeRoot.left; - treeRoot.left.right = new TreeNode(3); - treeRoot.left.right.parent = treeRoot.left; - treeRoot.left.left.left = new TreeNode(0); - treeRoot.left.left.left.parent = treeRoot.left.left; - treeRoot.right.left = new TreeNode(6); - treeRoot.right.left.parent = treeRoot.right; - treeRoot.right.right = new TreeNode(9); - treeRoot.right.right.parent = treeRoot.right; - treeRoot.right.left.right = new TreeNode(7); - treeRoot.right.left.right.parent = treeRoot.right.left; - - System.out.println("InOrder successor of 0 is: " + getInOrderSuccessor(treeRoot.left.left.left).val); - System.out.println("InOrder successor of 1 is: " + getInOrderSuccessor(treeRoot.left.left).val); - System.out.println("InOrder successor of 2 is: " + getInOrderSuccessor(treeRoot.left).val); - System.out.println("InOrder successor of 3 is: " + getInOrderSuccessor(treeRoot.left.right).val); - System.out.println("InOrder successor of 4 is: " + getInOrderSuccessor(treeRoot).val); - System.out.println("InOrder successor of 6 is: " + getInOrderSuccessor(treeRoot.right.left).val); - System.out.println("InOrder successor of 7 is: " + getInOrderSuccessor(treeRoot.right.left.right).val); - System.out.println("InOrder successor of 8 is: " + getInOrderSuccessor(treeRoot.right).val); - System.out.println("InOrder successor of 9 is: " + getInOrderSuccessor(treeRoot.right.right)); - } -} \ No newline at end of file diff --git a/src/main/java/com/ctci/treesandgraphs/TreeNode.java b/src/main/java/com/ctci/treesandgraphs/TreeNode.java deleted file mode 100644 index 3fe24210..00000000 --- a/src/main/java/com/ctci/treesandgraphs/TreeNode.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.ctci.treesandgraphs; - -/** - * @author rampatra - * @since 2019-02-15 - */ -public class TreeNode { - public int val; - public TreeNode left; - public TreeNode right; - - public TreeNode(int val) { - this.val = val; - } -} diff --git a/src/main/java/com/ctci/treesandgraphs/ValidateBST.java b/src/main/java/com/ctci/treesandgraphs/ValidateBST.java deleted file mode 100644 index 0170cdfe..00000000 --- a/src/main/java/com/ctci/treesandgraphs/ValidateBST.java +++ /dev/null @@ -1,101 +0,0 @@ -package com.ctci.treesandgraphs; - -import java.util.ArrayList; -import java.util.List; - -/** - * Implement a function to check if a binary tree is a binary search tree. - * - * @author rampatra - * @since 2019-02-17 - */ -public class ValidateBST { - - private static boolean isBST(TreeNode node) { - return isBST(node, new ArrayList<>()); - } - - /** - * This method exploits the fact that the inorder traversal of a binary search tree - * results in the values being sorted in ascending order. Here, we have used a list - * but if you see closely we use this list to only compare with the previous element. - * Ergo, we can use an instance/class variable to store just the last element. This - * will be a good optimization for space. - *

- * Time Complexity: O(n) as we touch all the nodes in the tree. - * Space Complexity: O(n) as we use a list to store all the elements in the tree. If we - * had used just a instance/class variable, the space complexity would have been O(log n) - * as there can be up to O(log n) recursive calls as we may recurse up to the depth of - * the tree. Note, the tree has to balanced though. - * - * @param node - * @param values - * @return - */ - private static boolean isBST(TreeNode node, List values) { - if (node == null) return true; - - isBST(node.left, values); - if (values.isEmpty() || node.val > values.get(values.size() - 1)) { - values.add(node.val); - } else { - return false; - } - isBST(node.right, values); - - return true; - } - - private static boolean isBSTApproach2(TreeNode node) { - return isBSTApproach2(node, Integer.MIN_VALUE, Integer.MAX_VALUE); - } - - /** - * This approach exploits the condition that all left nodes must be less than or equal to - * the current node, which must be less than all the right nodes. - *

- * Time Complexity: O(n) as we touch all the nodes in the tree. - * Space Complexity: O(log n) as there are up to O(log n) recursive calls on the stack - * as we may recurse up to the depth fo the tree. Note, the tree has to be balanced though. - * - * @param node - * @param min - * @param max - * @return - */ - private static boolean isBSTApproach2(TreeNode node, int min, int max) { - if (node == null) return true; - - if (node.val < min || node.val > max) { - return false; - } - - return isBSTApproach2(node.left, min, node.val) && isBSTApproach2(node.right, node.val + 1, max); - } - - public static void main(String[] args) { - TreeNode treeRoot = new TreeNode(1); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(3); - System.out.println("Is BST Approach 1: " + isBST(treeRoot)); - System.out.println("Is BST Approach 2: " + isBSTApproach2(treeRoot)); - - treeRoot = new TreeNode(2); - treeRoot.left = new TreeNode(1); - treeRoot.right = new TreeNode(3); - System.out.println("Is BST Approach 1: " + isBST(treeRoot)); - System.out.println("Is BST Approach 2: " + isBSTApproach2(treeRoot)); - - treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(8); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(3); - treeRoot.left.left.left = new TreeNode(0); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - treeRoot.right.left.right = new TreeNode(7); - System.out.println("Is BST Approach 1: " + isBST(treeRoot)); - System.out.println("Is BST Approach 2: " + isBSTApproach2(treeRoot)); - } -} \ No newline at end of file diff --git a/src/main/java/com/hackerrank/algorithms/recursion/RecursiveDigitSum.java b/src/main/java/com/hackerrank/algorithms/recursion/RecursiveDigitSum.java deleted file mode 100644 index cd9cae21..00000000 --- a/src/main/java/com/hackerrank/algorithms/recursion/RecursiveDigitSum.java +++ /dev/null @@ -1,60 +0,0 @@ -package com.hackerrank.algorithms.recursion; - -import java.io.BufferedWriter; -import java.io.FileWriter; -import java.io.IOException; -import java.util.Scanner; - -/** - * Recursive Digit Sum Problem. - * - * @link https://www.hackerrank.com/challenges/recursive-digit-sum/problem - * @author rpatra16 - * @since 06/11/2018 - */ -public class RecursiveDigitSum { - - /** - * Finds the recursive digit sum of n. - * - * @param n number - * @param k the number would be repeated k times - * @return recursive sum of the digits - */ - private static int superDigit(String n, int k) { - if (n.length() == 1 && k == 0) { - return Integer.parseInt(n); - } - - Long sum = 0L; - char[] num = n.toCharArray(); - for (int i = 0; i < num.length; i++) { - sum += Long.parseLong(String.valueOf(num[i])); - } - - if (k != 0) sum *= k; - - return superDigit(sum.toString(), 0); - } - - private static final Scanner scanner = new Scanner(System.in); - - public static void main(String[] args) throws IOException { - BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH"))); - - String[] nk = scanner.nextLine().split(" "); - - String n = nk[0]; - - int k = Integer.parseInt(nk[1]); - - int result = superDigit(n, k); - - bufferedWriter.write(String.valueOf(result)); - bufferedWriter.newLine(); - - bufferedWriter.close(); - - scanner.close(); - } -} diff --git a/src/main/java/com/hackerrank/algorithms/strings/MakingAnagrams.java b/src/main/java/com/hackerrank/algorithms/strings/MakingAnagrams.java deleted file mode 100644 index b218c04e..00000000 --- a/src/main/java/com/hackerrank/algorithms/strings/MakingAnagrams.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.hackerrank.algorithms.strings; - -import java.util.Arrays; - -/** - * @author rampatra - * @version 28/09/2016 - */ -public class MakingAnagrams { - - /** - * Find number of characters to be deleted to make {@param a} - * and {@param b} anagrams. - * See: https://www.hackerrank.com/challenges/making-anagrams - * - * @param a - * @param b - * @return - */ - public static int makeAnagrams(String a, String b) { - - int i = 0, j = 0, c = 0; - char[] s1 = a.toCharArray(); - char[] s2 = b.toCharArray(); - Arrays.sort(s1); - Arrays.sort(s2); - - while (i < s1.length || j < s2.length) { - if (i >= s1.length) { - c++; - j++; - } else if (j >= s2.length) { - c++; - i++; - } else if (s1[i] < s2[j]) { - c++; - i++; - } else if (s1[i] > s2[j]) { - c++; - j++; - } else { - i++; - j++; - } - } - - return c; - } - - public static void main(String[] args) { - System.out.println(makeAnagrams("abc", "cde")); - } -} diff --git a/src/main/java/com/hackerrank/contests/SwappingInAnArray.java b/src/main/java/com/hackerrank/contests/SwappingInAnArray.java deleted file mode 100644 index d21866d8..00000000 --- a/src/main/java/com/hackerrank/contests/SwappingInAnArray.java +++ /dev/null @@ -1,75 +0,0 @@ -package com.hackerrank.contests; - -import java.io.BufferedWriter; -import java.io.FileWriter; -import java.io.IOException; -import java.util.Scanner; - -/** - * @author rpatra16 - * @since 04/11/2018 - */ -public class SwappingInAnArray { - - /** - * The problem asks if we can sort the array with only one swap. - * - * @param a array to sort - * @return 0 if already sorted, 1 if it can be sorted with one swap, -1 otherwise - */ - static int swapToSort(int[] a) { - int swaps = 0; - for (int i=0; i < a.length-1; i++) { - int swapIndex = i; - for (int j = i + 1; j < a.length; j++) { - if (a[i] > a[j]) { - swapIndex = j; - } - } - if (swapIndex != i) { - swap(a, i, swapIndex); - swaps++; - i--; - } - } - if (swaps > 1) { - return -1; - } else { - return swaps; - } - } - - private static void swap(int[] a, int i, int j) { - int temp = a[i]; - a[i] = a[j]; - a[j] = temp; - } - - private static final Scanner scanner = new Scanner(System.in); - - public static void main(String[] args) throws IOException { - BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH"))); - - int n = scanner.nextInt(); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - int[] a = new int[n]; - - String[] aItems = scanner.nextLine().split(" "); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - for (int i = 0; i < n; i++) { - int aItem = Integer.parseInt(aItems[i]); - a[i] = aItem; - } - - int result = swapToSort(a); - - bufferedWriter.write(String.valueOf(result)); - bufferedWriter.newLine(); - - bufferedWriter.close(); - - scanner.close(); - } -} diff --git a/src/main/java/com/hackerrank/interviewpreparation/arrays/DS2DArrayProblem.java b/src/main/java/com/hackerrank/interviewpreparation/arrays/DS2DArrayProblem.java deleted file mode 100644 index ba7a2fe6..00000000 --- a/src/main/java/com/hackerrank/interviewpreparation/arrays/DS2DArrayProblem.java +++ /dev/null @@ -1,55 +0,0 @@ -package com.hackerrank.interviewpreparation.arrays; - -import java.io.BufferedWriter; -import java.io.FileWriter; -import java.io.IOException; -import java.util.Scanner; - -/** - * @author rpatra16 - * @since 31/10/2018 - */ -public class DS2DArrayProblem { - - private static final Scanner scanner = new Scanner(System.in); - - private static int hourglassSum(int[][] arr) { - int maxSum = Integer.MIN_VALUE; - int hourglassSum; - for (int i = 0; i < arr.length - 2; i++) { - for (int j = 0; j < arr[0].length - 2; j++) { - hourglassSum = arr[i][j] + arr[i][j + 1] + arr[i][j + 2] + arr[i + 1][j + 1] + - arr[i + 2][j] + arr[i + 2][j + 1] + arr[i + 2][j + 2]; - if (hourglassSum > maxSum) { - maxSum = hourglassSum; - } - } - } - return maxSum; - } - - public static void main(String[] args) throws IOException { - BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH"))); - - int[][] arr = new int[6][6]; - - for (int i = 0; i < 6; i++) { - String[] arrRowItems = scanner.nextLine().split(" "); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - for (int j = 0; j < 6; j++) { - int arrItem = Integer.parseInt(arrRowItems[j]); - arr[i][j] = arrItem; - } - } - - int result = hourglassSum(arr); - - bufferedWriter.write(String.valueOf(result)); - bufferedWriter.newLine(); - - bufferedWriter.close(); - - scanner.close(); - } -} diff --git a/src/main/java/com/hackerrank/interviewpreparation/arrays/NewYearChaos.java b/src/main/java/com/hackerrank/interviewpreparation/arrays/NewYearChaos.java deleted file mode 100644 index a065be9d..00000000 --- a/src/main/java/com/hackerrank/interviewpreparation/arrays/NewYearChaos.java +++ /dev/null @@ -1,56 +0,0 @@ -package com.hackerrank.interviewpreparation.arrays; - -import java.util.Scanner; - -/** - * @author rpatra16 - * @since 02/11/2018 - */ -public class NewYearChaos { - - /** - * To solve this question, we just need to count the number of persons - * that overtake a particular person. - * - * @param q the queue - */ - private static void minimumBribes(int[] q) { - int bribes = 0; - for (int i = q.length - 1; i >= 0; i--) { - if (q[i] - i - 1 > 2) { - System.out.println("Too chaotic"); - return; - } - for (int j = Math.max(0, q[i] - 2); j < i; j++) { - if (q[j] > q[i]) bribes++; - } - } - System.out.println(bribes); - } - - private static final Scanner scanner = new Scanner(System.in); - - public static void main(String[] args) { - int t = scanner.nextInt(); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - for (int tItr = 0; tItr < t; tItr++) { - int n = scanner.nextInt(); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - int[] q = new int[n]; - - String[] qItems = scanner.nextLine().split(" "); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - for (int i = 0; i < n; i++) { - int qItem = Integer.parseInt(qItems[i]); - q[i] = qItem; - } - - minimumBribes(q); - } - - scanner.close(); - } -} diff --git a/src/main/java/com/hackerrank/interviewpreparation/greedyalgorithmns/LuckBalance.java b/src/main/java/com/hackerrank/interviewpreparation/greedyalgorithmns/LuckBalance.java deleted file mode 100644 index 3cf74165..00000000 --- a/src/main/java/com/hackerrank/interviewpreparation/greedyalgorithmns/LuckBalance.java +++ /dev/null @@ -1,77 +0,0 @@ -package com.hackerrank.interviewpreparation.greedyalgorithmns; - -import java.io.BufferedWriter; -import java.io.FileWriter; -import java.io.IOException; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Scanner; - -/** - * @author rpatra16 - * @since 04/11/2018 - */ -public class LuckBalance { - - /** - * For the full question, please see: https://www.hackerrank.com/challenges/luck-balance/ - * - * @param k - * @param contests - * @return - */ - private static int luckBalance(int k, int[][] contests) { - int lucks = 0; - List lucksForImportantContests = new ArrayList<>(); - for (int i = 0; i < contests.length; i++) { - if (contests[i][1] == 1) { - lucksForImportantContests.add(contests[i][0]); - } else { - lucks += contests[i][0]; - } - } - lucksForImportantContests.sort(Collections.reverseOrder()); - for (int i = 0; i < lucksForImportantContests.size(); i++) { - if (i < k) { // can lose at most k of the important contests - lucks += lucksForImportantContests.get(i); - } else { - lucks -= lucksForImportantContests.get(i); - } - } - return lucks; - } - - private static final Scanner scanner = new Scanner(System.in); - - public static void main(String[] args) throws IOException { - BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH"))); - - String[] nk = scanner.nextLine().split(" "); - - int n = Integer.parseInt(nk[0]); - - int k = Integer.parseInt(nk[1]); - - int[][] contests = new int[n][2]; - - for (int i = 0; i < n; i++) { - String[] contestsRowItems = scanner.nextLine().split(" "); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - for (int j = 0; j < 2; j++) { - int contestsItem = Integer.parseInt(contestsRowItems[j]); - contests[i][j] = contestsItem; - } - } - - int result = luckBalance(k, contests); - - bufferedWriter.write(String.valueOf(result)); - bufferedWriter.newLine(); - - bufferedWriter.close(); - - scanner.close(); - } -} diff --git a/src/main/java/com/hackerrank/interviewpreparation/greedyalgorithmns/MinimumAbsoluteDifference.java b/src/main/java/com/hackerrank/interviewpreparation/greedyalgorithmns/MinimumAbsoluteDifference.java deleted file mode 100644 index 6cff867b..00000000 --- a/src/main/java/com/hackerrank/interviewpreparation/greedyalgorithmns/MinimumAbsoluteDifference.java +++ /dev/null @@ -1,59 +0,0 @@ -package com.hackerrank.interviewpreparation.greedyalgorithmns; - -import java.io.BufferedWriter; -import java.io.FileWriter; -import java.io.IOException; -import java.util.Arrays; -import java.util.Scanner; - -/** - * @author rpatra16 - * @since 04/11/2018 - */ -public class MinimumAbsoluteDifference { - - /** - * Finds the minimum absolute difference in the array. - * - * @param a input array - * @return the minimum absolute difference between any two different elements in the array a - */ - static int minimumAbsoluteDifference(int[] a) { - int minDiff = Integer.MAX_VALUE, diff; - Arrays.sort(a); - for (int i = 0; i < a.length - 1; i++) { - if ((diff = Math.abs(a[i] - a[i + 1])) < minDiff) { - minDiff = diff; - } - } - return minDiff; - } - - private static final Scanner scanner = new Scanner(System.in); - - public static void main(String[] args) throws IOException { - BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH"))); - - int n = scanner.nextInt(); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - int[] arr = new int[n]; - - String[] arrItems = scanner.nextLine().split(" "); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - for (int i = 0; i < n; i++) { - int arrItem = Integer.parseInt(arrItems[i]); - arr[i] = arrItem; - } - - int result = minimumAbsoluteDifference(arr); - - bufferedWriter.write(String.valueOf(result)); - bufferedWriter.newLine(); - - bufferedWriter.close(); - - scanner.close(); - } -} diff --git a/src/main/java/com/hackerrank/interviewpreparation/warmup/JumpingClouds.java b/src/main/java/com/hackerrank/interviewpreparation/warmup/JumpingClouds.java deleted file mode 100644 index 36cab3dc..00000000 --- a/src/main/java/com/hackerrank/interviewpreparation/warmup/JumpingClouds.java +++ /dev/null @@ -1,58 +0,0 @@ -package com.hackerrank.interviewpreparation.warmup; - -import java.io.BufferedWriter; -import java.io.FileWriter; -import java.io.IOException; -import java.util.Scanner; - -/** - * @author rpatra16 - * @since 31/10/2018 - */ -public class JumpingClouds { - - private static final Scanner scanner = new Scanner(System.in); - - private static int jumpingOnClouds(int[] c) { - int jumps = 0; - int i = 0; - while (i < c.length) { - if (((i + 2) < c.length) && c[i + 2] != 1) { - i += 2; - } else if (((i + 1) < c.length) && c[i + 1] != 1) { - i += 1; - } - jumps++; - if (i == c.length - 1) { - break; - } - } - return jumps; - } - - public static void main(String[] args) throws IOException { - BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH"))); - - int n = scanner.nextInt(); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - int[] c = new int[n]; - - String[] cItems = scanner.nextLine().split(" "); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - for (int i = 0; i < n; i++) { - int cItem = Integer.parseInt(cItems[i]); - c[i] = cItem; - } - - int result = jumpingOnClouds(c); - - bufferedWriter.write(String.valueOf(result)); - bufferedWriter.newLine(); - - bufferedWriter.close(); - - scanner.close(); - } -} diff --git a/src/main/java/com/hackerrank/interviewpreparation/warmup/RepeatedString.java b/src/main/java/com/hackerrank/interviewpreparation/warmup/RepeatedString.java deleted file mode 100644 index 63b4ffba..00000000 --- a/src/main/java/com/hackerrank/interviewpreparation/warmup/RepeatedString.java +++ /dev/null @@ -1,56 +0,0 @@ -package com.hackerrank.interviewpreparation.warmup; - -import java.io.BufferedWriter; -import java.io.FileWriter; -import java.io.IOException; -import java.util.Scanner; - -/** - * Repeated String problem. - * - * @author rpatra16 - * @since 29/10/2018 - */ -public class RepeatedString { - - private static final Scanner scanner = new Scanner(System.in); - - private static long repeatedString(String s, long n) { - int extraLetters; - long totalCount = 0, count = 0, stringLength = s.length(); - // count the no of a in non-repeated string - for (int i = 0; i < stringLength; i++) { - if (s.charAt(i) == 'a') { - count++; - } - } - totalCount += (n / stringLength * count); - extraLetters = (int) (n % stringLength); - // count the no of a in the remainder of the string - for (int i = 0; i < extraLetters; i++) { - if (s.charAt(i) == 'a') { - totalCount++; - } - } - return totalCount; - } - - public static void main(String[] args) throws IOException { - BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH"))); - - String s = scanner.nextLine(); - - long n = scanner.nextLong(); - scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?"); - - long result = repeatedString(s, n); - - bufferedWriter.write(String.valueOf(result)); - bufferedWriter.newLine(); - - bufferedWriter.close(); - - scanner.close(); - } -} - diff --git a/src/main/java/com/hackerrank/java/advanced/JavaVisitorPattern.java b/src/main/java/com/hackerrank/java/advanced/JavaVisitorPattern.java deleted file mode 100644 index 5f91e9b5..00000000 --- a/src/main/java/com/hackerrank/java/advanced/JavaVisitorPattern.java +++ /dev/null @@ -1,226 +0,0 @@ -package com.hackerrank.java.advanced; - -import java.util.*; - -/** - * Level: Medium - * Problem Link: https://www.hackerrank.com/challenges/java-vistor-pattern/ - * - * @author rampatra - * @since 2019-06-22 - */ -enum Color { - RED, GREEN -} - -abstract class Tree { - - private int value; - private Color color; - private int depth; - - public Tree(int value, Color color, int depth) { - this.value = value; - this.color = color; - this.depth = depth; - } - - public int getValue() { - return value; - } - - public Color getColor() { - return color; - } - - public int getDepth() { - return depth; - } - - public abstract void accept(TreeVis visitor); - - -} - -class TreeNode extends Tree { - - private ArrayList children = new ArrayList<>(); - - public TreeNode(int value, Color color, int depth) { - super(value, color, depth); - } - - public void accept(TreeVis visitor) { - visitor.visitNode(this); - - for (Tree child : children) { - child.accept(visitor); - } - } - - public void addChild(Tree child) { - children.add(child); - } -} - -class TreeLeaf extends Tree { - - public TreeLeaf(int value, Color color, int depth) { - super(value, color, depth); - } - - public void accept(TreeVis visitor) { - visitor.visitLeaf(this); - } -} - -abstract class TreeVis { - public abstract int getResult(); - - public abstract void visitNode(TreeNode node); - - public abstract void visitLeaf(TreeLeaf leaf); - -} - -class SumInLeavesVisitor extends TreeVis { - int nodeSum = 0; - int leafSum = 0; - - public int getResult() { - //implement this - return leafSum; - } - - public void visitNode(TreeNode node) { - //implement this - //nodeSum += node.getValue(); - } - - public void visitLeaf(TreeLeaf leaf) { - //implement this - leafSum += leaf.getValue(); - } -} - -class ProductOfRedNodesVisitor extends TreeVis { - int prodOfRedNodesAndLeaves = 1; - private final int M = 1000000007; - - public int getResult() { - //implement this - return prodOfRedNodesAndLeaves; - } - - public void visitNode(TreeNode node) { - //implement this - if (node.getColor() == Color.RED) { - prodOfRedNodesAndLeaves *= (node.getValue() % M); - } - } - - public void visitLeaf(TreeLeaf leaf) { - //implement this - if (leaf.getColor() == Color.RED) { - prodOfRedNodesAndLeaves *= (leaf.getValue() % M); - } - } -} - -class FancyVisitor extends TreeVis { - int sumOfNodesAtEvenDepth = 0; - int sumOfGreenLeaves = 0; - - public int getResult() { - //implement this - return Math.abs(sumOfNodesAtEvenDepth - sumOfGreenLeaves); - } - - public void visitNode(TreeNode node) { - //implement this - if (node.getDepth() % 2 == 0) { - sumOfNodesAtEvenDepth += node.getValue(); - } - } - - public void visitLeaf(TreeLeaf leaf) { - //implement this - if (leaf.getColor() == Color.GREEN) { - sumOfGreenLeaves += leaf.getValue(); - } - } -} - -public class JavaVisitorPattern { - - public static Tree solve() { - //read the tree from STDIN and return its root as a return value of this function - Scanner s = new Scanner(System.in); - - int numOfNodes = s.nextInt(); - int[] nodeValues = new int[numOfNodes]; - int[] nodeColors = new int[numOfNodes]; - Map> parentToChildMap = new HashMap<>(); - Map childToParentMap = new HashMap<>(); - - for (int i = 0; i < numOfNodes; i++) { - nodeValues[i] = s.nextInt(); - } - for (int i = 0; i < numOfNodes; i++) { - nodeColors[i] = s.nextInt(); - } - for (int i = 0; i < numOfNodes - 1; i++) { - int parentIndex = s.nextInt(); - int childIndex = s.nextInt(); - - Set children = parentToChildMap.get(parentIndex - 1) != null ? parentToChildMap.get(parentIndex - 1) : new HashSet<>(); - children.add(childIndex - 1); - parentToChildMap.put(parentIndex - 1, children); - childToParentMap.put(childIndex - 1, parentIndex - 1); - } - - List nodes = new ArrayList<>(numOfNodes); - for (int i = 0; i < numOfNodes; i++) { - - int depth = childToParentMap.get(i) == null ? -1 : nodes.get(childToParentMap.get(i)).getDepth(); - - if (parentToChildMap.get(i) != null) { - nodes.add(new TreeNode(nodeValues[i], nodeColors[i] == 0 ? Color.RED : Color.GREEN, depth + 1)); - } else { - nodes.add(new TreeLeaf(nodeValues[i], nodeColors[i] == 0 ? Color.RED : Color.GREEN, depth + 1)); - } - } - - - for (Map.Entry> entry : parentToChildMap.entrySet()) { - - TreeNode parent = (TreeNode) nodes.get(entry.getKey()); - - for (Integer childIndex : entry.getValue()) { - parent.addChild(nodes.get(childIndex)); - } - } - - return nodes.get(0); - } - - - public static void main(String[] args) { - Tree root = solve(); - SumInLeavesVisitor vis1 = new SumInLeavesVisitor(); - ProductOfRedNodesVisitor vis2 = new ProductOfRedNodesVisitor(); - FancyVisitor vis3 = new FancyVisitor(); - - root.accept(vis1); - root.accept(vis2); - root.accept(vis3); - - int res1 = vis1.getResult(); - int res2 = vis2.getResult(); - int res3 = vis3.getResult(); - - System.out.println(res1); - System.out.println(res2); - System.out.println(res3); - } -} \ No newline at end of file diff --git a/src/main/java/com/hackerrank/java/bignumber/BigDecimal.java b/src/main/java/com/hackerrank/java/bignumber/BigDecimal.java deleted file mode 100644 index 7e1b804e..00000000 --- a/src/main/java/com/hackerrank/java/bignumber/BigDecimal.java +++ /dev/null @@ -1,40 +0,0 @@ -package com.hackerrank.java.bignumber; - -import java.util.Arrays; -import java.util.List; -import java.util.Scanner; - -/** - * Problem Link: https://www.hackerrank.com/challenges/java-bigdecimal/ - * - * @author rampatra - * @since 2019-06-22 - */ -class BigDecimal { - public static void main(String[] args) { - //Input - Scanner sc = new Scanner(System.in); - int n = sc.nextInt(); - String[] s = new String[n + 2]; - for (int i = 0; i < n; i++) { - s[i] = sc.next(); - } - sc.close(); - - //Write your code here - s = Arrays.copyOfRange(s, 0, s.length - 2); - List input = Arrays.asList(s); - Arrays.sort(s, (s1, s2) -> { - int compare = new java.math.BigDecimal(s2).compareTo(new java.math.BigDecimal(s1)); - if (compare == 0) { - return Integer.compare(input.indexOf(s1), input.indexOf(s2)); - } - return compare; - }); - - //Output - for (int i = 0; i < n; i++) { - System.out.println(s[i]); - } - } -} \ No newline at end of file diff --git a/src/main/java/com/hackerrank/tutorials/ctci/QueuesWithTwoStacks.java b/src/main/java/com/hackerrank/tutorials/ctci/QueuesWithTwoStacks.java deleted file mode 100644 index 333ecd1d..00000000 --- a/src/main/java/com/hackerrank/tutorials/ctci/QueuesWithTwoStacks.java +++ /dev/null @@ -1,56 +0,0 @@ -package com.hackerrank.tutorials.ctci; - -import java.util.Scanner; -import java.util.Stack; - -/** - * Question: https://www.hackerrank.com/challenges/ctci-queue-using-two-stacks - * Level: Medium - * - * @author rampatra - * @version 07/10/2016 - */ -public class QueuesWithTwoStacks { - - public static class MyQueue { - Stack stackNewestOnTop = new Stack(); - Stack stackOldestOnTop = new Stack(); - - public void enqueue(T value) { // Push onto newest stack - stackNewestOnTop.push(value); - } - - public T peek() { - return stackOldestOnTop.isEmpty() ? stackNewestOnTop.firstElement() : stackOldestOnTop.peek(); - } - - public T dequeue() { - if (stackOldestOnTop.isEmpty()) { - while (!stackNewestOnTop.isEmpty()) { - stackOldestOnTop.push(stackNewestOnTop.pop()); - } - } - return stackOldestOnTop.pop(); - } - } - - - public static void main(String[] args) { - MyQueue queue = new MyQueue<>(); - - Scanner scan = new Scanner(System.in); - int n = scan.nextInt(); - - for (int i = 0; i < n; i++) { - int operation = scan.nextInt(); - if (operation == 1) { // enqueue - queue.enqueue(scan.nextInt()); - } else if (operation == 2) { // dequeue - queue.dequeue(); - } else if (operation == 3) { // print/peek - System.out.println(queue.peek()); - } - } - scan.close(); - } -} diff --git a/src/main/java/com/hackerrank/tutorials/ctci/RansomNote.java b/src/main/java/com/hackerrank/tutorials/ctci/RansomNote.java deleted file mode 100644 index b0d45c75..00000000 --- a/src/main/java/com/hackerrank/tutorials/ctci/RansomNote.java +++ /dev/null @@ -1,70 +0,0 @@ -package com.hackerrank.tutorials.ctci; - -import java.util.HashMap; -import java.util.Map; -import java.util.Scanner; - -/** - * Question: https://www.hackerrank.com/challenges/ctci-ransom-note - * Level: Easy - * - * @author rampatra - * @version 30/09/2016 - */ -public class RansomNote { - - Map magazineMap; - Map noteMap; - - public RansomNote(String magazine, String note) { - - magazineMap = new HashMap<>(); - noteMap = new HashMap<>(); - String[] magazineWords = magazine.split(" "); - String[] noteWords = note.split(" "); - Integer c; - - for (int i = 0; i < magazineWords.length; i++) { - if ((c = magazineMap.get(magazineWords[i])) == null) { - magazineMap.put(magazineWords[i], 1); - } else { - magazineMap.put(magazineWords[i], c + 1); - } - } - - for (int i = 0; i < noteWords.length; i++) { - if ((c = noteMap.get(noteWords[i])) == null) { - noteMap.put(noteWords[i], 1); - } else { - noteMap.put(noteWords[i], c + 1); - } - } - } - - public boolean solve() { - for (Map.Entry entry : noteMap.entrySet()) { - if (magazineMap.get(entry.getKey()) == null || magazineMap.get(entry.getKey()) - entry.getValue() < 0) { - return false; - } - } - return true; - } - - public static void main(String[] args) { - Scanner scanner = new Scanner(System.in); - int m = scanner.nextInt(); - int n = scanner.nextInt(); - - // Eat whitespace to beginning of next line - scanner.nextLine(); - - RansomNote s = new RansomNote(scanner.nextLine(), scanner.nextLine()); - scanner.close(); - - if (s.solve()) { - System.out.println("Yes"); - } else { - System.out.println("No"); - } - } -} diff --git a/src/main/java/com/leetcode/arrays/BuySellStocks.java b/src/main/java/com/leetcode/arrays/BuySellStocks.java deleted file mode 100644 index 4d4ba02b..00000000 --- a/src/main/java/com/leetcode/arrays/BuySellStocks.java +++ /dev/null @@ -1,67 +0,0 @@ -package com.leetcode.arrays; - -/** - * Level: Easy - * Link: https://leetcode.com/problems/best-time-to-buy-and-sell-stock/ - * Description: - * Say you have an array for which the ith element is the price of a given stock on day i. - * - * If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), - * design an algorithm to find the maximum profit. - * - * Note that you cannot sell a stock before you buy one. - * - * Example 1: - * - * Input: [7,1,5,3,6,4] - * Output: 5 - * Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5. - * Not 7-1 = 6, as selling price needs to be larger than buying price. - * - * Example 2: - * - * Input: [7,6,4,3,1] - * Output: 0 - * Explanation: In this case, no transaction is done, i.e. max profit = 0. - * - * @author rampatra - * @since 2019-04-23 - */ -public class BuySellStocks { - - /** - * Time complexity: O(n) - * where, - * n = no. of stock prices - *

- * Runtime: 0 ms. - * - * @param prices - * @return - */ - public static int maxProfit(int[] prices) { - int profit = 0; - int buyPrice = Integer.MAX_VALUE; - - for (int i = 0; i < prices.length; i++) { - if (prices[i] < buyPrice) { - buyPrice = prices[i]; - } else if (prices[i] - buyPrice > profit) { - profit = prices[i] - buyPrice; - } - } - - return profit; - } - - public static void main(String[] args) { - - System.out.println(maxProfit(new int[]{7, 1, 5, 3, 6, 4})); - System.out.println(maxProfit(new int[]{7, 1, 5, 0, 6, 4})); - System.out.println(maxProfit(new int[]{4, 3, 2, 1})); - - // edge cases - System.out.println(maxProfit(new int[]{})); - System.out.println(maxProfit(new int[]{1})); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/BuySellStocksII.java b/src/main/java/com/leetcode/arrays/BuySellStocksII.java deleted file mode 100644 index d215246e..00000000 --- a/src/main/java/com/leetcode/arrays/BuySellStocksII.java +++ /dev/null @@ -1,94 +0,0 @@ -package com.leetcode.arrays; - -/** - * Level: Easy - * Link: https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/ - * Description: - * Say you have an array for which the ith element is the price of a given stock on day i. - *

- * Design an algorithm to find the maximum profit. You may complete as many transactions as you - * like (i.e., buy one and sell one share of the stock multiple times). - *

- * Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock - * before you buy again). - * - * @author rampatra - * @since 2019-04-23 - */ -public class BuySellStocksII { - - /** - * The key point is we need to consider every peak immediately following a valley to maximize the profit. In case - * we skip one of the peaks (trying to obtain more profit), we will end up losing the profit over one of the - * transactions leading to an overall lesser profit. - * Read this to learn more. - *

- * Time complexity: O(n) - * where, - * n = no. of stock prices - *

- * Runtime: 0 ms. - * - * @param prices - * @return - */ - public static int maxProfit(int[] prices) { - int valley; - int peak; - int maxProfit = 0; - - for (int i = 0; i < prices.length; i++) { - while (i < prices.length - 1 && prices[i] > prices[i + 1]) { - i++; - } - valley = i; - - while (i < prices.length - 1 && prices[i] < prices[i + 1]) { - i++; - } - peak = i; - - maxProfit += prices[peak] - prices[valley]; - } - - return maxProfit; - } - - /** - * This solution follows the logic used in the above approach {@link #maxProfit(int[])}, but with only a slight - * variation. In this case, instead of looking for every peak following a valley, we can simply go on crawling over - * the slope and keep on adding the profit obtained from every consecutive transaction. - * In the end, we will be using the peaks and valleys effectively, but we need not track the costs corresponding to - * the peaks and valleys along with the maximum profit, but we can directly keep on adding the difference between the - * consecutive numbers of the array if the second number is larger than the first one, and at the total sum we obtain - * will be the maximum profit. This approach will simplify the solution. - *

- * Time complexity: O(n) - * where, - * n = no. of stock prices - * - * @param prices - * @return - */ - public static int maxProfitSimplified(int[] prices) { - int maxProfit = 0; - for (int i = 1; i < prices.length; i++) { - if (prices[i] > prices[i - 1]) { - maxProfit += prices[i] - prices[i - 1]; - } - } - return maxProfit; - } - - public static void main(String[] args) { - System.out.println(maxProfit(new int[]{7, 1, 5, 3, 6, 4})); - System.out.println(maxProfit(new int[]{1, 2, 3, 4, 5})); - System.out.println(maxProfit(new int[]{7, 6, 4, 3, 1})); - - System.out.println("----"); - - System.out.println(maxProfitSimplified(new int[]{7, 1, 5, 3, 6, 4})); - System.out.println(maxProfitSimplified(new int[]{1, 2, 3, 4, 5})); - System.out.println(maxProfitSimplified(new int[]{7, 6, 4, 3, 1})); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/CanPlaceFlowers.java b/src/main/java/com/leetcode/arrays/CanPlaceFlowers.java deleted file mode 100644 index 916499ac..00000000 --- a/src/main/java/com/leetcode/arrays/CanPlaceFlowers.java +++ /dev/null @@ -1,68 +0,0 @@ -package com.leetcode.arrays; - - -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/can-place-flowers/ - * Problem Description: - * Suppose you have a long flowerBed in which some of the plots are planted and some are not. However, flowers cannot - * be planted in adjacent plots - they would compete for water and both would die. - *

- * Given a flowerBed (represented as an array containing 0 and 1, where 0 means empty and 1 means not empty), and a - * number n, return if n new flowers can be planted in it without violating the no-adjacent-flowers rule. - *

- * Example 1: - * Input: flowerBed = [1,0,0,0,1], n = 1 - * Output: True - *

- * Example 2: - * Input: flowerBed = [1,0,0,0,1], n = 2 - * Output: False - *

- * Note: - * The input array won't violate no-adjacent-flowers rule. - * The input array size is in the range of [1, 20000]. - * n is a non-negative integer which won't exceed the input array size. - * - * @author rampatra - * @since 2019-07-24 - */ -public class CanPlaceFlowers { - - /** - * Time Complexity: O(n) - * Space Complexity: O(1) - * Runtime: 1 ms. - * - * @param flowerBed - * @param n - * @return - */ - public static boolean canPlaceFlowers(int[] flowerBed, int n) { - int i = 0, count = 0; - while (i < flowerBed.length) { - if (flowerBed[i] == 0 && (i == 0 || flowerBed[i - 1] == 0) && (i == flowerBed.length - 1 || flowerBed[i + 1] == 0)) { - flowerBed[i++] = 1; - count++; - } - if (count >= n) - return true; - i++; - } - return false; - } - - public static void main(String[] args) { - assertTrue(canPlaceFlowers(new int[]{0}, 0)); - assertTrue(canPlaceFlowers(new int[]{0}, 1)); - assertTrue(canPlaceFlowers(new int[]{1}, 0)); - assertFalse(canPlaceFlowers(new int[]{1}, 1)); - assertTrue(canPlaceFlowers(new int[]{1, 0, 0, 0, 1}, 1)); - assertFalse(canPlaceFlowers(new int[]{1, 0, 0, 0, 1}, 2)); - assertFalse(canPlaceFlowers(new int[]{1, 0, 0, 0, 0, 1}, 2)); - assertTrue(canPlaceFlowers(new int[]{1, 0, 0, 0, 1, 0, 0}, 2)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/FindTheCelebrity.java b/src/main/java/com/leetcode/arrays/FindTheCelebrity.java deleted file mode 100644 index 1b15d996..00000000 --- a/src/main/java/com/leetcode/arrays/FindTheCelebrity.java +++ /dev/null @@ -1,105 +0,0 @@ -package com.leetcode.arrays; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/find-the-celebrity/ - * Problem Description: - * Suppose you are at a party with n people (labeled from 0 to n - 1) and among them, there may exist one celebrity. - * The definition of a celebrity is that all the other n - 1 people know him/her but he/she does not know any of them. - * - * Now you want to find out who the celebrity is or verify that there is not one. The only thing you are allowed to do - * is to ask questions like: "Hi, A. Do you know B?" to get information of whether A knows B. You need to find out the - * celebrity (or verify there is not one) by asking as few questions as possible (in the asymptotic sense). - * - * You are given a helper function bool knows(a, b) which tells you whether A knows B. Implement a - * function int findCelebrity(n). There will be exactly one celebrity if he/she is in the party. Return the celebrity's - * label if there is a celebrity in the party. If there is no celebrity, return -1. - * - * Example 1: - * - * Input: graph = [ - * [1,1,0], - * [0,1,0], - * [1,1,1] - * ] - * Output: 1 - * Explanation: There are three persons labeled with 0, 1 and 2. graph[i][j] = 1 means person i knows person j, otherwise - * graph[i][j] = 0 means person i does not know person j. The celebrity is the person labeled as 1 because both 0 and 2 - * know him but 1 does not know anybody. - * - * - * Example 2: - * - * Input: graph = [ - * [1,0,1], - * [1,1,0], - * [0,1,1] - * ] - * Output: -1 - * Explanation: There is no celebrity. - * - * - * Note: The directed graph is represented as an adjacency matrix, which is an n x n matrix where a[i][j] = 1 means - * person i knows person j while a[i][j] = 0 means the contrary. Remember that you won't have direct access to the - * adjacency matrix. - * - * @author rampatra - * @since 2019-08-04 - */ -public class FindTheCelebrity { - - private int[][] knowsMatrix; - - FindTheCelebrity(int[][] knowsMatrix) { - this.knowsMatrix = knowsMatrix; - } - - public boolean knows(int a, int b) { - return knowsMatrix[a][b] == 1; - } - - /** - * Time Complexity: O(n) - * Space Complexity: O(1) - * Runtime: 6 ms. - * - * @param n - * @return - */ - public int findCelebrity(int n) { - int celebrityIndex = 0; - - for (int i = 1; i < n; i++) { - // if a person doesn't know another person then he maybe a celebrity - if (!knows(i, celebrityIndex)) { - celebrityIndex = i; - } - } - - for (int i = 0; i < n; i++) { - // verify whether the celebrity only knows himself and all other people know the celebrity - if ((knows(celebrityIndex, i) && i != celebrityIndex) || !knows(i, celebrityIndex)) { - return -1; - } - } - - return celebrityIndex; - } - - public static void main(String[] args) { - FindTheCelebrity findTheCelebrity = new FindTheCelebrity(new int[][]{ - {1, 1, 0}, - {0, 1, 0}, - {1, 1, 1}}); - - assertEquals(1, findTheCelebrity.findCelebrity(3)); - - findTheCelebrity = new FindTheCelebrity(new int[][]{ - {1, 0}, - {0, 1}}); - - assertEquals(-1, findTheCelebrity.findCelebrity(2)); - } -} diff --git a/src/main/java/com/leetcode/arrays/InsertInterval.java b/src/main/java/com/leetcode/arrays/InsertInterval.java deleted file mode 100644 index 52155f19..00000000 --- a/src/main/java/com/leetcode/arrays/InsertInterval.java +++ /dev/null @@ -1,78 +0,0 @@ -package com.leetcode.arrays; - -import java.util.Arrays; - -/** - * Level: Hard - * Problem Link: https://leetcode.com/problems/insert-interval/ - * Problem Description: - * Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary). - *

- * You may assume that the intervals were initially sorted according to their start times. - *

- * Example 1: - * Input: intervals = [[1,3],[6,9]], newInterval = [2,5] - * Output: [[1,5],[6,9]] - *

- * Example 2: - * Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8] - * Output: [[1,2],[3,10],[12,16]] - * Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10]. - *

- * Companies: LinkedIn. - * Related: {@link MergeIntervals}. - * - * @author rampatra - * @since 2019-07-23 - */ -public class InsertInterval { - - /** - * Time Complexity: O(n) - * Space Complexity: O(n) - * Runtime: 2 ms. - * - * @param intervals - * @param newInterval - * @return - */ - public static int[][] insert(int[][] intervals, int[] newInterval) { - if (intervals.length == 0 && newInterval.length == 0) { - return new int[][]{}; - } else if (intervals.length == 0) { - return new int[][]{newInterval}; - } - - int[][] mergedIntervals = new int[intervals.length + 1][2]; - int j = 0; - - for (int i = 0; i < intervals.length; i++) { - if (newInterval == null || newInterval[0] > intervals[i][1]) { // newInterval is after the ith interval - mergedIntervals[j++] = intervals[i]; - } else if (newInterval[1] < intervals[i][0]) { // newInterval is before the ith interval - mergedIntervals[j++] = newInterval; - mergedIntervals[j++] = intervals[i]; - newInterval = null; - } else { // if overlapping - newInterval[0] = Math.min(newInterval[0], intervals[i][0]); - newInterval[1] = Math.max(newInterval[1], intervals[i][1]); - } - } - - if (newInterval != null) { - mergedIntervals[j++] = newInterval; - } - - return Arrays.copyOfRange(mergedIntervals, 0, j); - } - - public static void main(String[] args) { - System.out.println(Arrays.deepToString(insert(new int[][]{}, new int[]{}))); - System.out.println(Arrays.deepToString(insert(new int[][]{}, new int[]{5, 7}))); - System.out.println(Arrays.deepToString(insert(new int[][]{{1, 5}}, new int[]{0, 0}))); - System.out.println(Arrays.deepToString(insert(new int[][]{{1, 5}}, new int[]{2, 3}))); - System.out.println(Arrays.deepToString(insert(new int[][]{{2, 5}, {6, 7}, {8, 9}}, new int[]{0, 1}))); - System.out.println(Arrays.deepToString(insert(new int[][]{{1, 3}, {6, 9}}, new int[]{2, 5}))); - System.out.println(Arrays.deepToString(insert(new int[][]{{1, 2}, {3, 5}, {6, 7}, {8, 10}, {12, 16}}, new int[]{4, 8}))); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/MajorityElement.java b/src/main/java/com/leetcode/arrays/MajorityElement.java deleted file mode 100644 index 2ccdd116..00000000 --- a/src/main/java/com/leetcode/arrays/MajorityElement.java +++ /dev/null @@ -1,47 +0,0 @@ -package com.leetcode.arrays; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/majority-element/ - * Problem Description: - * Given an array of size n, find the majority element. The majority element is the element - * that appears more than ⌊ n/2 ⌋ times. You may assume that the array is non-empty and the - * majority element always exist in the array. - * - * @author rampatra - * @since 2019-04-27 - */ -public class MajorityElement { - - /** - * Time complexity: O(n) - * Runtime: 1 ms. - * - * @param nums - * @return - */ - public static int majorityElement(int[] nums) { - int count = 1; - int majElem = nums[0]; - - for (int i = 1; i < nums.length; i++) { - if (count <= 0) { - majElem = nums[i]; - count = 0; - } - if (majElem == nums[i]) { - count++; - } else { - count--; - } - } - - return majElem; - } - - public static void main(String[] args) { - System.out.println(majorityElement(new int[]{10, 9, 9, 9, 10})); - System.out.println(majorityElement(new int[]{2, 3, 2, 2, 3, 2})); - System.out.println(majorityElement(new int[]{2, 3, 2, 2, 2, 3})); - } -} diff --git a/src/main/java/com/leetcode/arrays/MergeIntervals.java b/src/main/java/com/leetcode/arrays/MergeIntervals.java deleted file mode 100644 index 58f56ebc..00000000 --- a/src/main/java/com/leetcode/arrays/MergeIntervals.java +++ /dev/null @@ -1,78 +0,0 @@ -package com.leetcode.arrays; - -import java.util.Arrays; -import java.util.Comparator; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/merge-intervals/ - * Problem Description: - *

- * Given a collection of intervals, merge all overlapping intervals. - *

- * Example 1: - * Input: [[1,3],[2,6],[8,10],[15,18]] - * Output: [[1,6],[8,10],[15,18]] - * Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6]. - *

- * Example 2: - * Input: [[1,4],[4,5]] - * Output: [[1,5]] - * Explanation: Intervals [1,4] and [4,5] are considered overlapping. - *

- * Companies: LinkedIn - * Related: {@link InsertInterval}. - * - * @author rampatra - * @since 2019-07-22 - */ -public class MergeIntervals { - - /** - * Time complexity: O(n log n) - * Space complexity: O(n) - * Runtime: 6 ms - * - * @param intervals a list of intervals, may not be sorted - * @return a list of intervals, with overlapping intervals merged - */ - public static int[][] merge(int[][] intervals) { - // some validations - if (intervals.length == 0) return new int[0][2]; - - // we first sort the intervals based on their start times - Arrays.sort(intervals, new IntervalComparator()); - - int[][] mergedIntervals = new int[intervals.length][2]; - int lastMergedIndex = 0; - mergedIntervals[lastMergedIndex] = intervals[0]; - - for (int i = 1; i < intervals.length; i++) { - if (isOverlap(mergedIntervals[lastMergedIndex], intervals[i])) { - // if two intervals overlap, then merge the two - mergedIntervals[lastMergedIndex] = new int[]{Math.min(mergedIntervals[lastMergedIndex][0], intervals[i][0]), - Math.max(mergedIntervals[lastMergedIndex][1], intervals[i][1])}; - } else { - mergedIntervals[++lastMergedIndex] = intervals[i]; - } - } - - return Arrays.copyOfRange(mergedIntervals, 0, lastMergedIndex + 1); - } - - private static boolean isOverlap(int[] interval1, int[] interval2) { - return interval1[0] <= interval2[0] && interval1[1] >= interval2[0]; - } - - private static class IntervalComparator implements Comparator { - @Override - public int compare(int[] interval1, int[] interval2) { - return interval1[0] - interval2[0]; - } - } - - public static void main(String[] args) { - System.out.println(Arrays.deepToString(merge(new int[][]{{1, 3}, {2, 6}, {8, 10}, {15, 18}}))); - System.out.println(Arrays.deepToString(merge(new int[][]{{1, 4}, {4, 5}}))); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/MergeSortedArray.java b/src/main/java/com/leetcode/arrays/MergeSortedArray.java deleted file mode 100644 index 975db8ec..00000000 --- a/src/main/java/com/leetcode/arrays/MergeSortedArray.java +++ /dev/null @@ -1,86 +0,0 @@ -package com.leetcode.arrays; - -import java.util.Arrays; - -/** - * Level: Easy - * Link: https://leetcode.com/problems/merge-sorted-array/ - * Description: - * Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array. - * - * Note: - * The number of elements initialized in nums1 and nums2 are m and n respectively. - * You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold - * additional elements from nums2. - * - * Example: - * Input: - * nums1 = [1,2,3,0,0,0], m = 3 - * nums2 = [2,5,6], n = 3 - * Output: [1,2,2,3,5,6] - * - * @author rampatra - * @since 2019-04-26 - */ -public class MergeSortedArray { - - /** - * Time complexity: O(m*n) - * Runtime: 1 ms. - * - * @param nums1 - * @param m - * @param nums2 - * @param n - */ - public static void mergeSimple(int[] nums1, int m, int[] nums2, int n) { - int i = 0; - - for (int j = 0; j < n; j++) { - // find the index where the element from nums2 need to be inserted - while (i < m + j && nums1[i] < nums2[j]) { - i++; - } - // copy elements from i+1th position to one position right - for (int k = m + j; k > i; k--) { // note: replacing this with System.arraycopy() gives a 0 ms runtime - nums1[k] = nums1[k - 1]; - } - nums1[i] = nums2[j]; - } - } - - /** - * Time complexity: O(m+n) - * Runtime: 0 ms. - * - * @param nums1 - * @param m - * @param nums2 - * @param n - */ - public static void merge(int[] nums1, int m, int[] nums2, int n) { - for (int i = m + n - 1; i >= 0; i--) { - if (m == 0) { - nums1[i] = nums2[--n]; - } else if (n == 0) { // we ran out of nums2 elements so there is nothing left to merge - return; - } else if (nums1[m - 1] > nums2[n - 1]) { - nums1[i] = nums1[--m]; - } else { - nums1[i] = nums2[--n]; - } - } - } - - public static void main(String[] args) { - int[] nums1 = {1, 2, 3, 0, 0, 0}; - int[] nums2 = {4, 5, 6}; - merge(nums1, 3, nums2, 3); - System.out.println(Arrays.toString(nums1)); - - nums1 = new int[]{4, 5, 6, 0, 0, 0}; - nums2 = new int[]{1, 2, 3}; - merge(nums1, 3, nums2, 3); - System.out.println(Arrays.toString(nums1)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/NumberOfIslands.java b/src/main/java/com/leetcode/arrays/NumberOfIslands.java deleted file mode 100644 index 04ac6831..00000000 --- a/src/main/java/com/leetcode/arrays/NumberOfIslands.java +++ /dev/null @@ -1,107 +0,0 @@ -package com.leetcode.arrays; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/number-of-islands/ - * Description: - * Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water - * and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid - * are all surrounded by water. - *

- * Example 1: - * Input: - * 11110 - * 11010 - * 11000 - * 00000 - * Output: 1 - *

- * Example 2: - * Input: - * 11000 - * 11000 - * 00100 - * 00011 - * Output: 3 - * - * @author rampatra - * @since 2019-08-07 - */ -public class NumberOfIslands { - - /** - * The idea is simple and straightforward. Once we encounter land ('1' in grid) we drown the island or change the - * neighboring '1's to '0's. Therefore, the number of '1's we encounter, we can say that we have that many islands. - *

- * Time Complexity: O(n) - * Space Complexity: O(n) - * Runtime: 1 ms. - * - * @param grid - * @return - */ - public static int numIslands(char[][] grid) { - int count = 0; - - for (int i = 0; i < grid.length; i++) { - for (int j = 0; j < grid[0].length; j++) { - if (grid[i][j] == '1') { - drownTheIsland(grid, i, j); - count++; - } - } - } - - return count; - } - - private static void drownTheIsland(char[][] grid, int i, int j) { - if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length || grid[i][j] == '0') { - return; - } - - grid[i][j] = '0'; - - drownTheIsland(grid, i, j + 1); - drownTheIsland(grid, i, j - 1); - drownTheIsland(grid, i + 1, j); - drownTheIsland(grid, i - 1, j); - } - - public static void main(String[] args) { - assertEquals(1, numIslands(new char[][]{ - {'1', '1', '1', '1', '0'}, - {'1', '1', '0', '1', '0'}, - {'1', '1', '0', '0', '0'}, - {'0', '0', '0', '0', '0'} - })); - - assertEquals(2, numIslands(new char[][]{ - {'1', '1', '1', '1', '0'}, - {'1', '1', '0', '1', '0'}, - {'1', '1', '0', '0', '0'}, - {'0', '0', '0', '1', '0'} - })); - - assertEquals(1, numIslands(new char[][]{ - {'1', '1', '1', '1', '1'}, - {'1', '1', '1', '1', '1'}, - {'1', '1', '1', '1', '1'}, - {'1', '1', '1', '1', '1'} - })); - - assertEquals(1, numIslands(new char[][]{ - {'1'} - })); - - assertEquals(0, numIslands(new char[][]{ - {'0'} - })); - - assertEquals(0, numIslands(new char[][]{ - {} - })); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/PascalsTriangle.java b/src/main/java/com/leetcode/arrays/PascalsTriangle.java deleted file mode 100644 index 5f32d69f..00000000 --- a/src/main/java/com/leetcode/arrays/PascalsTriangle.java +++ /dev/null @@ -1,53 +0,0 @@ -package com.leetcode.arrays; - -import java.util.ArrayList; -import java.util.List; - -/** - * Level: Easy - * Problem: https://leetcode.com/problems/pascals-triangle/ - * - * @author rampatra - * @since 2019-04-20 - */ -public class PascalsTriangle { - - /** - * Time complexity: O(numRows^2) - * Space complexity: O(numRows^2) - *

- * Runtime: 0 ms. - * - * @param numRows - * @return - */ - public static List> generatePascalsTriangle(int numRows) { - List> pascalsTriangle = new ArrayList<>(); - - if (numRows == 0) return pascalsTriangle; - - List firstRow = new ArrayList<>(); - firstRow.add(1); - pascalsTriangle.add(firstRow); - - List prevRow; - for (int i = 1; i < numRows; i++) { - prevRow = pascalsTriangle.get(i - 1); - - List currRow = new ArrayList<>(); - currRow.add(1); - for (int j = 0; j < prevRow.size() - 1; j++) { - currRow.add(prevRow.get(j) + prevRow.get(j + 1)); - } - currRow.add(1); - - pascalsTriangle.add(currRow); - } - - return pascalsTriangle; - } - - public static void main(String[] args) { - System.out.println(generatePascalsTriangle(5)); - } -} diff --git a/src/main/java/com/leetcode/arrays/RemoveDuplicates.java b/src/main/java/com/leetcode/arrays/RemoveDuplicates.java deleted file mode 100644 index 57eba5ad..00000000 --- a/src/main/java/com/leetcode/arrays/RemoveDuplicates.java +++ /dev/null @@ -1,62 +0,0 @@ -package com.leetcode.arrays; - -import java.util.Arrays; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/remove-duplicates-from-sorted-array/ - * Problem Description: - * Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length. - *

- * Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory. - * Example 1: - *

- * Given nums = [1,1,2] - *

- * Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. - *

- * NOTE: It doesn't matter what you leave beyond the returned length. - * - * @author rampatra - * @since 2019-04-24 - */ -public class RemoveDuplicates { - - /** - * This removes the duplicates from the array in-place. - *

- * Time complexity: O(n) - * where, - * n = no. of elements in the array - *

- * Runtime: 1 ms. - * - * @param nums - * @return - */ - public static int removeDuplicatesInSortedArray(int[] nums) { - int insertIndex = 0; - - for (int i = 1; i < nums.length; i++) { - if (nums[i] != nums[i - 1]) { - nums[++insertIndex] = nums[i]; - } - } - - return insertIndex + 1; - } - - public static void main(String[] args) { - int[] arr = new int[]{1, 1, 2}; - System.out.println(removeDuplicatesInSortedArray(arr)); - System.out.println(Arrays.toString(arr)); - - arr = new int[]{0, 0, 1, 1, 1, 2, 2, 3, 3, 4}; - System.out.println(removeDuplicatesInSortedArray(arr)); - System.out.println(Arrays.toString(arr)); - - arr = new int[]{0, 1, 2, 3, 4, 5}; - System.out.println(removeDuplicatesInSortedArray(arr)); - System.out.println(Arrays.toString(arr)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/RotateArray.java b/src/main/java/com/leetcode/arrays/RotateArray.java deleted file mode 100644 index 91475160..00000000 --- a/src/main/java/com/leetcode/arrays/RotateArray.java +++ /dev/null @@ -1,93 +0,0 @@ -package com.leetcode.arrays; - -import java.util.Arrays; - -/** - * Level: Easy - * Link: https://leetcode.com/problems/rotate-array/ - * Description: - * Given an array, rotate the array to the right by k steps, where k is non-negative. - * - * Example 1: - * Input: [1,2,3,4,5,6,7] and k = 3 - * Output: [5,6,7,1,2,3,4] - * Explanation: - * rotate 1 steps to the right: [7,1,2,3,4,5,6] - * rotate 2 steps to the right: [6,7,1,2,3,4,5] - * rotate 3 steps to the right: [5,6,7,1,2,3,4] - * - * Example 2: - * Input: [-1,-100,3,99] and k = 2 - * Output: [3,99,-1,-100] - * Explanation: - * rotate 1 steps to the right: [99,-1,-100,3] - * rotate 2 steps to the right: [3,99,-1,-100] - * - * Note: - * Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem. - * Could you do it in-place with O(1) extra space? - * - * @author rampatra - * @since 2019-04-20 - */ -public class RotateArray { - - /** - * Time complexity: O(n) - * where, - * n = no. of elements in the array - *

- * Runtime: 0 ms. - * - * @param nums - * @param k - */ - public static void rotate(int[] nums, int k) { - - if (k > nums.length) { - k = k % nums.length; - } - - reverse(nums, 0, nums.length); - reverse(nums, 0, k); - reverse(nums, k, nums.length); - } - - private static void reverse(int[] nums, int start, int end) { - int temp; - for (int i = start, j = end - 1; i < j; i++, j--) { - temp = nums[i]; - nums[i] = nums[j]; - nums[j] = temp; - } - } - - public static void main(String[] args) { - // normal case - int[] arr = {1, 2, 3, 4, 5, 6, 7}; - System.out.println(Arrays.toString(arr)); - rotate(arr, 3); - System.out.println(Arrays.toString(arr)); - - // edge cases - arr = new int[]{1, 2}; - System.out.println(Arrays.toString(arr)); - rotate(arr, 2); - System.out.println(Arrays.toString(arr)); // should be [1, 2] - - arr = new int[]{1, 2}; - System.out.println(Arrays.toString(arr)); - rotate(arr, 3); - System.out.println(Arrays.toString(arr)); // should be [2, 1] - - arr = new int[]{1, 2, 3}; - System.out.println(Arrays.toString(arr)); - rotate(arr, 4); - System.out.println(Arrays.toString(arr)); // should be [3, 1, 2] - - arr = new int[]{1}; - System.out.println(Arrays.toString(arr)); - rotate(arr, 2); - System.out.println(Arrays.toString(arr)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/ShortestWordDistance.java b/src/main/java/com/leetcode/arrays/ShortestWordDistance.java deleted file mode 100644 index 5cd0c821..00000000 --- a/src/main/java/com/leetcode/arrays/ShortestWordDistance.java +++ /dev/null @@ -1,71 +0,0 @@ -package com.leetcode.arrays; - -import com.leetcode.hashtables.ShortestWordDistanceII; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/shortest-word-distance/ - * Problem Description: - * Given a list of words and two words word1 and word2, return the shortest distance between these two words in the - * list of words. - * - * Example 1: - * Assume that words = ["practice", "makes", "perfect", "coding", "makes"]. - * Given word1 = "coding", word2 = "practice", return 3. - * Given word1 = "makes", word2 = "coding", return 1. - * - * Note: You may assume that word1 does not equal to word2, and word1 and word2 are both in the list. - * - * Lastly, for a more complex variant, see {@link ShortestWordDistanceII}. - * - * @author rampatra - * @since 2019-07-31 - */ -public class ShortestWordDistance { - - /** - * Time Complexity: - * Space Complexity: - * Runtime: 1 ms. - * - * @param words - * @param word1 - * @param word2 - * @return - */ - public static int findShortestDistance(String[] words, String word1, String word2) { - int indexWord1 = -1; - int indexWord2 = -1; - int minDistance = Integer.MAX_VALUE; - - for (int i = 0; i < words.length; i++) { - if (words[i].equals(word1)) { - indexWord1 = i; - } else if (words[i].equals(word2)) { - indexWord2 = i; - } - if (indexWord1 != -1 && indexWord2 != -1) { - minDistance = Math.min(minDistance, Math.abs(indexWord1 - indexWord2)); - } - } - - return minDistance; - } - - public static void main(String[] args) { - assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "practice", "coding")); - assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "coding", "practice")); - assertEquals(1, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "makes", "coding")); - assertEquals(1, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "makes", "perfect")); - assertEquals(0, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "perfect", "perfect")); - assertEquals(0, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "makes", "makes")); - } -} diff --git a/src/main/java/com/leetcode/arrays/ShortestWordDistanceIII.java b/src/main/java/com/leetcode/arrays/ShortestWordDistanceIII.java deleted file mode 100644 index 0d404633..00000000 --- a/src/main/java/com/leetcode/arrays/ShortestWordDistanceIII.java +++ /dev/null @@ -1,80 +0,0 @@ -package com.leetcode.arrays; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/shortest-word-distance-iii/ - * Problem Description: - * This is a follow-up problem of {@link ShortestWordDistance}. The only difference is that now word1 could be the - * same as word2. - *

- * Given a list of words and two words word1 and word2, return the shortest distance between these two words in the list. - * word1 and word2 may be the same and they represent two individual words in the list. - *

- * For example, - * Assume that words = ["practice", "makes", "perfect", "coding", "makes"]. - * Given word1 = “makes”, word2 = “coding”, return 1. - * Given word1 = "makes", word2 = "makes", return 3. - *

- * Note: You may assume word1 and word2 are both in the list. If they are same then it's guaranteed that there are - * two occurrences of the same. - * - * @author rampatra - * @since 2019-07-31 - */ -public class ShortestWordDistanceIII { - - /** - * Time Complexity: - * Space Complexity: - * TODO - * - * @param words - * @param word1 - * @param word2 - * @return - */ - public static int findShortestDistance(String[] words, String word1, String word2) { - int indexWord1 = -1; - int indexWord2 = -1; - int minDistance = Integer.MAX_VALUE; - - for (int i = 0; i < words.length; i++) { - if (words[i].equals(word1)) { - // if both words are same and the first index is already set then do nothing - if (word1.equals(word2) && indexWord1 != -1) { - - } else { - indexWord1 = i; - } - } - if (words[i].equals(word2)) { - // if both words are same and i is same as first index then it implies its the - // first occurrence, skip and continue look for the second occurrence - if (word1.equals(word2) && i == indexWord1) { - continue; - } - indexWord2 = i; - } - if (indexWord1 != -1 && indexWord2 != -1) { - minDistance = Math.min(minDistance, Math.abs(indexWord1 - indexWord2)); - } - } - - return minDistance; - } - - public static void main(String[] args) { - assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "makes", "makes")); - assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "coding", "practice")); - assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "practice", "coding")); - assertEquals(1, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "makes", "coding")); - assertEquals(1, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"}, - "makes", "perfect")); - } -} diff --git a/src/main/java/com/leetcode/arrays/SparseMatrixMultiplication.java b/src/main/java/com/leetcode/arrays/SparseMatrixMultiplication.java deleted file mode 100644 index 78c884e4..00000000 --- a/src/main/java/com/leetcode/arrays/SparseMatrixMultiplication.java +++ /dev/null @@ -1,87 +0,0 @@ -package com.leetcode.arrays; - -import java.util.Arrays; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/sparse-matrix-multiplication/ - * Description: - * Given two sparse matrices A and B, return the result of AB. - * - * You may assume that A's column number is equal to B's row number. - * - * Example: - * - * Input: - * - * A = [ - * [ 1, 0, 0], - * [-1, 0, 3] - * ] - * - * B = [ - * [ 7, 0, 0 ], - * [ 0, 0, 0 ], - * [ 0, 0, 1 ] - * ] - * - * Output: - * - * | 1 0 0 | | 7 0 0 | | 7 0 0 | - * AB = | -1 0 3 | x | 0 0 0 | = | -7 0 3 | - * | 0 0 1 | - * - * @author rampatra - * @since 2019-08-09 - */ -public class SparseMatrixMultiplication { - - /** - * Time Complexity: O(Arow * Acol * Bcol) - * Space Complexity: O(Arow * Bcol) - * - * @param A - * @param B - * @return - */ - public static int[][] multiply(int[][] A, int[][] B) { - int[][] AB = new int[A.length][B[0].length]; - - for (int Bcol = 0; Bcol < B[0].length; Bcol++) { - for (int Arow = 0; Arow < A.length; Arow++) { - int sum = 0; - for (int Acol = 0; Acol < A[0].length; Acol++) { - sum += A[Arow][Acol] * B[Acol][Bcol]; - } - AB[Arow][Bcol] = sum; - } - } - - return AB; - } - - public static void main(String[] args) { - assertEquals(Arrays.deepToString(new int[][]{ - {7, 0, 0}, - {-7, 0, 3} - }), Arrays.deepToString(multiply(new int[][]{ - {1, 0, 0}, - {-1, 0, 3} - }, new int[][]{ - {7, 0, 0}, - {0, 0, 0}, - {0, 0, 1} - }))); - - assertEquals(Arrays.deepToString(new int[][]{ - {0} - }), Arrays.deepToString(multiply(new int[][]{ - {0, 1} - }, new int[][]{ - {1}, - {0} - }))); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/ValidTriangleNumber.java b/src/main/java/com/leetcode/arrays/ValidTriangleNumber.java deleted file mode 100644 index cdbfb0c5..00000000 --- a/src/main/java/com/leetcode/arrays/ValidTriangleNumber.java +++ /dev/null @@ -1,117 +0,0 @@ -package com.leetcode.arrays; - -import java.util.Arrays; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/valid-triangle-number/ - * Problem Description: - * Given an array consists of non-negative integers, your task is to count the number of triplets chosen from the array - * that can make triangles if we take them as side lengths of a triangle. - *

- * Example 1: - * Input: [2,2,3,4] - * Output: 3 - * Explanation: - * Valid combinations are: - * 2,3,4 (using the first 2) - * 2,3,4 (using the second 2) - * 2,2,3 - *

- * Note: - * - The length of the given array won't exceed 1000. - * - The integers in the given array are in the range of [0, 1000]. - * - Triangle Property: Sum of any 2 sides must be greater than the 3rd side. - * - * @author rampatra - * @since 2019-08-07 - */ -public class ValidTriangleNumber { - - /** - * Time complexity : O(n^2 log n). In worst case, the inner loop will take n log n (binary search applied n times). - * Space complexity : O(log n). Sorting takes O(log n) space. - * Runtime: 13 ms. - * - * @param nums - * @return - */ - public static int triangleNumberUsingBinarySearch(int[] nums) { - int noOfTriangles = 0; - - Arrays.sort(nums); - - for (int i = 0; i < nums.length - 2; i++) { - int k = i + 2; - for (int j = i + 1; j < nums.length - 1; j++) { - k = binarySearch(nums, k, nums.length - 1, nums[i] + nums[j]); - if (k - j - 1 > 0) { - noOfTriangles += k - j - 1; - } - } - } - - return noOfTriangles; - } - - private static int binarySearch(int[] nums, int low, int high, int num) { - while (low <= high) { - int mid = (low + high) / 2; - if (nums[mid] < num) { - low = mid + 1; - } else { - high = mid - 1; - } - } - - return low; - } - - /** - * The concept is simple. For each pair (i,j), find the value of k such that nums[i] + nums[j] > nums[k] (as per - * triangle property). Once we find k then we can form k- j - 1 triangles. - * - * Time Complexity: O(n^2) Loop of k and j will be executed O(n^2) times in total, because, we do - * not reinitialize the value of k for a new value of j chosen(for the same i). Thus, the complexity - * will be O(n^2 + n^2) = O(n^2). - * Space Complexity: O(log n). Sorting takes O(log n) space. - * Runtime: 5 ms. - * - * @param nums - * @return - */ - public static int triangleNumber(int[] nums) { - int noOfTriangles = 0; - Arrays.sort(nums); - - for (int i = 0; i < nums.length - 2; i++) { - int k = i + 2; - for (int j = i + 1; j < nums.length - 1; j++) { - while (k < nums.length && nums[i] + nums[j] > nums[k]) { - k++; - } - if (k - j - 1 > 0) { - noOfTriangles += k - j - 1; - } - } - } - - return noOfTriangles; - } - - public static void main(String[] args) { - assertEquals(0, triangleNumberUsingBinarySearch(new int[]{})); - assertEquals(0, triangleNumberUsingBinarySearch(new int[]{1})); - assertEquals(3, triangleNumberUsingBinarySearch(new int[]{2, 2, 3, 4})); - assertEquals(0, triangleNumberUsingBinarySearch(new int[]{0, 1, 0, 1})); - assertEquals(7, triangleNumberUsingBinarySearch(new int[]{1, 2, 3, 4, 5, 6})); - - assertEquals(0, triangleNumber(new int[]{})); - assertEquals(0, triangleNumber(new int[]{1})); - assertEquals(3, triangleNumber(new int[]{2, 2, 3, 4})); - assertEquals(0, triangleNumber(new int[]{0, 1, 0, 1})); - assertEquals(7, triangleNumber(new int[]{1, 2, 3, 4, 5, 6})); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/binarysearch/PowXN.java b/src/main/java/com/leetcode/arrays/binarysearch/PowXN.java deleted file mode 100644 index 3591c50e..00000000 --- a/src/main/java/com/leetcode/arrays/binarysearch/PowXN.java +++ /dev/null @@ -1,85 +0,0 @@ -package com.leetcode.arrays.binarysearch; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/powx-n/ - * Description: - * Implement pow(x, n), which calculates x raised to the power n (x^n). - *

- * Example 1: - * Input: 2.00000, 10 - * Output: 1024.00000 - *

- * Example 2: - * Input: 2.10000, 3 - * Output: 9.26100 - *

- * Example 3: - * Input: 2.00000, -2 - * Output: 0.25000 - * Explanation: 2^-2 = 1/22 = 1/4 = 0.25 - *

- * Note: - * -100.0 < x < 100.0 - * n is a 32-bit signed integer, within the range [−231, 231 − 1] - * - * @author rampatra - * @since 2019-08-19 - */ -public class PowXN { - - /** - * In this approach we iterate n times and keep multiplying x with x. - * Runtime: Time limit exceeded. - * - * @param x - * @param n - * @return - */ - public static double myPowNaive(double x, int n) { - if (n == 0) { - return 1; - } - double res = x; - int absN = Math.abs(n); - for (int i = 1; i < absN; i++) { - res *= x; - } - return n < 0 ? 1 / res : res; - } - - - /** - * In this approach, we iterate log n times. We omit half of n each time. When n is odd, we store whatever product - * we have calculated so far in the final result. - *

- * Runtime: 1 ms. - * - * @param x - * @param n - * @return - */ - public static double myPow(double x, int n) { - double res = 1; - long absN = Math.abs((long) n); // used a long so that `absN / 2` doesn't overflow - - while (absN > 0) { - if (absN % 2 == 1) res *= x; // store whatever we have calculated so far in the final result - x *= x; - absN /= 2; - } - return n < 0 ? 1 / res : res; - } - - public static void main(String[] args) { - assertEquals(1024.0, myPowNaive(2.0, 10)); - assertEquals(0.25, myPowNaive(2.0, -2)); - assertEquals(0.0, myPowNaive(0.00001, 2147483647)); - - assertEquals(1024.0, myPow(2.0, 10)); - assertEquals(0.25, myPow(2.0, -2)); - assertEquals(0.0, myPow(0.00001, 2147483647)); - } -} diff --git a/src/main/java/com/leetcode/arrays/binarysearch/SearchInsertPosition.java b/src/main/java/com/leetcode/arrays/binarysearch/SearchInsertPosition.java deleted file mode 100644 index 2f13214a..00000000 --- a/src/main/java/com/leetcode/arrays/binarysearch/SearchInsertPosition.java +++ /dev/null @@ -1,64 +0,0 @@ -package com.leetcode.arrays.binarysearch; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Easy - * Link: https://leetcode.com/problems/search-insert-position/ - * Description: - * Given a sorted array and a target value, return the index if the target is found. If not, return the index where it - * would be if it were inserted in order. - *

- * You may assume no duplicates in the array. - *

- * Example 1: - * Input: [1,3,5,6], 5 - * Output: 2 - *

- * Example 2: - * Input: [1,3,5,6], 2 - * Output: 1 - *

- * Example 3: - * Input: [1,3,5,6], 7 - * Output: 4 - *

- * Example 4: - * Input: [1,3,5,6], 0 - * Output: 0 - *

- * Similar question: {@link SmallestLetterGreaterThanTarget}. - * - * @author rampatra - * @since 2019-08-19 - */ -public class SearchInsertPosition { - - /** - * Runtime: 0 ms. - * - * @param nums - * @param target - * @return - */ - public static int searchInsert(int[] nums, int target) { - int low = 0; - int high = nums.length - 1; - while (low <= high) { - int mid = low + (high - low) / 2; - if (nums[mid] == target) { - return mid; - } else if (nums[mid] < target) { - low = mid + 1; - } else { - high = mid - 1; - } - } - return low; - } - - public static void main(String[] args) { - assertEquals(2, searchInsert(new int[]{1, 2}, 3)); - assertEquals(1, searchInsert(new int[]{1, 3, 5, 6}, 2)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/binarysearch/SmallestLetterGreaterThanTarget.java b/src/main/java/com/leetcode/arrays/binarysearch/SmallestLetterGreaterThanTarget.java deleted file mode 100644 index e44dc339..00000000 --- a/src/main/java/com/leetcode/arrays/binarysearch/SmallestLetterGreaterThanTarget.java +++ /dev/null @@ -1,87 +0,0 @@ -package com.leetcode.arrays.binarysearch; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Easy - * Link: https://leetcode.com/problems/find-smallest-letter-greater-than-target/ - * Description: - * Given a list of sorted characters letters containing only lowercase letters, and given a target letter target, find - * the smallest element in the list that is larger than the given target. - * - * Letters also wrap around. For example, if the target is target = 'z' and letters = ['a', 'b'], the answer is 'a'. - * - * Examples: - * - * Input: - * letters = ["c", "f", "j"] - * target = "a" - * Output: "c" - * - * Input: - * letters = ["c", "f", "j"] - * target = "c" - * Output: "f" - * - * Input: - * letters = ["c", "f", "j"] - * target = "d" - * Output: "f" - * - * Input: - * letters = ["c", "f", "j"] - * target = "g" - * Output: "j" - * - * Input: - * letters = ["c", "f", "j"] - * target = "j" - * Output: "c" - * - * Input: - * letters = ["c", "f", "j"] - * target = "k" - * Output: "c" - * - * Note: - * - letters has a length in range [2, 10000]. - * - letters consists of lowercase letters, and contains at least 2 unique letters. - * - target is a lowercase letter. - * - * @author rampatra - * @since 2019-08-19 - */ -public class SmallestLetterGreaterThanTarget { - - /** - * Runtime: 0 ms. - * - * @param letters - * @param target - * @return - */ - public static char nextGreatestLetter(char[] letters, char target) { - int low = 0, hi = letters.length - 1; - while (low <= hi) { - int mid = low + (hi - low) / 2; - if (letters[mid] <= target) { - low = mid + 1; - } else { - hi = mid - 1; - } - } - return letters[low % letters.length]; - } - - public static void main(String[] args) { - assertEquals('a', nextGreatestLetter(new char[]{'a'}, 'z')); - assertEquals('b', nextGreatestLetter(new char[]{'a', 'b'}, 'a')); - assertEquals('b', nextGreatestLetter(new char[]{'a', 'b', 'c'}, 'a')); - assertEquals('a', nextGreatestLetter(new char[]{'a', 'b', 'c'}, 'z')); - assertEquals('c', nextGreatestLetter(new char[]{'c', 'f', 'j'}, 'a')); - assertEquals('f', nextGreatestLetter(new char[]{'c', 'f', 'j'}, 'c')); - assertEquals('f', nextGreatestLetter(new char[]{'c', 'f', 'j'}, 'd')); - assertEquals('b', nextGreatestLetter(new char[]{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'l', - 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'}, 'a')); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/arrays/binarysearch/SqrtX.java b/src/main/java/com/leetcode/arrays/binarysearch/SqrtX.java deleted file mode 100644 index 0dde1308..00000000 --- a/src/main/java/com/leetcode/arrays/binarysearch/SqrtX.java +++ /dev/null @@ -1,62 +0,0 @@ -package com.leetcode.arrays.binarysearch; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Easy - * Link: https://leetcode.com/problems/sqrtx/ - * Description: - * Implement int sqrt(int x). - * - * Compute and return the square root of x, where x is guaranteed to be a non-negative integer. - * - * Since the return type is an integer, the decimal digits are truncated and only the integer part - * of the result is returned. - * - * Example 1: - * Input: 4 - * Output: 2 - * - * Example 2: - * Input: 8 - * Output: 2 - * Explanation: The square root of 8 is 2.82842..., and since - * the decimal part is truncated, 2 is returned. - * - * @author rampatra - * @since 2019-08-19 - */ -public class SqrtX { - - /** - * Runtime: 1 ms. - * - * @param x - * @return - */ - public static int mySqrt(int x) { - if (x == 0 || x == 1) { - return x; - } - long low = 1; - long high = x / 2; - - while (low <= high) { - long mid = low + (high - low) / 2; - if (mid * mid == x) { - return (int) mid; - } else if (mid * mid < x) { - low = mid + 1; - } else { - high = mid - 1; - } - } - return (int) high; - } - - public static void main(String[] args) { - assertEquals(2, mySqrt(8)); - assertEquals(3, mySqrt(9)); - assertEquals(46339, mySqrt(2147395599)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/design/AllOne.java b/src/main/java/com/leetcode/design/AllOne.java deleted file mode 100644 index 51f771d7..00000000 --- a/src/main/java/com/leetcode/design/AllOne.java +++ /dev/null @@ -1,125 +0,0 @@ -package com.leetcode.design; - -import java.util.HashMap; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Hard - * Link: https://leetcode.com/problems/all-oone-data-structure/ - * Description: - * Implement a data structure supporting the following operations: - * Inc(Key) - Inserts a new key with value 1. Or increments an existing key by 1. Key is guaranteed to be a non-empty - * string. - * Dec(Key) - If Key's value is 1, remove it from the data structure. Otherwise decrements an existing key by 1. If - * the key does not exist, this function does nothing. Key is guaranteed to be a non-empty string. - * GetMaxKey() - Returns one of the keys with maximal value. If no element exists, return an empty string "". - * GetMinKey() - Returns one of the keys with minimal value. If no element exists, return an empty string "". - *

- * Challenge: Perform all these in O(1) time complexity. - * - * @author rampatra - * @since 2019-08-11 - */ -public class AllOne { - - - - Map keyToValMap; - Map> valToKeyMap; - - /** - * Initialize your data structure here. - */ - public AllOne() { - keyToValMap = new HashMap<>(); - valToKeyMap = new HashMap<>(); - } - - /** - * Inserts a new key with value 1. Or increments an existing key by 1. - */ - public void inc(String key) { - - } - - /** - * Decrements an existing key by 1. If Key's value is 1, remove it from the data structure. - */ - public void dec(String key) { - - } - - /** - * Returns one of the keys with maximal value. - */ - public String getMaxKey() { - return null; - } - - /** - * Returns one of the keys with Minimal value. - */ - public String getMinKey() { - return null; - } - - public static void main(String[] args) { - AllOne allOne = new AllOne(); - allOne.inc("r"); - allOne.inc("r"); - allOne.dec("r"); - allOne.inc("a"); - allOne.inc("b"); - allOne.inc("b"); - assertEquals("b", allOne.getMaxKey()); - assertEquals("a", allOne.getMinKey()); - - allOne = new AllOne(); - allOne.dec("hello"); - assertEquals("", allOne.getMaxKey()); - - allOne = new AllOne(); - allOne.inc("a"); - allOne.inc("b"); - allOne.inc("b"); - allOne.inc("b"); - allOne.inc("b"); - allOne.dec("b"); - allOne.dec("b"); - assertEquals("b", allOne.getMaxKey()); - assertEquals("a", allOne.getMinKey()); - - allOne = new AllOne(); - allOne.inc("hello"); - allOne.inc("hello"); - assertEquals("hello", allOne.getMaxKey()); - assertEquals("hello", allOne.getMinKey()); - allOne.inc("leet"); - assertEquals("hello", allOne.getMaxKey()); - assertEquals("leet", allOne.getMinKey()); - - allOne = new AllOne(); - allOne.inc("a"); - allOne.inc("b"); - allOne.inc("b"); - allOne.inc("c"); - allOne.inc("c"); - allOne.inc("c"); - allOne.dec("b"); - allOne.dec("b"); - assertEquals("a", allOne.getMinKey()); - allOne.dec("a"); - assertEquals("c", allOne.getMaxKey()); - //assertEquals("c", allOne.getMinKey()); - - allOne = new AllOne(); - allOne.inc("hello"); - allOne.dec("hello"); - assertEquals("", allOne.getMaxKey()); - assertEquals("", allOne.getMinKey()); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/design/DesignHitCounter.java b/src/main/java/com/leetcode/design/DesignHitCounter.java deleted file mode 100644 index 62133196..00000000 --- a/src/main/java/com/leetcode/design/DesignHitCounter.java +++ /dev/null @@ -1,117 +0,0 @@ -package com.leetcode.design; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/design-hit-counter/ - * Problem Description: - * Design a hit counter which counts the number of hits received in the past 5 minutes. - * - * Each function accepts a timestamp parameter (in seconds granularity) and you may assume that calls are being made - * to the system in chronological order (ie, the timestamp is monotonically increasing). You may assume that the - * earliest timestamp starts at 1. - * - * It is possible that several hits arrive roughly at the same time. - * - * Example: - * - * HitCounter counter = new HitCounter(); - * - * // hit at timestamp 1. - * counter.hit(1); - * - * // hit at timestamp 2. - * counter.hit(2); - * - * // hit at timestamp 3. - * counter.hit(3); - * - * // get hits at timestamp 4, should return 3. - * counter.getHits(4); - * - * // hit at timestamp 300. - * counter.hit(300); - * - * // get hits at timestamp 300, should return 4. - * counter.getHits(300); - * - * // get hits at timestamp 301, should return 3. - * counter.getHits(301); - * - * Follow up: - * What if the number of hits per second could be very large? Does your design scale? - * - * Runtime: 42 ms (better than ~98%). - * - * @author rampatra - * @since 2019-08-04 - */ -public class DesignHitCounter { - - private int[] timestamps; - private int[] hits; - - /** - * Initialize your data structure here. - */ - public DesignHitCounter() { - this.timestamps = new int[300]; - this.hits = new int[300]; - } - - /** - * Record a hit. - * - * @param timestamp - The current timestamp (in seconds granularity). - */ - public void hit(int timestamp) { - int bucket = timestamp % 300; - if (timestamps[bucket] == timestamp) { - hits[bucket]++; - } else { - timestamps[bucket] = timestamp; - hits[bucket] = 1; - } - } - - /** - * Return the number of hits in the past 5 minutes. - * - * @param timestamp - The current timestamp (in seconds granularity). - */ - public int getHits(int timestamp) { - int totalHits = 0; - for (int i = 0; i < 300; i++) { - if (timestamp - 300 < timestamps[i]) { - totalHits += hits[i]; - } - } - return totalHits; - } - - public static void main(String[] args) { - DesignHitCounter counter = new DesignHitCounter(); - - // hit at timestamp 1. - counter.hit(1); - - // hit at timestamp 2. - counter.hit(2); - - // hit at timestamp 3. - counter.hit(3); - - // get hits at timestamp 4, should return 3. - assertEquals(3, counter.getHits(4)); - - // hit at timestamp 300. - counter.hit(300); - - // get hits at timestamp 300, should return 4. - assertEquals(4, counter.getHits(300)); - - // get hits at timestamp 301, should return 3. - assertEquals(3, counter.getHits(301)); - } -} diff --git a/src/main/java/com/leetcode/design/InsertDeleteGetRandom.java b/src/main/java/com/leetcode/design/InsertDeleteGetRandom.java deleted file mode 100644 index a6c2f376..00000000 --- a/src/main/java/com/leetcode/design/InsertDeleteGetRandom.java +++ /dev/null @@ -1,106 +0,0 @@ -package com.leetcode.design; - -import java.util.*; - -import static org.junit.jupiter.api.Assertions.*; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/insert-delete-getrandom-o1/ - * Description: - * Design a data structure that supports all following operations in average O(1) time. - * - * insert(val): Inserts an item val to the set if not already present. - * remove(val): Removes an item val from the set if present. - * getRandom: Returns a random element from current set of elements. Each element must have the same probability of - * being returned. - * - * Example: - * - * // Init an empty set. - * RandomizedSet randomSet = new RandomizedSet(); - * - * // Inserts 1 to the set. Returns true as 1 was inserted successfully. - * randomSet.insert(1); - * - * // Returns false as 2 does not exist in the set. - * randomSet.remove(2); - * - * // Inserts 2 to the set, returns true. Set now contains [1,2]. - * randomSet.insert(2); - * - * // getRandom should return either 1 or 2 randomly. - * randomSet.getRandom(); - * - * // Removes 1 from the set, returns true. Set now contains [2]. - * randomSet.remove(1); - * - * // 2 was already in the set, so return false. - * randomSet.insert(2); - * - * // Since 2 is the only number in the set, getRandom always return 2. - * randomSet.getRandom(); - * - * Runtime: 54 ms. - * - * @author rampatra - * @since 2019-08-20 - */ -public class LRUCache { - - private LinkedHashMap cache; - - public LRUCache(int capacity) { - this.cache = new LinkedHashMap(capacity, 0.75f, true) { - @Override - protected boolean removeEldestEntry(Map.Entry eldest) { - return size() > capacity; - } - }; - } - - public int get(int key) { - Integer val = cache.get(key); - return val == null ? -1 : val; - } - - public void put(int key, int value) { - cache.put(key, value); - } - - public static void main(String[] args) { - LRUCache cache = new LRUCache(2); - cache.put(1,1); - cache.put(2,2); - cache.put(1,1); - cache.put(3,3); - assertEquals(1, cache.get(1)); - assertEquals(-1, cache.get(2)); - assertEquals(3, cache.get(3)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/dynamicprogramming/MaximumProductSubArray.java b/src/main/java/com/leetcode/dynamicprogramming/MaximumProductSubArray.java deleted file mode 100644 index 781cad13..00000000 --- a/src/main/java/com/leetcode/dynamicprogramming/MaximumProductSubArray.java +++ /dev/null @@ -1,62 +0,0 @@ -package com.leetcode.dynamicprogramming; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/maximum-product-subarray/ - * Description: - * Given an integer array nums, find the contiguous subarray within an array (containing at least one number) which - * has the largest product. - *

- * Example 1: - * Input: [2,3,-2,4] - * Output: 6 - * Explanation: [2,3] has the largest product 6. - *

- * Example 2: - * Input: [-2,0,-1] - * Output: 0 - * Explanation: The result cannot be 2, because [-2,-1] is not a subarray. - * - * @author rampatra - * @since 2019-08-18 - */ -public class MaximumProductSubArray { - - /** - * The approach is similar to {@link MaximumSubArray} where we update maxUntilIndex only if multiplying the current - * number to the product of of all numbers until index produces a larger product and if not make maxUntilIndex the - * current number. The only twist here is that we keep two such variables, one for max and one for min, and that's - * because the product of two negatives gives us a positive number. - *

- * Runtime: 1 ms. - * - * @param nums - * @return - */ - public static int maxProduct(int[] nums) { - int maxProd = nums[0]; - int maxUntilIndex = nums[0]; - int minUntilIndex = nums[0]; - - for (int i = 1; i < nums.length; i++) { - if (nums[i] >= 0) { - maxUntilIndex = Math.max(nums[i], maxUntilIndex * nums[i]); - minUntilIndex = Math.min(nums[i], minUntilIndex * nums[i]); - } else { - int prevMaxUntilIndex = maxUntilIndex; - maxUntilIndex = Math.max(nums[i], minUntilIndex * nums[i]); // when current number is -ve then multiply with minUntilIndex to get the max as product of two negatives is a positive - minUntilIndex = Math.min(nums[i], prevMaxUntilIndex * nums[i]); - } - - maxProd = Math.max(maxProd, maxUntilIndex); - } - - return maxProd; - } - - public static void main(String[] args) { - assertEquals(24, maxProduct(new int[]{-2, 3, -4})); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/dynamicprogramming/MaximumSubArray.java b/src/main/java/com/leetcode/dynamicprogramming/MaximumSubArray.java deleted file mode 100644 index 90a28c93..00000000 --- a/src/main/java/com/leetcode/dynamicprogramming/MaximumSubArray.java +++ /dev/null @@ -1,104 +0,0 @@ -package com.leetcode.dynamicprogramming; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/maximum-subarray - * - * @author rampatra - * @since 2019-04-26 - */ -public class MaximumSubArray { - - /** - * Time complexity: O(n) - * Runtime: 0 ms. - * - * @param nums - * @return - */ - public static int maxSubArray(int[] nums) { - if (nums.length == 0) { - return 0; - } - - int consecutiveSum = nums[0]; - int maxSum = nums[0]; - - for (int i = 1; i < nums.length; i++) { - consecutiveSum += nums[i]; - - /* if the current number is larger than the summation of all the - previous numbers then start from current number */ - if (nums[i] > consecutiveSum) { - consecutiveSum = nums[i]; - } - - if (consecutiveSum > maxSum) { - maxSum = consecutiveSum; - } - } - - return maxSum; - } - - - /** - * Divide and Conquer approach. - * Time complexity: O(n log n). See Master's Theorem to understand how. - * Runtime: 1 ms. - * - * @param nums - * @return - */ - public static int maxSubArrayDivideAndConquer(int[] nums) { - return maxSubArrayDivideAndConquer(nums, 0, nums.length - 1); - } - - public static int maxSubArrayDivideAndConquer(int[] nums, int start, int end) { - if (start == end) { - return nums[start]; - } - - int mid = start + (end - start) / 2; - int leftSASum = maxSubArrayDivideAndConquer(nums, start, mid); - int rightSASum = maxSubArrayDivideAndConquer(nums, mid + 1, end); - - int leftSum = Integer.MIN_VALUE; - int rightSum = Integer.MIN_VALUE; - - // compute consecutive sum from mid towards start - int sum = 0; - for (int i = mid; i >= start; i--) { - sum += nums[i]; - if (sum > leftSum) { - leftSum = sum; - } - } - - // compute consecutive sum from mid towards end - sum = 0; - for (int i = mid + 1; i <= end; i++) { - sum += nums[i]; - if (sum > rightSum) { - rightSum = sum; - } - } - - // return the max of left sub-array, right sub-array, and the consecutive sum between start and end via mid - return Math.max(Math.max(leftSASum, rightSASum), leftSum + rightSum); - } - - public static void main(String[] args) { - System.out.println(maxSubArray(new int[]{3})); - System.out.println(maxSubArray(new int[]{-3})); - System.out.println(maxSubArray(new int[]{-2, 1, -3, 4, -1, 2, 1, -5, 4})); - System.out.println(maxSubArray(new int[]{4, -5, 1, 2, -1, 4, -3, 1, -2})); - - System.out.println("----"); - - System.out.println(maxSubArrayDivideAndConquer(new int[]{3})); - System.out.println(maxSubArrayDivideAndConquer(new int[]{-3})); - System.out.println(maxSubArrayDivideAndConquer(new int[]{-2, 1, -3, 4, -1, 2, 1, -5, 4})); - System.out.println(maxSubArrayDivideAndConquer(new int[]{4, -5, 1, 2, -1, 4, -3, 1, -2})); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/dynamicprogramming/PaintHouse.java b/src/main/java/com/leetcode/dynamicprogramming/PaintHouse.java deleted file mode 100644 index 5692b0d8..00000000 --- a/src/main/java/com/leetcode/dynamicprogramming/PaintHouse.java +++ /dev/null @@ -1,52 +0,0 @@ -package com.leetcode.dynamicprogramming; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/paint-house/ - * Problem Description: - * There are a row of n houses, each house can be painted with one of the three colors: red, blue or green. The cost - * of painting each house with a certain color is different. You have to paint all the houses such that no two adjacent - * houses have the same color. The cost of painting each house with a certain color is represented by a n x 3 cost matrix. - *

- * For example, costs[0][0] is the cost of painting house 0 with color red; costs[1][2] is the cost of painting - * house 1 with color green, and so on... Find the minimum cost to paint all houses. - *

- * Companies: LinkedIn. - * Related: {@link PaintHouseII}. - * - * @author rampatra - * @since 2019-07-23 - */ -public class PaintHouse { - - /** - * Runtime: 1 ms. - * - * @param costs of coloring the houses with red, blue, and green respectively. 1st row represents house 1, 2nd row - * house 2 and so on - * @return the minimum cost to paint all houses such that no two adjacent houses are of same color - */ - public static int minCost(int[][] costs) { - if (costs == null || costs.length == 0) return 0; - - for (int i = 1; i < costs.length; i++) { - costs[i][0] += Math.min(costs[i - 1][1], costs[i - 1][2]); - costs[i][1] += Math.min(costs[i - 1][0], costs[i - 1][2]); - costs[i][2] += Math.min(costs[i - 1][0], costs[i - 1][1]); - } - - int lastRow = costs.length - 1; - return Math.min(Math.min(costs[lastRow][0], costs[lastRow][1]), costs[lastRow][2]); - } - - public static void main(String[] args) { - System.out.println(minCost(new int[][]{ - })); - - System.out.println(minCost(new int[][]{ - {2, 3, 4}, - {5, 7, 6}, - {8, 7, 2} - })); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/dynamicprogramming/PaintHouseII.java b/src/main/java/com/leetcode/dynamicprogramming/PaintHouseII.java deleted file mode 100644 index 431ce612..00000000 --- a/src/main/java/com/leetcode/dynamicprogramming/PaintHouseII.java +++ /dev/null @@ -1,120 +0,0 @@ -package com.leetcode.dynamicprogramming; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Hard - * Problem Link: https://leetcode.com/problems/paint-house-ii/ - * Problem Description: - * There are a row of n houses, each house can be painted with one of the m colors. - * The cost of painting each house with a certain color is different. - * You have to paint all the houses such that no two adjacent houses have the same color. - *

- * The cost of painting each house with a certain color is represented by a n x m cost matrix. - *

- * For example, costs[0][0] is the cost of painting house 0 with color 0; - * costs[1][2] is the cost of painting house 1 with color 2, and so on... - * Find the minimum cost to paint all houses. - *

- * Note: All costs are positive integers. - *

- * Follow up: Could you solve it in O(n * m) runtime? // TODO - * - * Companies: LinkedIn. - * Related: {@link PaintHouse}. - * - * @author rampatra - * @since 2019-07-24 - */ -public class PaintHouseII { - - /** - * The approach is similar to {@link PaintHouse} but slightly complex as the number of colors are arbitrary - * instead of the 3 fixed colors. So, we use two additional for loops to cycle through all the colors. - * Time Complexity: O(n * m * m) - * Space Complexity: O(1) - * - * @param costs the costs of coloring the house, each row represents the cost of coloring a particular - * house with different colors - * @return the minimum cost to paint all houses such that no two adjacent houses are of same color - */ - public static int minCost(int[][] costs) { - if (costs == null || costs.length == 0) return 0; - - for (int i = 1; i < costs.length; i++) { - for (int j = 0; j < costs[0].length; j++) { - int min = Integer.MAX_VALUE; - // loop through all colors for the previous house except the color of the current house - for (int k = 0; k < costs[0].length; k++) { - if (k != j) { - min = Math.min(costs[i - 1][k], min); - } - } - costs[i][j] += min; - } - } - - int minCost = Integer.MAX_VALUE; - for (int i = 0; i < costs[0].length; i++) { - minCost = Math.min(costs[costs.length - 1][i], minCost); - } - - return minCost; - } - - public static void main(String[] args) { - assertEquals(0, minCost(new int[][]{})); - - assertEquals(10, minCost(new int[][]{ - {2, 3, 4}, - {5, 7, 6}, - {8, 7, 2} - })); - - assertEquals(10, minCost(new int[][]{{10, 30, 20}})); - - assertEquals(3, minCost(new int[][]{{1, 1, 1}, - {1, 1, 1}, - {1, 1, 1}})); - - assertEquals(5, minCost(new int[][]{{1, 2, 3}, - {3, 2, 1}, - {2, 2, 2}, - {3, 1, 2}})); - - assertEquals(10, minCost(new int[][]{{17, 2, 17}, - {16, 16, 5}, - {14, 3, 19}})); - - assertEquals(5, minCost(new int[][]{{1, 5, 3}, - {2, 9, 4}})); - - assertEquals(8, minCost(new int[][]{{8}})); - - assertEquals(143, minCost(new int[][]{{12, 1, 19}, - {15, 1, 10}, - {3, 11, 10}, - {9, 3, 10}, - {4, 8, 7}, - {4, 18, 2}, - {16, 6, 6}, - {3, 3, 6}, - {10, 18, 16}, - {5, 4, 8}, - {5, 3, 16}, - {11, 8, 19}, - {18, 15, 18}, - {16, 4, 15}, - {10, 7, 13}, - {11, 10, 14}, - {3, 9, 8}, - {5, 2, 2}, - {3, 2, 5}, - {2, 19, 14}, - {17, 3, 6}, - {6, 4, 17}, - {5, 15, 19}, - {2, 14, 14}, - {19, 4, 16}})); - } -} diff --git a/src/main/java/com/leetcode/graphs/GraphValidTree.java b/src/main/java/com/leetcode/graphs/GraphValidTree.java deleted file mode 100644 index 15950143..00000000 --- a/src/main/java/com/leetcode/graphs/GraphValidTree.java +++ /dev/null @@ -1,131 +0,0 @@ -package com.leetcode.graphs; - -import java.util.ArrayList; -import java.util.List; - -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/graph-valid-tree/ - * Problem Description: - * Given n nodes labeled from 0 to n-1 and a list of undirected edges (each edge is a pair of nodes), write a function - * to check whether these edges make up a valid tree. - *

- * Example 1: - * Input: n = 5, and edges = [[0,1], [0,2], [0,3], [1,4]] - * Output: true - *

- * Example 2: - * Input: n = 5, and edges = [[0,1], [1,2], [2,3], [1,3], [1,4]] - * Output: false - *

- * Note: you can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0,1] is the - * same as [1,0] and thus will not appear together in edges. - * - * @author rampatra - * @since 2019-08-05 - */ -public class GraphValidTree { - - /** - * - * @param n - * @param edges - * @return - */ - public static boolean isValidTree(int n, int[][] edges) { - List> adjacencyList = new ArrayList<>(n); - - for (int i = 0; i < n; i++) { - adjacencyList.add(new ArrayList<>()); - } - - for (int i = 0; i < edges.length; i++) { - adjacencyList.get(edges[i][0]).add(edges[i][1]); - } - - boolean[] visited = new boolean[n]; - - if (hasCycle(adjacencyList, 0, -1, visited)) { - return false; - } - - for (int i = 0; i < n; i++) { - if (!visited[i]) { - return false; - } - } - - return true; - } - - private static boolean hasCycle(List> adjacencyList, int node1, int exclude, boolean[] visited) { - visited[node1] = true; - - for (int i = 0; i < adjacencyList.get(node1).size(); i++) { - int node2 = adjacencyList.get(node1).get(i); - - if ((visited[node2] && exclude != node2) || (!visited[node2] && hasCycle(adjacencyList, node2, node1, visited))) { - return true; - } - } - - return false; - } - - - /** - * Union-find algorithm: We keep all connected nodes in one set in the union operation and in find operation we - * check whether two nodes belong to the same set. If yes then there's a cycle and if not then no cycle. - * - * Good articles on union-find: - * - https://www.hackerearth.com/practice/notes/disjoint-set-union-union-find/ - * - https://www.youtube.com/watch?v=wU6udHRIkcc - * - * @param n - * @param edges - * @return - */ - public static boolean isValidTreeUsingUnionFind(int n, int[][] edges) { - int[] roots = new int[n]; - - for (int i = 0; i < n; i++) { - roots[i] = i; - } - - for (int i = 0; i < edges.length; i++) { - // find operation - if (roots[edges[i][0]] == roots[edges[i][1]]) { - return false; - } - // union operation - roots[edges[i][1]] = findRoot(roots, roots[edges[i][0]]); // note: we can optimize this even further by - // considering size of each side and then join the side with smaller size to the one with a larger size (weighted union). - // We can use another array called size to keep count of the size or we can use the same root array with - // negative values, i.e, negative resembles that the node is pointing to itself and the number will represent - // the size. For example, roots = [-2, -1, -1, 0] means that node 3 is pointing to node 0 and node 0 is pointing - // to itself and is has 2 nodes under it including itself. - } - - return edges.length == n - 1; - } - - private static int findRoot(int[] roots, int node) { - while (roots[node] != node) { - node = roots[node]; - } - return node; - } - - public static void main(String[] args) { - assertTrue(isValidTree(5, new int[][]{{0, 1}, {0, 2}, {0, 3}, {1, 4}})); - assertFalse(isValidTree(5, new int[][]{{0, 1}, {1, 2}, {2, 3}, {1, 3}, {1, 4}})); - assertFalse(isValidTree(3, new int[][]{{0, 1}, {1, 2}, {2, 0}})); - - assertTrue(isValidTreeUsingUnionFind(5, new int[][]{{0, 1}, {0, 2}, {0, 3}, {1, 4}})); - assertFalse(isValidTreeUsingUnionFind(5, new int[][]{{0, 1}, {1, 2}, {2, 3}, {1, 3}, {1, 4}})); - assertFalse(isValidTreeUsingUnionFind(3, new int[][]{{0, 1}, {1, 2}, {2, 0}})); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/graphs/WordLadder.java b/src/main/java/com/leetcode/graphs/WordLadder.java deleted file mode 100644 index 61e706ce..00000000 --- a/src/main/java/com/leetcode/graphs/WordLadder.java +++ /dev/null @@ -1,121 +0,0 @@ -package com.leetcode.graphs; - - -import javafx.util.Pair; - -import java.util.*; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/word-ladder/ - * Description: - * Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation - * sequence from beginWord to endWord, such that: - *

- * Only one letter can be changed at a time. Each transformed word must exist in the word list. Note that beginWord - * is not a transformed word. - *

- * Note: - * - Return 0 if there is no such transformation sequence. - * - All words have the same length. - * - All words contain only lowercase alphabetic characters. - * - You may assume no duplicates in the word list. - * - You may assume beginWord and endWord are non-empty and are not the same. - *

- * Example 1: - * Input: - * beginWord = "hit", - * endWord = "cog", - * wordList = ["hot","dot","dog","lot","log","cog"] - *

- * Output: 5 - *

- * Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog", - * return its length 5. - *

- * Example 2: - * Input: - * beginWord = "hit" - * endWord = "cog" - * wordList = ["hot","dot","dog","lot","log"] - *

- * Output: 0 - *

- * Explanation: The endWord "cog" is not in wordList, therefore no possible transformation. - * - * @author rampatra - * @since 2019-08-15 - */ -public class WordLadder { - - /** - * Runtime: 79 ms. - * - * @param beginWord - * @param endWord - * @param wordList - * @return - */ - public static int ladderLength(String beginWord, String endWord, List wordList) { - int L = beginWord.length(); - Map> transformedToOriginalWordMap = new HashMap<>(); - Queue> queue = new LinkedList<>(); - - wordList.forEach(word -> { - String transformedWord; - for (int i = 0; i < L; i++) { - transformedWord = word.substring(0, i) + "*" + word.substring(i + 1, L); - transformedToOriginalWordMap.putIfAbsent(transformedWord, new HashSet<>()); - transformedToOriginalWordMap.get(transformedWord).add(word); - } - } - ); - - Set visited = new HashSet<>(); - queue.add(new Pair<>(beginWord, 1)); - visited.add(beginWord); - - while (!queue.isEmpty()) { - Pair currPair = queue.poll(); - String word = currPair.getKey(); - Integer level = currPair.getValue(); - - if (word.equals(endWord)) { - return level; - } - - String transformedWord; - for (int i = 0; i < L; i++) { - transformedWord = word.substring(0, i) + "*" + word.substring(i + 1, L); - - for (String originalWord : transformedToOriginalWordMap.getOrDefault(transformedWord, Collections.emptySet())) { - if (!visited.contains(originalWord)) { - queue.add(new Pair<>(originalWord, level + 1)); - visited.add(originalWord); - } - } - } - } - - return 0; - } - - /** - * TODO: Optimized both end BFS solution - * - * @param beginWord - * @param endWord - * @param wordList - * @return - */ - public static int ladderLengthOptimized(String beginWord, String endWord, List wordList) { - return -1; - } - - public static void main(String[] args) { - assertEquals(5, ladderLength("hit", "cog", Arrays.asList("hot", "dot", "dog", "lot", "log", "cog"))); - assertEquals(0, ladderLength("hit", "cog", Arrays.asList("hot", "dot", "dog", "lot", "log"))); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/graphs/WordLadderII.java b/src/main/java/com/leetcode/graphs/WordLadderII.java deleted file mode 100644 index 8265c259..00000000 --- a/src/main/java/com/leetcode/graphs/WordLadderII.java +++ /dev/null @@ -1,152 +0,0 @@ -package com.leetcode.graphs; - -import javafx.util.Pair; - -import java.util.*; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Hard - * Link: https://leetcode.com/problems/word-ladder-ii/ - * Description: - * Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) - * from beginWord to endWord, such that: - *

- * Only one letter can be changed at a time - * Each transformed word must exist in the word list. Note that beginWord is not a transformed word. - *

- * Note: - * - Return an empty list if there is no such transformation sequence. - * - All words have the same length. - * - All words contain only lowercase alphabetic characters. - * - You may assume no duplicates in the word list. - * - You may assume beginWord and endWord are non-empty and are not the same. - *

- * Example 1: - * Input: - * beginWord = "hit", - * endWord = "cog", - * wordList = ["hot","dot","dog","lot","log","cog"] - *

- * Output: - * [ - * ["hit","hot","dot","dog","cog"], - * ["hit","hot","lot","log","cog"] - * ] - *

- *

- * Example 2: - * Input: - * beginWord = "hit" - * endWord = "cog" - * wordList = ["hot","dot","dog","lot","log"] - *

- * Output: [] - * Explanation: The endWord "cog" is not in wordList, therefore no possible transformation. - * - * @author rampatra - * @since 2019-08-15 - */ -public class WordLadderII { - - /** - * The approach is same as {@link WordLadder}. We calculate the {@code minDistance} from start to end word and also - * keep a map of words and its adjacent words (i.e, with only character difference). After we are done calculating - * the {@code mindistance}, we perform a dfs on the map upto depth {@code minDistance} and if the last word at this - * depth is equal to the end word then we add all words to the result. - * - * @param beginWord - * @param endWord - * @param wordList - * @return - */ - public static List> findLadders(String beginWord, String endWord, List wordList) { - int L = beginWord.length(); - List> ladders = new LinkedList<>(); - Map> transformedToOriginalWordMap = new HashMap<>(); - Queue> queue = new LinkedList<>(); - - wordList.forEach(word -> { - String transformedWord; - for (int i = 0; i < L; i++) { - transformedWord = word.substring(0, i) + "*" + word.substring(i + 1, L); - transformedToOriginalWordMap.putIfAbsent(transformedWord, new HashSet<>()); - transformedToOriginalWordMap.get(transformedWord).add(word); - } - } - ); - - int minDistance = -1; - Set visited = new HashSet<>(); - queue.add(new Pair<>(beginWord, 1)); - visited.add(beginWord); - - HashMap> connectedNodes = new HashMap<>(); - - while (!queue.isEmpty()) { - Pair currPair = queue.poll(); - String word = currPair.getKey(); - Integer level = currPair.getValue(); - - if (word.equals(endWord) && minDistance == -1) { - minDistance = level - 1; - } - - String transformedWord; - for (int i = 0; i < L; i++) { - transformedWord = word.substring(0, i) + "*" + word.substring(i + 1, L); - - for (String originalWord : transformedToOriginalWordMap.getOrDefault(transformedWord, Collections.emptySet())) { - if (!visited.contains(originalWord)) { - queue.add(new Pair<>(originalWord, level + 1)); - visited.add(originalWord); - } - - if (!word.equals(originalWord)) { - connectedNodes.putIfAbsent(word, new HashSet<>()); - connectedNodes.get(word).add(originalWord); - } - } - } - } - - dfs(ladders, new LinkedHashSet<>(), connectedNodes, beginWord, endWord, 0, minDistance); - - return ladders; - } - - /** - * Perform dfs on the map which contains words and its adjacent words. - * - * @param ladders - * @param ladder - * @param connectedNodes - * @param startNode - * @param endNode - * @param distance - * @param minDistance - */ - private static void dfs(List> ladders, Set ladder, Map> connectedNodes, - String startNode, String endNode, int distance, int minDistance) { - if (distance == minDistance && startNode.equals(endNode)) { - ladder.add(endNode); - ladders.add(new ArrayList<>(ladder)); - return; - } else if (distance > minDistance) { - return; - } - - ladder.add(startNode); - for (String nextNode : connectedNodes.getOrDefault(startNode, new HashSet<>())) { - if (!ladder.contains(nextNode)) { - dfs(ladders, new LinkedHashSet<>(ladder), connectedNodes, nextNode, endNode, distance + 1, minDistance); - } - } - } - - public static void main(String[] args) { - assertEquals("[[hit, hot, lot, log, cog], [hit, hot, dot, dog, cog]]", findLadders("hit", "cog", Arrays.asList("hot", "dot", "dog", "lot", "log", "cog")).toString()); - // TODO Fix this test case System.out.println(findLadders("cet", "ism", Arrays.asList("kid", "tag", "pup", "ail", "tun", "woo", "erg", "luz", "brr", "gay", "sip", "kay", "per", "val", "mes", "ohs", "now", "boa", "cet", "pal", "bar", "die", "war", "hay", "eco", "pub", "lob", "rue", "fry", "lit", "rex", "jan", "cot", "bid", "ali", "pay", "col", "gum", "ger", "row", "won", "dan", "rum", "fad", "tut", "sag", "yip", "sui", "ark", "has", "zip", "fez", "own", "ump", "dis", "ads", "max", "jaw", "out", "btu", "ana", "gap", "cry", "led", "abe", "box", "ore", "pig", "fie", "toy", "fat", "cal", "lie", "noh", "sew", "ono", "tam", "flu", "mgm", "ply", "awe", "pry", "tit", "tie", "yet", "too", "tax", "jim", "san", "pan", "map", "ski", "ova", "wed", "non", "wac", "nut", "why", "bye", "lye", "oct", "old", "fin", "feb", "chi", "sap", "owl", "log", "tod", "dot", "bow", "fob", "for", "joe", "ivy", "fan", "age", "fax", "hip", "jib", "mel", "hus", "sob", "ifs", "tab", "ara", "dab", "jag", "jar", "arm", "lot", "tom", "sax", "tex", "yum", "pei", "wen", "wry", "ire", "irk", "far", "mew", "wit", "doe", "gas", "rte", "ian", "pot", "ask", "wag", "hag", "amy", "nag", "ron", "soy", "gin", "don", "tug", "fay", "vic", "boo", "nam", "ave", "buy", "sop", "but", "orb", "fen", "paw", "his", "sub", "bob", "yea", "oft", "inn", "rod", "yam", "pew", "web", "hod", "hun", "gyp", "wei", "wis", "rob", "gad", "pie", "mon", "dog", "bib", "rub", "ere", "dig", "era", "cat", "fox", "bee", "mod", "day", "apr", "vie", "nev", "jam", "pam", "new", "aye", "ani", "and", "ibm", "yap", "can", "pyx", "tar", "kin", "fog", "hum", "pip", "cup", "dye", "lyx", "jog", "nun", "par", "wan", "fey", "bus", "oak", "bad", "ats", "set", "qom", "vat", "eat", "pus", "rev", "axe", "ion", "six", "ila", "lao", "mom", "mas", "pro", "few", "opt", "poe", "art", "ash", "oar", "cap", "lop", "may", "shy", "rid", "bat", "sum", "rim", "fee", "bmw", "sky", "maj", "hue", "thy", "ava", "rap", "den", "fla", "auk", "cox", "ibo", "hey", "saw", "vim", "sec", "ltd", "you", "its", "tat", "dew", "eva", "tog", "ram", "let", "see", "zit", "maw", "nix", "ate", "gig", "rep", "owe", "ind", "hog", "eve", "sam", "zoo", "any", "dow", "cod", "bed", "vet", "ham", "sis", "hex", "via", "fir", "nod", "mao", "aug", "mum", "hoe", "bah", "hal", "keg", "hew", "zed", "tow", "gog", "ass", "dem", "who", "bet", "gos", "son", "ear", "spy", "kit", "boy", "due", "sen", "oaf", "mix", "hep", "fur", "ada", "bin", "nil", "mia", "ewe", "hit", "fix", "sad", "rib", "eye", "hop", "haw", "wax", "mid", "tad", "ken", "wad", "rye", "pap", "bog", "gut", "ito", "woe", "our", "ado", "sin", "mad", "ray", "hon", "roy", "dip", "hen", "iva", "lug", "asp", "hui", "yak", "bay", "poi", "yep", "bun", "try", "lad", "elm", "nat", "wyo", "gym", "dug", "toe", "dee", "wig", "sly", "rip", "geo", "cog", "pas", "zen", "odd", "nan", "lay", "pod", "fit", "hem", "joy", "bum", "rio", "yon", "dec", "leg", "put", "sue", "dim", "pet", "yaw", "nub", "bit", "bur", "sid", "sun", "oil", "red", "doc", "moe", "caw", "eel", "dix", "cub", "end", "gem", "off", "yew", "hug", "pop", "tub", "sgt", "lid", "pun", "ton", "sol", "din", "yup", "jab", "pea", "bug", "gag", "mil", "jig", "hub", "low", "did", "tin", "get", "gte", "sox", "lei", "mig", "fig", "lon", "use", "ban", "flo", "nov", "jut", "bag", "mir", "sty", "lap", "two", "ins", "con", "ant", "net", "tux", "ode", "stu", "mug", "cad", "nap", "gun", "fop", "tot", "sow", "sal", "sic", "ted", "wot", "del", "imp", "cob", "way", "ann", "tan", "mci", "job", "wet", "ism", "err", "him", "all", "pad", "hah", "hie", "aim", "ike", "jed", "ego", "mac", "baa", "min", "com", "ill", "was", "cab", "ago", "ina", "big", "ilk", "gal", "tap", "duh", "ola", "ran", "lab", "top", "gob", "hot", "ora", "tia", "kip", "han", "met", "hut", "she", "sac", "fed", "goo", "tee", "ell", "not", "act", "gil", "rut", "ala", "ape", "rig", "cid", "god", "duo", "lin", "aid", "gel", "awl", "lag", "elf", "liz", "ref", "aha", "fib", "oho", "tho", "her", "nor", "ace", "adz", "fun", "ned", "coo", "win", "tao", "coy", "van", "man", "pit", "guy", "foe", "hid", "mai", "sup", "jay", "hob", "mow", "jot", "are", "pol", "arc", "lax", "aft", "alb", "len", "air", "pug", "pox", "vow", "got", "meg", "zoe", "amp", "ale", "bud", "gee", "pin", "dun", "pat", "ten", "mob"))); - } -} diff --git a/src/main/java/com/leetcode/hashtables/ContainsDuplicates.java b/src/main/java/com/leetcode/hashtables/ContainsDuplicates.java deleted file mode 100644 index 7b12311b..00000000 --- a/src/main/java/com/leetcode/hashtables/ContainsDuplicates.java +++ /dev/null @@ -1,49 +0,0 @@ -package com.leetcode.hashtables; - -import java.util.Arrays; -import java.util.HashSet; -import java.util.Set; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/contains-duplicate/ - * - * @author rampatra - * @since 2019-04-24 - */ -public class ContainsDuplicates { - - public static boolean containsDuplicates(int[] nums) { - Set numSet = new HashSet<>(); - for (int num : nums) { - if (!numSet.add(num)) { - return true; - } - } - return false; - } - - /** - * Runtime: 5 ms. - * - * @param nums - * @return - */ - public static boolean containsDuplicatesWithoutSet(int[] nums) { - Arrays.sort(nums); - for (int i = 0; i < nums.length - 1; i++) { - if (nums[i] == nums[i + 1]) { - return true; - } - } - return false; - } - - public static void main(String[] args) { - System.out.println(containsDuplicates(new int[]{1, 2, 3, 1})); - System.out.println(containsDuplicates(new int[]{1, 2, 3, 4})); - - System.out.println(containsDuplicatesWithoutSet(new int[]{1, 2, 3, 1})); - System.out.println(containsDuplicatesWithoutSet(new int[]{1, 2, 3, 4})); - } -} diff --git a/src/main/java/com/leetcode/hashtables/IsomorphicStrings.java b/src/main/java/com/leetcode/hashtables/IsomorphicStrings.java deleted file mode 100644 index f9a7f4eb..00000000 --- a/src/main/java/com/leetcode/hashtables/IsomorphicStrings.java +++ /dev/null @@ -1,104 +0,0 @@ -package com.leetcode.hashtables; - -import java.util.HashMap; -import java.util.Map; - -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * Level: Easy - * Link: https://leetcode.com/problems/isomorphic-strings/ - * Description: - * Given two strings s and t, determine if they are isomorphic. - * - * Two strings are isomorphic if the characters in s can be replaced to get t. - * - * All occurrences of a character must be replaced with another character while preserving the order of characters. No - * two characters may map to the same character but a character may map to itself. - * - * Example 1: - * Input: s = "egg", t = "add" - * Output: true - * - * Example 2: - * Input: s = "foo", t = "bar" - * Output: false - * - * Example 3: - * Input: s = "paper", t = "title" - * Output: true - * - * Note: - * You may assume both s and t have the same length. - * - * @author rampatra - * @since 2019-08-11 - */ -public class IsomorphicStrings { - - /** - * Time Complexity: - * Space Complexity: - * Runtime: 8 ms. - * - * @param s - * @param t - * @return - */ - public static boolean isIsomorphic(String s, String t) { - - Map sToTCharMap = new HashMap<>(); - Map tToSCharMap = new HashMap<>(); - - for (int i = 0; i < s.length(); i++) { - char chFromS = s.charAt(i); - char chFromT = t.charAt(i); - if (sToTCharMap.get(chFromS) == null && tToSCharMap.get(chFromT) == null) { - sToTCharMap.put(chFromS, chFromT); - tToSCharMap.put(chFromT, chFromS); - } - Character mappedChFromSToT = sToTCharMap.get(chFromS); - if (mappedChFromSToT == null || mappedChFromSToT != chFromT) { - return false; - } - } - - return true; - } - - /** - * Time Complexity: - * Space Complexity: - * Runtime: 3 ms. - * - * @param s - * @param t - * @return - */ - public static boolean isIsomorphicWithoutMaps(String s, String t) { - int[] charMap = new int[512]; - for (int i = 0; i < s.length(); i++) { - char chFromS = s.charAt(i); - char chFromT = t.charAt(i); - if (charMap[chFromS] != charMap[chFromT + 256]) { - return false; - } - charMap[chFromS] = charMap[chFromT + 256] = i + 1; - } - - return true; - } - - public static void main(String[] args) { - assertTrue(isIsomorphic("egg", "add")); - assertFalse(isIsomorphic("foo", "bar")); - assertTrue(isIsomorphic("paper", "title")); - assertFalse(isIsomorphic("ab", "aa")); - - assertTrue(isIsomorphicWithoutMaps("egg", "add")); - assertFalse(isIsomorphicWithoutMaps("foo", "bar")); - assertTrue(isIsomorphicWithoutMaps("paper", "title")); - assertFalse(isIsomorphicWithoutMaps("ab", "aa")); - } -} diff --git a/src/main/java/com/leetcode/hashtables/MyHashMap.java b/src/main/java/com/leetcode/hashtables/MyHashMap.java deleted file mode 100644 index cf13c344..00000000 --- a/src/main/java/com/leetcode/hashtables/MyHashMap.java +++ /dev/null @@ -1,105 +0,0 @@ -package com.leetcode.hashtables; - -/** - * Level: Learning cards - * Problem Link: https://leetcode.com/explore/learn/card/hash-table/182/practical-applications/1140/ - * Runtime: https://leetcode.com/submissions/detail/224928756/ - * - * @author rampatra - * @since 2019-04-25 - */ -public class MyHashMap { - - class Entry { - int key; - int value; - Entry next; - - Entry(int key, int value) { - this.key = key; - this.value = value; - } - } - - private final int SIZE = 10000; - private final Entry[] entries; - - /** - * Initialize your data structure here. - */ - public MyHashMap() { - entries = new Entry[SIZE]; - } - - /** - * value will always be non-negative. - */ - public void put(int key, int value) { - int bucket = key % SIZE; - Entry entry = entries[bucket]; - - if (entry == null) { - entries[bucket] = new Entry(key, value); - } else { - while (entry.next != null && entry.key != key) { - entry = entry.next; - } - - if (entry.key == key) { - entry.value = value; - } else { - entry.next = new Entry(key, value); - } - } - } - - /** - * Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key - */ - public int get(int key) { - int bucket = key % SIZE; - Entry entry = entries[bucket]; - while (entry != null) { - if (entry.key == key) { - return entry.value; - } - entry = entry.next; - } - return -1; - } - - /** - * Removes the mapping of the specified value key if this map contains a mapping for the key - */ - public void remove(int key) { - int bucket = key % SIZE; - Entry entry = entries[bucket]; - - if (entry != null && entry.key == key) { - entries[bucket] = entry.next; - return; - } - - Entry curr = new Entry(0, 0); - curr.next = entry; - - while (curr.next != null && curr.next.key != key) { - curr = curr.next; - } - - if (curr.next != null) { - curr.next = curr.next.next; - } - } - - public static void main(String[] args) { - MyHashMap map = new MyHashMap(); - map.put(1, 2); - System.out.println("1 -> " + map.get(1)); - map.put(1, 4); - System.out.println("1 -> " + map.get(1)); - map.remove(1); - System.out.println("1 -> " + map.get(1)); - System.out.println("5 -> " + map.get(5)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/hashtables/MyHashSet.java b/src/main/java/com/leetcode/hashtables/MyHashSet.java deleted file mode 100644 index 3c13d488..00000000 --- a/src/main/java/com/leetcode/hashtables/MyHashSet.java +++ /dev/null @@ -1,93 +0,0 @@ -package com.leetcode.hashtables; - -/** - * Level: Learning Cards - * Problem Link: https://leetcode.com/explore/learn/card/hash-table/182/practical-applications/1139/ - * Runtime: https://leetcode.com/submissions/detail/224872991/ - * - * @author rampatra - * @since 2019-04-24 - */ -public class MyHashSet { - - private final int SIZE = 10000; - private final Entry[] entries; - - class Entry { - int key; - Entry next; - - Entry(int key) { - this.key = key; - } - } - - /** - * Initialize your data structure here. - */ - public MyHashSet() { - entries = new Entry[SIZE]; - } - - public void add(int key) { - if (contains(key)) return; - - Entry newEntry = new Entry(key); - int bucket = key % SIZE; - - newEntry.next = entries[bucket]; - entries[bucket] = newEntry; - } - - public void remove(int key) { - int bucket = key % SIZE; - Entry entry = entries[bucket]; - - if (entry != null && entry.key == key) { - entries[bucket] = entry.next; - return; - } - - Entry curr = new Entry(0); - curr.next = entry; - - while (curr.next != null && curr.next.key != key) { - curr = curr.next; - } - - if (curr.next != null) { - curr.next = curr.next.next; - } - } - - /** - * Returns true if this set contains the specified element - */ - public boolean contains(int key) { - int bucket = key % SIZE; - Entry entry = entries[bucket]; - - while (entry != null) { - if (entry.key == key) { - return true; - } - entry = entry.next; - } - - return false; - } - - public static void main(String[] args) { - MyHashSet set = new MyHashSet(); - set.add(1); - set.add(2); - set.add(3); - System.out.println(set.contains(1)); - System.out.println(set.contains(2)); - set.remove(2); - System.out.println(set.contains(2)); - System.out.println(set.contains(3)); - set.remove(3); - System.out.println(set.contains(3)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/hashtables/RepeatedDnaSequence.java b/src/main/java/com/leetcode/hashtables/RepeatedDnaSequence.java deleted file mode 100644 index 7674273d..00000000 --- a/src/main/java/com/leetcode/hashtables/RepeatedDnaSequence.java +++ /dev/null @@ -1,89 +0,0 @@ -package com.leetcode.hashtables; - -import java.util.*; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/repeated-dna-sequences/submissions/ - * Problem Description: - * All DNA is composed of a series of nucleotides abbreviated as A, C, G, and T, for example: "ACGAATTCCG". When - * studying DNA, it is sometimes useful to identify repeated sequences within the DNA. - * - * Write a function to find all the 10-letter-long sequences (substrings) that occur more than once in a DNA molecule. - * - * Example: - * Input: s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT" - * Output: ["AAAAACCCCC", "CCCCCAAAAA"] - * - * TODO: Figure another method which would have a better runtime. - * - * @author rampatra - * @since 2019-07-29 - */ -public class RepeatedDnaSequence { - - /** - * Rabin-Karp Algorithm: https://brilliant.org/wiki/rabin-karp-algorithm/ - * Following Rabin-Karp's approach let's you avoid spurious hits (worst case scenario) but once the hash matches, - * you will have to compare and check the string you're searching. I tried to just rely on the hash and few test - * cases failed for me (https://leetcode.com/submissions/detail/247342702/). - *

- * Time Complexity: - * Space Complexity: - * Runtime: 38 ms. - * - * @param s - * @return - */ - public static List findRepeatedDnaSequences(String s) { - if (s.length() < 10) return new ArrayList<>(); - - Set repeatedSequences = new HashSet<>(); - Map> hashToStringMap = new HashMap<>(); - long hashOfSequence = computeHash(s); - hashToStringMap.put(hashOfSequence, new HashSet() {{ - add(s.substring(0, 10)); - }}); - - long pow = (long) Math.pow(4, 9); - - for (int i = 10; i < s.length(); i++) { - hashOfSequence = (hashOfSequence - (pow * (s.charAt(i - 10) - 'A'))) * 4 + (s.charAt(i) - 'A'); - String subString = s.substring(i - 10 + 1, i + 1); - - if (hashToStringMap.get(hashOfSequence) != null && hashToStringMap.get(hashOfSequence).contains(subString)) { - repeatedSequences.add(subString); - continue; - } - - hashToStringMap.putIfAbsent(hashOfSequence, new HashSet<>()); - hashToStringMap.get(hashOfSequence).add(subString); - } - - return new ArrayList<>(repeatedSequences); - } - - private static long computeHash(String s) { - long hash = 0; - for (int i = 0; i < 10; i++) { - hash += (Math.pow(4, i) * (s.charAt(9 - i) - 'A')); - } - return hash; - } - - public static void main(String[] args) { - assertEquals(new ArrayList<>(), - findRepeatedDnaSequences("AAAAACCC")); - - assertEquals(Arrays.asList("AAAAACCCCC", "CCCCCAAAAA"), - findRepeatedDnaSequences("AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT")); - - assertEquals(Collections.singletonList("AAAAAAAAAA"), - findRepeatedDnaSequences("AAAAAAAAAAAA")); - - assertEquals(Collections.singletonList("BBBBBBBBBB"), - findRepeatedDnaSequences("BBBBBBBBBBBB")); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/hashtables/ShortestWordDistanceII.java b/src/main/java/com/leetcode/hashtables/ShortestWordDistanceII.java deleted file mode 100644 index 3932cebf..00000000 --- a/src/main/java/com/leetcode/hashtables/ShortestWordDistanceII.java +++ /dev/null @@ -1,89 +0,0 @@ -package com.leetcode.hashtables; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/shortest-word-distance-ii/ - * Problem Description: - * Design a class which receives a list of words in the constructor, and implements a method that takes two words - * word1 and word2 and return the shortest distance between these two words in the list. Your method will be called - * repeatedly many times with different parameters. For a simpler variant, see {@link com.leetcode.arrays.ShortestWordDistance}. - *

- * Examples: - * Assume that words = ["practice", "makes", "perfect", "coding", "makes"]. - *

- * Input1: word1 = “coding”, word2 = “practice” - * Output1: 3 - *

- * Input2: word1 = "makes", word2 = "coding" - * Output2: 1 - *

- * Note: You may assume that word1 does not equal to word2, and word1 and word2 are both in the list. - * - * @author rampatra - * @since 2019-07-31 - */ -public class ShortestWordDistanceII { - - private String[] words; - private Map> wordsToIndexesMap; - - ShortestWordDistanceII(String[] words) { - this.words = words; - this.wordsToIndexesMap = getWordsToIndexesMap(); - } - - /** - * Runtime: 65 ms. - * - * @param word1 - * @param word2 - * @return - */ - public int findShortestDistance(String word1, String word2) { - return findShortestDistance(wordsToIndexesMap.get(word1), wordsToIndexesMap.get(word2)); - } - - private int findShortestDistance(List indexes1, List indexes2) { - int minDistance = Integer.MAX_VALUE; - - for (int i = 0, j = 0; i < indexes1.size() && j < indexes2.size(); ) { - if (indexes1.get(i) <= indexes2.get(j)) { - minDistance = Math.min(minDistance, Math.abs(indexes1.get(i) - indexes2.get(j))); - i++; - } else if (indexes1.get(i) > indexes2.get(j)) { - minDistance = Math.min(minDistance, Math.abs(indexes1.get(i) - indexes2.get(j))); - j++; - } - } - - return minDistance; - } - - private Map> getWordsToIndexesMap() { - Map> wordsToIndexesMap = new HashMap<>(); - - for (int i = 0; i < words.length; i++) { - wordsToIndexesMap.putIfAbsent(words[i], new ArrayList<>()); - wordsToIndexesMap.get(words[i]).add(i); - } - return wordsToIndexesMap; - } - - public static void main(String[] args) { - ShortestWordDistanceII shortestWordDist = new ShortestWordDistanceII(new String[]{"practice", "makes", "perfect", "coding", "makes"}); - assertEquals(1, shortestWordDist.findShortestDistance("coding", "makes")); - assertEquals(1, shortestWordDist.findShortestDistance("perfect", "makes")); - assertEquals(1, shortestWordDist.findShortestDistance("practice", "makes")); - assertEquals(1, shortestWordDist.findShortestDistance("makes", "practice")); - assertEquals(3, shortestWordDist.findShortestDistance("coding", "practice")); - assertEquals(0, shortestWordDist.findShortestDistance("coding", "coding")); - assertEquals(0, shortestWordDist.findShortestDistance("makes", "makes")); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/hashtables/TwoSumIII.java b/src/main/java/com/leetcode/hashtables/TwoSumIII.java deleted file mode 100644 index 88916db0..00000000 --- a/src/main/java/com/leetcode/hashtables/TwoSumIII.java +++ /dev/null @@ -1,78 +0,0 @@ -package com.leetcode.hashtables; - -import java.util.HashMap; -import java.util.Map; - -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/two-sum-iii-data-structure-design/ - * Problem Description: - * Design and implement a TwoSum class. It should support the following operations: add and find. - *

- * add - Add the number to an internal data structure. - * find - Find if there exists any pair of numbers which sum is equal to the value. - *

- * Example 1: - * add(1); add(3); add(5); - * find(4) -> true - * find(7) -> false - *

- * Example 2: - * add(3); add(1); add(2); - * find(3) -> true - * find(6) -> false - * - * @author rampatra - * @since 2019-08-03 - */ -public class TwoSumIII { - - Map numCount; - - /** - * Initialize your data structure here. - */ - public TwoSumIII() { - this.numCount = new HashMap<>(); - } - - /** - * Add the number to an internal data structure.. - */ - public void add(int number) { - if (numCount.containsKey(number)) { - numCount.put(number, 2); - } else { - numCount.put(number, 1); - } - } - - /** - * Find if there exists any pair of numbers which sum is equal to the value. - */ - public boolean find(int value) { - for (Map.Entry entry : numCount.entrySet()) { - int num1 = entry.getKey(); - int num2 = value - num1; - if ((num2 == num1 && entry.getValue() == 2) || (num1 != num2 && numCount.containsKey(num2))) { - return true; - } - } - return false; - } - - /** - * Runtime: 115 ms. - * - * @param args - */ - public static void main(String[] args) { - TwoSumIII twoSumIII = new TwoSumIII(); - twoSumIII.add(0); - twoSumIII.add(-1); - twoSumIII.add(1); - assertTrue(twoSumIII.find(0)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/hashtables/slidingwindow/LongestSubstringWithKDistinctCharacters.java b/src/main/java/com/leetcode/hashtables/slidingwindow/LongestSubstringWithKDistinctCharacters.java deleted file mode 100644 index 4b209b6e..00000000 --- a/src/main/java/com/leetcode/hashtables/slidingwindow/LongestSubstringWithKDistinctCharacters.java +++ /dev/null @@ -1,83 +0,0 @@ -package com.leetcode.hashtables.slidingwindow; - -import java.util.HashMap; -import java.util.Map; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Hard - * Link: https://leetcode.com/problems/longest-substring-with-at-most-k-distinct-characters/ - * Description: - * Given a string, find the length of the longest substring T that contains at most k distinct characters. - *

- * Example 1: - * Input: s = "eceba", k = 2 - * Output: 3 - * Explanation: T is "ece" which its length is 3. - *

- * Example 2: - * Input: s = "aa", k = 1 - * Output: 2 - * Explanation: T is "aa" which its length is 2. - * - * @author rampatra - * @since 2019-08-09 - */ -public class LongestSubstringWithKDistinctCharacters { - - /** - * Time Complexity: O(n) - * Space Complexity: O(k), as we keep at most k characters in the hash table - * - * @param str - * @param k - * @return - */ - public static int lengthOfLongestSubstringKDistinct(String str, int k) { - int length = 0; - Map letterCountInWindow = new HashMap<>(); - - int left = 0; // start of window - int right = 0; // end of window - - while (right < str.length()) { - char ch = str.charAt(right); - - letterCountInWindow.put(ch, letterCountInWindow.getOrDefault(ch, 0) + 1); - - // when number of distinct characters in the window exceeds k: - // - update length - // - remove the first character in the window or reduce its count if the window has more than one of this character - // - lastly, move the window forward - if (letterCountInWindow.keySet().size() > k) { - char firstChar = str.charAt(left); - int firstCharCount = letterCountInWindow.get(firstChar); - if (firstCharCount > 1) { - letterCountInWindow.put(firstChar, firstCharCount - 1); - } else { - letterCountInWindow.remove(firstChar); - } - length = Math.max(length, right - left); - left++; - } - right++; - } - - return Math.max(length, right - left); - } - - public static void main(String[] args) { - assertEquals(3, lengthOfLongestSubstringKDistinct("eceba", 2)); - assertEquals(7, lengthOfLongestSubstringKDistinct("eceeeeeba", 2)); - assertEquals(12, lengthOfLongestSubstringKDistinct("bbbeeeeebaaaaaaaaaaa", 2)); - assertEquals(2, lengthOfLongestSubstringKDistinct("abcdef", 2)); - assertEquals(1, lengthOfLongestSubstringKDistinct("a", 1)); - assertEquals(0, lengthOfLongestSubstringKDistinct("aa", 0)); - assertEquals(2, lengthOfLongestSubstringKDistinct("aa", 1)); - assertEquals(3, lengthOfLongestSubstringKDistinct("aaa", 1)); - assertEquals(3, lengthOfLongestSubstringKDistinct("aab", 2)); - assertEquals(8, lengthOfLongestSubstringKDistinct("abcabcbb", 3)); - assertEquals(5, lengthOfLongestSubstringKDistinct("pwwkew", 3)); - } -} diff --git a/src/main/java/com/leetcode/hashtables/slidingwindow/LongestSubstringWithoutRepeatingCharacters.java b/src/main/java/com/leetcode/hashtables/slidingwindow/LongestSubstringWithoutRepeatingCharacters.java deleted file mode 100644 index 93a940e4..00000000 --- a/src/main/java/com/leetcode/hashtables/slidingwindow/LongestSubstringWithoutRepeatingCharacters.java +++ /dev/null @@ -1,128 +0,0 @@ -package com.leetcode.hashtables.slidingwindow; - -import java.util.HashSet; -import java.util.Set; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/longest-substring-without-repeating-characters/ - * Description: - * Given a string, find the length of the longest substring without repeating characters. - *

- * Example 1: - * Input: "abcabcbb" - * Output: 3 - * Explanation: The answer is "abc", with the length of 3. - *

- * Example 2: - * Input: "bbbbb" - * Output: 1 - * Explanation: The answer is "b", with the length of 1. - *

- * Example 3: - * Input: "pwwkew" - * Output: 3 - * Explanation: The answer is "wke", with the length of 3. - * Note that the answer must be a substring, "pwke" is a subsequence and not a substring. - * - * @author rampatra - * @since 2019-08-15 - */ -public class LongestSubstringWithoutRepeatingCharacters { - - /** - * Sliding Window Approach (using map). - *

- * Note: - * If we know that the charset is rather small, we can replace the Map with an integer array as direct access table. - *

- * Commonly used tables are: - *

- * int[26] for Letters 'a' - 'z' or 'A' - 'Z' - * int[128] for ASCII - * int[256] for Extended ASCII - *

- * Runtime: 8 ms. - * - * @param s - * @return - */ - public static int lengthOfLongestSubstring(String s) { - int left = 0; - int right = 0; - int longestSubstringLen = 0; - Set charsInWindow = new HashSet<>(); - - - while (right < s.length()) { - - if (charsInWindow.contains(s.charAt(right))) { - while (s.charAt(left) != s.charAt(right)) { - longestSubstringLen = Math.max(longestSubstringLen, right - left); - charsInWindow.remove(s.charAt(left)); - left++; - } - left++; - } - - charsInWindow.add(s.charAt(right)); - right++; - } - - return Math.max(longestSubstringLen, right - left); - } - - /** - * Sliding Window Approach using int array. - * - * Runtime: 2 ms. - * - * @param s - * @return - */ - public static int lengthOfLongestSubstringNoMap(String s) { - int left = 0; - int right = 0; - int longestSubstringLen = 0; - int[] charsInWindow = new int[128]; - - // keep moving forward the right pointer and adding characters to the window - while (right < s.length()) { - - // once we encounter repeated characters, move the left pointer until the repeated character is removed - if (charsInWindow[s.charAt(right)] == 1) { - while (s.charAt(left) != s.charAt(right)) { - longestSubstringLen = Math.max(longestSubstringLen, right - left); - charsInWindow[s.charAt(left)] = 0; - left++; - } - left++; - } - - charsInWindow[s.charAt(right)] = 1; - right++; - } - - return Math.max(longestSubstringLen, right - left); - } - - public static void main(String[] args) { - assertEquals(0, lengthOfLongestSubstring("")); - assertEquals(1, lengthOfLongestSubstring(" ")); - assertEquals(1, lengthOfLongestSubstring("a")); - assertEquals(2, lengthOfLongestSubstring("aab")); - assertEquals(3, lengthOfLongestSubstring("abcabcbb")); - assertEquals(1, lengthOfLongestSubstring("bbbbb")); - assertEquals(3, lengthOfLongestSubstring("pwwkew")); - - assertEquals(0, lengthOfLongestSubstringNoMap("")); - assertEquals(1, lengthOfLongestSubstringNoMap(" ")); - assertEquals(1, lengthOfLongestSubstringNoMap("a")); - assertEquals(2, lengthOfLongestSubstringNoMap("aab")); - assertEquals(3, lengthOfLongestSubstringNoMap("abcabcbb")); - assertEquals(1, lengthOfLongestSubstringNoMap("bbbbb")); - assertEquals(3, lengthOfLongestSubstringNoMap("pwwkew")); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/hashtables/slidingwindow/MinimumWindowSubstring.java b/src/main/java/com/leetcode/hashtables/slidingwindow/MinimumWindowSubstring.java deleted file mode 100644 index 5414cdc1..00000000 --- a/src/main/java/com/leetcode/hashtables/slidingwindow/MinimumWindowSubstring.java +++ /dev/null @@ -1,104 +0,0 @@ -package com.leetcode.hashtables.slidingwindow; - -import java.util.HashMap; -import java.util.Map; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Hard - * Link: https://leetcode.com/problems/minimum-window-substring/ - * Description: - * Given a string S and a string T, find the minimum window in S which will contain all the characters in T in - * complexity O(n). - *

- * Example: - *

- * Input: S = "ADOBECODEBANC", T = "ABC" - * Output: "BANC" - *

- * Note: - * - If there is no such window in S that covers all characters in T, return the empty string "". - * - If there is such window, you are guaranteed that there will always be only one unique minimum window in S. - * - * @author rampatra - * @since 2019-08-13 - */ -public class MinimumWindowSubstring { - - /** - * Sliding Window Approach (using map). - * - * Note: - * If we know that the charset is rather small, we can replace the Map with an integer array as direct access table. - * - * Commonly used tables are: - * - * int[26] for Letters 'a' - 'z' or 'A' - 'Z' - * int[128] for ASCII - * int[256] for Extended ASCII - * - * Runtime: 22 ms. - * - * @param s - * @param t - * @return - */ - public static String minWindow(String s, String t) { - - int left = 0; // start of window - int right = 0; // end of window - int begin = 0; - int windowSize = Integer.MAX_VALUE; - int charsInWindow = 0; // to check whether the window has all the characters in t with the required frequency - - // characters and their counts in t - Map dictT = new HashMap<>(); - for (int i = 0; i < t.length(); i++) { - char ch = t.charAt(i); - dictT.put(ch, dictT.getOrDefault(ch, 0) + 1); - } - - // characters and their counts in the window - Map dictWindow = new HashMap<>(); - - while (right < s.length()) { - char rightChar = s.charAt(right); - int rightCharCount; - dictWindow.put(rightChar, (rightCharCount = dictWindow.getOrDefault(rightChar, 0) + 1)); - - // once the window has a character in t with the required frequency, increment charsInWindow - if (dictT.get(rightChar) != null && dictT.get(rightChar).equals(rightCharCount)) { - charsInWindow++; - } - - // once the window has all characters in t with required frequency then shorten the window by moving the - // left window forward until the window no longer has all characters of t - while (left <= right && charsInWindow == dictT.size()) { - if (right - left < windowSize) { - windowSize = right - left + 1; - begin = left; - } - - char leftChar = s.charAt(left); - Integer leftCharCount = dictWindow.get(leftChar); - dictWindow.put(leftChar, leftCharCount - 1); - - if (dictT.get(leftChar) != null && leftCharCount - 1 < dictT.get(leftChar)) { - charsInWindow--; - } - left++; - } - right++; - } - - return windowSize == Integer.MAX_VALUE ? "" : s.substring(begin, begin + windowSize); - } - - public static void main(String[] args) { - assertEquals("BANC", minWindow("ADOBECODEBANC", "ABC")); - assertEquals("BAC", minWindow("ADOBECODEBAC", "ABC")); - assertEquals("ba", minWindow("bba", "ab")); - assertEquals("baca", minWindow("acbbaca", "aba")); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/heaps/KthLargestElementInArray.java b/src/main/java/com/leetcode/heaps/KthLargestElementInArray.java deleted file mode 100644 index 2422de08..00000000 --- a/src/main/java/com/leetcode/heaps/KthLargestElementInArray.java +++ /dev/null @@ -1,143 +0,0 @@ -package com.leetcode.heaps; - -import com.rampatra.base.MaxHeap; - -import java.util.PriorityQueue; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/kth-largest-element-in-an-array/ - * Description: - * Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not - * the kth distinct element. - *

- * Example 1: - * Input: [3,2,1,5,6,4] and k = 2 - * Output: 5 - *

- * Example 2: - * Input: [3,2,3,1,2,4,5,5,6] and k = 4 - * Output: 4 - *

- * Note: - * You may assume k is always valid, 1 ≤ k ≤ array's length. - * - * @author rampatra - * @since 2019-08-19 - */ -public class KthLargestElementInArray { - - /** - * Runtime: 1 ms. - * - * @param nums - * @param k - * @return - */ - public static int findKthLargest(int[] nums, int k) { - return heapSortUntilK(nums, k); - } - - /** - * In heapsort, after each iteration we have the max element at the end of the array. Ergo, if we run the algorithm - * k times then we would have our kth largest element. - * - * @param a - * @param k - * @return - */ - public static int heapSortUntilK(int[] a, int k) { - buildMaxHeap(a); - int count = 0; - - for (int i = a.length - 1; i > 0; i--) { - if (count++ == k) { - break; - } - swap(a, 0, i); - maxHeapify(a, 0, i); - } - - return a[a.length - k]; - } - - /** - * Makes the array {@param a} satisfy the max heap property starting from - * {@param index} till {@param end} position in array. - *

- * See this {@link MaxHeap#maxHeapify} for a basic version of maxHeapify. - *

- * Time complexity: O(log n). - * - * @param a - * @param index - * @param end - */ - public static void maxHeapify(int[] a, int index, int end) { - int largest = index; - int leftIndex = 2 * index + 1; - int rightIndex = 2 * index + 2; - - if (leftIndex < end && a[index] < a[leftIndex]) { - largest = leftIndex; - } - if (rightIndex < end && a[largest] < a[rightIndex]) { - largest = rightIndex; - } - - if (largest != index) { - swap(a, index, largest); - maxHeapify(a, largest, end); - } - } - - /** - * Converts array {@param a} in to a max heap. - *

- * Time complexity: O(n) and is not O(n log n). - */ - private static void buildMaxHeap(int[] a) { - for (int i = a.length / 2 - 1; i >= 0; i--) { - maxHeapify(a, i, a.length); - } - } - - - /** - * When you poll() on a PriorityQueue the smallest number in the queue is removed. Based on this property, we can - * iterate over the entire array and in the end we would be left with the k largest element in the queue. - * - * @param nums - * @param k - * @return - */ - public static int findKthLargestUsingPriorityQueue(int[] nums, int k) { - PriorityQueue priorityQueue = new PriorityQueue<>(); - - for (int num : nums) { - priorityQueue.add(num); - - if (priorityQueue.size() > k) { - priorityQueue.poll(); - } - } - - return priorityQueue.isEmpty() ? -1 : priorityQueue.peek(); - } - - private static void swap(int[] a, int firstIndex, int secondIndex) { - a[firstIndex] = a[firstIndex] + a[secondIndex]; - a[secondIndex] = a[firstIndex] - a[secondIndex]; - a[firstIndex] = a[firstIndex] - a[secondIndex]; - } - - public static void main(String[] args) { - assertEquals(5, findKthLargest(new int[]{3, 2, 1, 5, 6, 4}, 2)); - assertEquals(3, findKthLargest(new int[]{3, 2, 1, 5, 6, 4}, 4)); - - assertEquals(5, findKthLargestUsingPriorityQueue(new int[]{3, 2, 1, 5, 6, 4}, 2)); - assertEquals(3, findKthLargestUsingPriorityQueue(new int[]{3, 2, 1, 5, 6, 4}, 4)); - } -} diff --git a/src/main/java/com/leetcode/heaps/TopKFrequentElements.java b/src/main/java/com/leetcode/heaps/TopKFrequentElements.java deleted file mode 100644 index 5a684325..00000000 --- a/src/main/java/com/leetcode/heaps/TopKFrequentElements.java +++ /dev/null @@ -1,68 +0,0 @@ -package com.leetcode.heaps; - -import javafx.util.Pair; - -import java.util.*; -import java.util.stream.Collectors; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/top-k-frequent-elements/ - * Description: - * Given a non-empty array of integers, return the k most frequent elements. - *

- * Example 1: - * Input: nums = [1,1,1,2,2,3], k = 2 - * Output: [1,2] - *

- * Example 2: - * Input: nums = [1], k = 1 - * Output: [1] - *

- * Note: - * - You may assume k is always valid, 1 ≤ k ≤ number of unique elements. - * - Your algorithm's time complexity must be better than O(n log n), where n is the array's size. - * - * @author rampatra - * @since 2019-08-19 - */ -public class TopKFrequentElements { - - /** - * TODO: A faster approach without using Pair. - *

- * Runtime: 51 ms. - * - * @param nums - * @param k - * @return - */ - public static List topKFrequent(int[] nums, int k) { - Map numCount = new HashMap<>(); - PriorityQueue> pq = new PriorityQueue<>(Comparator.comparing(Pair::getValue)); - - for (int num : nums) { - numCount.put(num, numCount.getOrDefault(num, 0) + 1); - } - - for (Map.Entry entry : numCount.entrySet()) { - pq.add(new Pair<>(entry.getKey(), entry.getValue())); - - if (pq.size() > k) { - pq.poll(); - } - } - - return pq.stream().map(Pair::getKey).collect(Collectors.toList()); - } - - public static void main(String[] args) { - assertEquals("[2, 1]", topKFrequent(new int[]{1, 1, 1, 2, 2, 3}, 2).toString()); - assertEquals("[0]", topKFrequent(new int[]{3, 0, 1, 0}, 1).toString()); - assertEquals("[1]", topKFrequent(new int[]{1}, 1).toString()); - assertEquals("[1, 2]", topKFrequent(new int[]{1, 2}, 2).toString()); - assertEquals("[2, -1]", topKFrequent(new int[]{4, 1, -1, 2, -1, 2, 3}, 2).toString()); - } -} diff --git a/src/main/java/com/leetcode/linkedlists/AddOneToNumberInList.java b/src/main/java/com/leetcode/linkedlists/AddOneToNumberInList.java deleted file mode 100644 index 9f0a029c..00000000 --- a/src/main/java/com/leetcode/linkedlists/AddOneToNumberInList.java +++ /dev/null @@ -1,91 +0,0 @@ -package com.leetcode.linkedlists; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/plus-one-linked-list/ - * Problem Description: Given a non-empty single linked list representing a number where the head is the - * most significant bit, add one to the number and return a new linked list. - * - * @author rampatra - * @since 2019-06-19 - */ -public class AddOneToNumberInList { - - - /** - * Add {@code one} to the number represented by linked list {@code head}. - * - * @param head the starting node of the linked list - * @return the head of the linked list after adding {@code one} - */ - private static Node addOne(Node head) { - Node currOrig = reverse(head); - Node currRes = null; - Node res = null; - - int sum = 1; - int carry = 0; - int rem; - - while (currOrig != null) { - sum += carry + currOrig.val; - rem = sum % 10; - carry = sum / 10; - - if (res == null) { - res = currRes = new Node(rem); - } else { - currRes.next = new Node(rem); - currRes = currRes.next; - } - - sum = 0; - currOrig = currOrig.next; - } - - if (carry != 0) { - currRes.next = new Node(carry); - } - - return reverse(res); - } - - private static Node reverse(Node head) { - Node prev = null; - Node curr = head; - Node next; - - while (curr != null) { - next = curr.next; - curr.next = prev; - - prev = curr; - curr = next; - } - - return prev; - } - - - public static void main(String[] args) { - Node node = new Node(9); - node.next = new Node(9); - node.next.next = new Node(9); - node.print(); - addOne(node).print(); - - System.out.println("---------"); - - node = new Node(1); - node.next = new Node(9); - node.next.next = new Node(9); - node.print(); - addOne(node).print(); - - System.out.println("---------"); - - node = new Node(0); - node.print(); - addOne(node).print(); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/linkedlists/LinkedListCycleII.java b/src/main/java/com/leetcode/linkedlists/LinkedListCycleII.java deleted file mode 100644 index d5fe0e50..00000000 --- a/src/main/java/com/leetcode/linkedlists/LinkedListCycleII.java +++ /dev/null @@ -1,73 +0,0 @@ -package com.leetcode.linkedlists; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/linked-list-cycle-ii/ - * Description: - * Given a linked list, return the node where the cycle begins. If there is no cycle, return null. - * - * To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in - * the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list. - * - * Note: Do not modify the linked list. - * - * Example 1: - * - * Input: head = [3,2,0,-4], pos = 1 - * Output: tail connects to node index 1 - * Explanation: There is a cycle in the linked list, where tail connects to the second node. - * - * - * Example 2: - * - * Input: head = [1,2], pos = 0 - * Output: tail connects to node index 0 - * Explanation: There is a cycle in the linked list, where tail connects to the first node. - * - * - * Example 3: - * - * Input: head = [1], pos = -1 - * Output: no cycle - * Explanation: There is no cycle in the linked list. - * - * Follow-up: - * Can you solve it without using extra space? - * - * @author rampatra - * @since 2019-08-18 - */ -public class LinkedListCycleII { - - /** - * Runtime: 0 ms. - * - * @param head - * @return - */ - public Node detectCycle(Node head) { - Node slow = head; - Node fast = head; - - while (fast != null && fast.next != null) { - slow = slow.next; - fast = fast.next.next; - if (slow == fast) { - break; - } - } - - if (fast == null || fast.next == null) { - return null; - } else { - slow = head; - - while (slow != fast) { - slow = slow.next; - fast = fast.next; - } - - return slow; - } - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/linkedlists/Node.java b/src/main/java/com/leetcode/linkedlists/Node.java deleted file mode 100644 index 3276413f..00000000 --- a/src/main/java/com/leetcode/linkedlists/Node.java +++ /dev/null @@ -1,23 +0,0 @@ -package com.leetcode.linkedlists; - -/** - * @author rampatra - * @since 21/11/2018 - */ -class Node { - int val; - Node next; - - Node(int val) { - this.val = val; - } - - public void print() { - Node curr = this; - while (curr.next != null) { - System.out.print(curr.val + "->"); - curr = curr.next; - } - System.out.println(curr.val); - } -} diff --git a/src/main/java/com/leetcode/math/BestMeetingPoint.java b/src/main/java/com/leetcode/math/BestMeetingPoint.java deleted file mode 100644 index 84d96fe9..00000000 --- a/src/main/java/com/leetcode/math/BestMeetingPoint.java +++ /dev/null @@ -1,141 +0,0 @@ -package com.leetcode.math; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Hard - * Link: https://leetcode.com/problems/best-meeting-point/ - * Description: - * A group of two or more people wants to meet and minimize the total travel distance. You are given a 2D grid - * of values 0 or 1, where each 1 marks the home of someone in the group. The distance is calculated using - * Manhattan Distance, where distance(p1, p2) = |p2.x - p1.x| + |p2.y - p1.y|. - * - * Example: - * - * Input: - * - * 1 - 0 - 0 - 0 - 1 - * | | | | | - * 0 - 0 - 0 - 0 - 0 - * | | | | | - * 0 - 0 - 1 - 0 - 0 - * - * Output: 6 - * - * Explanation: Given three people living at (0,0), (0,4), and (2,2): - * The point (0,2) is an ideal meeting point, as the total travel distance - * of 2+2+2=6 is minimal. So, return 6. - * - * @author rampatra - * @since 2019-08-07 - */ -public class BestMeetingPoint { - - /** - * Time Complexity: O(k * i * j) - * Space Complexity: O(1) - * where, - * k = no of homes - * i = rows in grid - * j = columns in grid - * - * So, if i = j = k then you can see that it has a O(n^3) time complexity. - * - * @param grid - * @return - */ - public static int minTotalDistanceBrutForce(int[][] grid) { - int minDistance = Integer.MAX_VALUE; - List> homeCoordinates = new ArrayList<>(); - - for (int i = 0; i < grid.length; i++) { - for (int j = 0; j < grid[0].length; j++) { - if (grid[i][j] == 1) { - homeCoordinates.add(Arrays.asList(i, j)); - } - } - } - - for (int i = 0; i < grid.length; i++) { - for (int j = 0; j < grid[0].length; j++) { - int distance = 0; - for (int k = 0; k < homeCoordinates.size(); k++) { - distance += Math.abs(homeCoordinates.get(k).get(0) - i) + Math.abs(homeCoordinates.get(k).get(1) - j); - } - minDistance = Math.min(minDistance, distance); - } - } - - return minDistance; - } - - public static int minTotalDistance(int[][] grid) { - return -1; // todo - } - - public static void main(String[] args) { - assertEquals(6, minTotalDistanceBrutForce(new int[][]{ - {1,0,0,0,1}, - {0,0,0,0,0}, - {0,0,1,0,0} - })); - - assertEquals(4, minTotalDistanceBrutForce(new int[][]{ - {1,0,0,0,1}, - {0,0,0,0,0}, - {0,0,0,0,0} - })); - - assertEquals(1, minTotalDistanceBrutForce(new int[][]{ - {1,1,0,0,0}, - {0,0,0,0,0}, - {0,0,0,0,0} - })); - - assertEquals(0, minTotalDistanceBrutForce(new int[][]{ - {1,0,0,0,0}, - {0,0,0,0,0}, - {0,0,0,0,0} - })); - - assertEquals(0, minTotalDistanceBrutForce(new int[][]{ - {0,0,0,0,0}, - {0,0,0,0,0}, - {0,0,0,0,0} - })); - - assertEquals(6, minTotalDistance(new int[][]{ - {1,0,0,0,1}, - {0,0,0,0,0}, - {0,0,1,0,0} - })); - - assertEquals(4, minTotalDistance(new int[][]{ - {1,0,0,0,1}, - {0,0,0,0,0}, - {0,0,0,0,0} - })); - - assertEquals(1, minTotalDistance(new int[][]{ - {1,1,0,0,0}, - {0,0,0,0,0}, - {0,0,0,0,0} - })); - - assertEquals(0, minTotalDistance(new int[][]{ - {1,0,0,0,0}, - {0,0,0,0,0}, - {0,0,0,0,0} - })); - - assertEquals(0, minTotalDistance(new int[][]{ - {0,0,0,0,0}, - {0,0,0,0,0}, - {0,0,0,0,0} - })); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/math/ExcelSheetColumnNumber.java b/src/main/java/com/leetcode/math/ExcelSheetColumnNumber.java deleted file mode 100644 index 29e1dded..00000000 --- a/src/main/java/com/leetcode/math/ExcelSheetColumnNumber.java +++ /dev/null @@ -1,44 +0,0 @@ -package com.leetcode.math; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/excel-sheet-column-number/ - * Problem Description: - * Given a column title as appear in an Excel sheet, return its corresponding column number. - * - * For example: - * - * A -> 1 - * B -> 2 - * C -> 3 - * ... - * Z -> 26 - * AA -> 27 - * AB -> 28 - * ... - * - * Example 1: - * Input: "A" - * Output: 1 - * - * Example 2: - * Input: "AB" - * Output: 28 - * - * Example 3: - * Input: "ZY" - * Output: 701 - * - * @author rampatra - * @since 2019-05-31 - */ -public class ExcelSheetColumnNumber { - - private static int titleToNumber(String title) { - return 0; - } - - public static void main(String[] args) { - - } -} diff --git a/src/main/java/com/leetcode/math/ReverseInteger.java b/src/main/java/com/leetcode/math/ReverseInteger.java deleted file mode 100644 index 7e540778..00000000 --- a/src/main/java/com/leetcode/math/ReverseInteger.java +++ /dev/null @@ -1,62 +0,0 @@ -package com.leetcode.math; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/reverse-integer/ - * Problem Description: - * Given a 32-bit signed integer, reverse digits of an integer. - *

- * Example 1: - * Input: 123 - * Output: 321 - *

- * Example 2: - * Input: -123 - * Output: -321 - *

- * Example 3: - * Input: 120 - * Output: 21 - *

- * Note: Assume we are dealing with an environment which could only store integers within the 32-bit signed - * integer range: [−2^31, 2^31 − 1]. For the purpose of this problem, assume that your function returns 0 when - * the reversed integer overflows. - * - * @author rampatra - * @since 2019-05-31 - */ -public class ReverseInteger { - - /** - * Reverses the input integer. - * Time complexity: O(d) - * where, - * d = number of digits in num - *

- * Runtime: 1 ms. - * - * @param num an integer. - * @return the reverse of {@code num}. - */ - private static int reverse(int num) { - long reverse = 0; - int pop; - - while (num != 0) { - pop = num % 10; - num = num / 10; - reverse = reverse * 10 + pop; - } - - return reverse < Integer.MIN_VALUE || reverse > Integer.MAX_VALUE ? 0 : (int) reverse; - } - - public static void main(String[] args) { - System.out.println(reverse(0)); - System.out.println(reverse(-0)); - System.out.println(reverse(123)); - System.out.println(reverse(-123)); - System.out.println(reverse(Integer.MAX_VALUE)); - System.out.println(reverse(Integer.MIN_VALUE)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/recursion/FlattenNestListIterator.java b/src/main/java/com/leetcode/recursion/FlattenNestListIterator.java deleted file mode 100644 index b443e954..00000000 --- a/src/main/java/com/leetcode/recursion/FlattenNestListIterator.java +++ /dev/null @@ -1,69 +0,0 @@ -package com.leetcode.recursion; - -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/flatten-nested-list-iterator/ - * Description: - * Given a nested list of integers, implement an iterator to flatten it. - * - * Each element is either an integer, or a list -- whose elements may also be integers or other lists. - * - * Example 1: - * Input: [[1,1],2,[1,1]] - * Output: [1,1,2,1,1] - * Explanation: By calling next repeatedly until hasNext returns false, - * the order of elements returned by next should be: [1,1,2,1,1]. - * - * Example 2: - * Input: [1,[4,[6]]] - * Output: [1,4,6] - * Explanation: By calling next repeatedly until hasNext returns false, - * the order of elements returned by next should be: [1,4,6]. - * - * Runtime: 2 ms. - * - * @author rampatra - * @since 2019-08-12 - */ -public class FlattenNestListIterator implements Iterator { - - private int index; - private List flattenedList; - - public FlattenNestListIterator(List nestedList) { - index = 0; - flattenedList = getFlattenedList(nestedList); - } - - private List getFlattenedList(List nestedList) { - List flattenedList = new ArrayList<>(); - - for (NestedInteger nestedInteger : nestedList) { - if (nestedInteger.isInteger()) { - flattenedList.add(nestedInteger.getInteger()); - } else { - flattenedList.addAll(getFlattenedList(nestedInteger.getList())); - } - } - - return flattenedList; - } - - @Override - public Integer next() { - return flattenedList.get(index++); - } - - @Override - public boolean hasNext() { - return index < flattenedList.size(); - } - - public static void main(String[] args) { - // TODO add some test cases - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/recursion/NestedInteger.java b/src/main/java/com/leetcode/recursion/NestedInteger.java deleted file mode 100644 index 1bba817e..00000000 --- a/src/main/java/com/leetcode/recursion/NestedInteger.java +++ /dev/null @@ -1,46 +0,0 @@ -package com.leetcode.recursion; - -import java.util.ArrayList; -import java.util.List; - -/** - * Class needed for various problems like {@link NestedListWeightSumII}, {@link FlattenNestListIterator}, etc. - * - * @author rampatra - * @since 2019-08-12 - */ -public class NestedInteger { - - private Integer integer; - private List list; - - public NestedInteger() { - this.list = new ArrayList<>(); - } - - public NestedInteger(int integer) { - this.integer = integer; - this.list = new ArrayList<>(); - } - - public boolean isInteger() { - return this.integer != null; - } - - public Integer getInteger() { - return integer; - } - - public void setInteger(Integer integer) { - this.integer = integer; - } - - public List getList() { - return list; - } - - public NestedInteger add(NestedInteger nestedInteger) { - this.list.add(nestedInteger); - return this; - } -} diff --git a/src/main/java/com/leetcode/recursion/NestedListWeightSum.java b/src/main/java/com/leetcode/recursion/NestedListWeightSum.java deleted file mode 100644 index 1079b29f..00000000 --- a/src/main/java/com/leetcode/recursion/NestedListWeightSum.java +++ /dev/null @@ -1,57 +0,0 @@ -package com.leetcode.recursion; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/nested-list-weight-sum/ - * Problem Description: - * Given a nested list of integers, return the sum of all integers in the list weighted by their depth. Each element - * is either an integer, or a list – whose elements may also be integers or other lists. - *

- * Example 1: - * Given the list [[1,1],2,[1,1]], return 10. (four 1’s at depth 2, one 2 at depth 1) - *

- * Example 2: - * Given the list [1,[4,[6]]], return 27. (one 1 at depth 1, one 4 at depth 2, and one 6 at depth 3; 1 + 42 + 63 = 27) - * - * Note: For a more complex variant, see {@link NestedListWeightSumII}. - * - * @author rampatra - * @since 2019-07-27 - */ -public class NestedListWeightSum { - - /** - * Time Complexity: The algorithm takes O(N) time, where N is the total number of nested elements in the input - * list. For example, the list [ [[[[1]]]], 2 ] contains 4 nested lists and 2 nested integers (11 and 22), so N=6. - * Space Complexity: In terms of space, at most O(D) recursive calls are placed on the stack, where D is the - * maximum level of nesting in the input. For example, D=2 for the input [[1,1],2,[1,1]], and D=3 for the - * input [1,[4,[6]]]. - * - * @param nestedList - * @return - */ - public static long nestedSum(Object[] nestedList) { - return nestedSum(nestedList, 1); - } - - private static long nestedSum(Object[] nestedList, int depth) { - long sum = 0; - for (int i = 0; i < nestedList.length; i++) { - if (nestedList[i] instanceof Integer) { - sum += ((int) nestedList[i] * depth); - } else { - sum += nestedSum((Object[]) nestedList[i], depth + 1); - } - } - return sum; - } - - public static void main(String[] args) { - assertEquals(0, nestedSum(new Object[]{})); - assertEquals(0, nestedSum(new Object[]{new Object[]{}})); - assertEquals(10, nestedSum(new Object[]{new Object[]{1, 1}, 2, new Object[]{1, 1}})); - assertEquals(27, nestedSum(new Object[]{1, new Object[]{4, new Object[]{6}}})); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/recursion/NestedListWeightSumII.java b/src/main/java/com/leetcode/recursion/NestedListWeightSumII.java deleted file mode 100644 index eadd121b..00000000 --- a/src/main/java/com/leetcode/recursion/NestedListWeightSumII.java +++ /dev/null @@ -1,80 +0,0 @@ -package com.leetcode.recursion; - -import java.util.*; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/nested-list-weight-sum-ii/ - * Problem Description: - * Given a nested list of integers, return the sum of all integers in the list weighted by their depth. Each element - * is either an integer, or a list – whose elements may also be integers or other lists. - *

- * Different from {@link NestedListWeightSum} where weight is increasing from root to leaf, now the weight is defined - * from bottom up, i.e., the leaf level integers have weight 1, and the root level integers have the largest weight. - *

- * Example 1: - * Given the list [[1,1],2,[1,1]], return 8. (four 1’s at depth 1, one 2 at depth 2) - *

- * Example 2: - * Given the list [1,[4,[6]]], return 17. (one 1 at depth 3, one 4 at depth 2, and one 6 at depth 1; 13 + 42 + 6*1 = 17) - *

- * Note: For a simpler variant, see {@link NestedListWeightSum}. - * - * @author rampatra - * @since 2019-07-27 - */ -public class NestedListWeightSumII { - - /** - * Time Complexity: - * Space Complexity: - * Runtime: 1 ms. - * - * @param nestedList - * @return - */ - public static int nestedSum(List nestedList) { - int weightedSum = 0; - int unweightedSum = 0; - - while (!nestedList.isEmpty()) { - List nextLevel = new ArrayList<>(); - - for (NestedInteger ni : nestedList) { - if (ni.isInteger()) { - unweightedSum += ni.getInteger(); - } else { - nextLevel.addAll(ni.getList()); - } - } - - unweightedSum += unweightedSum; // multiplication by repetitive addition - weightedSum = unweightedSum; - nestedList = nextLevel; - } - - return weightedSum; - } - - public static void main(String[] args) { - assertEquals(0, nestedSum(Collections.singletonList(new NestedInteger()))); - - assertEquals(0, nestedSum(Collections.singletonList(new NestedInteger().add(new NestedInteger())))); - - // TODO: fix the test cases - // {2, {1,1}, {1,1}} - NestedInteger ni = new NestedInteger(2); - ni.add(new NestedInteger().add(new NestedInteger(1)).add(new NestedInteger(1))); - ni.add(new NestedInteger().add(new NestedInteger(1)).add(new NestedInteger(1))); - - assertEquals(6, nestedSum(Collections.singletonList(ni))); - - // {1, {4, {6}}} - ni = new NestedInteger(1); - ni.add(new NestedInteger(4).add(new NestedInteger(6))); - - assertEquals(17, nestedSum(Collections.singletonList(ni))); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/stacks/ExclusiveTimeOfFunctions.java b/src/main/java/com/leetcode/stacks/ExclusiveTimeOfFunctions.java deleted file mode 100644 index 63c61dc2..00000000 --- a/src/main/java/com/leetcode/stacks/ExclusiveTimeOfFunctions.java +++ /dev/null @@ -1,89 +0,0 @@ -package com.leetcode.stacks; - -import javafx.util.Pair; - -import java.util.Arrays; -import java.util.List; -import java.util.Stack; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/exclusive-time-of-functions/ - * Description: - * On a single threaded CPU, we execute some functions. Each function has a unique id between 0 and N-1. - * - * We store logs in timestamp order that describe when a function is entered or exited. - * - * Each log is a string with this format: "{function_id}:{"start" | "end"}:{timestamp}". For example, "0:start:3" - * means the function with id 0 started at the beginning of timestamp 3. "1:end:2" means the function with id 1 ended - * at the end of timestamp 2. - * - * A function's exclusive time is the number of units of time spent in this function. Note that this does not include - * any recursive calls to child functions. - * - * The CPU is single threaded which means that only one function is being executed at a given time unit. - * - * Return the exclusive time of each function, sorted by their function id. - * - * Input: - * n = 2 - * logs = ["0:start:0","1:start:2","1:end:5","0:end:6"] - * Output: [3, 4] - * Explanation: - * Function 0 starts at the beginning of time 0, then it executes 2 units of time and reaches the end of time 1. - * Now function 1 starts at the beginning of time 2, executes 4 units of time and ends at time 5. - * Function 0 is running again at the beginning of time 6, and also ends at the end of time 6, thus executing for 1 unit of time. - * So function 0 spends 2 + 1 = 3 units of total time executing, and function 1 spends 4 units of total time executing. - * - * - * Note: - * -> 1 <= n <= 100 - * -> Two functions won't start or end at the same time. - * -> Functions will always log when they exit. - * - * @author rampatra - * @since 2019-08-17 - */ -public class ExclusiveTimeOfFunctions { - - /** - * Runtime: 18 ms. - * - * @param n - * @param logs - * @return - */ - public static int[] exclusiveTime(int n, List logs) { - int[] times = new int[n]; - Stack> stack = new Stack<>(); - - for (String log : logs) { - String[] l = log.split(":"); - int id = Integer.parseInt(l[0]); - String operation = l[1]; - int timestamp = Integer.parseInt(l[2]); - - if (operation.equals("start")) { - if (!stack.empty()) { // if there are other processes started before, calculate their time until now - times[stack.peek().getKey()] += (timestamp - stack.peek().getValue() - 1); - } - stack.push(new Pair<>(id, timestamp)); - } else { - times[id] += timestamp - stack.pop().getValue() + 1; - if (!stack.isEmpty()) { // if there are other processes, make their start time to now - stack.push(new Pair<>(stack.pop().getKey(), timestamp)); - } - } - } - - return times; - } - - public static void main(String[] args) { - assertEquals("[4]", Arrays.toString(exclusiveTime(1, Arrays.asList("0:start:0", "0:start:1", "0:end:2", "0:end:3")))); - assertEquals("[6]", Arrays.toString(exclusiveTime(1, Arrays.asList("0:start:0", "0:start:1", "0:start:2", "0:end:3", "0:end:4", "0:end:5")))); - assertEquals("[3, 4]", Arrays.toString(exclusiveTime(2, Arrays.asList("0:start:0", "1:start:2", "1:end:5", "0:end:6")))); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/stacks/ReversePolishNotation.java b/src/main/java/com/leetcode/stacks/ReversePolishNotation.java deleted file mode 100644 index f917099a..00000000 --- a/src/main/java/com/leetcode/stacks/ReversePolishNotation.java +++ /dev/null @@ -1,93 +0,0 @@ -package com.leetcode.stacks; - -import java.util.Stack; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/evaluate-reverse-polish-notation - * Problem Description: - * Evaluate the value of an arithmetic expression in Reverse Polish Notation. - *

- * Valid operators are +, -, *, /. Each operand may be an integer or another expression. - *

- * Note: - * Division between two integers should truncate toward zero. - * The given RPN expression is always valid. That means the expression would always evaluate to a result and there - * won't be any divide by zero operation. - *

- * Example 1: - * Input: ["2", "1", "+", "3", "*"] - * Output: 9 - * Explanation: ((2 + 1) * 3) = 9 - *

- * Example 2: - * Input: ["4", "13", "5", "/", "+"] - * Output: 6 - * Explanation: (4 + (13 / 5)) = 6 - *

- * Example 3: - * Input: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"] - * Output: 22 - * Explanation: - * ((10 * (6 / ((9 + 3) * -11))) + 17) + 5 - * = ((10 * (6 / (12 * -11))) + 17) + 5 - * = ((10 * (6 / -132)) + 17) + 5 - * = ((10 * 0) + 17) + 5 - * = (0 + 17) + 5 - * = 17 + 5 - * = 22 - * - * @author rampatra - * @since 2019-07-27 - */ -public class ReversePolishNotation { - - /** - * Time Complexity: - * Space Complexity: - * Runtime: 5 ms. - * - * @param tokens - * @return - */ - public static int evalRPN(String[] tokens) { - int operand1; - int operand2; - - Stack stack = new Stack<>(); - - for (String s : tokens) { - switch (s) { - case "+": - stack.push(stack.pop() + stack.pop()); - break; - case "-": - operand1 = stack.pop(); - operand2 = stack.pop(); - stack.push(operand2 - operand1); - break; - case "*": - stack.push(stack.pop() * stack.pop()); - break; - case "/": - operand1 = stack.pop(); - operand2 = stack.pop(); - stack.push(operand2 / operand1); - break; - default: - stack.push(Integer.parseInt(s)); - } - } - - return stack.pop(); - } - - public static void main(String[] args) { - assertEquals(18, evalRPN(new String[]{"18"})); - assertEquals(9, evalRPN(new String[]{"2", "1", "+", "3", "*"})); - assertEquals(6, evalRPN(new String[]{"4", "13", "5", "/", "+"})); - assertEquals(22, evalRPN(new String[]{"10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"})); - } -} diff --git a/src/main/java/com/leetcode/strings/AnagramsInString.java b/src/main/java/com/leetcode/strings/AnagramsInString.java deleted file mode 100644 index 12e7d766..00000000 --- a/src/main/java/com/leetcode/strings/AnagramsInString.java +++ /dev/null @@ -1,143 +0,0 @@ -package com.leetcode.strings; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -/** - * Level: Medium - * Problem: https://leetcode.com/problems/find-all-anagrams-in-a-string/ - * Description: - * Given a string s and a non-empty string p, find all the start indices of p's anagrams in s. - * - * Strings consists of lowercase English letters only and the length of both strings s and p will not be larger - * than 20,100. - * - * The order of output does not matter. - * - * Example 1: - * - * Input: - * s: "cbaebabacd" p: "abc" - * - * Output: - * [0, 6] - * - * Explanation: - * The substring with start index = 0 is "cba", which is an anagram of "abc". - * The substring with start index = 6 is "bac", which is an anagram of "abc". - * - * Example 2: - * - * Input: - * s: "abab" p: "ab" - * - * Output: - * [0, 1, 2] - * - * Explanation: - * The substring with start index = 0 is "ab", which is an anagram of "ab". - * The substring with start index = 1 is "ba", which is an anagram of "ab". - * The substring with start index = 2 is "ab", which is an anagram of "ab". - * - * @author rampatra - * @since 2019-04-13 - */ -public class AnagramsInString { - - /** - * Time complexity: O((n-m) * m log m) - * where, - * n = text length - * m = pattern length - * - * @param text - * @param pattern - * @return - */ - private static List findAllAnagramsInTextNaive(String text, String pattern) { - List indexes = new ArrayList<>(); - - int textLen = text.length(); - int patternLen = pattern.length(); - - char[] patternChars = pattern.toCharArray(); - Arrays.sort(patternChars); // takes O(m log m) time - String patternSorted = String.valueOf(patternChars); - - String subText; - char[] subTextChars; - String subTextSorted; - - for (int i = 0; i <= textLen - patternLen; i++) { // loops n-m number of times - subText = text.substring(i, i + patternLen); - subTextChars = subText.toCharArray(); - Arrays.sort(subTextChars); // sorts m number of characters, takes O(m log m) - subTextSorted = String.valueOf(subTextChars); - - if (subTextSorted.equals(patternSorted)) { // compare m characters takes m time - indexes.add(i); - } - } - return indexes; - } - - /** - * Time complexity: O(n) - * where, - * n = length of text or number of characters in text - *

- * Runtime: 6 ms. - * - * @param text - * @param pattern - * @return - */ - private static List findAllAnagramsInText(String text, String pattern) { - List indices = new ArrayList<>(); - - int textLen = text.length(); - int patternLen = pattern.length(); - - int[] textCharCountInWindow = new int[26]; - int[] patternCharCount = new int[26]; - - for (int i = 0; i < patternLen; i++) { - patternCharCount[pattern.charAt(i) - 'a']++; - } - - for (int i = 0; i < textLen; i++) { - textCharCountInWindow[text.charAt(i) - 'a']++; - if (i >= patternLen) { - textCharCountInWindow[text.charAt(i - patternLen) - 'a']--; - } - if (Arrays.equals(textCharCountInWindow, patternCharCount)) { // loops 26 times no matter the text/pattern length - indices.add(i - patternLen + 1); - } - } - - return indices; - } - - public static void main(String[] args) { - // basic use cases - System.out.println(findAllAnagramsInTextNaive("cbaebabacd", "abc")); - System.out.println(findAllAnagramsInTextNaive("abab", "ab")); - System.out.println(findAllAnagramsInTextNaive("af", "af")); - System.out.println(findAllAnagramsInTextNaive("af", "be")); - - // corner case - System.out.println(findAllAnagramsInTextNaive("", "ab")); - - System.out.println("-----"); - - // basic use cases - System.out.println(findAllAnagramsInText("cbaebabacd", "abc")); - System.out.println(findAllAnagramsInText("abab", "ab")); - System.out.println(findAllAnagramsInText("af", "af")); - System.out.println(findAllAnagramsInText("af", "be")); - - // corner case - System.out.println(findAllAnagramsInText("", "ab")); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/strings/CountAndSay.java b/src/main/java/com/leetcode/strings/CountAndSay.java deleted file mode 100644 index 24f41a3e..00000000 --- a/src/main/java/com/leetcode/strings/CountAndSay.java +++ /dev/null @@ -1,48 +0,0 @@ -package com.leetcode.strings; - -/** - * Level: Easy - * Problem: https://leetcode.com/problems/count-and-say/ - * - * @author rampatra - * @since 2019-04-20 - */ -public class CountAndSay { - - /** - * Time complexity: - * Runtime: 1 ms. - * - * @param n - * @return - */ - public static String countAndSay(int n) { - if (n == 1) return "1"; - - String s = countAndSay(n - 1); - StringBuilder sb = new StringBuilder(); - int count = 0; - - for (int i = 0; i < s.length(); i++) { - count++; - - if (i + 1 >= s.length() || s.charAt(i) != s.charAt(i + 1)) { - sb.append(count); - sb.append(s.charAt(i)); - count = 0; - } - } - - return sb.toString(); - } - - public static void main(String[] args) { - System.out.println(countAndSay(1)); - System.out.println(countAndSay(2)); - System.out.println(countAndSay(3)); - System.out.println(countAndSay(4)); - System.out.println(countAndSay(5)); - System.out.println(countAndSay(6)); - System.out.println(countAndSay(10)); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/strings/LongestCommonPrefix.java b/src/main/java/com/leetcode/strings/LongestCommonPrefix.java deleted file mode 100644 index 07bd6392..00000000 --- a/src/main/java/com/leetcode/strings/LongestCommonPrefix.java +++ /dev/null @@ -1,48 +0,0 @@ -package com.leetcode.strings; - -/** - * Level: Easy - * Problem: https://leetcode.com/problems/longest-common-prefix/ - * - * @author rampatra - * @since 2019-04-20 - */ -public class LongestCommonPrefix { - - /** - * Time complexity: O(r * c) - * where, - * r = no. of strings - * c = max. no. of characters in a particular string - *

- * Runtime: 1 ms. - * - * @param strs - * @return - */ - public static String longestCommonPrefix(String[] strs) { - if (strs == null || strs.length == 0) return ""; - - int row; - for (int col = 0; col < strs[0].length(); col++) { - for (row = 0; row < strs.length - 1; row++) { - // once we find a different character under one column, return the characters read so far - if (col == strs[row].length() - || col == strs[row + 1].length() - || strs[row].charAt(col) != strs[row + 1].charAt(col)) { - return strs[row].substring(0, col); - } - } - } - - return strs[0]; - } - - public static void main(String[] args) { - System.out.println(longestCommonPrefix(new String[]{})); - System.out.println(longestCommonPrefix(new String[]{""})); - System.out.println(longestCommonPrefix(new String[]{"a"})); - System.out.println(longestCommonPrefix(new String[]{"flower", "flow", "flight"})); - System.out.println(longestCommonPrefix(new String[]{"dog", "racecar", "car"})); - } -} diff --git a/src/main/java/com/leetcode/strings/RansomNote.java b/src/main/java/com/leetcode/strings/RansomNote.java deleted file mode 100644 index c6b66fb0..00000000 --- a/src/main/java/com/leetcode/strings/RansomNote.java +++ /dev/null @@ -1,40 +0,0 @@ -package com.leetcode.strings; - -/** - * Level: Easy - * Problem: https://leetcode.com/problems/ransom-note/ - * - * @author rampatra - * @since 2019-04-19 - */ -public class RansomNote { - - /** - * Runtime: 4 ms/a>. - * - * @param ransomNote - * @param magazine - * @return - */ - public static boolean canConstruct(String ransomNote, String magazine) { - char[] charCount = new char[26]; - - for (int i = 0; i < magazine.length(); i++) { - charCount[magazine.charAt(i) - 'a']++; - } - - for (int i = 0; i < ransomNote.length(); i++) { - if (charCount[ransomNote.charAt(i) - 'a']-- == 0) { - return false; - } - } - return true; - } - - public static void main(String[] args) { - System.out.println(canConstruct("", "")); - System.out.println(canConstruct("a", "a")); - System.out.println(canConstruct("ab", "ab")); - System.out.println(canConstruct("aab", "ab")); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/strings/ReverseStringII.java b/src/main/java/com/leetcode/strings/ReverseStringII.java deleted file mode 100644 index 4a5aabd4..00000000 --- a/src/main/java/com/leetcode/strings/ReverseStringII.java +++ /dev/null @@ -1,46 +0,0 @@ -package com.leetcode.strings; - -/** - * Level: Easy - * Problem: https://leetcode.com/problems/reverse-string-ii/ - * - * @author rampatra - * @since 2019-04-20 - */ -public class ReverseStringII { - - /** - * Time complexity: O(n) - * where, - * n = no. of characters in string - *

- * Runtime: 0 ms. - * - * @param str - * @param k - * @return - */ - public static String reverseStr(String str, int k) { - char[] chars = str.toCharArray(); - int len = str.length(); - for (int i = 0; i < len; i += 2 * k) { - reverse(chars, i, Math.min(len, i + k)); - } - return new String(chars); - } - - private static void reverse(char[] chars, int start, int end) { - char temp; - for (int i = start, j = end - 1; i < j; i++, j--) { - temp = chars[i]; - chars[i] = chars[j]; - chars[j] = temp; - } - } - - public static void main(String[] args) { - System.out.println(reverseStr("abcdefg", 2)); - System.out.println(reverseStr("abcdef", 2)); - System.out.println(reverseStr("abcde", 2)); - } -} diff --git a/src/main/java/com/leetcode/strings/ReverseVowels.java b/src/main/java/com/leetcode/strings/ReverseVowels.java deleted file mode 100644 index 25518cac..00000000 --- a/src/main/java/com/leetcode/strings/ReverseVowels.java +++ /dev/null @@ -1,66 +0,0 @@ -package com.leetcode.strings; - -/** - * Level: Easy - * Problem: https://leetcode.com/problems/reverse-vowels-of-a-string/ - * - * @author rampatra - * @since 2019-04-19 - */ -public class ReverseVowels { - - /** - * Reverse only the vowels in the string {@code str}. - *

- * Time Complexity: O(n) - * where, - * n = no. of characters in the string - *

- * Runtime: 2 ms on leetcode. - * - * @param str - * @return - */ - private static String reverseVowels(String str) { - - char[] chars = str.toCharArray(); - char temp; - int left = 0; - int right = str.length() - 1; - - while (left < right) { - // find the vowel from left - while (!isVowel(chars[left]) && left < right) { - left++; - } - // find the vowel from right - while (!isVowel(chars[right]) && left < right) { - right--; - } - - if (!isVowel(chars[left]) || !isVowel(chars[right])) { - break; - } - - // swap the characters - temp = chars[left]; - chars[left] = chars[right]; - chars[right] = temp; - - left++; - right--; - } - return new String(chars); - } - - private static boolean isVowel(char c) { - return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || - c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U'; - } - - public static void main(String[] args) { - System.out.println(reverseVowels("hello")); - System.out.println(reverseVowels("a")); - System.out.println(reverseVowels("")); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/strings/StrStr.java b/src/main/java/com/leetcode/strings/StrStr.java deleted file mode 100644 index aa3bc896..00000000 --- a/src/main/java/com/leetcode/strings/StrStr.java +++ /dev/null @@ -1,59 +0,0 @@ -package com.leetcode.strings; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/implement-strstr/ - * Problem Description: - * Implement strStr(). Return the index of the first occurrence of needle in haystack, or -1 if needle - * is not part of haystack. - *

- * Example 1: - *

- * Input: haystack = "hello", needle = "ll" - * Output: 2 - * Example 2: - *

- * Input: haystack = "aaaaa", needle = "bba" - * Output: -1 - * - * @author rampatra - * @since 2019-04-28 - */ -public class StrStr { - - /** - * Time complexity: O(m*n) - * where, - * m = length of haystack - * n = length of needle - *

- * Runtime: 3 ms. - * - * @param haystack - * @param needle - * @return - */ - public static int strStr(String haystack, String needle) { - for (int i = 0; ; i++) { - for (int j = 0; ; j++) { - if (j == needle.length()) return i; - if (i + j == haystack.length()) return -1; - if (needle.charAt(j) != haystack.charAt(i + j)) break; - } - } - } - - public static void main(String[] args) { - System.out.println(strStr("hello", "ll")); - System.out.println(strStr("leet", "e")); - System.out.println(strStr("mississippi", "issip")); - System.out.println(strStr("mississippi", "pi")); - System.out.println(strStr("aaaa", "bba")); - - // edge cases - System.out.println(strStr("aaa", "aaaa")); - System.out.println(strStr("aaaa", "")); - System.out.println(strStr("", "abc")); - System.out.println(strStr("", "")); - } -} diff --git a/src/main/java/com/leetcode/strings/StringCompression.java b/src/main/java/com/leetcode/strings/StringCompression.java deleted file mode 100644 index 7697f591..00000000 --- a/src/main/java/com/leetcode/strings/StringCompression.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.leetcode.strings; - -/** - * @author rampatra - * @since 2019-04-16 - */ -public class StringCompression { - - private static int compress(char[] chars) { - return -1; - } - - public static void main(String[] args) { - } -} diff --git a/src/main/java/com/leetcode/strings/UniqueCharacterInString.java b/src/main/java/com/leetcode/strings/UniqueCharacterInString.java deleted file mode 100644 index da155710..00000000 --- a/src/main/java/com/leetcode/strings/UniqueCharacterInString.java +++ /dev/null @@ -1,38 +0,0 @@ -package com.leetcode.strings; - -/** - * Level: Easy - * Problem: https://leetcode.com/problems/first-unique-character-in-a-string/ - * - * @author rampatra - * @since 2019-04-16 - */ -public class UniqueCharacterInString { - - /** - * Time complexity: O(n) - * Runtime: 7 ms on leetcode. - * - * @param str the input string - * @return the index of the first non-repeating character in {@code str}, {@code -1} otherwise. - */ - private static int findFirstUniqueCharacterInString(String str) { - int[] charCount = new int[26]; - - for (int i = 0; i < str.length(); i++) { - charCount[str.charAt(i) - 'a']++; - } - - for (int i = 0; i < str.length(); i++) { - if (charCount[str.charAt(i) - 'a'] == 1) { - return i; - } - } - return -1; - } - - public static void main(String[] args) { - System.out.println(findFirstUniqueCharacterInString("leetcode")); - System.out.println(findFirstUniqueCharacterInString("loveleetcode")); - } -} diff --git a/src/main/java/com/leetcode/strings/ValidPalindrome.java b/src/main/java/com/leetcode/strings/ValidPalindrome.java deleted file mode 100644 index 451849b6..00000000 --- a/src/main/java/com/leetcode/strings/ValidPalindrome.java +++ /dev/null @@ -1,59 +0,0 @@ -package com.leetcode.strings; - -/** - * Level: Easy - * Problem: https://leetcode.com/problems/valid-palindrome/ - * - * @author rampatra - * @since 2019-04-19 - */ -public class ValidPalindrome { - - /** - * Time complexity: O(n) - * where, - * n = no. of characters in the string - *

- * Runtime: 2 ms on leetcode. - * - * @param str - * @return - */ - private static boolean isPalindrome(String str) { - char[] chars = str.toCharArray(); - int left = 0; - int right = chars.length - 1; - - while (left < right) { - // if it's not alphanumeric then move the left pointer forward - while (!isAlphaNumeric(chars[left]) && left < right) { - left++; - } - // if it's not alphanumeric then move the right pointer backward - while (!isAlphaNumeric(chars[right]) && left < right) { - right--; - } - - // case insensitive comparison - if (Character.toLowerCase(chars[left]) != Character.toLowerCase(chars[right])) { - return false; - } - - left++; - right--; - } - - return true; - } - - private static boolean isAlphaNumeric(char c) { - int i = (int) c; - return (i >= 48 && i <= 57) || (i >= 65 && i <= 90) || (i >= 97 && i <= 122); - } - - public static void main(String[] args) { - System.out.println(isPalindrome("A man, a plan, a canal: Panama")); - System.out.println(isPalindrome("race a car")); - System.out.println(isPalindrome("0P")); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/trees/BinaryTreeUpsideDown.java b/src/main/java/com/leetcode/trees/BinaryTreeUpsideDown.java deleted file mode 100644 index aa43bf50..00000000 --- a/src/main/java/com/leetcode/trees/BinaryTreeUpsideDown.java +++ /dev/null @@ -1,207 +0,0 @@ -package com.leetcode.trees; - -import java.util.Stack; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNull; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/binary-tree-upside-down/ - * Problem Description: - * Given a binary tree where all the right nodes are either leaf nodes with a sibling (a left node that shares the - * same parent node) or empty, flip it upside down and turn it into a tree where the original right nodes turned into - * left leaf nodes. Return the new root. - * - * Example: - * Input: [1,2,3,4,5] - * - * 1 - * / \ - * 2 3 - * / \ - * 4 5 - * - * Output: return the root of the binary tree [4,5,2,#,#,3,1] - * - * 4 - * / \ - * 5 2 - * / \ - * 3 1 - * - * Clarification: - * Confused what [4,5,2,#,#,3,1] means? Read more below on how binary tree is serialized on OJ. The serialization of - * a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below. - * - * Here's an example: - * - * 1 - * / \ - * 2 3 - * / - * 4 - * \ - * 5 - * - * The above binary tree is serialized as [1,2,3,#,#,4,#,#,5]. - * - * @author rampatra - * @since 2019-08-04 - */ -public class BinaryTreeUpsideDown { - - /** - * The solution is simple, every node (except the root) on the left of the tree would have its parent's right child - * as it's left child and parent as its right child. That's all you have to do to flip the tree upside down. - * - * Time Complexity: O(h) - * Space Complexity: O(h) - * where, - * h = height of the tree - * - * Runtime: 1 ms. - * - * @param root - * @return - */ - public static TreeNode upsideDownBinaryTreeUsingStack(TreeNode root) { - if (root == null) return null; - - TreeNode curr = root; - TreeNode currParent; - TreeNode newRoot = null; - - // using stack to keep track of the parent node - Stack stack = new Stack<>(); - - while (curr != null) { - stack.add(curr); - curr = curr.left; - } - - while (!stack.empty()) { - curr = stack.pop(); - currParent = stack.empty() ? null : stack.peek(); - - if (newRoot == null) newRoot = curr; - - if (currParent != null) { - curr.left = currParent.right; - curr.right = currParent; - } else { - curr.left = null; - curr.right = null; - } - } - - return newRoot; - } - - /** - * The solution is simple, every node (except the root) on the left of the tree would have its parent's right child - * as it's left child and parent as its right child. That's all you have to do to flip the tree upside down. - * - * Time Complexity: O(h) - * Space Complexity: O(h) - * where, - * h = height of the tree - * - * Runtime: 0 ms. - * - * @param node - * @return - */ - public static TreeNode upsideDownBinaryTree(TreeNode node) { - if (node == null || node.left == null) return node; - - // go to the last node on the extreme left branch - TreeNode newRoot = upsideDownBinaryTree(node.left); - - // do the node changes as you backtrack - node.left.left = node.right; - node.left.right = node; - - // clean up - node.left = null; - node.right = null; - - return newRoot; - } - - public static void main(String[] args) { - /* - Binary Tree - - 1 - / \ - 2 3 - / \ - 4 5 - */ - TreeNode tree = new TreeNode(1); - tree.left = new TreeNode(2); - tree.right = new TreeNode(3); - tree.left.left = new TreeNode(4); - tree.left.right = new TreeNode(5); - - /* - Upside Down Binary Tree - - 4 - / \ - 5 2 - / \ - 3 1 - */ - TreeNode upsideDownTree = upsideDownBinaryTreeUsingStack(tree); - assertEquals(4, upsideDownTree.val); - assertEquals(5, upsideDownTree.left.val); - assertEquals(2, upsideDownTree.right.val); - assertEquals(1, upsideDownTree.right.right.val); - assertEquals(3, upsideDownTree.right.left.val); - assertNull(upsideDownTree.right.right.left); - assertNull(upsideDownTree.right.right.right); - - - - /****************************** - * - * Test for the recursive method - * - ******************************/ - - /* - Binary Tree - - 1 - / \ - 2 3 - / \ - 4 5 - */ - tree = new TreeNode(1); - tree.left = new TreeNode(2); - tree.right = new TreeNode(3); - tree.left.left = new TreeNode(4); - tree.left.right = new TreeNode(5); - - /* - Upside Down Binary Tree - - 4 - / \ - 5 2 - / \ - 3 1 - */ - upsideDownTree = upsideDownBinaryTree(tree); - assertEquals(4, upsideDownTree.val); - assertEquals(5, upsideDownTree.left.val); - assertEquals(2, upsideDownTree.right.val); - assertEquals(1, upsideDownTree.right.right.val); - assertEquals(3, upsideDownTree.right.left.val); - assertNull(upsideDownTree.right.right.right); - assertNull(upsideDownTree.right.right.left); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/trees/BinaryTreeZigZagLevelOrderTraversal.java b/src/main/java/com/leetcode/trees/BinaryTreeZigZagLevelOrderTraversal.java deleted file mode 100644 index 1a54d952..00000000 --- a/src/main/java/com/leetcode/trees/BinaryTreeZigZagLevelOrderTraversal.java +++ /dev/null @@ -1,100 +0,0 @@ -package com.leetcode.trees; - -import java.util.*; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Link: https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/ - * Description: - * Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then - * right to left for the next level and alternate between). - * - * For example: - * Given binary tree [3,9,20,null,null,15,7], - * 3 - * / \ - * 9 20 - * / \ - * 15 7 - * return its zigzag level order traversal as: - * [ - * [3], - * [20,9], - * [15,7] - * ] - * - * @author rampatra - * @since 2019-08-11 - */ -public class BinaryTreeZigZagLevelOrderTraversal { - - /** - * Time Complexity: - * Space Complexity: - * Runtime: 1 ms. - * - * @param root - * @return - */ - public static List> zigzagLevelOrder(TreeNode root) { - - int levelNo = 0; - LinkedList currLevel = new LinkedList<>(); - List> levelOrderTraversal = new LinkedList<>(); - - if (root == null) { - return levelOrderTraversal; - } - - Queue queue = new LinkedList<>(); - queue.add(root); - queue.add(null); - - while (!queue.isEmpty()) { - - TreeNode treeNode = queue.poll(); - - if (treeNode == null) { - levelOrderTraversal.add(currLevel); - currLevel = new LinkedList<>(); - levelNo++; - - if (queue.size() > 0) { - queue.add(null); - } - } else { - if (levelNo % 2 == 0) { - currLevel.add(treeNode.val); - } else { - currLevel.add(0, treeNode.val); - } - if (treeNode.left != null) queue.add(treeNode.left); - if (treeNode.right != null) queue.add(treeNode.right); - } - } - - return levelOrderTraversal; - } - - public static void main(String[] args) { - /* - Binary Tree - - 1 - / \ - 2 3 - / \ - 4 5 - */ - TreeNode tree = new TreeNode(1); - tree.left = new TreeNode(2); - tree.right = new TreeNode(3); - tree.left.left = new TreeNode(4); - tree.left.right = new TreeNode(5); - - assertEquals("[[1], [3, 2], [4, 5]]", zigzagLevelOrder(tree).toString()); - assertEquals("[]", zigzagLevelOrder(null).toString()); - } -} diff --git a/src/main/java/com/leetcode/trees/ClosestBinarySearchTreeValue.java b/src/main/java/com/leetcode/trees/ClosestBinarySearchTreeValue.java deleted file mode 100644 index ca6d94b7..00000000 --- a/src/main/java/com/leetcode/trees/ClosestBinarySearchTreeValue.java +++ /dev/null @@ -1,110 +0,0 @@ -package com.leetcode.trees; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/closest-binary-search-tree-value/ - * Problem Description: - * Given a non-empty binary search tree and a target value, find the value in the BST that is closest to the target. - *

- * Note: - * - Given target value is a floating point. - * - You are guaranteed to have only one unique value in the BST that is closest to the target. - * - * @author rampatra - * @since 2019-07-31 - */ -public class ClosestBinarySearchTreeValue { - - /** - * Runtime: 0 ms. - * - * @param root - * @param target - * @return - */ - public static int closestValue(TreeNode root, double target) { - if (root == null) return -1; - - return closestValue(root, root, target); - } - - private static int closestValue(TreeNode node, TreeNode closestNode, double val) { - if (node == null) return closestNode.val; - - if (Math.abs(node.val - val) < Math.abs(closestNode.val - val)) { - closestNode = node; - } - - if (node.val > val) { - return closestValue(node.left, closestNode, val); - } else { - return closestValue(node.right, closestNode, val); - } - } - - public static void main(String[] args) { - - /* - BST looks like: - - 9 - / \ - 7 13 - / \ \ - 5 8 20 - / \ - 2 6 - */ - TreeNode root = new TreeNode(9); - root.left = new TreeNode(7); - root.right = new TreeNode(13); - root.left.left = new TreeNode(5); - root.left.right = new TreeNode(8); - root.left.left.right = new TreeNode(6); - root.left.left.left = new TreeNode(2); - root.right.right = new TreeNode(20); - - assertEquals(13, closestValue(root, 15)); - assertEquals(13, closestValue(root, 13)); - assertEquals(9, closestValue(root, 9)); - assertEquals(2, closestValue(root, 2)); - assertEquals(2, closestValue(root, 1)); - assertEquals(6, closestValue(root, 6)); - assertEquals(13, closestValue(root, 11)); // tie b/w 9 and 13 - - /* - BST looks like: - - 9 - / \ - 7 13 - / \ / \ - 5 8 13 20 - */ - root = new TreeNode(9); - root.left = new TreeNode(7); - root.right = new TreeNode(13); - root.left.left = new TreeNode(5); - root.left.right = new TreeNode(8); - root.right.left = new TreeNode(13); - root.right.right = new TreeNode(20); - - assertEquals(13, closestValue(root, 15)); - - /* - BST looks like: - - 1500000000 - / - / - / - 1400000000 - */ - root = new TreeNode(1500000000); - root.left = new TreeNode(1400000000); - - assertEquals(1400000000, closestValue(root, -1500000000.0)); - } -} diff --git a/src/main/java/com/leetcode/trees/ClosestBinarySearchTreeValueII.java b/src/main/java/com/leetcode/trees/ClosestBinarySearchTreeValueII.java deleted file mode 100644 index e583723a..00000000 --- a/src/main/java/com/leetcode/trees/ClosestBinarySearchTreeValueII.java +++ /dev/null @@ -1,166 +0,0 @@ -package com.leetcode.trees; - -import java.util.LinkedList; -import java.util.List; -import java.util.Queue; -import java.util.Stack; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Hard - * Problem Link: https://leetcode.com/problems/closest-binary-search-tree-value-ii/ - * Problem Description: - * Given a non-empty binary search tree and a target value, find k values in the BST that are closest to the target. - * - * Note: - * - Given target value is a floating point. - * - You may assume k is always valid, that is: k ≤ total nodes. - * - You are guaranteed to have only one unique set of k values in the BST that are closest to the target. - * - * Example: - * Input: root = [4,2,5,1,3], target = 3.714286, and k = 2 - * - * 4 - * / \ - * 2 5 - * / \ - * 1 3 - * - * Output: [4,3] - * - * Follow up: - * Assume that the BST is balanced, could you solve it in less than O(n) runtime (where n = total nodes)? - * - * @author rampatra - * @since 2019-07-31 - */ -public class ClosestBinarySearchTreeValueII { - - - /** - * The idea is simple. We do the inorder traversal and keep the values less than or equal to target in a stack and - * the values greater than target in a queue. And finally, we compare values from both stack and queue and take - * whichever is the closest to target value each time. - * - * Note: We can optimize it even further in terms of space. We can get rid of the stack and queue and just fill up - * the result list in the recursive inOrder call. Once the result list is of size k, we can compare and remove the - * farthest value and insert the closer value. See {@link ClosestBinarySearchTreeValueII#closestKValuesOptimized(TreeNode, double, int)}. - * - * @param root - * @param target - * @param k - * @return - */ - public static List closestKValues(TreeNode root, double target, int k) { - int count = 0; - List closestKValues = new LinkedList<>(); - - Stack predecessors = new Stack<>(); - Queue successors = new LinkedList<>(); - inOrder(root, predecessors, successors, target, k); - - while (count < k) { - if (predecessors.empty()) { - closestKValues.add(successors.poll()); - } else if (successors.isEmpty()) { - closestKValues.add(predecessors.pop()); - } else if (Math.abs(target - predecessors.peek()) < Math.abs(target - successors.peek())) { - closestKValues.add(predecessors.pop()); - } else { - closestKValues.add(successors.poll()); - } - count++; - } - - return closestKValues; - } - - private static void inOrder(TreeNode root, Stack predecessors, Queue successors, double target, int k) { - if (root == null || successors.size() == k) return; - inOrder(root.left, predecessors, successors, target, k); - if (root.val <= target) { - predecessors.add(root.val); - } else { - successors.add(root.val); - } - inOrder(root.right, predecessors, successors, target, k); - } - - - /** - * This approach is similar to the above one but it doesn't use stack or queue. - * - * @param root - * @param target - * @param k - * @return - */ - public static List closestKValuesOptimized(TreeNode root, double target, int k) { - LinkedList closestKValues = new LinkedList<>(); - inOrder(root, target, k, closestKValues); - return closestKValues; - } - - private static void inOrder(TreeNode root, double target, int k, LinkedList closestKValues) { - if (root == null) return; - - inOrder(root.left, target, k, closestKValues); - if (closestKValues.size() == k) { - //if size k, add current and remove head if it's closer to target, otherwise return - if (Math.abs(target - root.val) < Math.abs(target - closestKValues.peekFirst())) - closestKValues.removeFirst(); - else { - return; - } - } - closestKValues.add(root.val); - inOrder(root.right, target, k, closestKValues); - } - - public static void main(String[] args) { - - /* - BST looks like: - - 9 - / \ - 7 13 - / \ \ - 5 8 20 - / \ - 2 6 - */ - TreeNode root = new TreeNode(9); - root.left = new TreeNode(7); - root.right = new TreeNode(13); - root.left.left = new TreeNode(5); - root.left.right = new TreeNode(8); - root.left.left.left = new TreeNode(2); - root.left.left.right = new TreeNode(6); - root.right.right = new TreeNode(20); - - assertEquals("[9, 8, 7, 6, 5]", closestKValues(root, 8.5, 5).toString()); - assertEquals("[5, 6, 7, 8, 9]", closestKValuesOptimized(root, 8.5, 5).toString()); - - /* - BST looks like: - - 9 - / \ - 7 13 - / \ / \ - 5 8 13 20 - */ - root = new TreeNode(9); - root.left = new TreeNode(7); - root.right = new TreeNode(13); - root.left.left = new TreeNode(5); - root.right.left = new TreeNode(13); - root.left.right = new TreeNode(8); - root.right.right = new TreeNode(20); - - assertEquals("[13, 13, 9, 20, 8]", closestKValues(root, 14, 5).toString()); - assertEquals("[8, 9, 13, 13, 20]", closestKValuesOptimized(root, 14, 5).toString()); - } -} diff --git a/src/main/java/com/leetcode/trees/LeavesOfBinaryTree.java b/src/main/java/com/leetcode/trees/LeavesOfBinaryTree.java deleted file mode 100644 index 6ca15e22..00000000 --- a/src/main/java/com/leetcode/trees/LeavesOfBinaryTree.java +++ /dev/null @@ -1,97 +0,0 @@ -package com.leetcode.trees; - -import java.util.ArrayList; -import java.util.List; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -/** - * Level: Medium - * Problem Link: https://leetcode.com/problems/find-leaves-of-binary-tree/ - * Problem Description: - * Given a binary tree, collect a tree's nodes as if you were doing this: Collect and remove all leaves, repeat - * until the tree is empty. - * - * Example: - * Input: [1,2,3,4,5] - * - * 1 - * / \ - * 2 3 - * / \ - * 4 5 - * - * Output: [[4,5,3],[2],[1]] - * - * Explanation: - * 1. Removing the leaves [4,5,3] would result in this tree: - * 1 - * / - * 2 - * - * 2. Now removing the leaf [2] would result in this tree: - * 1 - * - * 3. Now removing the leaf [1] would result in the empty tree: - * [] - * - * @author rampatra - * @since 2019-08-01 - */ -public class LeavesOfBinaryTree { - - /** - * THe idea is to perform a DFS and backtrack. While backtracking, check the height of the node and insert - * the node into the list indexed by their heights. - * Time Complexity: - * Space Complexity: - * Runtime: 1 ms. - * - * @param root - * @return - */ - public static List> findLeavesOfBinaryTree(TreeNode root) { - List> levels = new ArrayList<>(); - findLeavesOfBinaryTree(root, levels); - return levels; - } - - private static int findLeavesOfBinaryTree(TreeNode root, List> levels) { - if (root == null) return -1; - - int leftHeight = findLeavesOfBinaryTree(root.left, levels); - int rightHeight = findLeavesOfBinaryTree(root.right, levels); - int height = Math.max(leftHeight, rightHeight) + 1; - - if (height >= levels.size()) { - levels.add(height, new ArrayList<>()); - } - levels.get(height).add(root.val); - - return height; - } - - public static void main(String[] args) { - /* - BST looks like: - - 4 - / \ - 1 7 - / \ \ - 3 8 20 - / \ - 2 6 - */ - TreeNode root = new TreeNode(4); - root.left = new TreeNode(1); - root.right = new TreeNode(7); - root.left.left = new TreeNode(3); - root.left.right = new TreeNode(8); - root.left.left.left = new TreeNode(2); - root.left.left.right = new TreeNode(6); - root.right.right = new TreeNode(20); - - assertEquals("[[2, 6, 8, 20], [3, 7], [1], [4]]", findLeavesOfBinaryTree(root).toString()); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/trees/SecondMinNodeInBinaryTree.java b/src/main/java/com/leetcode/trees/SecondMinNodeInBinaryTree.java deleted file mode 100644 index a8cddf74..00000000 --- a/src/main/java/com/leetcode/trees/SecondMinNodeInBinaryTree.java +++ /dev/null @@ -1,108 +0,0 @@ -package com.leetcode.trees; - -import java.util.Stack; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/ - * Problem Description: - * Given a non-empty special binary tree consisting of nodes with the non-negative value, where each node in this - * tree has exactly two or zero sub-node. If the node has two sub-nodes, then this node's value is the smaller value - * among its two sub-nodes. More formally, the property root.val = min(root.left.val, root.right.val) always holds. - * - * Given such a binary tree, you need to output the second minimum value in the set made of all the nodes' value in - * the whole tree. - * - * If no such second minimum value exists, output -1 instead. - * - * Example 1: - * Input: - * 2 - * / \ - * 2 5 - * / \ - * 5 7 - * - * Output: 5 - * Explanation: The smallest value is 2, the second smallest value is 5. - * - * - * Example 2: - * Input: - * 2 - * / \ - * 2 2 - * - * Output: -1 - * Explanation: The smallest value is 2, but there isn't any second smallest value. - * - * @author rampatra - * @since 2019-08-03 - */ -public class SecondMinNodeInBinaryTree { - - /** - * Time Complexity: O(n) - * Space Complexity: O(n) - * Runtime: 1 ms. - * @param root - * @return - */ - public static int findSecondMinimumValueIterative(TreeNode root) { - if (root == null || (root.left == null && root.right == null)) return -1; - - int min = root.val; - long secondMin = Long.MAX_VALUE; - - Stack stack = new Stack<>(); - stack.push(root); - - while (!stack.empty()) { - TreeNode node = stack.pop(); - if (node == null) continue; - - if (node.val > min && node.val < secondMin) { - secondMin = node.val; - } - stack.push(node.left); - stack.push(node.right); - } - - return secondMin == Long.MAX_VALUE ? -1 : (int) secondMin; - } - - - /** - * Time Complexity: - * Space Complexity: - * Runtime: 0 ms. - * - * @param root - * @return - */ - public static int findSecondMinimumValue(TreeNode root) { - // passing a long as secondMin because TreeNode can have Integer.MAX_VALUE as its value - long ans = findSecondMinimumValue(root, root.val, Long.MAX_VALUE); - return ans == Long.MAX_VALUE ? -1 : (int) ans; - } - - private static long findSecondMinimumValue(TreeNode root, int min, long secondMin) { - if (root == null) return Long.MAX_VALUE; - - if (root.val > min && root.val < secondMin) { - return root.val; - } else { - return Math.min(findSecondMinimumValue(root.left, min, secondMin), - findSecondMinimumValue(root.right, min, secondMin)); - } - } - - public static void main(String[] args) { - System.out.println((int) 2147483647L); - System.out.println(Integer.MAX_VALUE); - // TODO: A function called buildTree which would take an array like [1,1,3,1,1,3,4,3,1,1,1,3,8,4,8,3,3,1,6,2,1] - // and return a Binary Tree - //assertEquals(2, findSecondMinimumValue(buildTree(new int[]{1,1,3,1,1,3,4,3,1,1,1,3,8,4,8,3,3,1,6,2,1}))); - //assertEquals(2147483647, findSecondMinimumValue(buildTree(new int[]{2,2,2147483647}))); - } -} diff --git a/src/main/java/com/leetcode/trees/SerializeDeserializeBinaryTree.java b/src/main/java/com/leetcode/trees/SerializeDeserializeBinaryTree.java deleted file mode 100644 index 690de39d..00000000 --- a/src/main/java/com/leetcode/trees/SerializeDeserializeBinaryTree.java +++ /dev/null @@ -1,179 +0,0 @@ -package com.leetcode.trees; - - -import java.util.LinkedList; -import java.util.Queue; - -/** - * Level: Hard - * Link: https://leetcode.com/problems/serialize-and-deserialize-binary-tree/ - * Description: - * Serialization is the process of converting a data structure or object into a sequence of bits so that it can be - * stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in - * the same or another computer environment. - * - * Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your - * serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized - * to a string and this string can be deserialized to the original tree structure. - * - * Example: - * - * You may serialize the following tree: - * - * 1 - * / \ - * 2 3 - * / \ - * 4 5 - * - * as "[1,2,3,null,null,4,5]" - * - * Clarification: The above format is the same as how LeetCode serializes a binary tree. You do not necessarily need - * to follow this format, so please be creative and come up with different approaches yourself. - * - * Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms - * should be stateless. - * - * @author rampatra - * @since 2019-08-17 - */ -public class SerializeDeserializeBinaryTree { - - /** - * Runtime: 31 ms. - * - * @param root - * @return - */ - public static String serialize(TreeNode root) { - if (root == null) { - return "[]"; - } - - StringBuilder sb = new StringBuilder(); - sb.append("["); - - Queue queue = new LinkedList<>(); - queue.add(root); - - while (!queue.isEmpty()) { - TreeNode node = queue.poll(); - - if (sb.length() > 1) { - sb.append(", "); - } - if (node == null) { - sb.append("null"); - continue; - } - - sb.append(node.val); - - queue.add(node.left); - queue.add(node.right); - } - - sb.append("]"); - return removeExtraNulls(sb.toString()); - } - - private static String removeExtraNulls(String data) { - int i = data.length() - 1; - while (!(data.charAt(i) >= 48 && data.charAt(i) <= 57)) { - i--; - } - return data.substring(0, i + 1) + "]"; - } - - /** - * - * @param data - * @return - */ - public static TreeNode deserialize(String data) { - data = data.substring(1, data.length() - 1); - - if (data.length() == 0) { - return null; - } - - String[] values = data.split(", "); - - TreeNode root = new TreeNode(Integer.parseInt(values[0])); - - Queue queue = new LinkedList<>(); - queue.add(root); - - for (int i = 0; i < values.length && !queue.isEmpty(); i += 2) { - TreeNode currNode = queue.poll(); - - if (i + 1 < values.length && !values[i + 1].equals("null")) { - TreeNode leftNode = new TreeNode(Integer.parseInt(values[i + 1])); - currNode.left = leftNode; - queue.add(leftNode); - } - - if (i + 2 < values.length && !values[i + 2].equals("null")) { - TreeNode rightNode = new TreeNode(Integer.parseInt(values[i + 2])); - currNode.right = rightNode; - queue.add(rightNode); - } - } - - return root; - } - - public static void main(String[] args) { - // TODO Convert the print statements to asserts - - System.out.println(serialize(new TreeNode(1))); - - /* - Binary Tree - - 1 - / \ - 2 3 - / \ - 4 5 - */ - TreeNode tree = new TreeNode(1); - tree.left = new TreeNode(2); - tree.right = new TreeNode(3); - tree.left.left = new TreeNode(4); - tree.left.right = new TreeNode(5); - - System.out.println(serialize(tree)); - - System.out.println(serialize(deserialize(serialize(tree)))); - - System.out.println(serialize(deserialize(serialize(null)))); - - TreeNode tree2 = new TreeNode(1); - tree2.right = new TreeNode(2); - tree2.right.right = new TreeNode(3); - tree2.right.right.right = new TreeNode(4); - tree2.right.right.right.right = new TreeNode(5); - tree2.right.right.right.right.right = new TreeNode(6); - tree2.right.right.right.right.right.right = new TreeNode(7); - tree2.right.right.right.right.right.right.right = new TreeNode(8); - - System.out.println(serialize(tree2)); - System.out.println(serialize(deserialize(serialize(tree2)))); - - System.out.println("---"); - - System.out.println(serialize(deserialize("[1, 2]"))); - System.out.println(serialize(deserialize("[1, 2, 3]"))); - System.out.println(serialize(deserialize("[3, 2, 4, 1]"))); - System.out.println(serialize(deserialize("[3, 2, 4, 1, 5, 6]"))); - System.out.println(serialize(deserialize("[1, 2, 3, null, null, 4, 5]"))); - System.out.println(serialize(deserialize("[5, 2, 3, null, null, 2, 4, 3, 1]"))); - - System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5]"))); - System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5, null, 6]"))); - System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5, null, 6, null, 7]"))); - System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5, null, 6, null, 7, null, 8]"))); - System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5, null, 6, null, 7, null, 8, null, 9]"))); - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/trees/SymmetricTree.java b/src/main/java/com/leetcode/trees/SymmetricTree.java deleted file mode 100644 index 093d9a6f..00000000 --- a/src/main/java/com/leetcode/trees/SymmetricTree.java +++ /dev/null @@ -1,117 +0,0 @@ -package com.leetcode.trees; - -import java.util.LinkedList; -import java.util.Queue; - -import static org.junit.jupiter.api.Assertions.assertTrue; - -/** - * Level: Easy - * Problem Link: https://leetcode.com/problems/symmetric-tree/ - * Problem Description: - * Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center). - * - * For example, this binary tree [1,2,2,3,4,4,3] is symmetric: - * - * 1 - * / \ - * 2 2 - * / \ / \ - * 3 4 4 3 - * - * - * But the following [1,2,2,null,3,null,3] is not: - * - * 1 - * / \ - * 2 2 - * \ \ - * 3 3 - * - * - * Note: - * Bonus points if you could solve it both recursively and iteratively. - * - * @author rampatra - * @since 2019-07-25 - */ -public class SymmetricTree { - - /** - * Time Complexity: O(n) Because we traverse the entire input tree once, the total run time is O(n), where n is - * the total number of nodes in the tree. - * Space Complexity: O(n) The number of recursive calls is bound by the height of the tree. In the worst case, the - * tree is linear and the height is in O(n). Therefore, space complexity due to recursive calls on the stack is - * O(n) in the worst case. - * Runtime: 0 ms. - * - * @param root - * @return - */ - public static boolean isSymmetric(TreeNode root) { - if (root == null) { - return true; - } - - return isSymmetric(root.left, root.right); - } - - private static boolean isSymmetric(TreeNode leftRoot, TreeNode rightRoot) { - if (leftRoot == null && rightRoot == null) { - return true; - } else if (leftRoot == null || rightRoot == null) { - return false; - } - - return isSymmetric(leftRoot.left, rightRoot.right) && isSymmetric(leftRoot.right, rightRoot.left) && leftRoot.val == rightRoot.val; - } - - /** - * Time Complexity: O(n) Because we traverse the entire input tree once, the total run time is O(n), where n is the - * total number of nodes in the tree. - * Space Complexity: There is additional space required for the search queue. In the worst case, we have to - * insert O(n) nodes in the queue. Therefore, space complexity is O(n). - * Runtime: 1 ms. - * - * @param root - * @return - */ - public static boolean isSymmetricIterative(TreeNode root) { - if (root == null || (root.left == null && root.right == null)) return true; - if (root.left == null || root.right == null) return false; - - Queue queue = new LinkedList<>(); - queue.add(root.left); - queue.add(root.right); - - while (!queue.isEmpty()) { - TreeNode t1 = queue.poll(); - TreeNode t2 = queue.poll(); - - if (t1 == null && t2 == null) continue; - if (t1 == null || t2 == null) return false; - if (t1.val != t2.val) return false; - - // enqueue left and then right child of t1 but do the opposite for t2 - queue.add(t1.left); - queue.add(t2.right); - queue.add(t1.right); - queue.add(t2.left); - } - - return true; - } - - public static void main(String[] args) { - TreeNode root = new TreeNode(1); - root.left = new TreeNode(2); - root.right = new TreeNode(2); - root.left.left = new TreeNode(4); - root.left.right = new TreeNode(3); - root.right.left = new TreeNode(3); - root.right.right = new TreeNode(4); - - assertTrue(isSymmetric(root)); - assertTrue(isSymmetricIterative(root)); - } -} diff --git a/src/main/java/com/leetcode/trees/TreeNode.java b/src/main/java/com/leetcode/trees/TreeNode.java deleted file mode 100644 index 4c4c2569..00000000 --- a/src/main/java/com/leetcode/trees/TreeNode.java +++ /dev/null @@ -1,21 +0,0 @@ -package com.leetcode.trees; - -/** - * @author rampatra - * @since 2019-07-25 - */ -public class TreeNode { - - int val; - TreeNode left; - TreeNode right; - - public TreeNode(int val) { - this.val = val; - } - - @Override - public String toString() { - return val + ""; - } -} \ No newline at end of file diff --git a/src/main/java/com/leetcode/trie/LongestWord.java b/src/main/java/com/leetcode/trie/LongestWord.java deleted file mode 100644 index 155ea295..00000000 --- a/src/main/java/com/leetcode/trie/LongestWord.java +++ /dev/null @@ -1,78 +0,0 @@ -package com.leetcode.trie; - -import java.util.HashMap; -import java.util.Stack; - -/** - * Level: Easy - * Problem: https://leetcode.com/problems/longest-word-in-dictionary/ - * - * @author rampatra - * @since 2019-04-10 - */ -public class LongestWord { - - private class TrieNode { - char ch; - HashMap children = new HashMap<>(); - String completeWord; // to mark a complete word in the trie data structure - - TrieNode(char ch) { - this.ch = ch; - } - } - - private TrieNode root = new TrieNode('0'); - - /** - * Inserts {@code data} in trie. - * - * @param str - */ - public void insert(String str) { - char c; - TrieNode curr = root; - - for (int i = 0; i < str.length(); i++) { - c = str.charAt(i); - curr.children.putIfAbsent(c, new TrieNode(c)); - curr = curr.children.get(c); - } - - curr.completeWord = str; - } - - public String longestWord(String[] words) { - for (int i = 0; i < words.length; i++) { - insert(words[i]); - } - - return longestWord(); - } - - private String longestWord() { - String longestWord = ""; - TrieNode curr; - Stack stack = new Stack<>(); - stack.addAll(root.children.values()); - - while (!stack.empty()) { - curr = stack.pop(); - if (curr.completeWord != null) { - if (curr.completeWord.length() > longestWord.length() || - (curr.completeWord.length() == longestWord.length() && - curr.completeWord.compareTo(longestWord) < 0)) { - longestWord = curr.completeWord; - } - stack.addAll(curr.children.values()); - } - } - return longestWord; - } - - public static void main(String[] args) { - LongestWord longestWord = new LongestWord(); - System.out.println(longestWord.longestWord(new String[]{"w", "wo", "wor", "worl", "world"})); - System.out.println(longestWord.longestWord(new String[]{"a", "banana", "app", "appl", "ap", "apply", "apple"})); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/arrays/ArrangeNosToFormBiggestNo.java b/src/main/java/com/rampatra/arrays/ArrangeNosToFormBiggestNo.java deleted file mode 100644 index ce069e34..00000000 --- a/src/main/java/com/rampatra/arrays/ArrangeNosToFormBiggestNo.java +++ /dev/null @@ -1,50 +0,0 @@ -package com.rampatra.arrays; - -import java.util.Arrays; - -/** - * Created by IntelliJ IDEA. - * - * @author rampatra - * @since 11/1/15 - */ -public class ArrangeNosToFormBiggestNo { - - /** - * Sorts {@code numbers} such that if you form a number {@code n} - * by concatenating digits in order a[0]....a[size], it results being the - * largest number possible. - *

- * For example, - * I/P: {54, 546, 548, 60} - * O/P: {60, 548, 546, 54}, i.e, 6054854654 - *

- * I/P: {1, 34, 3, 98, 9, 76, 45, 4} - * O/P: {9, 98, 76, 45, 4, 34, 3, 1}, i.e, 998764543431 - * - * @param numbers input integer array - * @return integer array where if you concatenate all its elements, you will get the largest number - */ - private static Integer[] arrangeArrayOfNosToFormBiggestNo(Integer[] numbers) { - - Arrays.sort(numbers, (o1, o2) -> Integer.parseInt(o1 + "" + o2) >= Integer.parseInt(o2 + "" + o1) ? -1 : 1); - - /* - Use the below version (without lambda) if you use JDK < 8 - - Arrays.sort(numbers, new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return Integer.parseInt(o1 + "" + o2) >= Integer.parseInt(o2 + "" + o1) ? -1 : 1; - } - }); - */ - return numbers; - } - - public static void main(String[] args) { - System.out.println(Arrays.toString(arrangeArrayOfNosToFormBiggestNo(new Integer[]{45, 567, 12, 1}))); - System.out.println(Arrays.toString(arrangeArrayOfNosToFormBiggestNo(new Integer[]{54, 546, 548, 60}))); - System.out.println(Arrays.toString(arrangeArrayOfNosToFormBiggestNo(new Integer[]{1, 34, 3, 98, 9, 76, 45, 4}))); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/arrays/CountDivisors.java b/src/main/java/com/rampatra/arrays/CountDivisors.java deleted file mode 100644 index 3023dc3c..00000000 --- a/src/main/java/com/rampatra/arrays/CountDivisors.java +++ /dev/null @@ -1,35 +0,0 @@ -package com.rampatra.arrays; - -/** - * @author rampatra - * @since 31/05/2016 - */ -public class CountDivisors { - - /** - * Counts the number of integers in the range {@code begin} - * and {@code end} that are divisible by {@code n}. - * - * @param begin - * @param end - * @param n - * @return - */ - private static int countDivisorsInRange(int begin, int end, int n) { - int b = end / n + 1; // From 0 to end the integers divisible by n - int a = begin / n + 1; // From 0 to begin the integers divisible by n - - if (begin % n == 0) { // "begin" is inclusive; if divisible by n then - --a; // remove 1 from "a" - } - return b - a; // return integers in range - } - - public static void main(String[] args) { - System.out.println(countDivisorsInRange(0, 0, 5)); - System.out.println(countDivisorsInRange(1, 1, 5)); - System.out.println(countDivisorsInRange(0, 1, 5)); - System.out.println(countDivisorsInRange(0, 10, 5)); - System.out.println(countDivisorsInRange(0, 2000000000, 5)); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/arrays/DistinctPairs.java b/src/main/java/com/rampatra/arrays/DistinctPairs.java deleted file mode 100644 index 3ba861ab..00000000 --- a/src/main/java/com/rampatra/arrays/DistinctPairs.java +++ /dev/null @@ -1,50 +0,0 @@ -package com.rampatra.arrays; - -import java.util.HashSet; -import java.util.Set; - -/** - * Level: Easy - * Problem Description: - * Given an array and a target sum, return the number of distinct pairs whose sum is equal to the target sum. - *

- * For Example, given an array [1, 2, 3, 6, 7, 8, 9, 1] and a target sum of 10, - * the 7 pairs, i.e, (1, 9), (2, 8), (3, 7), (8, 2), (9, 1), (9, 1), and (1, 9) all sum to 10 but there are only - * three distinct pairs, i.e, (1, 9), (2, 8), and (3, 7) so the answer would be 3. - * - * @author rampatra - * @since 2019-06-03 - */ -public class DistinctPairs { - - /** - * Time complexity: O(n), n = size of the array - * Space complexity: O(n) - * - * @param arr - * @param targetSum - * @return - */ - private static int numberOfDistinctPairs(int[] arr, int targetSum) { - Set numSet = new HashSet<>(); - Set> pairSet = new HashSet<>(); - - for (int i = 0; i < arr.length; i++) { - if (numSet.contains(targetSum - arr[i])) { - Set pair = new HashSet<>(); - pair.add(arr[i]); - pair.add(targetSum - arr[i]); - pairSet.add(pair); - } - numSet.add(arr[i]); - } - - return pairSet.size(); - } - - public static void main(String[] args) { - System.out.println(numberOfDistinctPairs(new int[]{1, 2, 3, 6, 7, 8, 9, 1}, 1)); - System.out.println(numberOfDistinctPairs(new int[]{1, 2, 3, 6, 7, 8, 9, 1}, 2)); - System.out.println(numberOfDistinctPairs(new int[]{1, 2, 3, 6, 7, 8, 9, 1}, 10)); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/arrays/FlattenArray.java b/src/main/java/com/rampatra/arrays/FlattenArray.java deleted file mode 100644 index e68c250b..00000000 --- a/src/main/java/com/rampatra/arrays/FlattenArray.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.rampatra.arrays; - -import java.util.ArrayList; -import java.util.List; - -public class FlattenArray { - - /** - * Given a nested array like [[1, 2], 3, [4]], return an array like [1, 2, 3, 4, 5]. - * - * @param nestedArray an Object array - * @return a list of all elements in the nestedArray but all at the same level - */ - private static List flattenArray(Object[] nestedArray) { - if (nestedArray == null || nestedArray.length == 0) return new ArrayList<>(); - - List flattenedArray = new ArrayList<>(); - - for (Object obj : nestedArray) { - if (obj instanceof Object[]) { - flattenedArray.addAll(flattenArray((Object[]) obj)); - } else if (obj instanceof Integer) { - flattenedArray.add((Integer) obj); - } - } - - return flattenedArray; - } - - public static void main(String[] args) { - System.out.println(flattenArray(null)); - System.out.println(flattenArray(new Object[]{null})); - System.out.println(flattenArray(new Object[]{new Object[]{}})); - System.out.println(flattenArray(new Object[]{new Object[]{1, 2}})); - System.out.println(flattenArray(new Object[]{1, 2, new Object[]{4, 5}, 6})); - System.out.println(flattenArray(new Object[]{new Object[]{4, 5}, 1, 2, 6})); - System.out.println(flattenArray(new Object[]{1, 2, 6, new Object[]{4, 5}})); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/arrays/LongestConsecutiveSubsequence.java b/src/main/java/com/rampatra/arrays/LongestConsecutiveSubsequence.java deleted file mode 100644 index 8e6a99f8..00000000 --- a/src/main/java/com/rampatra/arrays/LongestConsecutiveSubsequence.java +++ /dev/null @@ -1,80 +0,0 @@ -package com.rampatra.arrays; - -import java.util.HashSet; -import java.util.Set; - -/** - * @author rampatra - * @since 25/11/2018 - */ -public class LongestConsecutiveSubsequence { - - /** - * Given an array of distinct integers, find the length of the longest sub-sequence such that - * elements in the subsequence are consecutive integers, the consecutive numbers can be in any order. - *

- * Examples: - * Input: arr[] = {1, 9, 3, 10, 4, 20, 2}; - * Output: 4 - * The subsequence {1, 3, 4, 2} is the longest subsequence - * of consecutive elements - *

- * Input: arr[] = {36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42} - * Output: 5 - * The subsequence {36, 35, 33, 34, 32} is the longest subsequence - * of consecutive elements. - *

- * NOTE: You can also sort this array and check for consecutive elements. You can take this approach if interviewer - * asks to solve with no additional space but do bear in mind that some sorting algorithms do require extra space. - * - * @param arr unsorted array of non-repeating integers - * @return the length of the longest consecutive subsequence - */ - private static int findLengthOfLongestConsecutiveSubsequence(int[] arr) { - int longestSubseqCount = 0; - int subseqCount; - int currElem; - // add all numbers to a set to have O(1) time complexity for searching elements - Set numSet = new HashSet<>(); - for (int n : arr) { - numSet.add(n); - } - - for (int n : arr) { - subseqCount = 1; - currElem = n; - // check for the next consecutive elements - while (numSet.contains(currElem + 1)) { - numSet.remove(currElem); - numSet.remove(currElem + 1); - currElem++; - subseqCount++; - } - // check for the previous consecutive elements - while (numSet.contains(currElem - 1)) { - numSet.remove(currElem); - numSet.remove(currElem - 1); - currElem--; - subseqCount++; - } - // update longest counter if the length of the current subsequence is larger - if (subseqCount > longestSubseqCount) { - longestSubseqCount = subseqCount; - } - } - return longestSubseqCount; - } - - public static void main(String[] args) { - - System.out.println("{1, 9, 3, 10, 4, 20, 2}: " + - findLengthOfLongestConsecutiveSubsequence(new int[]{1, 9, 3, 10, 4, 20, 2})); - System.out.println("{36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42}: " + - findLengthOfLongestConsecutiveSubsequence(new int[]{36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42})); - System.out.println("{1,5,8,3}: " + findLengthOfLongestConsecutiveSubsequence(new int[]{1, 5, 8, 3})); - - // corner cases - System.out.println("{1}: " + findLengthOfLongestConsecutiveSubsequence(new int[]{1})); - System.out.println("{}: " + findLengthOfLongestConsecutiveSubsequence(new int[]{})); - } -} diff --git a/src/main/java/com/rampatra/arrays/MaxSpan.java b/src/main/java/com/rampatra/arrays/MaxSpan.java deleted file mode 100644 index 7db17c18..00000000 --- a/src/main/java/com/rampatra/arrays/MaxSpan.java +++ /dev/null @@ -1,45 +0,0 @@ -package com.rampatra.arrays; - -import com.sun.tools.javac.util.Assert; - -/** - * Consider the leftmost and rightmost appearances of some value in an array. We'll say that the "span" is the - * number of elements between the two inclusive. A single value has a span of 1. Returns the largest span found - * in the given array. - *

- * Examples: - * maxSpan([1, 2, 1, 1, 3]) → 4 - * maxSpan([1, 4, 2, 1, 4, 1, 4]) → 6 - * maxSpan([1, 4, 2, 1, 4, 4, 4]) → 6 - *

- * Level: Easy - * - * @author rampatra - * @link https://codingbat.com/prob/p189576 - * @since 2019-01-23 - */ -public class MaxSpan { - - public static int maxSpan(int[] nums) { - if (nums.length == 0) return 0; - int largestSpan = 1; - for (int i = 0; i < nums.length; i++) { - for (int j = nums.length - 1; j > i; j--) { - if (nums[i] == nums[j]) { - if (j - i + 1 > largestSpan) { - largestSpan = j - i + 1; - } - } - } - } - return largestSpan; - } - - public static void main(String[] args) { - Assert.check(maxSpan(new int[]{1, 2, 1, 1, 3}) == 4); - Assert.check(maxSpan(new int[]{1, 4, 2, 1, 4, 1, 4}) == 6); - Assert.check(maxSpan(new int[]{1, 4, 2, 1, 4, 4, 4}) == 6); - Assert.check(maxSpan(new int[]{1}) == 1); - Assert.check(maxSpan(new int[]{}) == 0); - } -} diff --git a/src/main/java/com/rampatra/arrays/NthSmallestNumber.java b/src/main/java/com/rampatra/arrays/NthSmallestNumber.java deleted file mode 100644 index 8f7fbaf1..00000000 --- a/src/main/java/com/rampatra/arrays/NthSmallestNumber.java +++ /dev/null @@ -1,61 +0,0 @@ -package com.rampatra.arrays; - -/** - * A Google Interview Question. For a simpler version of this question see {@link SmallestAndSecondSmallest}. - * - * @author rampatra - * @since 2019-02-01 - */ -public class NthSmallestNumber { - - /** - * Given an unsorted array of integers, find the nth smallest integer in the array in most optimized way possible. - *

- * Approach: Similar to Quick Sort where in every iteration, we choose a pivot element and shift all lesser integers - * to left and higher integers to the right. After doing this we compare the pivot index with n and recursively call - * the method accordingly. See {@link com.rampatra.sorting.QuickSort}. - * - * @param arr the input unsorted array of integers - * @param n nth smallest integer to find - * @param start the start index in the array to search (inclusive) - * @param end the last index in the array to search (inclusive) - * @return the nth smallest integer, {@code -1} if invalid input - */ - private static int findNthSmallestNumber(int[] arr, int n, int start, int end) { - if (arr.length == 0 || arr.length < n) { - return -1; - } - int temp; - int lastBigger = start; - for (int i = start; i < end; i++) { - if (arr[i] < arr[end]) { - temp = arr[i]; - arr[i] = arr[lastBigger]; - arr[lastBigger] = temp; - lastBigger++; - } - } - temp = arr[lastBigger]; - arr[lastBigger] = arr[end]; - arr[end] = temp; - - if (lastBigger + 1 < n) { - return findNthSmallestNumber(arr, n, lastBigger + 1, end); - } else if (lastBigger + 1 > n) { - return findNthSmallestNumber(arr, n, start, lastBigger - 1); - } else { - return arr[lastBigger]; - } - } - - public static void main(String[] args) { - System.out.println(findNthSmallestNumber(new int[]{}, 3, 0, 5)); - System.out.println(findNthSmallestNumber(new int[]{0, 1}, 3, 0, 1)); - System.out.println(findNthSmallestNumber(new int[]{0, 1}, 2, 0, 1)); - System.out.println(findNthSmallestNumber(new int[]{1, 0}, 2, 0, 1)); - System.out.println(findNthSmallestNumber(new int[]{2, 3, 5, 10, 9, 4}, 3, 0, 5)); - System.out.println(findNthSmallestNumber(new int[]{2, 3, 4, 10, 9, 4}, 3, 0, 5)); - System.out.println(findNthSmallestNumber(new int[]{4, 4, 4, 4, 4, 4}, 3, 0, 5)); - System.out.println(findNthSmallestNumber(new int[]{4, 8, 1, 9, 10, 2, 7, 3, 2, 6}, 3, 0, 9)); // TODO: doesn't work with duplicates currently - } -} diff --git a/src/main/java/com/rampatra/arrays/PivotedBinarySearch.java b/src/main/java/com/rampatra/arrays/PivotedBinarySearch.java deleted file mode 100644 index 2f104e6f..00000000 --- a/src/main/java/com/rampatra/arrays/PivotedBinarySearch.java +++ /dev/null @@ -1,74 +0,0 @@ -package com.rampatra.arrays; - -import com.rampatra.searching.BinarySearch; - -/** - * Created by IntelliJ IDEA. - * - * @author rampatra - * @since 5/31/15 - */ -public class PivotedBinarySearch { - - /** - * Search an element in a sorted pivoted array {@code arr}. - *

- * Example, - * 1) For array [3,4,5,1,2] pivot is 5 - * 2) For array [6,7,8,5,4] pivot is 8 - * - * @param arr - * @param n - * @return - */ - public static int pivotedBinarySearch(int[] arr, int n) { - int pivot = findPivotIndex(arr, 0, arr.length - 1); - - if (pivot == -1 || arr[pivot] == n) { - return pivot; - } else if (n < arr[0]) { - return BinarySearch.binarySearch(arr, n, pivot + 1, arr.length - 1); - } else { - return BinarySearch.binarySearch(arr, n, 0, pivot - 1); - } - } - - /** - * Finds the pivot element in array {@code arr}. Pivot element is the only - * element for which next element to it is smaller than it. - * - * @param arr - * @param low - * @param high - * @return the index of the pivot element in the {@code arr}. - */ - public static int findPivotIndex(int[] arr, int low, int high) { - if (low > high) return -1; - - int mid = (low + high) / 2; - - if (mid == 0 || mid == arr.length - 1) return -1; - - if (arr[mid] > arr[mid + 1] && arr[mid] > arr[mid - 1]) { - return mid; - } else if (arr[mid] > arr[mid - 1] && arr[mid] < arr[mid + 1]) { - return findPivotIndex(arr, mid + 1, arr.length - 1); - } else { - return findPivotIndex(arr, 0, mid - 1); - } - } - - public static void main(String[] args) { - System.out.println("Pivot: " + findPivotIndex(new int[]{3, 4, 5, 1, 2}, 0, 4)); - System.out.println("Index: " + pivotedBinarySearch(new int[]{3, 4, 5, 1, 2}, 5)); - - System.out.println("Pivot: " + findPivotIndex(new int[]{1, 2, 3, 4, 5}, 0, 4)); - System.out.println("Index: " + pivotedBinarySearch(new int[]{1, 2, 3, 4, 5}, 4)); - - System.out.println("Pivot: " + findPivotIndex(new int[]{5, 4, 3, 2, 1}, 0, 4)); - System.out.println("Index: " + pivotedBinarySearch(new int[]{5, 4, 3, 2, 1}, 4)); - - System.out.println("Pivot: " + findPivotIndex(new int[]{5}, 0, -1)); - System.out.println("Index: " + pivotedBinarySearch(new int[]{5}, -1)); - } -} diff --git a/src/main/java/com/rampatra/arrays/RotatedIndex.java b/src/main/java/com/rampatra/arrays/RotatedIndex.java deleted file mode 100644 index 4478e5e3..00000000 --- a/src/main/java/com/rampatra/arrays/RotatedIndex.java +++ /dev/null @@ -1,55 +0,0 @@ -package com.rampatra.arrays; - -/** - * @author rampatra - * @since 2019-04-04 - */ -public class RotatedIndex { - - private static int findIndexOfRotationPoint(String[] words) { - return findIndexOfRotationPoint(words, 0, words.length - 1); - } - - private static int findIndexOfRotationPoint(String[] words, int start, int end) { - if (start > end) return -1; - - int mid = (start + end) / 2; - - if (mid == 0 || mid == words.length - 1) return -1; - - if (words[mid].compareTo(words[mid - 1]) < 0 && words[mid].compareTo(words[mid + 1]) < 0) { - return mid; - } else if (words[mid].compareTo(words[mid - 1]) > 0 && words[mid].compareTo(words[mid + 1]) < 0) { - return findIndexOfRotationPoint(words, start, mid - 1); - } else { - return findIndexOfRotationPoint(words, mid + 1, end); - } - } - - public static void main(String[] args) { - System.out.println(findIndexOfRotationPoint(new String[]{ - "ptolemaic", - "retrograde", - "supplant", - "undulate", - "xenoepist", - "asymptote", // <-- rotates here! - "babka", - "banoffee", - "engender", - "karpatka", - "othellolagkage", - })); - - System.out.println(findIndexOfRotationPoint(new String[]{})); - - System.out.println(findIndexOfRotationPoint(new String[]{ - "asymptote", - "babka", - "banoffee", - "engender", - "karpatka", - "othellolagkage", - })); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/base/Graph.java b/src/main/java/com/rampatra/base/Graph.java deleted file mode 100644 index 0de77ba1..00000000 --- a/src/main/java/com/rampatra/base/Graph.java +++ /dev/null @@ -1,10 +0,0 @@ -package com.rampatra.base; - -/** - * A rudimentary Graph having all the basic methods. - * - * @author rampatra - * @since 2019-02-10 - */ -public class Graph> { -} diff --git a/src/main/java/com/rampatra/base/GraphNode.java b/src/main/java/com/rampatra/base/GraphNode.java deleted file mode 100644 index 90f98478..00000000 --- a/src/main/java/com/rampatra/base/GraphNode.java +++ /dev/null @@ -1,37 +0,0 @@ -package com.rampatra.base; - -import java.util.HashSet; -import java.util.Set; - -/** - * The class for a node in a graph. Ideally, you should make member variable {@code private} and have - * getters, setters, etc. but to keep it simple, I have omitted all those boilerplate code. - * - * @author rampatra - * @since 2019-02-10 - */ -public class GraphNode> { - public E value; - public Set> adjacentNodes = new HashSet<>(); - - public GraphNode(E value) { - this(value, null); - } - - public GraphNode(E value, Set> adjacentNodes) { - this.value = value; - if (adjacentNodes != null) { - this.adjacentNodes = adjacentNodes; - } - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - GraphNode graphNode = (GraphNode) o; - - return value.equals(graphNode.value); - } -} diff --git a/src/main/java/com/rampatra/base/Trie.java b/src/main/java/com/rampatra/base/Trie.java deleted file mode 100644 index 65cb7cbb..00000000 --- a/src/main/java/com/rampatra/base/Trie.java +++ /dev/null @@ -1,91 +0,0 @@ -package com.rampatra.base; - -import java.util.HashMap; - -/** - * Trie also called digital tree and sometimes radix tree or prefix tree (as they can be - * searched by prefixes), is an ordered tree data structure that is used to store a dynamic - * set or associative array where the keys are usually strings. - *

- * You can think it as HashMap of HashMap of HashMap and so on. Each key in the HashMap is a - * single digit/letter of the data you want to store and {@code data} is the final full word - * you want to save in trie. - *

- * Some resources: - * Trie Data Structure - * More about Tries - * Video explanation from Gayle McDowell - * - * @author rampatra - * @since 9/22/15 - */ -public class Trie { - - private class TrieNode { - char ch; - HashMap> children = new HashMap<>(); - boolean isCompleteWord; // to mark a complete word in the tri data structure - - TrieNode(char ch) { - this.ch = ch; - } - } - - private TrieNode root; - - Trie() { - root = new TrieNode<>('0'); - } - - /** - * Inserts {@code data} in trie. - * - * @param str - */ - public void insert(String str) { - char c; - TrieNode curr = root; - - for (int i = 0; i < str.length(); i++) { - c = str.charAt(i); - curr.children.putIfAbsent(c, new TrieNode<>(c)); - curr = curr.children.get(c); - } - - curr.isCompleteWord = true; - } - - /** - * Searches {@code data} in trie. - * - * @param str the value to search. - * @return {@code true} if {@code str} is present, {@code false} otherwise. - */ - public boolean search(String str) { - - TrieNode curr = root; - - for (int i = 0; i < str.length(); i++) { - if (curr.children.get(str.charAt(i)) == null) { - return false; - } - curr = curr.children.get(str.charAt(i)); - } - - return curr.isCompleteWord; - } - - // unit testing - public static void main(String[] args) { - Trie trie = new Trie(); - trie.insert("ram"); - trie.insert("r"); - trie.insert("rama"); - trie.insert("rampatra"); - System.out.println(trie.search("ram")); - System.out.println(trie.search("r")); - System.out.println(trie.search("ra")); - System.out.println(trie.search("raz")); - System.out.println(trie.search("rampatra")); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/base/UndirectedGraph.java b/src/main/java/com/rampatra/base/UndirectedGraph.java deleted file mode 100644 index 661fa45a..00000000 --- a/src/main/java/com/rampatra/base/UndirectedGraph.java +++ /dev/null @@ -1,166 +0,0 @@ -package com.rampatra.base; - -import java.util.ArrayDeque; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.Map; -import java.util.Queue; -import java.util.Set; -import java.util.stream.Collectors; - -/** - * @author rampatra - * @since 2019-02-14 - */ -public class UndirectedGraph> extends Graph { - // map for a fast lookup - private Map> nodes = new HashMap<>(); - - /** - * Adds an edge between a node with value {@code value} and another node with value {@code adjacentValue}. As the - * graph is undirected, the edges are added in both the nodes. If nodes with respective values are not present in - * the graph then this method creates the nodes. - * - * @param value refers to the value for first node - * @param adjacentValue refers to the value for the second node - * @return the node with value {@code value}, or the first node - */ - public GraphNode addEdge(E value, E adjacentValue) { - GraphNode node = nodes.get(value); - GraphNode adjNode = nodes.get(adjacentValue); - if (node == null && value != null) { - node = new GraphNode<>(value); - nodes.put(value, node); - } - if (adjNode == null && adjacentValue != null) { - adjNode = new GraphNode<>(adjacentValue); - nodes.put(adjacentValue, adjNode); - } - if (node != null && adjNode != null) { - node.adjacentNodes.add(adjNode); - adjNode.adjacentNodes.add(node); // as this is an undirected graph - } - return node; - } - - /** - * Method to check whether {@code src} and {@code dest} nodes are connected by depth first search (DFS). - * - * @param src source node in graph - * @param dest destination node in graph - * @return {@code true} if there is a path from {@code src} to {@code dest}, {@code false} otherwise - */ - public boolean hasPathDFS(E src, E dest) { - GraphNode s = nodes.get(src); - GraphNode d = nodes.get(dest); - Set> visited = new HashSet<>(); // to save all visited nodes so that we do not visit them again - return hasPathDFS(s, d, visited); - } - - private boolean hasPathDFS(GraphNode src, GraphNode dest, Set> visited) { - if (src == null || dest == null) { - return false; - } - if (src.value.compareTo(dest.value) == 0) { - return true; - } else if (!visited.contains(src)) { - visited.add(src); - for (GraphNode node : src.adjacentNodes) { - if (hasPathDFS(node, dest, visited)) { - return true; - } - } - } - return false; - } - - /** - * Method to check whether {@code src} and {@code dest} nodes are connected by breadth first search (BFS). - * - * @param src source node in graph - * @param dest destination node in graph - * @return {@code true} if there is a path from {@code src} to {@code dest}, {@code false} otherwise - */ - public boolean hasPathBFS(E src, E dest) { - GraphNode s = nodes.get(src); - GraphNode d = nodes.get(dest); - if (s == null || d == null) { - return false; - } - Set> visited = new HashSet<>(); - Queue> toVisit = new ArrayDeque<>(); - toVisit.add(s); - return hasPathBFS(d, visited, toVisit); - } - - private boolean hasPathBFS(GraphNode dest, Set> visited, Queue> toVisit) { - while (!toVisit.isEmpty()) { - GraphNode node = toVisit.poll(); - if (visited.contains(node)) { - continue; - } else { - visited.add(node); - } - toVisit.addAll(node.adjacentNodes.stream().filter(n -> !visited.contains(n)).collect(Collectors.toList())); - if (node.value.compareTo(dest.value) == 0) { - return true; - } - } - return false; - } - - - /** - * Prints the node values in the graph. - */ - public void print() { - Set visited = new HashSet<>(); - System.out.print("["); - Iterator iterator = nodes.keySet().iterator(); - while (iterator.hasNext()) { - E node = iterator.next(); - if (!visited.contains(node)) { - visited.add(node); - System.out.print(node); - if (iterator.hasNext()) { - System.out.print(", "); - } - } - } - System.out.println("]"); - } - - public static void main(String[] args) { - UndirectedGraph graph = new UndirectedGraph<>(); - graph.addEdge(1, 4); - graph.addEdge(4, 5); - graph.addEdge(4, 6); - graph.addEdge(4, 7); - graph.addEdge(5, 1); - graph.addEdge(5, 6); - graph.addEdge(8, null); - graph.addEdge(null, 9); - graph.print(); - - System.out.println("----"); - - // has path DFS - System.out.println(graph.hasPathDFS(1, 5)); - System.out.println(graph.hasPathDFS(1, 6)); - System.out.println(graph.hasPathDFS(1, 8)); - System.out.println(graph.hasPathDFS(4, 8)); - System.out.println(graph.hasPathDFS(4, 9)); - System.out.println(graph.hasPathDFS(4, 100)); - - System.out.println("----"); - - // has path BFS - System.out.println(graph.hasPathBFS(1, 5)); - System.out.println(graph.hasPathBFS(1, 6)); - System.out.println(graph.hasPathBFS(1, 8)); - System.out.println(graph.hasPathBFS(4, 8)); - System.out.println(graph.hasPathBFS(4, 9)); - System.out.println(graph.hasPathBFS(4, 100)); - } -} diff --git a/src/main/java/com/rampatra/bits/BinaryString.java b/src/main/java/com/rampatra/bits/BinaryString.java deleted file mode 100644 index ad0ffb84..00000000 --- a/src/main/java/com/rampatra/bits/BinaryString.java +++ /dev/null @@ -1,28 +0,0 @@ -package com.rampatra.bits; - -/** - * @author rampatra - * @since 2019-03-21 - */ -public class BinaryString { - - /** - * Returns the binary representation of a {@code byte}. - * - * @param b a byte. - * @return the binary representation of the input byte. - */ - private static String toBinaryString(byte b) { - StringBuilder sb = new StringBuilder(); - for (int i = 0; i < Byte.SIZE; i++) { - sb.append(b & (byte) 1); - b >>= 1; - } - return sb.reverse().toString(); - } - - public static void main(String[] args) { - System.out.println(toBinaryString((byte) 0xff)); - System.out.println(toBinaryString((byte) (0xff >> 3))); - } -} diff --git a/src/main/java/com/rampatra/bits/README.md b/src/main/java/com/rampatra/bits/README.md deleted file mode 100644 index 30119f20..00000000 --- a/src/main/java/com/rampatra/bits/README.md +++ /dev/null @@ -1,122 +0,0 @@ -# Bits - -## Basic Operators - -#### AND: - -| x | y | x `&` y | -----|---|:-------:| -| 0 | 0 | 0 | -| 0 | 1 | 0 | -| 1 | 0 | 0 | -| 1 | 1 | 1 | - -#### OR: - -| x | y | x `\|` y | -|---|---|:--------:| -| 0 | 0 | 0 | -| 0 | 1 | 1 | -| 1 | 0 | 1 | -| 1 | 1 | 1 | - -#### XOR: - -| x | y | x `^` y | -|---|---|:-------:| -| 0 | 0 | 0 | -| 0 | 1 | 1 | -| 1 | 0 | 1 | -| 1 | 1 | 0 | - - -## Shifts - -_Disclaimer: We are taking `byte` (8 bits) as our datatype to explain the - concepts instead of the usual integer._ - -#### 1. Left Shift (<<): - -1 << 3 = 8 - -> 00000001 << 3 = 00001000 - -#### 2. Right Shift: - -**Two types:** - -**a. Signed Right Shift (>>):** - -64 >> 2 = 16 - -> 001000000 >> 2 = 00010000 - --64 >> 2 = -16 - -> 111000000 >> 2 = 11110000 - -**b. Unsigned Right Shift (>>>):** - -64 >>> 2 = 16 - -> 001000000 >>> 2 = 00010000 - --64 >>> 2 = 56 - -> 111000000 >>> 2 = 00111000 - -## Helpful Masks - -#### 1. Set the 4th bit from right: - -```java -byte mask = 1 << 3; -``` - -Explanation, - -``` -00000001 << 3 = 00001000 -``` - -#### 2. Set the first 3 bits from right: - -```java -byte mask = (1 << 3) - 1; -``` - -Explanation, - -``` -00000001 << 3 = 00001000 - -00001000 - 00000001 = 00000111 -``` - -#### 3. Mask with alternating 1010...10 - -```java -byte mask = 0x55; -``` - -#### 4. Mask with alternating 0101...01 - -```java -byte mask = 0xaa; -``` - -#### 5. Unset the 4th bit - -```java -byte mask = 1 << 3; - -byte num = num & ~mask; -``` - -Explanation, - -``` -00000001 << 3 = 00001000 - -~(00001000) = 11110111 -``` \ No newline at end of file diff --git a/src/main/java/com/rampatra/bits/ShiftByNegativeNumber.java b/src/main/java/com/rampatra/bits/ShiftByNegativeNumber.java deleted file mode 100644 index 4acd83b3..00000000 --- a/src/main/java/com/rampatra/bits/ShiftByNegativeNumber.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.rampatra.bits; - -/** - * Understanding shifting in Java. What happens when you shift a number by a negative number. - * - * @author rampatra - * @link https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.19 - * @link https://stackoverflow.com/a/10516830/1385441 - * @since 18/11/2018 - */ -public class ShiftByNegativeNumber { - /** - * These both are the same as in java if the left operand is int only the low five bits are considered - * for shifting and if the left operand is a long then the low six bits are considered. - * Binary representation of -2 is 11.....11110. The last 5 bits are 11110 which is 30. - * - * @param args - */ - public static void main(String[] args) { - int v1 = 1 << -2; - int v2 = 1 << 30; - System.out.println(v1); - System.out.println(v2); - } -} diff --git a/src/main/java/com/rampatra/blockchain/Block.java b/src/main/java/com/rampatra/blockchain/Block.java deleted file mode 100644 index 8ba8eab5..00000000 --- a/src/main/java/com/rampatra/blockchain/Block.java +++ /dev/null @@ -1,87 +0,0 @@ -package com.rampatra.blockchain; - -import java.io.Serializable; - -/** - * @author rampatra - * @since 2019-03-05 - */ -public class Block implements Serializable { - - private int index; - private String previousHash; - private long timestamp; - private String data; - private String hash; - private int nonce; - - public Block(int index, String previousHash, long timestamp, String data, String hash, int nonce) { - this.index = index; - this.previousHash = previousHash; - this.timestamp = timestamp; - this.data = data; - this.hash = hash; - this.nonce = nonce; - } - - public int getIndex() { - return index; - } - - public void setIndex(int index) { - this.index = index; - } - - public String getPreviousHash() { - return previousHash; - } - - public void setPreviousHash(String previousHash) { - this.previousHash = previousHash; - } - - public long getTimestamp() { - return timestamp; - } - - public void setTimestamp(long timestamp) { - this.timestamp = timestamp; - } - - public String getData() { - return data; - } - - public void setData(String data) { - this.data = data; - } - - public String getHash() { - return hash; - } - - public void setHash(String hash) { - this.hash = hash; - } - - public int getNonce() { - return nonce; - } - - public void setNonce(int nonce) { - this.nonce = nonce; - } - - @Override - public String toString() { - final StringBuilder sb = new StringBuilder("Block{"); - sb.append("index=").append(index); - sb.append(", previousHash='").append(previousHash).append('\''); - sb.append(", timestamp=").append(timestamp); - sb.append(", data='").append(data).append('\''); - sb.append(", hash='").append(hash).append('\''); - sb.append(", nonce=").append(nonce); - sb.append('}'); - return sb.toString(); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/blockchain/Blockchain.java b/src/main/java/com/rampatra/blockchain/Blockchain.java deleted file mode 100644 index 58fe7813..00000000 --- a/src/main/java/com/rampatra/blockchain/Blockchain.java +++ /dev/null @@ -1,182 +0,0 @@ -package com.rampatra.blockchain; - -import java.nio.charset.StandardCharsets; -import java.security.MessageDigest; -import java.security.NoSuchAlgorithmException; -import java.util.Date; -import java.util.List; -import java.util.ListIterator; - -/** - * @author rampatra - * @since 2019-03-05 - */ -public class Blockchain { - - private List blocks; - private int difficulty; - - public Blockchain(List blocks, int difficulty) { - this.blocks = blocks; - this.difficulty = difficulty; - this.blocks.add(getGenesisBlock()); - } - - public List getBlocks() { - return blocks; - } - - public int getSize() { - return blocks.size(); - } - - public Block getLatestBlock() { - if (blocks.isEmpty()) return null; - - return blocks.get(blocks.size() - 1); - } - - public void addBlock(Block block) { - blocks.add(block); - } - - /** - * Mine, create a new block with the {@code data}, and finally, add it to the blockchain. - *

- * Mining is nothing but the process of calculating a hash of a {@link Block} with {@code data} such - * that the hash starts with a specific number of zeros equal to the difficulty of the blockchain. - * - * @param data - * @return - */ - public Block mine(String data) { - Block previousBlock = getLatestBlock(); - Block nextBlock = getNextBlock(previousBlock, data); - - if (isValidNextBlock(previousBlock, nextBlock)) { - blocks.add(nextBlock); - return nextBlock; - } else { - throw new RuntimeException("Invalid block"); - } - } - - /** - * Executes the {@link Blockchain#isValidNextBlock(Block, Block)} on the entire blockchain. - * - * @return {@code false} if at least one block in the blockchain is invalid, {@code true} otherwise. - */ - public boolean isValidChain() { - ListIterator listIterator = blocks.listIterator(); - listIterator.next(); - while (listIterator.hasPrevious() && listIterator.hasNext()) { - if (!isValidNextBlock(listIterator.previous(), listIterator.next())) { - return false; - } - } - return true; - } - - /** - * Creates the Genesis Block for the blockchain. The Genesis Block is the first block in the blockchain. - * - * @return the genesis block - */ - private Block getGenesisBlock() { - final long timestamp = new Date().getTime(); - int nonce = 0; - String data = "Blockchain in Java"; - String hash; - while (!isValidHashDifficulty(hash = calculateHashForBlock(0, "0", timestamp, data, nonce))) { - nonce++; - } - - return new Block(0, "0", timestamp, data, hash, nonce); - } - - private Block getNextBlock(Block previousBlock, String data) { - final int index = previousBlock.getIndex() + 1; - final long timestamp = new Date().getTime(); - int nonce = 0; - String hash; - while (!isValidHashDifficulty( - hash = calculateHashForBlock(index, previousBlock.getHash(), timestamp, data, nonce))) { - nonce++; - } - return new Block(index, previousBlock.getHash(), timestamp, data, hash, nonce); - } - - private boolean isValidNextBlock(Block previousBlock, Block nextBlock) { - - String nextBlockHash = calculateHashForBlock(nextBlock.getIndex(), previousBlock.getHash(), - nextBlock.getTimestamp(), nextBlock.getData(), nextBlock.getNonce()); - - if (previousBlock.getIndex() + 1 != nextBlock.getIndex()) { - return false; - } else if (!previousBlock.getHash().equals(nextBlock.getPreviousHash())) { - return false; - } else if (!this.isValidHashDifficulty(nextBlockHash)) { - return false; - } else if (!nextBlockHash.equals(nextBlock.getHash())) { - return false; - } else { - return true; - } - } - - /** - * Checks if the hash respects the difficulty of the blockchain, i.e, if the hash - * begins with a number of zeros equal to the difficulty of the blockchain. - * - * @param hash the SHA256 hash of the block. - * @return {@code true} if hash obeys difficulty, {@code false} otherwise. - */ - private boolean isValidHashDifficulty(String hash) { - for (int i = 0; i < difficulty; i++) { - if (hash.charAt(i) != '0') { - return false; - } - } - return true; - } - - /** - * Calculates the SHA256 hash of the block. - * - * @param index - * @param previousHash - * @param timestamp - * @param data - * @param nonce - * @return the SHA256 hash of the block. - */ - private String calculateHashForBlock(final int index, final String previousHash, final long timestamp, - final String data, final int nonce) { - try { - MessageDigest digest = MessageDigest.getInstance("SHA-256"); - byte[] encodedhash = digest.digest( - (index + previousHash + timestamp + data + nonce).getBytes(StandardCharsets.UTF_8)); - return bytesToHex(encodedhash); - } catch (NoSuchAlgorithmException e) { - throw new RuntimeException("Encryption Error: {}", e); - } - } - - private static String bytesToHex(byte[] hash) { - StringBuilder hexString = new StringBuilder(); - for (int i = 0; i < hash.length; i++) { - String hex = Integer.toHexString(0xff & hash[i]); - if (hex.length() == 1) hexString.append('0'); - hexString.append(hex); - } - return hexString.toString(); - } - - @Override - public String toString() { - final StringBuilder sb = new StringBuilder("Blockchain{"); - sb.append("blocks=").append(blocks); - sb.append('}'); - return sb.toString(); - } -} diff --git a/src/main/java/com/rampatra/blockchain/Message.java b/src/main/java/com/rampatra/blockchain/Message.java deleted file mode 100644 index 9bebbae5..00000000 --- a/src/main/java/com/rampatra/blockchain/Message.java +++ /dev/null @@ -1,70 +0,0 @@ -package com.rampatra.blockchain; - -import java.io.Serializable; - -/** - * @author rampatra - * @since 2019-03-10 - */ -public class Message implements Serializable { - - enum MessageType { - REQUEST_LATEST_BLOCK, - RECEIVE_LATEST_BLOCK, - REQUEST_BLOCKCHAIN, - RECEIVE_BLOCKCHAIN - } - - private MessageType messageType; - private Block latestBlock; - private Blockchain blockchain; - - - public MessageType getMessageType() { - return messageType; - } - - public Block getLatestBlock() { - return latestBlock; - } - - public Blockchain getBlockchain() { - return blockchain; - } - - public static final class MessageBuilder { - private MessageType messageType; - private Block latestBlock; - private Blockchain blockchain; - - private MessageBuilder() { - } - - public static MessageBuilder aMessage() { - return new MessageBuilder(); - } - - public MessageBuilder withMessageType(MessageType messageType) { - this.messageType = messageType; - return this; - } - - public MessageBuilder withLatestBlock(Block latestBlock) { - this.latestBlock = latestBlock; - return this; - } - - public MessageBuilder withBlockchain(Blockchain blockchain) { - this.blockchain = blockchain; - return this; - } - - public Message build() { - Message message = new Message(); - message.latestBlock = this.latestBlock; - message.blockchain = this.blockchain; - message.messageType = this.messageType; - return message; - } - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/blockchain/MessageHandler.java b/src/main/java/com/rampatra/blockchain/MessageHandler.java deleted file mode 100644 index 52aaf328..00000000 --- a/src/main/java/com/rampatra/blockchain/MessageHandler.java +++ /dev/null @@ -1,123 +0,0 @@ -package com.rampatra.blockchain; - -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.net.Socket; -import java.net.SocketException; - -/** - * @author rampatra - * @since 2019-03-10 - */ -public class MessageHandler implements Runnable { - - private ObjectInputStream in; - private ObjectOutputStream out; - private Peer peer; - - MessageHandler(Socket client, Peer peer) { - try { - in = new ObjectInputStream(client.getInputStream()); - out = new ObjectOutputStream(client.getOutputStream()); - this.peer = peer; - } catch (IOException e) { - throw new RuntimeException(e); - } - } - - @Override - public void run() { - Message message; - try { - while ((message = (Message) in.readObject()) != null) { - handleMessage(message); - } - } catch (Exception e) { - if (!(e instanceof SocketException)) { - throw new RuntimeException(e); - } - } finally { - try { - in.close(); - out.close(); - } catch (Exception e) { - // do nothing - } - } - } - - /** - * Handle messages accordingly. - * - * @param message is the message object from the peer. - */ - private void handleMessage(Message message) { - Message.MessageType type = message.getMessageType(); - switch (type) { - case REQUEST_LATEST_BLOCK: - sendMessage(Message.MessageBuilder - .aMessage() - .withMessageType(Message.MessageType.RECEIVE_LATEST_BLOCK) - .withLatestBlock(peer.getBlockchain().getLatestBlock()) - .build()); - break; - case RECEIVE_LATEST_BLOCK: - handleLatestBlock(message.getLatestBlock()); - break; - case REQUEST_BLOCKCHAIN: - sendMessage(Message.MessageBuilder - .aMessage() - .withMessageType(Message.MessageType.RECEIVE_BLOCKCHAIN) - .withBlockchain(peer.getBlockchain()) - .build()); - break; - case RECEIVE_BLOCKCHAIN: - handleBlockchain(message.getBlockchain()); - break; - default: - throw new RuntimeException("Unknown message type"); - } - } - - private void sendMessage(Message message) { - try { - out.writeObject(message); - } catch (IOException e) { - throw new RuntimeException(e); - } - } - - /** - * If the latest block received from the peer has {@code previousHash} equal to the hash of the - * latest block in the current user's blockchain then add the latest block received to the - * current user's blockchain, or else, if the latest block received has a larger index then - * request the entire blockchain from the peer. - * - * @param latestBlock the block received from the peer - */ - private void handleLatestBlock(Block latestBlock) { - Block latestBlockWithCurrentPeer = peer.getBlockchain().getLatestBlock(); - - if (latestBlock.getPreviousHash().equals(latestBlockWithCurrentPeer.getHash())) { - peer.getBlockchain().addBlock(latestBlock); - } else if (latestBlock.getIndex() > latestBlockWithCurrentPeer.getIndex()) { - sendMessage(Message.MessageBuilder - .aMessage() - .withMessageType(Message.MessageType.REQUEST_BLOCKCHAIN) - .build()); - } - } - - /** - * If the blockchain received from the peer is valid and longer then replace current user's - * blockchain with the received blockchain. - * - * @param blockchain the entire blockchain received from the peer - */ - private void handleBlockchain(Blockchain blockchain) { - if (blockchain.isValidChain() && blockchain.getSize() > peer.getBlockchain().getSize()) { - peer.setBlockchain(blockchain); - } - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/blockchain/P2P.java b/src/main/java/com/rampatra/blockchain/P2P.java deleted file mode 100644 index c8c65ac6..00000000 --- a/src/main/java/com/rampatra/blockchain/P2P.java +++ /dev/null @@ -1,135 +0,0 @@ -package com.rampatra.blockchain; - -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; -import java.util.Scanner; - -/** - * @author rampatra - * @since 2019-03-09 - */ -public class P2P { - - private static List peers = new ArrayList<>(); - private static int lastUsedPort = 4000; - - public static Peer addPeer(Blockchain blockchain) { - Peer peer = new Peer(blockchain, lastUsedPort++); - peers.add(peer); - return peer; - } - - public static void removePeer(int index) { - Peer peer = peers.get(index); - peer.stopServer(); - peers.remove(index); - } - - public static void removePeer(Peer peer) { - Iterator iterator = peers.iterator(); - while (iterator.hasNext()) { - if (iterator.next().equals(peer)) { - peer.stopServer(); - iterator.remove(); - break; - } - } - } - - public static void removeAllPeers() { - Iterator iterator = peers.iterator(); - while (iterator.hasNext()) { - Peer peer = iterator.next(); - peer.stopServer(); - iterator.remove(); - } - } - - public static Peer getPeer(int index) { - return peers.get(index); - } - - public static List getPeers() { - return peers; - } - - public static void showPeers() { - for (int i = 0; i < peers.size(); i++) { - System.out.println("Peer " + (i + 1) + ": " + peers.get(i).getPort()); - } - } - - public static void showPeersWithBlockchain() { - for (int i = 0; i < peers.size(); i++) { - System.out.println("Peer " + (i + 1) + " (" + peers.get(i).getPort() + "): " + peers.get(i).getBlockchain()); - } - } - - /** - * The main starting point of the blockchain demo. At first, add some peers (option 1) and mine some data - * by choosing a particular peer (option 2). You would soon see that the newly mined block is broadcast to - * all the peers. - * - * @param args - */ - public static void main(String[] args) { - try { - int menuChoice; - int peerIndex; - String data; - Scanner s = new Scanner(System.in); - Blockchain blockchain = new Blockchain(new ArrayList<>(), 3); - - while (true) { - - System.out.println("\n======= Welcome to Blockchain in Java ======="); - System.out.println("1. Add Peer"); - System.out.println("2. Mine data in peer"); - System.out.println("3. Remove peer"); - System.out.println("4. Show peers"); - System.out.println("5. Exit"); - - menuChoice = s.nextInt(); - - switch (menuChoice) { - case 1: - P2P.addPeer(blockchain); - System.out.println("New peer added!"); - P2P.showPeersWithBlockchain(); - break; - case 2: - System.out.println("Choose peer: (a number for ex. 1, 2, etc.)"); - P2P.showPeers(); - peerIndex = s.nextInt(); - Peer p = P2P.getPeer(peerIndex - 1); - System.out.println("Enter data: (a string with no spaces)"); - data = s.next(); - p.mine(data); - System.out.println("Data mined!"); - P2P.showPeersWithBlockchain(); - break; - case 3: - System.out.println("Choose peer: (a number for ex. 1, 2, etc.)"); - P2P.showPeers(); - peerIndex = s.nextInt(); - P2P.removePeer(peerIndex - 1); - System.out.println("Peer " + peerIndex + " removed!"); - P2P.showPeersWithBlockchain(); - break; - case 4: - P2P.showPeersWithBlockchain(); - break; - case 5: - P2P.removeAllPeers(); - System.out.println("Bye, see you soon!"); - System.exit(0); - default: - System.out.println("Wrong choice!"); - } - } - } catch (Exception e) { - throw new RuntimeException(e); - } - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/blockchain/Peer.java b/src/main/java/com/rampatra/blockchain/Peer.java deleted file mode 100644 index fcb34632..00000000 --- a/src/main/java/com/rampatra/blockchain/Peer.java +++ /dev/null @@ -1,120 +0,0 @@ -package com.rampatra.blockchain; - -import java.io.ObjectOutputStream; -import java.net.ServerSocket; -import java.net.Socket; -import java.util.List; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.stream.Collectors; - -/** - * @author rampatra - * @since 2019-03-09 - */ -public class Peer { - - private Blockchain blockchain; - private int port; - private ServerSocket server; - private ExecutorService executor = Executors.newSingleThreadExecutor(); - - Peer(Blockchain blockchain, int port) { - this.blockchain = blockchain; - this.port = port; - startServer(); - getLatestBlockFromPeers(); - } - - /** - * Once a new peer is created, we start the socket server to receive messages from the peers. - */ - private void startServer() { - try { - executor.submit(() -> { - server = new ServerSocket(port); - while (true) { - // we create a new thread for each new client thereby supporting multiple client simultaneously - new Thread(new MessageHandler(server.accept(), this)).start(); - } - }); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - /** - * Stop the server once a peer is removed from the network. - */ - public void stopServer() { - try { - if (!server.isClosed()) { - server.close(); - } - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - /** - * Once a new peer is created and added to the network, it requests the latest block from - * all the peers and updates its blockchain if it is outdated. - */ - private void getLatestBlockFromPeers() { - sendMessageToPeers(Message.MessageBuilder - .aMessage() - .withMessageType(Message.MessageType.REQUEST_LATEST_BLOCK) - .build()); - } - - private void sendMessageToPeers(Message message) { - try { - // send to all peers except itself - List peers = P2P.getPeers() - .stream() - .filter(peer -> !(peer.port == this.port)) - .collect(Collectors.toList()); - for (Peer peer : peers) { - Socket client = new Socket("127.0.0.1", peer.port); - ObjectOutputStream out = new ObjectOutputStream(client.getOutputStream()); - out.writeObject(message); - } - } catch (Exception e) { - throw new RuntimeException(e); - } - } - - /** - * Mine, create a new block with the {@code data}, and finally, add it to the blockchain. - * - * @param data - */ - public void mine(String data) { - Block latestBlock = this.blockchain.mine(data); - sendMessageToPeers(Message.MessageBuilder - .aMessage().withMessageType(Message.MessageType.RECEIVE_LATEST_BLOCK) - .withLatestBlock(latestBlock) - .build()); - } - - public Blockchain getBlockchain() { - return blockchain; - } - - public void setBlockchain(Blockchain blockchain) { - this.blockchain = blockchain; - } - - public int getPort() { - return port; - } - - @Override - public String toString() { - final StringBuilder sb = new StringBuilder("Peer{"); - sb.append("blockchain=").append(blockchain); - sb.append(", port=").append(port); - sb.append('}'); - return sb.toString(); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/database/README.md b/src/main/java/com/rampatra/database/README.md deleted file mode 100644 index 0ea2737c..00000000 --- a/src/main/java/com/rampatra/database/README.md +++ /dev/null @@ -1,76 +0,0 @@ -# Relational Database (WIP) - -A __relational database__ is a digital database based on -the [relational model](https://en.wikipedia.org/wiki/Relational_model) of -data. In simple words, it is a collection of data items with pre-defined -relationships between them. These items are organized as a set of tables, -with columns and rows. Each column stores some specific attribute of an object/entity and the -row represents a specific object/entity. - -A software system used to maintain relational databases is a __relational -database management system (RDBMS)__, for e.g., MySQL, Oracle DB, PostgreSQL, etc. -Virtually all relational database systems use __SQL (Structured Query Language)__ -for querying and maintaining the database. - -## Basic Definitions - -1. Primary Key - -2. Candidate Key - -3. Composite Key - -4. Prime/Non-prime attribute - -## Types of SQL commands - -1. DDL -2. DML -3. DCL -4. TCL - -| Type | Command List | -|-------|-------------------| -| DDL | CREATE | -| | DROP | -| | ALTER | -| | RENAME | -| | TRUNCATE | -| | | -| DML | SELECT | -| | INSERT | -| | UPDATE | -| | DELETE | -| | | -| DCL | GRANT | -| | REVOKE | -| | | -| TCL | START TRANSACTION | -| | COMMIT | -| | ROLLBACK | - -## Types of Joins - -1. Inner Join -2. Left Outer Join -3. Right Outer Join -4. Full Join -5. Self Join - -## Normalization Forms - -1. 1NF -2. 2NF -3. 3NF -4. BCNF -5. 4NF -6. 5NF - -#### 1NF - -Required conditions: - -a. All values should be atomic (non-breakable). -b. There should be a candidate key or a composite key (basically you should be able to uniquely identify all records in the table). - - \ No newline at end of file diff --git a/src/main/java/com/rampatra/dynamicprogramming/MaximumRectangleOf1sInMatrix.java b/src/main/java/com/rampatra/dynamicprogramming/MaximumRectangleOf1sInMatrix.java deleted file mode 100644 index b49f55b6..00000000 --- a/src/main/java/com/rampatra/dynamicprogramming/MaximumRectangleOf1sInMatrix.java +++ /dev/null @@ -1,79 +0,0 @@ -package com.rampatra.dynamicprogramming; - -import com.rampatra.stacks.MaxRectangleAreaInHistogram; - -/** - * Given a 2D matrix of 0s and 1s. Find the largest rectangle of all 1s in this matrix. - *

- * Level: Hard - * Time Complexity: O(rows * cols) - * Space Complexity: O(cols) - *

- * Note: If the number of cols is too large as compared to rows then you can process the matrix column-wise and create - * the histogram for each column. In this way the hist[] array will be of size = number of rows in the matrix. - * - * @author rampatra - * @since 2019-04-05 - */ -public class MaximumRectangleOf1sInMatrix { - - private static int getMaxRectangleSizeOf1s(int[][] binaryMatrix) { - int area; - int maxArea = 0; - int[] hist = new int[binaryMatrix[0].length]; - - /* - Create a histogram with the rows. Start with the first row, create a histogram and then extend this - histogram based on the elements in the next rows. If the element in the row is a 0 then make the bar in - the histogram 0 or else just increase the bar in the histogram. - - Basically, we are creating a histogram with all the 1s in the matrix and then finding the maximum - rectangle size of this histogram. - */ - for (int row = 0; row < binaryMatrix.length; row++) { - for (int col = 0; col < binaryMatrix[0].length; col++) { - if (binaryMatrix[row][col] == 0) { - hist[col] = 0; - } else { - hist[col] += binaryMatrix[row][col]; - } - } - area = MaxRectangleAreaInHistogram.getMaxRectangleArea(hist); - maxArea = Math.max(maxArea, area); - } - return maxArea; - } - - public static void main(String[] args) { - System.out.println(getMaxRectangleSizeOf1s( - new int[][]{{0, 1, 1}, - {0, 0, 1}, - {0, 1, 1}})); - - System.out.println(getMaxRectangleSizeOf1s( - new int[][]{{0, 1, 1, 1, 0}, - {0, 0, 1, 1, 0}, - {0, 1, 1, 1, 0}})); - - System.out.println(getMaxRectangleSizeOf1s( - new int[][]{{1, 1, 1, 0}, - {1, 1, 1, 1}, - {0, 1, 1, 0}, - {0, 1, 1, 1}, - {1, 0, 0, 1}, - {1, 1, 1, 1}})); - - // edge cases - System.out.println(getMaxRectangleSizeOf1s( - new int[][]{{}})); - - System.out.println(getMaxRectangleSizeOf1s( - new int[][]{{0}})); - - System.out.println(getMaxRectangleSizeOf1s( - new int[][]{{0, 0, 0}})); - - System.out.println(getMaxRectangleSizeOf1s( - new int[][]{{1}})); - } -} diff --git a/src/main/java/com/rampatra/java8/DateTime.java b/src/main/java/com/rampatra/java8/DateTime.java deleted file mode 100644 index c564b7b4..00000000 --- a/src/main/java/com/rampatra/java8/DateTime.java +++ /dev/null @@ -1,29 +0,0 @@ -package com.rampatra.java8; - -import java.time.Instant; -import java.time.LocalDateTime; -import java.time.ZoneId; -import java.util.Date; - -/** - * @author rampatra - * @since 2019-05-15 - */ -public class DateTime { - - private static long getCurrentTimestampFromInstant() { - return Instant.now().toEpochMilli(); - } - - private static String addTwoDays() { - LocalDateTime now = LocalDateTime.ofInstant(Instant.now(), ZoneId.of("UTC")); - LocalDateTime afterTwoDays = now.plusDays(2); - return afterTwoDays.getDayOfMonth() + "-" + afterTwoDays.getMonthValue() + "-" + afterTwoDays.getYear(); - } - - public static void main(String[] args) { - System.out.println("Timestamp from Instant: " + getCurrentTimestampFromInstant() + - "\nTimestamp from Legacy Date: " + new Date().getTime()); - System.out.println("Add Two days: " + addTwoDays()); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/java8/FlatMapInStreams.java b/src/main/java/com/rampatra/java8/FlatMapInStreams.java deleted file mode 100644 index e5258deb..00000000 --- a/src/main/java/com/rampatra/java8/FlatMapInStreams.java +++ /dev/null @@ -1,67 +0,0 @@ -package com.rampatra.java8; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -/** - * @author rampatra - * @version 17/02/2017 - */ -public class FlatMapInStreams { - - public static long countTotalIngredientsInAllDishes(List dishes) { - return dishes.stream() - .map(Dish::getIngredients) - .flatMap(List::stream) - .count(); - } - - public static void main(String[] args) { - List ingredients = new ArrayList<>(); - ingredients.add("rice"); - ingredients.add("chicken"); - ingredients.add("haldi"); - List dishes = Arrays.asList( - new Dish("biriyani", 600, ingredients), - new Dish("pulao", 600, new ArrayList<>())); - // to show whether empty List is counted in flatMap - System.out.println(countTotalIngredientsInAllDishes(dishes)); - } -} - -class Dish { - private String name; - private int calories; - private List ingredients; - - public Dish(String name, int calories, List ingredients) { - this.name = name; - this.calories = calories; - this.ingredients = ingredients; - } - - public String getName() { - return name; - } - - public void setName(String name) { - this.name = name; - } - - public int getCalories() { - return calories; - } - - public void setCalories(int calories) { - this.calories = calories; - } - - public List getIngredients() { - return ingredients; - } - - public void setIngredients(List ingredients) { - this.ingredients = ingredients; - } -} diff --git a/src/main/java/com/rampatra/java8/Lambdas.java b/src/main/java/com/rampatra/java8/Lambdas.java deleted file mode 100644 index 2450d80c..00000000 --- a/src/main/java/com/rampatra/java8/Lambdas.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.rampatra.java8; - -import java.util.function.Consumer; - -/** - * @author rampatra - * @version 21/02/2017 - */ -public class Lambdas { - - private int a = 1; - - public void testScopeOfLambda(Consumer consumer) { - consumer.accept("Lambda"); - } - - public static void main(String[] args) { - Lambdas l = new Lambdas(); - l.testScopeOfLambda(x -> System.out.println(x)); - l.testScopeOfLambda(x -> System.out.println(x + l.a)); - l.a = 2; - l.testScopeOfLambda(x -> System.out.println(x + l.a)); - /*for (int i = 0; i < 10; i++) { - l.testScopeOfLambda(x -> System.out.println(x + i)); - }*/ - /*l.testScopeOfLambda(x -> { - int a = 2; - System.out.println(x + l.a); - });*/ - l.testScopeOfLambda(new Consumer() { - int a = 2; - - @Override - public void accept(String s) { - - } - }); - } -} diff --git a/src/main/java/com/rampatra/java8/Streams.java b/src/main/java/com/rampatra/java8/Streams.java deleted file mode 100644 index 86cd0336..00000000 --- a/src/main/java/com/rampatra/java8/Streams.java +++ /dev/null @@ -1,153 +0,0 @@ -package com.rampatra.java8; - -import java.util.Arrays; -import java.util.List; - -import static java.util.Comparator.comparing; -import static java.util.stream.Collectors.toList; - -/** - * @author rampatra - * @version 02/02/2017 - */ -class Trader { - - private final String name; - private final String city; - - public Trader(String n, String c) { - this.name = n; - this.city = c; - } - - public String getName() { - return this.name; - } - - public String getCity() { - return this.city; - } - - public String toString() { - return "Trader:" + this.name + " in " + this.city; - } -} - -class Transaction { - private final Trader trader; - private final int year; - private final int value; - - public Transaction(Trader trader, int year, int value) { - this.trader = trader; - this.year = year; - this.value = value; - } - - public Trader getTrader() { - return this.trader; - } - - public int getYear() { - return this.year; - } - - public int getValue() { - return this.value; - } - - public String toString() { - return "{" + this.trader + ", " + - "year: " + this.year + ", " + - "value:" + this.value + "}"; - } -} - -public class Streams { - - static final Trader raoul = new Trader("Raoul", "Cambridge"); - static final Trader mario = new Trader("Mario", "Milan"); - static final Trader alan = new Trader("Alan", "Cambridge"); - static final Trader brian = new Trader("Brian", "Cambridge"); - - static final List transactions = Arrays.asList( - new Transaction(brian, 2011, 300), - new Transaction(raoul, 2012, 1000), - new Transaction(raoul, 2011, 400), - new Transaction(mario, 2012, 710), - new Transaction(mario, 2012, 700), - new Transaction(alan, 2012, 950) - ); - - public static List getTransactionsIn2011SortedByValue() { - return transactions.stream() - .filter(t -> t.getYear() == 2011) - .sorted(comparing(Transaction::getValue)) - .collect(toList()); - } - - public static List findUniqueCities() { - return transactions.stream() - .map(t -> t.getTrader().getCity()) - .distinct() - .collect(toList()); - } - - public static List getAllTradersFromCambridgeAndSortByName() { - return transactions.stream() - .map(Transaction::getTrader) - .filter(traders -> traders.getCity().equals("Cambridge")) - .distinct() - .sorted(comparing(Trader::getName)) - .collect(toList()); - } - - public static List getAllTraderNamesAndSortByName() { - return transactions.stream() - .map(t -> t.getTrader().getName()) - .distinct() - .sorted() - .collect(toList()); - } - - public static boolean areAnyTradersFromMilan() { - return transactions.stream() - .anyMatch(t -> "Milan".equals(t.getTrader().getCity())); - } - - public static Integer[] getAllTransValuesFromTradersInCambridge() { - return transactions.stream() - .filter(t -> "Cambridge".equals(t.getTrader().getCity())) - .map(Transaction::getValue) - .toArray(Integer[]::new); - } - - public static int findHighestTransactionValue() { - return transactions.stream() - .mapToInt(Transaction::getValue) - .max().getAsInt(); - - /* this is another solution - return transactions.stream() - .map(Transaction::getValue) - .reduce((t1, t2) -> (t1 > t2) ? t1 : t2) // you can replace with .reduce(Integer::max) - .get();*/ - } - - public static Transaction getSmallestTransaction() { - return transactions.stream() - .reduce((t1, t2) -> t1.getValue() < t2.getValue() ? t1 : t2) - .get(); - } - - public static void main(String[] args) { - System.out.println("1: " + getTransactionsIn2011SortedByValue()); - System.out.println("2: " + findUniqueCities()); - System.out.println("3: " + getAllTradersFromCambridgeAndSortByName()); - System.out.println("4: " + getAllTraderNamesAndSortByName()); - System.out.println("5: " + areAnyTradersFromMilan()); - System.out.println("6: " + Arrays.asList(getAllTransValuesFromTradersInCambridge())); - System.out.println("7: " + findHighestTransactionValue()); - System.out.println("8: " + getSmallestTransaction()); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/linkedlists/DetectAndRemoveLoop.java b/src/main/java/com/rampatra/linkedlists/DetectAndRemoveLoop.java deleted file mode 100644 index 5ad549d4..00000000 --- a/src/main/java/com/rampatra/linkedlists/DetectAndRemoveLoop.java +++ /dev/null @@ -1,105 +0,0 @@ -package com.rampatra.linkedlists; - -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; - -/** - * See this Stackoverflow post to understand - * how to find the starting node of the loop. - *

- * Proof for Flyod's Loop Detection Algorithm: - *

- * Suppose fastRunner had just skipped over slowRunner. fastRunner would only be 1 node ahead of slowRunner, since their - * speeds differ by only 1. So we would have something like this: - *

- * [ ] -> [s] -> [f] - *

- * What would the step right before this "skipping step" look like? fastRunner would be 2 nodes back, and slowRunner - * would be 1 node back. But wait, that means they would be at the same node! So fastRunner didn't skip over slowRunner! - * (This is a proof by contradiction.) - * - * @author rampatra - * @since 7/1/15 - */ -public class DetectAndRemoveLoop { - - /** - * Detects loop, if any, in {@code list} and removes it. - *

- * Approach: - * 1) Use Floyd's cycle detection algorithm to detect loop. - * 2) Acc. to FCD, once the fast pointer meets the slow pointer we conclude that there is a loop. - * 4) Now that we have concluded there is a loop, let's detect the starting node and remove the loop: - * i. Move the slow pointer to head. - * ii. Now, move both slow and fast pointer at same pace and where they meet is the starting point of the loop. - * iii. Lastly, to remove the loop make the next of the node (before the starting point of loop) to null. - * - * Proof for Floyd's Cycle Detection: Consider a cyclic list and imagine the slow and fast pointers are two runners - * racing around a circle track. The fast runner will eventually meet the slow runner. Why? Consider this case - - * The fast runner is just one step behind the slow runner. In the next iteration, they both increment one and two - * steps respectively and meet each other. - * - * @param list - * @param - * @return {@code true} if loop exists {@code false} otherwise. - */ - public static > boolean detectAndRemoveLoop(SingleLinkedList list) { - boolean isLoopPresent = false; - SingleLinkedNode slow = list.head, fast = list.head; - - while (fast != null && fast.next != null) { - slow = slow.next; - fast = fast.next.next; - if (slow == fast) { - isLoopPresent = true; - break; - } - } - - if (!isLoopPresent) return false; - - slow = list.head; - // move both pointers at same pace to determine the starting node of loop - while (true) { - slow = slow.next; - fast = fast.next; - if (slow == fast) { - fast.next = null; - break; - } - } - - return isLoopPresent; - } - - public static void main(String[] args) { - SingleLinkedList linkedList = new SingleLinkedList<>(); - linkedList.add(0); - linkedList.add(1); - linkedList.add(2); - linkedList.add(3); - linkedList.add(4); - linkedList.add(5); - linkedList.getNode(4).next = linkedList.getNode(2); - System.out.println(detectAndRemoveLoop(linkedList)); - linkedList.printList(); - - linkedList = new SingleLinkedList<>(); - linkedList.add(0); - linkedList.add(1); - linkedList.getNode(1).next = linkedList.getNode(0); - System.out.println(detectAndRemoveLoop(linkedList)); - linkedList.printList(); - - linkedList = new SingleLinkedList<>(); - linkedList.add(0); - System.out.println(detectAndRemoveLoop(linkedList)); - linkedList.printList(); - - linkedList = new SingleLinkedList<>(); - linkedList.add(0); - linkedList.getNode(0).next = linkedList.getNode(0); - System.out.println(detectAndRemoveLoop(linkedList)); - linkedList.printList(); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/linkedlists/LRUCache.java b/src/main/java/com/rampatra/linkedlists/LRUCache.java deleted file mode 100644 index ed046035..00000000 --- a/src/main/java/com/rampatra/linkedlists/LRUCache.java +++ /dev/null @@ -1,65 +0,0 @@ -package com.rampatra.linkedlists; - -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.Map; - -/** - * A simple LRU cache using {@link LinkedHashMap}. A special - * LinkedHashMap(capacity, loadFactor, accessOrderBoolean) constructor is - * provided to create a linked hash map whose order of iteration is the - * order in which its entries were last accessed, from least-recently - * accessed to most-recently. Invoking the put or get method results - * in an access to the corresponding entry. If the enclosing Map is - * access-ordered, it moves the entry to the end of the list; otherwise, - * it does nothing. - * See Javarticles.com. - * - * @author rampatra - * @since 7/8/15 - */ -public class LRUCache { - - private LinkedHashMap linkedHashMap; - - // initialize cache - LRUCache(final int size) { - this.linkedHashMap = new LinkedHashMap(size, .75f, true) { - @Override - protected boolean removeEldestEntry(Map.Entry eldest) { - return size() > size; - } - }; - } - - V add(E key, V value) { - return linkedHashMap.put(key, value); - } - - V get(E key) { - return linkedHashMap.get(key); - } - - private void print() { - Iterator iterator = linkedHashMap.keySet().iterator(); - while (iterator.hasNext()) { - System.out.print(iterator.next() + ((iterator.hasNext()) ? "," : "\n")); - } - } - - public static void main(String[] args) { - LRUCache cache = new LRUCache<>(3); - cache.add(1, 1); - cache.add(2, 2); - cache.add(3, 3); - cache.print(); // initial cache contents - - cache.add(4, 4); // should remove 1 as it was accessed last - cache.print(); - - cache.get(2); - cache.add(5, 5); // should remove 3 as 2 was recently accessed - cache.print(); - } -} diff --git a/src/main/java/com/rampatra/linkedlists/NthNodeFromLast.java b/src/main/java/com/rampatra/linkedlists/NthNodeFromLast.java deleted file mode 100644 index 871af6cf..00000000 --- a/src/main/java/com/rampatra/linkedlists/NthNodeFromLast.java +++ /dev/null @@ -1,75 +0,0 @@ -package com.rampatra.linkedlists; - -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; - -/** - * Created by IntelliJ IDEA. - * - * @author rampatra - * @since 6/18/15 - */ -public class NthNodeFromLast { - - /** - * @param list - * @param n - * @param - * @return - */ - public static > SingleLinkedNode getNthNodeFromLast(SingleLinkedList list, int n) { - SingleLinkedNode slow = list.getNode(0); - SingleLinkedNode fast = list.getNode(0); - // move the fast reference ahead of slow reference by 'n' nodes - for (int i = 0; i < n; i++) { - // assert length of linkedlist > n - fast = fast.next; - } - while (fast != null) { - slow = slow.next; - fast = fast.next; - } - return slow; - } - - public static void main(String[] args) { - SingleLinkedList linkedList = new SingleLinkedList<>(); - linkedList.add(0); - linkedList.add(1); - linkedList.add(2); - linkedList.add(3); - linkedList.add(4); - linkedList.add(5); - linkedList.add(6); - linkedList.add(7); - linkedList.add(8); - linkedList.printList(); - System.out.println("n=3: " + getNthNodeFromLast(linkedList, 3).item); - - SingleLinkedList linkedList2 = new SingleLinkedList<>(); - linkedList2.add(0); - linkedList2.add(1); - linkedList2.add(2); - linkedList2.add(3); - linkedList2.add(4); - linkedList2.add(5); - linkedList2.add(6); - linkedList2.add(7); - linkedList2.add(8); - linkedList2.printList(); - System.out.println("n=1: " + getNthNodeFromLast(linkedList2, 1).item); - - SingleLinkedList linkedList3 = new SingleLinkedList<>(); - linkedList3.add(0); - linkedList3.add(1); - linkedList3.add(2); - linkedList3.add(3); - linkedList3.add(4); - linkedList3.add(5); - linkedList3.add(6); - linkedList3.add(7); - linkedList3.add(8); - linkedList3.printList(); - System.out.println("n=9: " + getNthNodeFromLast(linkedList3, 9).item); - } -} diff --git a/src/main/java/com/rampatra/misc/DivideByZero.java b/src/main/java/com/rampatra/misc/DivideByZero.java deleted file mode 100644 index e879a783..00000000 --- a/src/main/java/com/rampatra/misc/DivideByZero.java +++ /dev/null @@ -1,15 +0,0 @@ -package com.rampatra.misc; - -/** - * Created by IntelliJ IDEA. - * User: rampatra - * Date: 4/18/15 - * Time: 2:50 PM - * To change this template go to Preferences | IDE Settings | File and Code Templates - */ -public class DivideByZero { - public static void main(String[] args) { - System.out.println(5.0 / 0); // doesn't throw any exception - System.out.println(5 / 0); // throws runtime exception or unchecked exception (does NOT need explicit handling). To be specific, throws an arithmetic exception. - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/misc/MapReduce.java b/src/main/java/com/rampatra/misc/MapReduce.java deleted file mode 100644 index a69df528..00000000 --- a/src/main/java/com/rampatra/misc/MapReduce.java +++ /dev/null @@ -1,74 +0,0 @@ -package com.rampatra.misc; - -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.stream.Collectors; - -/** - * A rudimentary example explaining the concept of Map/Reduce paradigm. The question is, provided a list of Person - * objects from various countries, compute the total population in each country. - * - * @author rampatra - * @since 2019-02-26 - */ -public class MapReduce { - - private static class Person { - String name; - int age; - String country; - - Person(String country) { - this.country = country; - } - } - - /** - * The mapper function will take all the data and output only the information which we need, and in this - * case, it is just the country name to which a person belongs. - * - * @param personList a list of all persons - * @return a list of country names - */ - private static List mapper(List personList) { - return personList.stream().map(person -> person.country).collect(Collectors.toList()); - } - - /** - * The reducer function will take all the useful information from the mapper function and then compute the result - * we need. In this case, it is to count the number of persons in each country. - * - * @param countryNamesOfAllPersons a list of country names taken out of all {@code Person} objects - * @return a map containing country names as the keys and their resp. population as values - */ - private static Map reducer(List countryNamesOfAllPersons) { - Map countryToPopulationMap = new HashMap<>(); - - countryNamesOfAllPersons.forEach(countryName -> { - countryToPopulationMap.computeIfPresent(countryName, (country, population) -> population + 1); - countryToPopulationMap.computeIfAbsent(countryName, country -> countryToPopulationMap.put(country, 1)); - }); - - return countryToPopulationMap; - } - - /** - * Just to print the output. - * - * @param countryToPopulationMap a map containing country names as the keys and their resp. population as values - */ - private static void printPopulation(Map countryToPopulationMap) { - countryToPopulationMap.forEach((k, v) -> System.out.println(k + ": " + v)); - } - - public static void main(String[] args) { - - Person[] persons = new Person[]{new Person("India"), new Person("Ireland"), - new Person("Sweden"), new Person("United States"), new Person("India"), - new Person("Ireland"), new Person("India")}; - - printPopulation(reducer(mapper(Arrays.asList(persons)))); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/misc/MapWithTimestamp.java b/src/main/java/com/rampatra/misc/MapWithTimestamp.java deleted file mode 100644 index 184656a7..00000000 --- a/src/main/java/com/rampatra/misc/MapWithTimestamp.java +++ /dev/null @@ -1,50 +0,0 @@ -package com.rampatra.misc; - -import java.util.Date; -import java.util.HashMap; -import java.util.Map; - -/** - * @author rampatra - * @since 2019-05-15 - */ -public class MapWithTimestamp { - - private final Map> map = new HashMap<>(); - - public V get(K key, Long timestamp) { - Map entry = map.get(key); - - return entry != null ? entry.get(timestamp) : null; - } - - public void put(K key, Long timestamp, V value) { - Map entry = map.get(key); - - if (entry == null) { - map.put(key, new HashMap() {{ - put(timestamp, value); - }}); - } else { - entry.put(timestamp, value); - } - } - - public static void main(String[] args) throws Exception { - MapWithTimestamp mapWithTimestamp = new MapWithTimestamp<>(); - long timestamp1; - long timestamp2; - long timestamp3; - - mapWithTimestamp.put(1, timestamp1 = new Date().getTime(), 10_0); - mapWithTimestamp.put(2, timestamp2 = new Date().getTime(), 20_0); - Thread.sleep(100); - mapWithTimestamp.put(2, new Date().getTime(), 20_1); - Thread.sleep(100); - mapWithTimestamp.put(2, new Date().getTime(), 20_2); - mapWithTimestamp.put(3, timestamp3 = new Date().getTime(), 30_0); - System.out.println(mapWithTimestamp.get(2, timestamp2)); - System.out.println(mapWithTimestamp.get(3, timestamp2)); - System.out.println(mapWithTimestamp.get(3, timestamp3)); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/misc/ReadFile.java b/src/main/java/com/rampatra/misc/ReadFile.java deleted file mode 100644 index c5c64540..00000000 --- a/src/main/java/com/rampatra/misc/ReadFile.java +++ /dev/null @@ -1,71 +0,0 @@ -package com.rampatra.misc; - -import java.io.BufferedReader; -import java.io.FileReader; -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.ArrayList; -import java.util.List; -import java.util.stream.Collectors; -import java.util.stream.Stream; - - -/** - * Various ways to read a file in Java. - * - * @author rampatra - * @since 2019-06-03 - */ -public class ReadFile { - - private static Stream readFile(String filePath) throws IOException { - return Files.lines(Paths.get(filePath)); // use Files.readAllLines() to return a List instead of Stream - } - - private static String readFile(Path filePath) throws IOException { - Stream lines = Files.lines(filePath); - String data = lines.collect(Collectors.joining("\n")); - lines.close(); - return data; - } - - private static List readLargeFile(Path filePath) throws IOException { - try (BufferedReader reader = Files.newBufferedReader(filePath)) { - List result = new ArrayList<>(); - for (; ; ) { - String line = reader.readLine(); - if (line == null) - break; - result.add(line); - } - return result; - } - } - - private static String readFileOldWay(String filePath) throws IOException { - try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) { - StringBuilder builder = new StringBuilder(); - String currentLine = reader.readLine(); - while (currentLine != null) { - builder.append(currentLine); - builder.append("\n"); - currentLine = reader.readLine(); - } - // reader.close(); not required as try-with-resources is used - - return builder.toString(); - } - } - - public static void main(String[] args) throws IOException { - readFile("src/main/java/com/rampatra/misc/reverseandadd.txt").forEach(System.out::println); - System.out.println("=================="); - System.out.println(readFile(Paths.get("src/main/java/com/rampatra/misc/reverseandadd.txt"))); - System.out.println("=================="); - System.out.println(readLargeFile(Paths.get("src/main/java/com/rampatra/misc/reverseandadd.txt"))); - System.out.println("=================="); - System.out.println(readFileOldWay("src/main/java/com/rampatra/misc/reverseandadd.txt")); - } -} diff --git a/src/main/java/com/rampatra/permutations/StringPermutationsWithDuplicates.java b/src/main/java/com/rampatra/permutations/StringPermutationsWithDuplicates.java deleted file mode 100644 index 21d31cb3..00000000 --- a/src/main/java/com/rampatra/permutations/StringPermutationsWithDuplicates.java +++ /dev/null @@ -1,27 +0,0 @@ -package com.rampatra.permutations; - -/** - * A slight variation of {@link StringPermutations} where the input may - * contain repeated characters. - * - * @author rampatra - * @since 16/11/2018 - */ -public class StringPermutationsWithDuplicates { - - /** - * Generates and prints all possible permutations (in order) - * of string {@param s}. - * - * @param prefix empty string, needed for the recursive method - * @param s input string with repeated characters - */ - public static void printAllPermutations(String prefix, String s) { - // TODO - } - - public static void main(String[] args) { - printAllPermutations("", "aba"); - } -} - diff --git a/src/main/java/com/rampatra/searching/BinarySearch.java b/src/main/java/com/rampatra/searching/BinarySearch.java deleted file mode 100644 index 26997658..00000000 --- a/src/main/java/com/rampatra/searching/BinarySearch.java +++ /dev/null @@ -1,81 +0,0 @@ -package com.rampatra.searching; - -/** - * Created by IntelliJ IDEA. - * - * @author rampatra - * @version 9/1/15 - */ -public class BinarySearch { - - /** - * Searches an element {@param n} in a sorted array {@param a} - * and returns its index in O(log n) time. The Index may not - * correspond to the first occurrence of the element. - * - * @param a sorted array to be searched - * @param n number to be searched in the array - * @return index of {@param n} or {@code -1} if not present - */ - private static int binarySearch(int[] a, int n) { - return binarySearch(a, n, 0, a.length - 1); - } - - public static int binarySearch(int[] a, int n, int low, int high) { - - if (low <= high) { - int mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2 - - if (n == a[mid]) { - return mid; - } else if (n < a[mid]) { - return binarySearch(a, n, 0, mid - 1); - } else { - return binarySearch(a, n, mid + 1, high); - } - } else { - return -1; - } - } - - /** - * Non-recursive version of binary search. - * - * @param a sorted array to be searched - * @param n number to be searched in the array - * @return index of {@param n} or {@code -1} if not present - */ - private static int binarySearchNonRecursive(int[] a, int n) { - int low = 0, high = a.length, mid; - while (low <= high) { - mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2 - if (n == a[mid]) { - return mid; - } else if (n < a[mid]) { - high = mid - 1; - } else { - low = mid + 1; - } - } - return -1; - } - - /** - * Driver for testing. - * - * @param a - */ - public static void main(String[] args) { - System.out.println(binarySearch(new int[]{0, 2}, 2)); - System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 2)); - System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 3)); - System.out.println(binarySearch(new int[]{0, 2}, 0)); - System.out.println(binarySearch(new int[]{0, 1, 2, 2, 2, 3, 3}, 2)); // doesn't return index of first occurrence - System.out.println("---------"); - System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 2)); - System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 2)); - System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 3)); - System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 0)); - System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 2, 2, 3, 3}, 2)); - } -} diff --git a/src/main/java/com/rampatra/sorting/BubbleSort.java b/src/main/java/com/rampatra/sorting/BubbleSort.java deleted file mode 100644 index 8560319b..00000000 --- a/src/main/java/com/rampatra/sorting/BubbleSort.java +++ /dev/null @@ -1,49 +0,0 @@ -package com.rampatra.sorting; - -import java.util.Arrays; - -/** - * @author rpatra16 - * @since 03/11/2018 - */ -public class BubbleSort { - - /** - * In bubble sort, we start at the beginning of the array and swap - * the first two elements if the first is greater than the second. - * Then, we go to the next pair, and so on, continuously making sweeps - * of the array until it is sorted. In doing so, the smaller items - * slowly "bubble" up to the beginning of the list and in each inner - * iteration the largest element is sorted. Ergo, the inner loop runs - * until {@code length - i - 1} times. Time complexity: O(n^2). Space - * complexity: O(1), in place. To learn more: {@see https://youtu.be/6Gv8vg0kcHc} - * - * @param ar to be sorted - */ - private static void bubbleSort(int[] ar) { - for (int i = 0; i < ar.length - 1; i++) { - for (int j = 0; j < ar.length - i - 1; j++) { - if (ar[j] > ar[j + 1]) { - swap(ar, j, j + 1); - } - } - } - } - - private static void swap(int[] ar, int i, int j) { - int temp = ar[i]; - ar[i] = ar[j]; - ar[j] = temp; - } - - public static void main(String[] args) { - int[] ar = {2, 5, 1, 7, 8}; - System.out.println(Arrays.toString(ar)); - bubbleSort(ar); - System.out.println(Arrays.toString(ar)); - ar = new int[]{7, 5, 1, 7, 8, 0, 23}; - System.out.println(Arrays.toString(ar)); - bubbleSort(ar); - System.out.println(Arrays.toString(ar)); - } -} diff --git a/src/main/java/com/rampatra/sorting/MergeSortSpaceOptimized.java b/src/main/java/com/rampatra/sorting/MergeSortSpaceOptimized.java deleted file mode 100644 index 1b80caf8..00000000 --- a/src/main/java/com/rampatra/sorting/MergeSortSpaceOptimized.java +++ /dev/null @@ -1,67 +0,0 @@ -package com.rampatra.sorting; - -import java.util.Arrays; - -/** - * @author rampatra - * @since 13/11/2018 - */ -public class MergeSortSpaceOptimized { - - /** - * This is entry point. You can call this method to sort - * an array {@code arr}. - * - * @param arr array to be sorted - */ - public static void mergeSort(int[] arr) { - mergeSort(arr, new int[arr.length], 0, arr.length - 1); - } - - private static void mergeSort(int[] arr, int[] helper, int low, int high) { - if (low < high) { - int mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2 - - mergeSort(arr, helper, low, mid); - mergeSort(arr, helper, mid + 1, high); - - merge(arr, helper, low, mid, high); - } - } - - private static void merge(int[] arr, int[] helper, int low, int mid, int high) { - int k = low; - - /* - Similar to merging two sorted arrays, i.e, merge two parts of arr[], arr[low..mid] and arr[mid+1..high], - and store in helper[] - */ - for (int i = low, j = mid + 1; i <= mid || j <= high; ) { - if (i > mid) { - helper[k++] = arr[j++]; - } else if (j > high) { - helper[k++] = arr[i++]; - } else if (arr[i] <= arr[j]) { - helper[k++] = arr[i++]; - } else if (arr[i] > arr[j]) { - helper[k++] = arr[j++]; - } - } - - // finally copy the sorted result from helper[] to arr[] - for (int i = low; i <= high; i++) { // note: we can use System.arraycopy() for better performance - arr[i] = helper[i]; - } - } - - public static void main(String[] args) { - int[] arr = {3, 6, 8, 9, 1, 2, 4}; - System.out.println(Arrays.toString(arr)); - mergeSort(arr); - System.out.println(Arrays.toString(arr)); - arr = new int[]{5, 8, 1, 2, 5, 3, 0, 1, 2, 4}; - System.out.println(Arrays.toString(arr)); - mergeSort(arr); - System.out.println(Arrays.toString(arr)); - } -} diff --git a/src/main/java/com/rampatra/sorting/QuickSort.java b/src/main/java/com/rampatra/sorting/QuickSort.java deleted file mode 100644 index 48744ddc..00000000 --- a/src/main/java/com/rampatra/sorting/QuickSort.java +++ /dev/null @@ -1,104 +0,0 @@ -package com.rampatra.sorting; - -import java.util.Arrays; - -/** - * The basic Quick Sort. See http://www.csanimated.com/animation.php?t=Quicksort to learn more. - * - * @author rampatra - * @since 7/21/15 - */ -public class QuickSort { - - /** - * In-place partition method which moves all elements smaller than - * the pivot element to its left and all elements larger than the - * pivot element to its right and finally places the pivot element - * at its correct position. - * - * @param arr - * @param startIndex - * @param endIndex - * @return position of the pivot element - */ - public static int partition(int[] arr, int startIndex, int endIndex) { - int pivot = endIndex, temp; - - for (int i = startIndex; i < endIndex; i++) { - // if ith element is smaller than pivot element then - // swap it with the last larger element known - if (arr[i] < arr[pivot]) { - // swap a[startIndex] with a[i] - temp = arr[startIndex]; - arr[startIndex] = arr[i]; - arr[i] = temp; - startIndex++; - } - } - - // place the pivot element in its correct position - temp = arr[startIndex]; - arr[startIndex] = arr[pivot]; - arr[pivot] = temp; - - return startIndex; - } - - /** - * Recursive Quick sort. - * NOTE: This function is tail-recursive (doesn't use extra stack space per recursive call in many - * programming languages but not in Java as it doesn't support tail-recursive optimization). - *

- * Time complexity: - * Best Case: O(nlogn) - * Worst Case: O(n*n) - * - * @param arr - * @param startIndex - * @param endIndex - */ - public static void quickSort(int[] arr, int startIndex, int endIndex) { - if (startIndex < endIndex) { - int partition = partition(arr, startIndex, endIndex); - quickSort(arr, startIndex, partition - 1); - quickSort(arr, partition + 1, endIndex); - } - } - - /** - * Wrapper method to quick sort the entire array. - * - * @param arr the input array to sort - */ - public static void quickSort(int[] arr) { - quickSort(arr, 0, arr.length - 1); - } - - public static void main(String[] args) { - int[] ar = {3, 2, 1, 6, 4, 9, 7, 8}; - System.out.println(Arrays.toString(ar)); - quickSort(ar); - System.out.println(Arrays.toString(ar)); - - System.out.println("------"); - - ar = new int[]{3, 2, 6, 8, 4, 3, 7, 8}; - System.out.println(Arrays.toString(ar)); - quickSort(ar); - System.out.println(Arrays.toString(ar)); - - System.out.println("------"); - - ar = new int[]{4, 4, 4, 4, 4, 4, 4}; - System.out.println(Arrays.toString(ar)); - quickSort(ar); - System.out.println(Arrays.toString(ar)); - - System.out.println("------"); - - ar = new int[]{}; - System.out.println(Arrays.toString(ar)); - quickSort(ar); - System.out.println(Arrays.toString(ar)); - } -} diff --git a/src/main/java/com/rampatra/sorting/WiggleSort.java b/src/main/java/com/rampatra/sorting/WiggleSort.java deleted file mode 100644 index 51ef266a..00000000 --- a/src/main/java/com/rampatra/sorting/WiggleSort.java +++ /dev/null @@ -1,45 +0,0 @@ -package com.rampatra.sorting; - -import java.util.Arrays; - -/** - * Wiggle Sort: Arrange the elements in the array such that elements in - * even indices are greater than or equal to its neighbouring elements - * and elements in odd indices are less than or equal to its neighbouring - * elements. In other words, all elements in array {@code a} are arranged - * such that, a[i-1] <= a[i] => a[i+1] - *

- * Ex: {1, 3, 2, 5, 4, 6} - * - * @author rampatra - * @version 01/09/2016 - */ -public class WiggleSort { - - public static int[] wiggleSortEasyWay(int[] a) { - a = MergeSort.mergeSort(a); - for (int i = 1; i < a.length; i += 2) { - swap(a, i, i + 1); - } - return a; - } - - private static void swap(int[] a, int index1, int index2) { - if (index2 >= a.length) return; - - a[index1] = a[index1] + a[index2]; - a[index2] = a[index1] - a[index2]; - a[index1] = a[index1] - a[index2]; - } - - public static void main(String[] args) { - int[] ar = {3, 5, 6, 7, 8, 1, 2}; - System.out.println(Arrays.toString(wiggleSortEasyWay(ar))); - int[] ar1 = {3, 5, 6, 7, 2, 1}; - System.out.println(Arrays.toString(wiggleSortEasyWay(ar1))); - int[] ar2 = {3, 5, 6, 7, 8, 1}; - System.out.println(Arrays.toString(wiggleSortEasyWay(ar2))); - int[] ar3 = {3, 5, 6, 5, 8, 1}; - System.out.println(Arrays.toString(wiggleSortEasyWay(ar3))); - } -} diff --git a/src/main/java/com/rampatra/stacks/MaxRectangleAreaInHistogram.java b/src/main/java/com/rampatra/stacks/MaxRectangleAreaInHistogram.java deleted file mode 100644 index 8494b0e7..00000000 --- a/src/main/java/com/rampatra/stacks/MaxRectangleAreaInHistogram.java +++ /dev/null @@ -1,79 +0,0 @@ -package com.rampatra.stacks; - -/** - * Given a bar histogram, calculate the maximum possible rectangle area in the histogram. Consider each bar is 1 unit - * wide. - *

- * Level: Hard - * Time Complexity: O(n) - * Space Complexity: O(n) - * - * @author rampatra - * @since 2019-04-04 - */ -public class MaxRectangleAreaInHistogram { - - public static int getMaxRectangleArea(int[] hist) { - Stack stack = new Stack<>(); - int area; - int maxArea = 0; - int currMaxIndex; - int i = 0; - - while (i < hist.length) { - // keep adding indexes of bars which are equal to or larger than what's there in stack currently - if (stack.isEmpty() || hist[i] >= hist[stack.peek()]) { - stack.push(i); - i++; - } else { - /* - Whenever we encounter a bar smaller than what is there in the stack, we pop the topmost - element and compute the area. - */ - currMaxIndex = stack.pop(); - /* - Compute area from stack.peek() to (i - 1), - - Why (i - 1)? Because i has been incremented and is now pointing to the next bar in the - histogram - - Why stack.peak()? Because hist[stack.peek() + 1] is the last bar in the histogram with height more - than or equal to the current bar height - */ - area = hist[currMaxIndex] * (i - (stack.isEmpty() ? 0 : stack.peek() + 1)); - maxArea = Math.max(maxArea, area); - } - } - - /* - Process the left over elements in the stack. Note: the below code can also be merged with the loop - above but I have separated it out for simplicity. - */ - while (!stack.isEmpty()) { - currMaxIndex = stack.pop(); - area = hist[currMaxIndex] * (i - (stack.isEmpty() ? 0 : stack.peek() + 1)); - maxArea = Math.max(maxArea, area); - } - - return maxArea; - } - - public static void main(String[] args) { - /* - ___ - ___ | | ___ - | |__| |__| | - | | | | | | - 2 1 3 1 2 - - Max. area in this histogram is 5, which is the bottom horizontal rectangle. - */ - System.out.println(getMaxRectangleArea(new int[]{2, 1, 3, 1, 2})); // maxArea = 5 - System.out.println(getMaxRectangleArea(new int[]{2, 1, 5, 6, 2, 3})); // maxArea = 10 - System.out.println(getMaxRectangleArea(new int[]{2, 2, 2, 6, 1, 5, 4, 2, 2, 2, 2})); // maxArea = 12 - - // edge cases - System.out.println(getMaxRectangleArea(new int[]{})); // maxArea = 0 - System.out.println(getMaxRectangleArea(new int[]{1})); // maxArea = 1 - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/strings/BasicRegexParser.java b/src/main/java/com/rampatra/strings/BasicRegexParser.java deleted file mode 100644 index faf47331..00000000 --- a/src/main/java/com/rampatra/strings/BasicRegexParser.java +++ /dev/null @@ -1,59 +0,0 @@ -package com.rampatra.strings; - -/** - * @author rampatra - * @since 25/11/2018 - */ -public class BasicRegexParser { - - /** - * Implement a regular expression function isMatch that supports the '.' and '*' symbols. - * The function receives two strings - text and pattern - and should return true if the - * text matches the pattern as a regular expression. For simplicity, assume that the actual - * symbols '.' and '*' do not appear in the text string and are used as special symbols only - * in the pattern string. - * - * @param text - * @param pattern - * @return - */ - private static boolean isMatch(String text, String pattern) { - int textIndex = 0; - int patternIndex = 0; - - while (textIndex < text.length()) { - if (patternIndex >= pattern.length()) return false; - - if (pattern.charAt(patternIndex) == '.' || text.charAt(textIndex) == pattern.charAt(patternIndex)) { - // if the next character in the pattern is a '*' then forward the text pointer - if (patternIndex < pattern.length() - 1 && pattern.charAt(patternIndex + 1) == '*') { - while (textIndex < text.length() - 1 && text.charAt(textIndex + 1) == text.charAt(textIndex)) { - textIndex++; - } - patternIndex++; // for the '*' in the pattern - } - } else if (patternIndex < pattern.length() - 1 && pattern.charAt(patternIndex + 1) == '*') { // if the text - // and pattern are not equal at the index but the pattern has a '*' after then increment the pattern pointer - textIndex--; // as we incrementing the text pointer outside but we should, in fact, stay at the current text index - patternIndex++; - } else { - return false; - } - textIndex++; - patternIndex++; - } - return true; - } - - public static void main(String[] args) { - System.out.println(isMatch("aa", "a")); // output: false - System.out.println(isMatch("aa", "aa")); // output: true - System.out.println(isMatch("abc", "a.c")); // output: true - System.out.println(isMatch("abbb", "ab*")); // output: true - System.out.println(isMatch("acd", "ab*c.")); // output: true - System.out.println(isMatch("abbdbb", "ab*d")); // output: false - System.out.println(isMatch("aba", "a.a")); // output: true - System.out.println(isMatch("acd", "ab*c.")); // output: true - System.out.println(isMatch("abaa", "a.*a*")); // output: true - } -} diff --git a/src/main/java/com/rampatra/strings/CompressString.java b/src/main/java/com/rampatra/strings/CompressString.java deleted file mode 100644 index ed3ce3d1..00000000 --- a/src/main/java/com/rampatra/strings/CompressString.java +++ /dev/null @@ -1,60 +0,0 @@ -package com.rampatra.strings; - -/** - * @author rampatra - * @since 2019-04-08 - */ -public class CompressString { - - /** - * Compress a string, consisting of only alphabets, such that the compressed string contains the letter and - * a number next to it representing the number of times it is repeated. Also, compress only if the letter is - * repeated more than once and ignore it occurs just once. - * EXAMPLE: - * Input: aaabbcdd - * Output: a3b2cd2 - *

- * Time Complexity: O(n) - * Space Complexity: O(n) - * where, - * n is the number of characters in the input string - * - * @param str the input string consisting on only alphabets - * @return the compressed string - */ - private static String compress(String str) { - // some basic validation - if (str.length() == 0) { - throw new IllegalArgumentException("Empty String"); - } - - StringBuilder sb = new StringBuilder(); - int letterCount = 0; - - for (int i = 0; i < str.length(); i++) { - /* - When the current character is a different one, append the previous character and its count to the - result, and finally, reset the counter - */ - if (i != 0 && str.charAt(i) != str.charAt(i - 1)) { - sb.append(str.charAt(i - 1)); - if (letterCount > 1) sb.append(letterCount); - letterCount = 0; - } - letterCount++; - } - - // last character - sb.append(str.charAt(str.length() - 1)); - if (letterCount > 1) sb.append(letterCount); - - return sb.toString(); - } - - public static void main(String[] args) { - System.out.println(compress("a")); - System.out.println(compress("aabbcc")); - System.out.println(compress("aabcc")); - System.out.println(compress("aaaabbbccaad")); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/strings/IntegerToString.java b/src/main/java/com/rampatra/strings/IntegerToString.java deleted file mode 100644 index 08d27131..00000000 --- a/src/main/java/com/rampatra/strings/IntegerToString.java +++ /dev/null @@ -1,51 +0,0 @@ -package com.rampatra.strings; - -/** - * @author rampatra - * @since 2019-04-01 - */ -public class IntegerToString { - - private static final int[] sizeTable = {9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, - 999999999, Integer.MAX_VALUE}; - - private static String getStringFromInteger(int num) { - boolean isNegative = num < 0; - num = isNegative ? -num : num; - int size = getStringSize(num); - size = isNegative ? size + 1 : size; - char[] chars = new char[size]; - - int rem; - for (int i = size - 1; isNegative ? i > 0 : i >= 0; i--) { - rem = num % 10; - num = num / 10; - chars[i] = (char) (rem + '0'); - } - - if (isNegative) { - chars[0] = '-'; - } - - return new String(chars); - } - - private static int getStringSize(int num) { - if (num == Integer.MAX_VALUE) return 10; - - for (int i = 0; ; i++) { - if (num < sizeTable[i]) { - return i + 1; - } - } - } - - public static void main(String[] args) { - System.out.println(getStringFromInteger(0)); - System.out.println(getStringFromInteger(123)); - System.out.println(getStringFromInteger(+123)); - System.out.println(getStringFromInteger(-123)); - System.out.println(getStringFromInteger(Integer.MAX_VALUE)); - System.out.println(getStringFromInteger(Integer.MIN_VALUE)); // not working - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/strings/KeepOnlyKConsecutiveLetters.java b/src/main/java/com/rampatra/strings/KeepOnlyKConsecutiveLetters.java deleted file mode 100644 index aab4df26..00000000 --- a/src/main/java/com/rampatra/strings/KeepOnlyKConsecutiveLetters.java +++ /dev/null @@ -1,48 +0,0 @@ -package com.rampatra.strings; - -/** - * @author rampatra - * @since 30/11/2018 - */ -public class KeepOnlyKConsecutiveLetters { - - /** - * A method which takes a string {@code str} and a number {@code k} and - * returns a string with at most {@code k} consecutive characters in the - * string. - *

- * For example, - * 1) aaaaaabbbbbccccc, 3 -> aaabbbccc - * 2) abc, 2 -> abc - * 3) aabbccc, 3 -> aabbccc - * - * @param str input string - * @param k - * @return a string with at most {@code k} consecutive characters - */ - private static String keepOnlyKConsecutiveLetters(String str, int k) { - StringBuilder sb = new StringBuilder(); - int count = 0; - - for (int i = 0; i < str.length(); i++) { - if (i != 0 && str.charAt(i) != str.charAt(i - 1)) { - count = 0; - } - if (count < k) { - sb.append(str.charAt(i)); - count++; - } - } - - return sb.toString(); - } - - public static void main(String[] args) { - System.out.println("aaaaabbbbbccccc, 5: " + keepOnlyKConsecutiveLetters("aaaaabbbbbccccc", 5)); - System.out.println("aaaaabbbbbccccc, 2: " + keepOnlyKConsecutiveLetters("aaaaabbbbbccccc", 2)); - System.out.println("aaaaabbbbbccccc, 1: " + keepOnlyKConsecutiveLetters("aaaaabbbbbccccc", 1)); - System.out.println("aabbcc, 2: " + keepOnlyKConsecutiveLetters("aabbcc", 2)); - System.out.println("aabbcc, 0: " + keepOnlyKConsecutiveLetters("aabbcc", 0)); - System.out.println("abc, 2: " + keepOnlyKConsecutiveLetters("abc", 2)); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/strings/NearPalindrome.java b/src/main/java/com/rampatra/strings/NearPalindrome.java deleted file mode 100644 index 6e4efd7d..00000000 --- a/src/main/java/com/rampatra/strings/NearPalindrome.java +++ /dev/null @@ -1,37 +0,0 @@ -package com.rampatra.strings; - -/** - * @author rampatra - * @since 05/12/2018 - */ -public class NearPalindrome { - - /** - * Checks if a string can be a palindrome by changing just one character in the string {@code str}. - * - * @param str the input string - * @return {@code true} if it can be converted to a palindrome with one character change or else {@code false} - */ - private static boolean isStringPalindromeByChangingOneChar(String str) { - int diffCount = 0; - for (int i = 0, j = str.length() - 1; i < str.length() / 2; i++, j--) { - if (str.charAt(i) != str.charAt(j)) { - if (diffCount > 0) { - return false; - } else { - diffCount++; - } - } - } - return true; - } - - public static void main(String[] args) { - System.out.println(isStringPalindromeByChangingOneChar("")); - System.out.println(isStringPalindromeByChangingOneChar("a")); - System.out.println(isStringPalindromeByChangingOneChar("ab")); - System.out.println(isStringPalindromeByChangingOneChar("aabbca")); - System.out.println(isStringPalindromeByChangingOneChar("abccaa")); - System.out.println(isStringPalindromeByChangingOneChar("abbcca")); - } -} diff --git a/src/main/java/com/rampatra/strings/RemoveDuplicatesAndArrangeLetters.java b/src/main/java/com/rampatra/strings/RemoveDuplicatesAndArrangeLetters.java deleted file mode 100644 index edb99699..00000000 --- a/src/main/java/com/rampatra/strings/RemoveDuplicatesAndArrangeLetters.java +++ /dev/null @@ -1,37 +0,0 @@ -package com.rampatra.strings; - -import java.util.Set; -import java.util.TreeSet; -import java.util.stream.Collectors; - -/** - * @author rampatra - * @since 2019-04-02 - */ -public class RemoveDuplicatesAndArrangeLetters { - - private static String removeDuplicatesAndArrangeLettersLexicographically(String str) { - Set charSet = new TreeSet<>(); - char[] chars = str.toCharArray(); - - for (char ch : chars) { - charSet.add(ch); - } - - return charSet.toString(); - } - - private static String removeDuplicatesAndArrangeLettersLexicographically_Java8(String str) { - return str.chars() - .distinct() - .sorted() - .mapToObj(i -> (char) i) - .map(String::valueOf) - .collect(Collectors.joining()); - } - - public static void main(String[] args) { - System.out.println(removeDuplicatesAndArrangeLettersLexicographically("algo&dsInJava")); - System.out.println(removeDuplicatesAndArrangeLettersLexicographically_Java8("algo&dsInJava")); - } -} diff --git a/src/main/java/com/rampatra/strings/StringToInteger.java b/src/main/java/com/rampatra/strings/StringToInteger.java deleted file mode 100644 index 53b386e7..00000000 --- a/src/main/java/com/rampatra/strings/StringToInteger.java +++ /dev/null @@ -1,64 +0,0 @@ -package com.rampatra.strings; - -/** - * @author rampatra - * @since 2019-04-01 - */ -public class StringToInteger { - - /** - * This method converts a {@code String} to an {@code int}. It assumes the {@code string} contains ASCII - * characters only. - * - * @param str the input string, for example, 0, 123, +123, -123, etc. - * @return the equivalent integer. - */ - private static int getIntegerFromString(String str) { - int number = 0; - int digit; - char ch; - int weight = 0; - boolean isNegative = false; - - // remove all leading and trailing whitespaces - str = str.trim(); - if (str.length() == 0) { - throw new NumberFormatException("Empty string"); - } - - for (int i = str.length() - 1; i >= 0; i--) { - ch = str.charAt(i); - if (ch == '-' && i == 0) { - isNegative = true; - continue; - } else if (ch == '+' && i == 0) { - continue; - } - - digit = ch - '0'; - - if (digit < 0 || digit > 9) { - throw new NumberFormatException("Invalid characters"); - } - - number += digit * (Math.pow(10, weight++)); - } - return isNegative ? -number : number; - } - - public static void main(String[] args) { - // normal cases - System.out.println(getIntegerFromString("0")); - System.out.println(getIntegerFromString("123")); - System.out.println(getIntegerFromString("0123")); - System.out.println(getIntegerFromString("+123")); - System.out.println(getIntegerFromString("-123")); - - // error cases - System.out.println(getIntegerFromString("1-23")); - System.out.println(getIntegerFromString("")); - System.out.println(getIntegerFromString(" ")); - System.out.println(getIntegerFromString(" ")); - System.out.println(getIntegerFromString("123L")); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/strings/WithoutString.java b/src/main/java/com/rampatra/strings/WithoutString.java deleted file mode 100644 index 859b6a76..00000000 --- a/src/main/java/com/rampatra/strings/WithoutString.java +++ /dev/null @@ -1,45 +0,0 @@ -package com.rampatra.strings; - -import com.sun.tools.javac.util.Assert; - -/** - * Given two strings, base and remove, return a version of the base string where all instances - * of the remove string have been removed (not case sensitive). You may assume that the remove - * string is length 1 or more. Remove only non-overlapping instances, so with "xxx" removing - * "xx" leaves "x". - * - * @author rampatra - * @since 2019-01-23 - */ -public class WithoutString { - - private static String withoutString(String base, String remove) { - String original = base; - base = base.toLowerCase(); - remove = remove.toLowerCase(); - int baseLen = base.length(); - int removeLen = remove.length(); - StringBuilder sb = new StringBuilder(); - - for (int i = 0; i < baseLen; ) { - int j = 0; - // when we see a match, advance the pointer - while (j < removeLen && i + j < baseLen && base.charAt(i + j) == remove.charAt(j)) { - j++; - } - if (j == removeLen) { // an entire match was found, move ahead and skip these chars - i += removeLen; - } else { - sb.append(original.charAt(i)); // entire match was not found so append the char to StringBuilder - i++; - } - } - return sb.toString(); - } - - public static void main(String[] args) { - Assert.check(withoutString("Hello there", "llo").equals("He there")); - Assert.check(withoutString("THIS is a FISH", "is").equals("TH a FH")); - Assert.check(withoutString("xxx", "x").equals("")); - } -} diff --git a/src/main/java/com/rampatra/threads/ProducerConsumerUsingLockApi.java b/src/main/java/com/rampatra/threads/ProducerConsumerUsingLockApi.java deleted file mode 100644 index 4c1443e0..00000000 --- a/src/main/java/com/rampatra/threads/ProducerConsumerUsingLockApi.java +++ /dev/null @@ -1,106 +0,0 @@ -package com.rampatra.threads; - -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.locks.Condition; -import java.util.concurrent.locks.Lock; -import java.util.concurrent.locks.ReentrantLock; - -/** - * Problem Description: A simple Producer/Consumer using the Lock and Condition Api pattern. For the language primitive, - * i.e, synchronize and wait/notify pattern, please see {@link ProducerConsumerUsingWaitNotify}. - *

- *

- * There are a few advantages of going with the Lock Api pattern instead of the language primitive synchronize and - * wait/notify pattern: - *

- * - Can be interrupted which means that the application won't continue to run forever in weird situations. Consider this - * example, what happens if the Consumer starts first and there are no elements to consume and the Producer also fails - * due to some exception. In wait/notify the Consumer would stall forever. You would have to restart the JVM to get - * rid of this. However, with Lock api, you can use {@link Lock#lockInterruptibly()}. - *

- * - Timed lock acquisition. You can try to acquire a lock and if it is not instantly available then do something else. - * See {@link Lock#tryLock()} to learn more. You can also wait for a certain amount of time before giving up with the - * {@link Lock#tryLock(long, TimeUnit)} method. This isn't possible with the primitive pattern. - *

- * - A fair Lock generates a fair Condition. Fair here means the first thread in the waiting queue will be picked first - * by the scheduler. This is a costly operation so use it only when necessary. - * - * @author rampatra - * @since 2019-07-10 - */ -public class ProducerConsumerUsingLockApi { - - private static int currSize = 0; - private static int totalSize = 10; - private static int[] buffer = new int[totalSize]; - private static Lock lock = new ReentrantLock(); - private static Condition isEmpty = lock.newCondition(); - private static Condition isFull = lock.newCondition(); - - static class Producer { - static void produce() { - try { - - lock.lock(); - while (currSize >= totalSize) { - isFull.await(); - } - buffer[currSize++] = 1; - isEmpty.signal(); - - } catch (InterruptedException e) { - e.printStackTrace(); - } finally { - lock.unlock(); - } - } - } - - static class Consumer { - static void consume() { - try { - - lock.lock(); - while (currSize <= 0) { - isEmpty.await(); - } - System.out.println(buffer[--currSize]); - isFull.signal(); - - } catch (InterruptedException e) { - e.printStackTrace(); - } finally { - lock.unlock(); - } - } - } - - public static void main(String[] args) throws InterruptedException { - - ExecutorService executorService = Executors.newFixedThreadPool(2); - - Runnable producerTask = () -> { - for (int i = 0; i < 1000; i++) { - Producer.produce(); - } - }; - - Runnable consumerTask = () -> { - for (int i = 0; i < 1000; i++) { - Consumer.consume(); - } - }; - - executorService.submit(producerTask); - executorService.submit(consumerTask); - - executorService.awaitTermination(3000, TimeUnit.MILLISECONDS); - - // as produce() and consume() are called equal number of times, this should be zero in the end - System.out.println("Buffer Size: " + currSize); - - executorService.shutdown(); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/threads/ProducerConsumerUsingWaitNotify.java b/src/main/java/com/rampatra/threads/ProducerConsumerUsingWaitNotify.java deleted file mode 100644 index da753f04..00000000 --- a/src/main/java/com/rampatra/threads/ProducerConsumerUsingWaitNotify.java +++ /dev/null @@ -1,85 +0,0 @@ -package com.rampatra.threads; - -/** - * Problem Description: A simple Producer/Consumer using Synchronize and Wait/Notify pattern. For a better - * solution, please see {@link ProducerConsumerUsingLockApi}. - * - * @author rampatra - * @since 2019-06-30 - */ -public class ProducerConsumerUsingWaitNotify { - - private static int currSize = 0; - private static int totalSize = 10; - private static int[] buffer = new int[totalSize]; - private static final Object lock = new Object(); - - static class Producer { - void produce() throws InterruptedException { - synchronized (lock) { - if (isFull()) { - lock.wait(); - } - buffer[currSize++] = 1; - lock.notify(); - } - } - } - - static class Consumer { - void consume() throws InterruptedException { - synchronized (lock) { - if (isEmpty()) { - lock.wait(); - } - System.out.println(buffer[--currSize]); - lock.notify(); - } - } - } - - private static boolean isFull() { - return currSize >= totalSize - 1; // as index starts from zero - } - - private static boolean isEmpty() { - return currSize == 0; - } - - public static void main(String[] args) throws InterruptedException { - - Runnable producerTask = () -> { - for (int i = 0; i < 1000; i++) { - try { - new Producer().produce(); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - }; - - Runnable consumerTask = () -> { - for (int i = 0; i < 1000; i++) { - try { - new Consumer().consume(); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - }; - - Thread producer = new Thread(producerTask); - Thread consumer = new Thread(consumerTask); - - // start both the threads - producer.start(); - consumer.start(); - - // wait for both the threads to complete - producer.join(); - consumer.join(); - - // as produce() and consume() are called equal number of times, this should be zero in the end - System.out.println("Buffer Size: " + currSize); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/threads/SimpleDeadlock.java b/src/main/java/com/rampatra/threads/SimpleDeadlock.java deleted file mode 100644 index b3b749a4..00000000 --- a/src/main/java/com/rampatra/threads/SimpleDeadlock.java +++ /dev/null @@ -1,58 +0,0 @@ -package com.rampatra.threads; - - -import java.lang.management.ManagementFactory; -import java.lang.management.ThreadMXBean; - -/** - * Problem Description: Deadlock example. - * - * @author rampatra - * @since 2019-03-13 - */ -public class SimpleDeadlock implements Runnable { - - private final Object obj1; - private final Object obj2; - - private SimpleDeadlock(Object obj1, Object obj2) { - this.obj1 = obj1; - this.obj2 = obj2; - } - - public void run() { - try { - synchronized (obj1) { - // sleep for some time so that the next thread starts and acquires the other lock in the mean time - Thread.sleep(5000); - synchronized (obj2) { - System.out.println("No deadlock!"); - } - } - } catch (InterruptedException e) { - throw new RuntimeException(e); - } - } - - public static void main(String[] args) { - - Object obj1 = new Object(); - Object obj2 = new Object(); - - Thread thread1 = new Thread(new SimpleDeadlock(obj1, obj2)); - Thread thread2 = new Thread(new SimpleDeadlock(obj2, obj1)); // note here that the object order is different - - thread1.start(); - thread2.start(); - - // a way to detect deadlocks, although an expensive one - ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); - while (true) { - long[] deadlock = threadMXBean.findDeadlockedThreads(); - if (deadlock != null && deadlock.length > 0) { - System.out.println("Deadlock detected, exiting now..."); - System.exit(1); - } - } - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/trees/BFSUsingQueue.java b/src/main/java/com/rampatra/trees/BFSUsingQueue.java deleted file mode 100644 index 04166d8d..00000000 --- a/src/main/java/com/rampatra/trees/BFSUsingQueue.java +++ /dev/null @@ -1,87 +0,0 @@ -package com.rampatra.trees; - -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinaryTree; -import com.rampatra.base.LinkedQueue; -import com.rampatra.base.Queue; - -import java.util.NoSuchElementException; - -import static java.lang.System.out; - -/** - * Created by IntelliJ IDEA. - * - * @author rampatra - * @since 6/26/15 - * @time: 7:34 PM - */ -public class BFSUsingQueue { - - /** - * Breadth first traversal (Level-order traversal using Queue). - * - * @param node a tree node with left and right references and a value of type {@code E} - * @param the type of value that the {@code node} holds - */ - public static > void breadthFirstTraversalUsingQueue(BinaryNode node) { - Queue> queue = new LinkedQueue<>(); - breadthFirstTraversalUsingQueue(node, queue); - } - - private static > void breadthFirstTraversalUsingQueue(BinaryNode node, - Queue> queue) { - - if (node != null) { - printValue(node); - queue.add(node.left); - queue.add(node.right); - } - - try { - breadthFirstTraversalUsingQueue(queue.remove(), queue); - } catch (NoSuchElementException e) { - return; - } - } - - private static > void printValue(BinaryNode node) { - if (node == null) return; - - out.print(node.value); - } - - /** - * Level order traversal using queue but iteratively. - * - * @param root the root node from where the traversal should start - * @param type of the {@code value} that {@code BinaryNode} holds - */ - public static > void breadthFirstTraversalUsingQueueIterative(BinaryNode root) { - if (root == null) return; - - Queue> q = new LinkedQueue<>(); - q.add(root); - - while (!q.isEmpty()) { - BinaryNode node = q.remove(); - out.print(node.value); - - if (node.left != null) q.add(node.left); - if (node.right != null) q.add(node.right); - } - } - - public static void main(String[] args) { - BinaryTree bt = new BinaryTree<>(); - bt.put(6); - bt.put(3); - bt.put(5); - bt.put(7); - bt.put(8); - bt.put(9); - breadthFirstTraversalUsingQueue(bt.root); - System.out.println(); - breadthFirstTraversalUsingQueueIterative(bt.root); - } -} diff --git a/src/main/java/com/rampatra/trees/ConnectNodesAtSameLevel.java b/src/main/java/com/rampatra/trees/ConnectNodesAtSameLevel.java deleted file mode 100644 index 684e3e01..00000000 --- a/src/main/java/com/rampatra/trees/ConnectNodesAtSameLevel.java +++ /dev/null @@ -1,127 +0,0 @@ -package com.rampatra.trees; - -import java.util.ArrayDeque; -import java.util.ArrayList; -import java.util.List; -import java.util.Queue; - -/** - * Given a binary tree, return lists of nodes at each level. The number of lists in the output will be equal to - * the number of levels in the tree. - * - * @author rampatra - * @since 2019-04-02 - */ -public class ConnectNodesAtSameLevel { - - private static class TreeNode { - Integer val; - TreeNode left; - TreeNode right; - - TreeNode(Integer val) { - this.val = val; - } - - @Override - public String toString() { - return Integer.toString(val); - } - } - - private static List> connectNodes(TreeNode root) { - if (root == null) return null; - - Queue queue = new ArrayDeque<>(); - List> allNodes = new ArrayList<>(); - List connectedNodesAtLevel = new ArrayList<>(); - - queue.add(root); - queue.add(new TreeNode(null)); // we use a node with null value as a marker for each level - - while (!queue.isEmpty()) { - TreeNode node = queue.poll(); - - if (node.val != null) { - connectedNodesAtLevel.add(node); - } else { // when we encounter a null in the queue, we know that a level is completed - allNodes.add(connectedNodesAtLevel); - connectedNodesAtLevel = new ArrayList<>(); - if (queue.peek() != null) queue.add(new TreeNode(null)); - continue; - } - - if (node.left != null) queue.add(node.left); - if (node.right != null) queue.add(node.right); - } - - return allNodes; - } - - public static void main(String[] args) { - /* - The BST looks like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - / - 0 - - */ - TreeNode treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(8); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(3); - treeRoot.left.left.left = new TreeNode(0); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - - connectNodes(treeRoot).forEach(System.out::println); - System.out.println("--------------"); - - /* - The BST looks like: - - 4 - / \ - 2 8 - \ / \ - 3 6 9 - - */ - treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(8); - treeRoot.left.right = new TreeNode(3); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - - connectNodes(treeRoot).forEach(System.out::println); - System.out.println("--------------"); - - - /* - The BST looks like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - - */ - treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(8); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(3); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - - connectNodes(treeRoot).forEach(System.out::println); - } -} diff --git a/src/main/java/com/rampatra/trees/LeastCommonAncestorInBT.java b/src/main/java/com/rampatra/trees/LeastCommonAncestorInBT.java deleted file mode 100644 index 24bd6786..00000000 --- a/src/main/java/com/rampatra/trees/LeastCommonAncestorInBT.java +++ /dev/null @@ -1,83 +0,0 @@ -package com.rampatra.trees; - -/** - * Given a binary tree {@code root}, find the LCA of two given nodes {@code node1} and {@code node2}. LCA is a node - * which is closest to both of the nodes. - *

- * See this youtube video for a visual understanding of the - * approach taken to solve this problem. - * - * @author rampatra - * @since 2019-04-06 - */ -public class LeastCommonAncestorInBT { - private static class TreeNode { - int val; - TreeNode left; - TreeNode right; - - TreeNode(int val) { - this.val = val; - } - - @Override - public String toString() { - return String.valueOf(val); - } - } - - private static TreeNode findLCA(TreeNode root, TreeNode node1, TreeNode node2) { - if (root == null) return null; - - /* - optimal: check this first before checking the child nodes recursively because even if the other node - is in one of the sub-trees the LCA would be root node - */ - if (root == node1 || root == node2) { - return root; - } - - TreeNode left = findLCA(root.left, node1, node2); - TreeNode right = findLCA(root.right, node1, node2); - - if (left != null && right != null) { // one node is in the left sub-tree and the other on the right sub-tree - return root; - } else if (left != null) { // we found one node in the left sub-tree - return left; - } else if (right != null) { // we found one node in the right sub-tree - return right; - } else { - return null; - } - } - - public static void main(String[] args) { - /* - The BST looks like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - / - 0 - - */ - TreeNode treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(8); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(3); - treeRoot.left.left.left = new TreeNode(0); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - - System.out.println(findLCA(treeRoot, treeRoot, treeRoot).val); // findLCA(4, 4) - System.out.println(findLCA(treeRoot, treeRoot.left, treeRoot.right).val); // findLCA(2, 8) - System.out.println(findLCA(treeRoot, treeRoot.left, treeRoot.left.left).val); // findLCA(2, 1) - System.out.println(findLCA(treeRoot, treeRoot.left.left, treeRoot.left).val); // findLCA(1, 2) - System.out.println(findLCA(treeRoot, treeRoot.left.left.left, treeRoot.right.left).val); // findLCA(0, 6) - System.out.println(findLCA(treeRoot, treeRoot.right, treeRoot.right.right).val); // findLCA(8, 9) - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/trees/RandomNodeInBT.java b/src/main/java/com/rampatra/trees/RandomNodeInBT.java deleted file mode 100644 index a2719bc7..00000000 --- a/src/main/java/com/rampatra/trees/RandomNodeInBT.java +++ /dev/null @@ -1,82 +0,0 @@ -package com.rampatra.trees; - -import java.util.Random; - -/** - * You are implementing a binary tree class from scratch, which has a method getRandomNode() which returns a - * random node from the tree. All nodes should be equally likely to be chosen. Design and implement an algorithm - * for getRandomNode(). - * - * @author rampatra - * @since 2019-04-03 - */ -public class RandomNodeInBT { - - private static class TreeNode { - int val; - TreeNode left; - TreeNode right; - int size; // num of nodes in left subtree + 1 + num of nodes in right subtree - - TreeNode(int val, int size) { - this.val = val; - this.size = size; - } - - TreeNode getRandomNode() { - int randomNum = new Random().nextInt(this.size); // generates a random num from 0 to size - 1 (both inclusive) - - /* - the below makes all nodes equally likely because the probability is distributed - evenly (approximately) depending on the number of children - */ - if (this.left != null && randomNum < this.left.size) { - return left.getRandomNode(); - } else if (this.right != null && randomNum > this.right.size) { - return right.getRandomNode(); - } else { - return this; - } - } - } - - public static void main(String[] args) { - /* - The BST looks like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - - */ - TreeNode treeRoot = new TreeNode(4, 7); - treeRoot.left = new TreeNode(2, 3); - treeRoot.right = new TreeNode(8, 3); - treeRoot.left.left = new TreeNode(1, 1); - treeRoot.left.right = new TreeNode(3, 1); - treeRoot.right.left = new TreeNode(6, 1); - treeRoot.right.right = new TreeNode(9, 1); - - System.out.println(treeRoot.getRandomNode().val); - System.out.println(treeRoot.getRandomNode().val); - System.out.println(treeRoot.getRandomNode().val); - System.out.println(treeRoot.getRandomNode().val); - System.out.println(treeRoot.getRandomNode().val); - System.out.println(treeRoot.getRandomNode().val); - System.out.println(treeRoot.getRandomNode().val); - System.out.println(treeRoot.getRandomNode().val); - - System.out.println("-------"); - - System.out.println(new Random().nextInt(8)); - System.out.println(new Random().nextInt(8)); - System.out.println(new Random().nextInt(8)); - System.out.println(new Random().nextInt(8)); - System.out.println(new Random().nextInt(8)); - System.out.println(new Random().nextInt(8)); - System.out.println(new Random().nextInt(8)); - System.out.println(new Random().nextInt(8)); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/trees/SecondSmallestInBST.java b/src/main/java/com/rampatra/trees/SecondSmallestInBST.java deleted file mode 100644 index 4e287365..00000000 --- a/src/main/java/com/rampatra/trees/SecondSmallestInBST.java +++ /dev/null @@ -1,108 +0,0 @@ -package com.rampatra.trees; - -/** - * Given a Binary Search Tree, find out the second smallest element in the tree. - * - * @author rampatra - * @since 2019-04-02 - */ -public class SecondSmallestInBST { - - private static class TreeNode { - int val; - TreeNode left; - TreeNode right; - - TreeNode(int val) { - this.val = val; - } - } - - private static TreeNode getSecondSmallestNode(TreeNode root) { - if (root == null) return null; - - TreeNode curr = root; - - if (curr.left == null) { - if (curr.right == null) { - return null; - } else { - return curr; - } - } - - while (curr.left.left != null) { - curr = curr.left; - } - - if (curr.left.right != null) { - return curr.left.right; - } else { - return curr; - } - } - - public static void main(String[] args) { - /* - The BST looks like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - / - 0 - - */ - TreeNode treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(8); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(3); - treeRoot.left.left.left = new TreeNode(0); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - - System.out.println(getSecondSmallestNode(treeRoot).val); - - /* - The BST looks like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - - */ - treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(8); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(3); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - - System.out.println(getSecondSmallestNode(treeRoot).val); - - /* - The BST looks like: - - 4 - / \ - 2 8 - \ / \ - 3 6 9 - - */ - treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(2); - treeRoot.right = new TreeNode(8); - treeRoot.left.right = new TreeNode(3); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - - System.out.println(getSecondSmallestNode(treeRoot).val); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/trees/TwoSwappedNodesInBST.java b/src/main/java/com/rampatra/trees/TwoSwappedNodesInBST.java deleted file mode 100644 index 4ec473da..00000000 --- a/src/main/java/com/rampatra/trees/TwoSwappedNodesInBST.java +++ /dev/null @@ -1,143 +0,0 @@ -package com.rampatra.trees; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -/** - * Two nodes are swapped in a BST, write a function to find these two nodes. - *

- * Approach: - * 1. We perform an in-order traversal of the tree and find the 2 discontinuities, i.e, the nodes which are larger than their next node. - * 2. We take the left node of the first discontinuity and the right node of the second. - *

- * Note: There is one edge case where the two nodes swapped are parent and child nodes. This means that in the in-order - * traversal these two nodes will be adjacent. Therefore, in this case, these two nodes will be our answer. - *

- * See this youtube video for a visual understanding. - * - * @author rampatra - * @since 2019-04-06 - */ -public class TwoSwappedNodesInBST { - - private static class TreeNode { - int val; - TreeNode left; - TreeNode right; - - TreeNode(int val) { - this.val = val; - } - - @Override - public String toString() { - return String.valueOf(val); - } - } - - private static List findSwappedNodes(TreeNode root) { - List inOrderTraversal = new ArrayList<>(); - TreeNode firstSwappedNode = null; - TreeNode secondSwappedNode = null; - TreeNode plausibleSwappedNode = null; - - traverseInOrder(root, inOrderTraversal); - - for (int i = 0; i < inOrderTraversal.size() - 1; i++) { - // find nodes not in ascending order - if (inOrderTraversal.get(i).val > inOrderTraversal.get(i + 1).val) { - if (firstSwappedNode == null) { - firstSwappedNode = inOrderTraversal.get(i); // take the left node from the first violation - plausibleSwappedNode = inOrderTraversal.get(i + 1); - } else { - secondSwappedNode = inOrderTraversal.get(i + 1); // take the right node from the second violation - } - } - } - - return Arrays.asList(firstSwappedNode, secondSwappedNode == null ? plausibleSwappedNode : secondSwappedNode); - } - - private static void traverseInOrder(TreeNode node, List inOrderTraversal) { - if (node == null) return; - - traverseInOrder(node.left, inOrderTraversal); - inOrderTraversal.add(node); - traverseInOrder(node.right, inOrderTraversal); - } - - public static void main(String[] args) { - /* - - Test case 1: Node 8 and node 2 are swapped - - The current BST looks like: - - 4 - / \ - 8 2 - / \ / \ - 1 3 6 9 - / - 0 - - Instead, the correct BST should look like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - / - 0 - - */ - TreeNode treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(8); - treeRoot.right = new TreeNode(2); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(3); - treeRoot.left.left.left = new TreeNode(0); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - - System.out.println(findSwappedNodes(treeRoot)); - - /* - - Test case 2: Node 3 and node 2 are swapped (note: these are parent child nodes) - - The current BST looks like: - - 4 - / \ - 3 8 - / \ / \ - 1 2 6 9 - / - 0 - - Instead, the correct BST should look like: - - 4 - / \ - 2 8 - / \ / \ - 1 3 6 9 - / - 0 - - */ - treeRoot = new TreeNode(4); - treeRoot.left = new TreeNode(3); - treeRoot.right = new TreeNode(8); - treeRoot.left.left = new TreeNode(1); - treeRoot.left.right = new TreeNode(2); - treeRoot.left.left.left = new TreeNode(0); - treeRoot.right.left = new TreeNode(6); - treeRoot.right.right = new TreeNode(9); - - System.out.println(findSwappedNodes(treeRoot)); - } -} \ No newline at end of file diff --git a/src/main/java/com/rampatra/Main.java b/src/me/ramswaroop/Main.java similarity index 97% rename from src/main/java/com/rampatra/Main.java rename to src/me/ramswaroop/Main.java index 9306b1a2..a749125c 100644 --- a/src/main/java/com/rampatra/Main.java +++ b/src/me/ramswaroop/Main.java @@ -1,13 +1,6 @@ -package com.rampatra; +package me.ramswaroop; -import com.rampatra.base.CircularSingleLinkedList; -import com.rampatra.base.DoubleLinkedList; -import com.rampatra.base.LinkedList; -import com.rampatra.base.LinkedQueue; -import com.rampatra.base.LinkedStack; -import com.rampatra.base.Queue; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.Stack; +import me.ramswaroop.common.*; import java.util.Scanner; @@ -313,7 +306,7 @@ public static void main(String[] args) { break; case 7: out.println("Exiting..."); - return; + System.exit(0); default: out.println("Wrong choice!"); } diff --git a/src/me/ramswaroop/arrays/ArrangeNosToFormBiggestNo.java b/src/me/ramswaroop/arrays/ArrangeNosToFormBiggestNo.java new file mode 100644 index 00000000..889a0254 --- /dev/null +++ b/src/me/ramswaroop/arrays/ArrangeNosToFormBiggestNo.java @@ -0,0 +1,47 @@ +package me.ramswaroop.arrays; + +import java.util.Arrays; +import java.util.Comparator; + +/** + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 11/1/15 + * @time: 8:53 PM + */ +public class ArrangeNosToFormBiggestNo { + + /** + * Sorts no.s in array {@param a} such that if you form a number {@code n} + * by concatenating digits in order a[0]....a[size], it results being the + * largest number possible. + *

+ * For example, + * I/P: {54, 546, 548, 60} + * O/P: {60, 548, 546, 54} i.e, 6054854654 + *

+ * I/P: {1, 34, 3, 98, 9, 76, 45, 4} + * O/P: {9, 98, 76, 45, 4, 34, 3, 1} i.e, 998764543431 + * + * @param a + * @return + */ + public static Integer[] arrangeArrayOfNosToFormBiggestNo(Integer[] a) { + + Arrays.sort(a, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return Integer.parseInt(o1 + "" + o2) > Integer.parseInt(o2 + "" + o1) ? -1 : 1; + } + }); + + return a; + } + + public static void main(String a[]) { + System.out.println(Arrays.toString(arrangeArrayOfNosToFormBiggestNo(new Integer[]{45, 567, 12, 1}))); + System.out.println(Arrays.toString(arrangeArrayOfNosToFormBiggestNo(new Integer[]{54, 546, 548, 60}))); + System.out.println(Arrays.toString(arrangeArrayOfNosToFormBiggestNo(new Integer[]{1, 34, 3, 98, 9, 76, 45, 4}))); + } +} diff --git a/src/main/java/com/rampatra/arrays/BooleanMatrix.java b/src/me/ramswaroop/arrays/BooleanMatrix.java similarity index 95% rename from src/main/java/com/rampatra/arrays/BooleanMatrix.java rename to src/me/ramswaroop/arrays/BooleanMatrix.java index 04ee2d88..7e47012c 100644 --- a/src/main/java/com/rampatra/arrays/BooleanMatrix.java +++ b/src/me/ramswaroop/arrays/BooleanMatrix.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/11/15 + * @author: ramswaroop + * @date: 9/11/15 * @time: 3:28 PM * @see: http://www.geeksforgeeks.org/a-boolean-matrix-question/ */ @@ -67,7 +67,7 @@ private static void print2DMatrix(int[][] a) { } } - public static void main(String[] args) { + public static void main(String a[]) { int[][] ar = new int[][]{{1, 0, 0, 1}, {0, 0, 1, 0}, {0, 0, 0, 0}}; print2DMatrix(ar); modifyBooleanMatrix(ar); diff --git a/src/main/java/com/rampatra/arrays/CelebrityProblem.java b/src/me/ramswaroop/arrays/CelebrityProblem.java similarity index 93% rename from src/main/java/com/rampatra/arrays/CelebrityProblem.java rename to src/me/ramswaroop/arrays/CelebrityProblem.java index 8b7278ea..3be0049e 100644 --- a/src/main/java/com/rampatra/arrays/CelebrityProblem.java +++ b/src/me/ramswaroop/arrays/CelebrityProblem.java @@ -1,19 +1,19 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.base.LinkedStack; -import com.rampatra.base.Stack; +import me.ramswaroop.common.LinkedStack; +import me.ramswaroop.common.Stack; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/2/15 + * @author: ramswaroop + * @date: 10/2/15 * @time: 10:48 PM *

* In a party of N people, only one person is known to everyone. Such a person may be present in the party, if yes, * (s)he doesn’t know anyone in the party. We can only ask questions like “does A know B? “. Find the stranger * (celebrity) in minimum number of questions. - *

+ * * TODO: Not tested. */ public class CelebrityProblem { @@ -44,7 +44,7 @@ public static boolean haveAcquaintance(int[][] peoples, int a, int b) { * - Push the remained person onto stack. * - Repeat step 2 and 3 until only one person remains in the stack. * - Check the remained person in stack does not have acquaintance with anyone else. - * + * * @param peoples * @return */ @@ -78,7 +78,7 @@ public static int findCelebrity(int[][] peoples) { return firstPerson; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(findCelebrity(new int[][]{{0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 0, 0}, {0, 0, 1, 0}})); System.out.println(findCelebrity(new int[][]{{0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1}})); } diff --git a/src/main/java/com/rampatra/arrays/ConsecutiveElements.java b/src/me/ramswaroop/arrays/ConsecutiveElements.java similarity index 94% rename from src/main/java/com/rampatra/arrays/ConsecutiveElements.java rename to src/me/ramswaroop/arrays/ConsecutiveElements.java index f8dc151e..4cd92231 100644 --- a/src/main/java/com/rampatra/arrays/ConsecutiveElements.java +++ b/src/me/ramswaroop/arrays/ConsecutiveElements.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/28/15 + * @author: ramswaroop + * @date: 8/28/15 * @time: 10:32 AM */ public class ConsecutiveElements { @@ -62,7 +62,7 @@ public static boolean areConsecutiveElements(int[] a) { } /** - * This approach is similar to {@link ConsecutiveElements#areConsecutiveElements(int[])} but + * This approach is similar to {@link me.ramswaroop.arrays.ConsecutiveElements#areConsecutiveElements(int[])} but * requires O(1) auxiliary space instead of O(n). But the only con of this method is that it modifies the original * input array {@param a}. * @@ -99,7 +99,7 @@ public static boolean areConsecutiveElementsInO1Space(int[] a) { return true; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(areConsecutiveElements(new int[]{5, 4, 3, 2, 1})); System.out.println(areConsecutiveElements(new int[]{67, 68, 69, 72, 70, 71})); System.out.println(areConsecutiveElements(new int[]{67, 68, 69, 72, 70, 71, 70})); diff --git a/src/me/ramswaroop/arrays/CountDivisors.java b/src/me/ramswaroop/arrays/CountDivisors.java new file mode 100644 index 00000000..6a20dbd9 --- /dev/null +++ b/src/me/ramswaroop/arrays/CountDivisors.java @@ -0,0 +1,30 @@ +package me.ramswaroop.arrays; + +/** + * Created by ramswaroop on 31/05/2016. + */ +public class CountDivisors { + + /** + * Counts the number of integers in the range {@param begin} and + * {@param end} that are divisible by {@param n}. + * + * @param begin + * @param end + * @param n + * @return + */ + public static int countDivisorsInRange(int begin, int end, int n) { + int b = end / n + 1; // From 0 to end the integers divisible by n + int a = begin / n + 1; // From 0 to begin the integers divisible by n + + if (begin % n == 0) { // "begin" is inclusive; if divisible by n then + --a; // remove 1 from "a" + } + return b - a; // return integers in range + } + + public static void main(String[] a) { + countDivisorsInRange(0, 2000000000, 5); + } +} diff --git a/src/main/java/com/rampatra/arrays/CountSmallerElementsOnRHS.java b/src/me/ramswaroop/arrays/CountSmallerElementsOnRHS.java similarity index 83% rename from src/main/java/com/rampatra/arrays/CountSmallerElementsOnRHS.java rename to src/me/ramswaroop/arrays/CountSmallerElementsOnRHS.java index 413234ec..295b50ec 100644 --- a/src/main/java/com/rampatra/arrays/CountSmallerElementsOnRHS.java +++ b/src/me/ramswaroop/arrays/CountSmallerElementsOnRHS.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/19/15 + * @author: ramswaroop + * @date: 9/19/15 * @time: 11:33 PM */ public class CountSmallerElementsOnRHS { @@ -16,7 +16,7 @@ public static int[] getSmallerElementsCountOnRHSNaive(int[] a) { return null; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getSmallerElementsCountOnRHSNaive(new int[]{12, 1, 2, 3, 0, 11, 4}))); System.out.println(Arrays.toString(getSmallerElementsCountOnRHSNaive(new int[]{5, 4, 3, 2, 1}))); System.out.println(Arrays.toString(getSmallerElementsCountOnRHSNaive(new int[]{1, 2, 3, 4, 5}))); diff --git a/src/main/java/com/rampatra/arrays/DuplicatesInArray.java b/src/me/ramswaroop/arrays/DuplicatesInArray.java similarity index 85% rename from src/main/java/com/rampatra/arrays/DuplicatesInArray.java rename to src/me/ramswaroop/arrays/DuplicatesInArray.java index 5cb9cbe8..87402572 100644 --- a/src/main/java/com/rampatra/arrays/DuplicatesInArray.java +++ b/src/me/ramswaroop/arrays/DuplicatesInArray.java @@ -1,19 +1,20 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/21/15 + * @author: ramswaroop + * @date: 8/21/15 + * @time: 9:41 AM */ public class DuplicatesInArray { /** * Given an array of n elements which contains elements from 0 to n-1, with any of * these numbers appearing any number of times. Find these repeating numbers in O(n) - * time complexity. + * and using only constant memory space. *

* For example, let n be 7 and array be {1, 2, 3, 1, 3, 6, 6}, the answer should be * 1, 3 and 6. @@ -24,7 +25,7 @@ public class DuplicatesInArray { * to mark that we have encountered 2. When we encounter 2 again and see that 2nd index * is already -ve we conclude that 2 is repeated. *

- * Similar to {@link TwoRepeatingElements#findTwoRepeatingElements(int[])}. + * Similar to {@link me.ramswaroop.arrays.TwoRepeatingElements#findTwoRepeatingElements(int[])}. * * @param a * @return @@ -42,7 +43,7 @@ public static int[] findDuplicatesInArray(int[] a) { return duplicates; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(findDuplicatesInArray(new int[]{1, 1, 2, 3, 1, 3, 6, 6}))); // doesn't work if 0 is present in array (as -0 makes no sense but we can modify the algorithm to handle 0) System.out.println(Arrays.toString(findDuplicatesInArray(new int[]{1, 0, 1, 2, 3, 1, 3, 6, 6}))); diff --git a/src/main/java/com/rampatra/arrays/DuplicatesInArrayWithinKDistance.java b/src/me/ramswaroop/arrays/DuplicatesInArrayWithinKDistance.java similarity index 82% rename from src/main/java/com/rampatra/arrays/DuplicatesInArrayWithinKDistance.java rename to src/me/ramswaroop/arrays/DuplicatesInArrayWithinKDistance.java index 2117d712..05575bf3 100644 --- a/src/main/java/com/rampatra/arrays/DuplicatesInArrayWithinKDistance.java +++ b/src/me/ramswaroop/arrays/DuplicatesInArrayWithinKDistance.java @@ -1,4 +1,4 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; import java.util.HashSet; @@ -6,13 +6,14 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/18/15 + * @author: ramswaroop + * @date: 10/18/15 + * @time: 8:40 PM */ public class DuplicatesInArrayWithinKDistance { /** - * Finds duplicates in an unsorted array {@code a} which are + * Finds duplicates in an unsorted array {@param a} which are * only k distance apart from each other. * * @param a @@ -40,7 +41,7 @@ public static int[] findDuplicatesInArrayWithinKDistance(int[] a, int k) { return Arrays.copyOf(duplicates, index); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(findDuplicatesInArrayWithinKDistance(new int[]{1, 2, 8, 1, 3, 4, 5, 6, 6, 7}, 3))); } } diff --git a/src/main/java/com/rampatra/arrays/EqualProbabilityRandomNoGenerator.java b/src/me/ramswaroop/arrays/EqualProbabilityRandomNoGenerator.java similarity index 88% rename from src/main/java/com/rampatra/arrays/EqualProbabilityRandomNoGenerator.java rename to src/me/ramswaroop/arrays/EqualProbabilityRandomNoGenerator.java index c26d8694..d28d26b2 100644 --- a/src/main/java/com/rampatra/arrays/EqualProbabilityRandomNoGenerator.java +++ b/src/me/ramswaroop/arrays/EqualProbabilityRandomNoGenerator.java @@ -1,4 +1,4 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Random; import java.util.Scanner; @@ -6,11 +6,11 @@ /** * Given a random number generator f(n) which generates a random number * from {@code 0} (inclusive) to {@code n} (exclusive), design a method - * which uses f(n) to generate non repeating random numbers from + * which uses f(n) to generate non repeating random numbers from * {@code 0} (inclusive) to {@code n} (exclusive)? * - * @author rampatra - * @since 8/13/15 + * @author: ramswaroop + * @date: 8/13/15 * @time: 1:41 PM */ public class EqualProbabilityRandomNoGenerator { @@ -19,9 +19,9 @@ public class EqualProbabilityRandomNoGenerator { static int size; /** - * The algorithm is to create a bucket of numbers and then to keep on + * The algorithm is to create a bucket of numbers and then to keep on * removing the elements from the bucket which are returned. - * + * * @return */ public static int getRandom() { @@ -35,14 +35,14 @@ public static int f(int n) { return new Random().nextInt(n); } - public static void main(String[] args) { + public static void main(String a[]) { Scanner in = new Scanner(System.in); - + System.out.println("How many random numbers you would like to generate?"); size = in.nextInt(); - + bucket = new int[size]; - + for (int i = 0; i < bucket.length; i++) { bucket[i] = i; } diff --git a/src/main/java/com/rampatra/arrays/EquilibriumIndex.java b/src/me/ramswaroop/arrays/EquilibriumIndex.java similarity index 94% rename from src/main/java/com/rampatra/arrays/EquilibriumIndex.java rename to src/me/ramswaroop/arrays/EquilibriumIndex.java index c943c603..89f129ff 100644 --- a/src/main/java/com/rampatra/arrays/EquilibriumIndex.java +++ b/src/me/ramswaroop/arrays/EquilibriumIndex.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/22/15 + * @author: ramswaroop + * @date: 8/22/15 * @time: 11:56 AM */ public class EquilibriumIndex { @@ -44,7 +44,7 @@ public static int getEquilibriumIndex(int[] a) { return -1; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getEquilibriumIndex(new int[]{-7, 1, 5, 2, -4, 3, 0})); System.out.println(getEquilibriumIndex(new int[]{-7, 1, 5, 0, 0, 0, 0, 1, 2, -4, 1, 3, 0})); System.out.println(getEquilibriumIndex(new int[]{4, 5, 2, 1, 6, 7, 8, 0, 1})); diff --git a/src/main/java/com/rampatra/arrays/FixedPoint.java b/src/me/ramswaroop/arrays/FixedPoint.java similarity index 90% rename from src/main/java/com/rampatra/arrays/FixedPoint.java rename to src/me/ramswaroop/arrays/FixedPoint.java index 99e8a333..d893ba92 100644 --- a/src/main/java/com/rampatra/arrays/FixedPoint.java +++ b/src/me/ramswaroop/arrays/FixedPoint.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/8/15 + * @author: ramswaroop + * @date: 9/8/15 * @time: 11:34 PM */ public class FixedPoint { @@ -33,7 +33,7 @@ public static int findFixedPoint(int[] a) { return -1; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(findFixedPoint(new int[]{-10, -5, 0, 3, 7})); System.out.println(findFixedPoint(new int[]{0, 2, 5, 8, 17})); System.out.println(findFixedPoint(new int[]{-10, -5, 3, 4, 7, 9})); diff --git a/src/main/java/com/rampatra/arrays/IntersectionAndUnionOf2SortedArrays.java b/src/me/ramswaroop/arrays/IntersectionAndUnionOf2SortedArrays.java similarity index 91% rename from src/main/java/com/rampatra/arrays/IntersectionAndUnionOf2SortedArrays.java rename to src/me/ramswaroop/arrays/IntersectionAndUnionOf2SortedArrays.java index 595e85a5..7b6fae64 100644 --- a/src/main/java/com/rampatra/arrays/IntersectionAndUnionOf2SortedArrays.java +++ b/src/me/ramswaroop/arrays/IntersectionAndUnionOf2SortedArrays.java @@ -1,20 +1,20 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/13/15 + * @author: ramswaroop + * @date: 8/13/15 * @time: 3:56 PM */ public class IntersectionAndUnionOf2SortedArrays { /** - * Returns a 2-D array consisting of intersection and union of + * Returns a 2-D array consisting of intersection and union of * two sorted arrays {@param a} and {@param b} respectively. - * + * * @param a * @param b * @return @@ -24,7 +24,7 @@ public static int[][] getIntersectionAndUnionOf2SortedArrays(int[] a, int[] b) { int[] intersection = new int[length], union = new int[length]; for (int i = 0, j = 0; i < a.length || j < b.length; ) { - + // if either of the arrays runs out first if (i == a.length) { union[y++] = b[j++]; @@ -50,7 +50,7 @@ public static int[][] getIntersectionAndUnionOf2SortedArrays(int[] a, int[] b) { return new int[][]{intersection, union}; } - public static void main(String[] args) { + public static void main(String a[]) { int[] a1 = new int[]{2, 3, 4, 5, 6, 7, 8}; int[] a2 = new int[]{6, 7, 8, 10, 12, 14, 16}; int[][] result = getIntersectionAndUnionOf2SortedArrays(a1, a2); diff --git a/src/main/java/com/rampatra/arrays/InversionsInArray.java b/src/me/ramswaroop/arrays/InversionsInArray.java similarity index 95% rename from src/main/java/com/rampatra/arrays/InversionsInArray.java rename to src/me/ramswaroop/arrays/InversionsInArray.java index 1677764d..60a1a6dd 100644 --- a/src/main/java/com/rampatra/arrays/InversionsInArray.java +++ b/src/me/ramswaroop/arrays/InversionsInArray.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/29/15 + * @author: ramswaroop + * @date: 7/29/15 * @time: 8:37 PM */ public class InversionsInArray { @@ -40,7 +40,7 @@ public static int getInversionCountNaiveApproach(int[] a) { /** * Optimized approach. - *

+ * * Explanation: In merge() if a[i] > b[j] then all elements in array a starting * from i are greater than b[j] which equals to the number of inversions for * the two sub-arrays. @@ -95,7 +95,7 @@ public static int[] merge(int[] a, int[] b) { return sortedArray; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getInversionCountNaiveApproach(new int[]{2, 4, 1, 3, 5})); System.out.println(getInversionCount(new int[]{2, 4, 1, 3, 5})); } diff --git a/src/main/java/com/rampatra/arrays/KLargestElements.java b/src/me/ramswaroop/arrays/KLargestElements.java similarity index 88% rename from src/main/java/com/rampatra/arrays/KLargestElements.java rename to src/me/ramswaroop/arrays/KLargestElements.java index 87546e7d..aa173187 100644 --- a/src/main/java/com/rampatra/arrays/KLargestElements.java +++ b/src/me/ramswaroop/arrays/KLargestElements.java @@ -1,31 +1,31 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.base.MinHeap; +import me.ramswaroop.common.MinHeap; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/3/15 + * @author: ramswaroop + * @date: 8/3/15 * @time: 3:47 PM */ public class KLargestElements { /** * Finds {@param k} largest elements in array {@param a}. - *

+ * * Algorithm: * 1) Build a Min Heap MH of the first k elements (arr[0] to arr[k-1]) of the given array. This takes O(k) time. - *

+ * * 2) For each element, after the kth element (arr[k] to arr[n-1]), compare it with root of MH. * ……a) If the element is greater than the root then make it root and call buildHeap for MH * ……b) Else ignore it. * This step takes (n-k) * O(k) time. - *

+ * * 3) Finally, MH has k largest elements and root of the MH is the kth largest element. - *

+ * * Therefore, the total time complexity of the above algorithm is: O(k) + (n-k) * O(k). * * @param a @@ -49,7 +49,7 @@ public static int[] getKLargestElements(int[] a, int k) { return minHeap.getHeap(); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getKLargestElements(new int[]{2, 3, 4, 1, 5, 7, 9}, 3))); } } diff --git a/src/main/java/com/rampatra/arrays/KthLargestElement.java b/src/me/ramswaroop/arrays/KthLargestElement.java similarity index 73% rename from src/main/java/com/rampatra/arrays/KthLargestElement.java rename to src/me/ramswaroop/arrays/KthLargestElement.java index 65ca77c7..62c771b2 100644 --- a/src/main/java/com/rampatra/arrays/KthLargestElement.java +++ b/src/me/ramswaroop/arrays/KthLargestElement.java @@ -1,15 +1,15 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.sorting.MergeSort; -import com.rampatra.base.MaxHeap; +import me.ramswaroop.arrays.sorting.MergeSort; +import me.ramswaroop.common.MaxHeap; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/1/15 + * @author: ramswaroop + * @date: 8/1/15 * @time: 11:26 PM */ public class KthLargestElement { @@ -44,7 +44,7 @@ public static int getKthLargestElement(int[] a, int k) { maxHeap.buildMaxHeap(); while (true) { if (k == 1) break; - + maxHeap.extractMax(); k--; } @@ -52,7 +52,13 @@ public static int getKthLargestElement(int[] a, int k) { return maxHeap.findMax(); } - public static void main(String[] args) { + private static void swap(int[] a, int firstIndex, int secondIndex) { + a[firstIndex] = a[firstIndex] + a[secondIndex]; + a[secondIndex] = a[firstIndex] - a[secondIndex]; + a[firstIndex] = a[firstIndex] - a[secondIndex]; + } + + public static void main(String a[]) { int[] ar = new int[]{2, 4, 5, 7, 1, 8, 9}; System.out.println(Arrays.toString(ar)); System.out.println(getKthLargestElementNaive(ar, 3)); diff --git a/src/main/java/com/rampatra/arrays/LargestProductContiguousSubArray.java b/src/me/ramswaroop/arrays/LargestProductContiguousSubArray.java similarity index 79% rename from src/main/java/com/rampatra/arrays/LargestProductContiguousSubArray.java rename to src/me/ramswaroop/arrays/LargestProductContiguousSubArray.java index c7afb19b..367c5541 100644 --- a/src/main/java/com/rampatra/arrays/LargestProductContiguousSubArray.java +++ b/src/me/ramswaroop/arrays/LargestProductContiguousSubArray.java @@ -1,15 +1,16 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 5/28/15 + * @author: ramswaroop + * @date: 5/28/15 * @time: 12:44 PM */ public class LargestProductContiguousSubArray { /** + * * @param a * @return */ @@ -17,7 +18,7 @@ public static int getLargestProductContiguousSubArray(int[] a) { return 0; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getLargestProductContiguousSubArray(new int[]{-2, 1, -3, 4, 5, -1, 4})); System.out.println(getLargestProductContiguousSubArray(new int[]{6, -3, -10, 0, 2})); } diff --git a/src/main/java/com/rampatra/arrays/LargestSumContiguousSubArray.java b/src/me/ramswaroop/arrays/LargestSumContiguousSubArray.java similarity index 94% rename from src/main/java/com/rampatra/arrays/LargestSumContiguousSubArray.java rename to src/me/ramswaroop/arrays/LargestSumContiguousSubArray.java index 8b34d9ef..14266935 100644 --- a/src/main/java/com/rampatra/arrays/LargestSumContiguousSubArray.java +++ b/src/me/ramswaroop/arrays/LargestSumContiguousSubArray.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 5/28/15 + * @author: ramswaroop + * @date: 5/28/15 * @time: 12:44 PM */ public class LargestSumContiguousSubArray { @@ -47,7 +47,7 @@ public static int getLargestSumOfContiguousSubArrayWhenAllNosNegative(int[] a) { return maxSum; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getLargestSumOfContiguousSubArray(new int[]{-2, 1, -3, 4, 5, -1, 4})); System.out.println(getLargestSumOfContiguousSubArray(new int[]{2, -1, -3, 4, -5, 1, 4})); // kadane's algorithm doesn't work if all no.s are -ve diff --git a/src/main/java/com/rampatra/arrays/LeadersInArray.java b/src/me/ramswaroop/arrays/LeadersInArray.java similarity index 90% rename from src/main/java/com/rampatra/arrays/LeadersInArray.java rename to src/me/ramswaroop/arrays/LeadersInArray.java index c2075751..837da57c 100644 --- a/src/main/java/com/rampatra/arrays/LeadersInArray.java +++ b/src/me/ramswaroop/arrays/LeadersInArray.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/29/15 + * @author: ramswaroop + * @date: 7/29/15 * @time: 12:06 PM */ public class LeadersInArray { @@ -37,7 +37,7 @@ public static int[] getAllLeaders(int[] a) { return Arrays.copyOfRange(leaders, 0, j + 1); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getAllLeaders(new int[]{16, 17, 4, 3, 5, 2}))); System.out.println(Arrays.toString(getAllLeaders(new int[]{16, 1, 4, 3, 5, 12}))); System.out.println(Arrays.toString(getAllLeaders(new int[]{16, 15, 14, 13, 12, 10}))); diff --git a/src/main/java/com/rampatra/arrays/LongestBitonicSubArray.java b/src/me/ramswaroop/arrays/LongestBitonicSubArray.java similarity index 94% rename from src/main/java/com/rampatra/arrays/LongestBitonicSubArray.java rename to src/me/ramswaroop/arrays/LongestBitonicSubArray.java index dc3caafb..e804b8fa 100644 --- a/src/main/java/com/rampatra/arrays/LongestBitonicSubArray.java +++ b/src/me/ramswaroop/arrays/LongestBitonicSubArray.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/18/15 + * @author: ramswaroop + * @date: 9/18/15 * @time: 5:10 PM */ public class LongestBitonicSubArray { @@ -54,7 +54,7 @@ public static int getLongestBitonicSubArrayLength(int[] a) { return bitonicLength; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getLongestBitonicSubArrayLength(new int[]{1, 2, 5, 4, 3})); System.out.println(getLongestBitonicSubArrayLength(new int[]{12, 4, 78, 90, 45, 23})); System.out.println(getLongestBitonicSubArrayLength(new int[]{10, 20, 30, 40})); diff --git a/src/main/java/com/rampatra/arrays/MajorityElement.java b/src/me/ramswaroop/arrays/MajorityElement.java similarity index 80% rename from src/main/java/com/rampatra/arrays/MajorityElement.java rename to src/me/ramswaroop/arrays/MajorityElement.java index 51e5d11f..1e1dc32a 100644 --- a/src/main/java/com/rampatra/arrays/MajorityElement.java +++ b/src/me/ramswaroop/arrays/MajorityElement.java @@ -1,18 +1,24 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; + +/** + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 5/20/15 + * @time: 2:36 PM + */ + /** * The algorithm for finding a possible candidate * works in O(n) which is known as Moore’s Voting Algorithm. * Basic idea of the algorithm is if we cancel out each * occurrence of an element e with all the other elements - * that are different from e then e will exist until end + * that are different from e then e will exist till end * if it is a majority element. *

* Time Complexity: O(n) * Auxiliary Space : O(1) - * - * @author rampatra - * @since 5/20/15 */ public class MajorityElement { @@ -23,7 +29,7 @@ public class MajorityElement { * @param a * @return */ - public static int findCandidate(int[] a) { + public static int findCandidate(int a[]) { int candidate = a[0], count = 1; for (int i = 1; i < a.length; i++) { if (candidate == a[i]) { @@ -39,7 +45,7 @@ public static int findCandidate(int[] a) { return candidate; } - public static void majorityElement(int[] a) { + public static void majorityElement(int a[]) { int candidate = findCandidate(a), count = 0; @@ -56,7 +62,7 @@ public static void majorityElement(int[] a) { } } - public static void main(String[] args) { + public static void main(String a[]) { majorityElement(new int[]{1, 6, 2, 2, 2, 1, 2, 2, 7, 2}); } -} \ No newline at end of file +} diff --git a/src/main/java/com/rampatra/arrays/MajorityElementInSortedArray.java b/src/me/ramswaroop/arrays/MajorityElementInSortedArray.java similarity index 59% rename from src/main/java/com/rampatra/arrays/MajorityElementInSortedArray.java rename to src/me/ramswaroop/arrays/MajorityElementInSortedArray.java index ded2db27..f75289fe 100644 --- a/src/main/java/com/rampatra/arrays/MajorityElementInSortedArray.java +++ b/src/me/ramswaroop/arrays/MajorityElementInSortedArray.java @@ -1,31 +1,32 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/31/15 + * @author: ramswaroop + * @date: 7/31/15 + * @time: 10:02 AM */ public class MajorityElementInSortedArray { /** - * Checks if {@code n} is a majority element in array {@code arr} + * Checks if {@param n} is a majority element in array {@param a} * by performing a binary search. *

* Time complexity: O(log n) * - * @param arr + * @param a * @param n * @return */ - public static boolean isMajorityElement(int[] arr, int n) { - int l = arr.length; - int startIndex = getFirstIndexOf(arr, n, 0, l - 1); + public static boolean isMajorityElement(int[] a, int n) { + int l = a.length; + int startIndex = getFirstIndexOf(a, n, 0, l - 1); // element not found if (startIndex == -1) return false; - if (startIndex + l / 2 < l && arr[startIndex + l / 2] == n) { + if (startIndex + l / 2 < l && a[startIndex + l / 2] == n) { return true; } else { return false; @@ -34,15 +35,15 @@ public static boolean isMajorityElement(int[] arr, int n) { } /** - * Returns the index of first occurrence of {@code n} in array {@code arr}. + * Returns the index of first occurrence of {@param n} in array {@param a}. * - * @param arr + * @param a * @param low * @param high * @param n * @return */ - public static int getFirstIndexOf(int[] arr, int n, int low, int high) { + public static int getFirstIndexOf(int[] a, int n, int low, int high) { if (low <= high) { int mid = (low + high) / 2; /** @@ -52,18 +53,18 @@ public static int getFirstIndexOf(int[] arr, int n, int low, int high) { * (i) mid == 0 and a[mid] == n * (ii) n > a[mid-1] and a[mid] == n */ - if (arr[mid] == n && (mid == 0 || n > arr[mid - 1])) { + if (a[mid] == n && (mid == 0 || n > a[mid - 1])) { return mid; - } else if (n <= arr[mid]) { - return getFirstIndexOf(arr, n, low, mid - 1); + } else if (n <= a[mid]) { + return getFirstIndexOf(a, n, low, mid - 1); } else { - return getFirstIndexOf(arr, n, mid + 1, high); + return getFirstIndexOf(a, n, mid + 1, high); } } return -1; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(isMajorityElement(new int[]{2, 2}, 2)); System.out.println(isMajorityElement(new int[]{1, 2}, 2)); System.out.println(isMajorityElement(new int[]{1, 2, 2, 2, 2, 2, 3, 3}, 2)); diff --git a/src/main/java/com/rampatra/arrays/MatrixInSpiral.java b/src/me/ramswaroop/arrays/MatrixInSpiral.java similarity index 94% rename from src/main/java/com/rampatra/arrays/MatrixInSpiral.java rename to src/me/ramswaroop/arrays/MatrixInSpiral.java index a498f39a..da4ce95e 100644 --- a/src/main/java/com/rampatra/arrays/MatrixInSpiral.java +++ b/src/me/ramswaroop/arrays/MatrixInSpiral.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import static java.lang.System.out; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/9/15 + * @author: ramswaroop + * @date: 9/9/15 * @time: 2:55 PM */ public class MatrixInSpiral { @@ -43,7 +43,7 @@ public static void printMatrixInSpiral(int[][] a) { } } - public static void main(String[] args) { + public static void main(String a[]) { printMatrixInSpiral(new int[][]{{1}, {2}}); out.println(); printMatrixInSpiral(new int[][]{{1, 2}, {3, 4}}); diff --git a/src/main/java/com/rampatra/arrays/MaxDiffWithLargerElementAfterSmallerElement.java b/src/me/ramswaroop/arrays/MaxDiffWithLargerElementAfterSmallerElement.java similarity index 91% rename from src/main/java/com/rampatra/arrays/MaxDiffWithLargerElementAfterSmallerElement.java rename to src/me/ramswaroop/arrays/MaxDiffWithLargerElementAfterSmallerElement.java index 04d7a9f8..b5aa0d01 100644 --- a/src/main/java/com/rampatra/arrays/MaxDiffWithLargerElementAfterSmallerElement.java +++ b/src/me/ramswaroop/arrays/MaxDiffWithLargerElementAfterSmallerElement.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/12/15 + * @author: ramswaroop + * @date: 8/12/15 * @time: 5:40 PM */ public class MaxDiffWithLargerElementAfterSmallerElement { @@ -35,7 +35,7 @@ public static int getMaxDiffWithLargerElementAfterSmallerElement(int[] a) { return maxDiff; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getMaxDiffWithLargerElementAfterSmallerElement(new int[]{2, 1, 4, 5, 10, 0})); System.out.println(getMaxDiffWithLargerElementAfterSmallerElement(new int[]{2, -6, 4, 5, 10, 1})); System.out.println(getMaxDiffWithLargerElementAfterSmallerElement(new int[]{-2, -6, -4, -5, -10, -1})); diff --git a/src/main/java/com/rampatra/arrays/MaxInAllSubArrays.java b/src/me/ramswaroop/arrays/MaxInAllSubArrays.java similarity index 95% rename from src/main/java/com/rampatra/arrays/MaxInAllSubArrays.java rename to src/me/ramswaroop/arrays/MaxInAllSubArrays.java index 8061d44d..6bfb01da 100644 --- a/src/main/java/com/rampatra/arrays/MaxInAllSubArrays.java +++ b/src/me/ramswaroop/arrays/MaxInAllSubArrays.java @@ -1,6 +1,6 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.base.MaxHeap; +import me.ramswaroop.common.MaxHeap; import java.util.ArrayDeque; import java.util.Arrays; @@ -8,8 +8,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/3/15 + * @author: ramswaroop + * @date: 9/3/15 * @time: 9:21 PM */ public class MaxInAllSubArrays { @@ -46,10 +46,10 @@ public static int[] maxInAllSubArraysOfSizeKNaive(int[] a, int k) { /** * Finds the maximum element in each and every sub-array * in {@param a} of size {@param k}. - *

+ * * Time complexity: O(n) * Auxiliary Space: O(k) - * + * * @param a * @param k * @return @@ -93,7 +93,7 @@ public static int[] maxInAllSubArraysOfSizeK(int[] a, int k) { return result; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(maxInAllSubArraysOfSizeKNaive(new int[]{1, 2, 3, 1, 4, 5, 2, 3, 6}, 3))); System.out.println(Arrays.toString(maxInAllSubArraysOfSizeKNaive(new int[]{8, 5, 10, 7, 9, 4, 15, 12, 90, 13}, 4))); System.out.println(Arrays.toString(maxInAllSubArraysOfSizeK(new int[]{1, 2, 3, 1, 4, 5, 2, 3, 6}, 3))); diff --git a/src/main/java/com/rampatra/arrays/MaxIndexDiff.java b/src/me/ramswaroop/arrays/MaxIndexDiff.java similarity index 94% rename from src/main/java/com/rampatra/arrays/MaxIndexDiff.java rename to src/me/ramswaroop/arrays/MaxIndexDiff.java index 9eb982c4..03c7ea5d 100644 --- a/src/main/java/com/rampatra/arrays/MaxIndexDiff.java +++ b/src/me/ramswaroop/arrays/MaxIndexDiff.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/1/15 + * @author: ramswaroop + * @date: 9/1/15 * @time: 10:21 PM */ public class MaxIndexDiff { @@ -49,7 +49,7 @@ public static int maxDiff(int[] a) { return maxDiff; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(maxDiff(new int[]{34, 8, 10, 3, 2, 80, 30, 33, 1})); System.out.println(maxDiff(new int[]{9, 2, 3, 4, 5, 6, 7, 8, 18, 0})); System.out.println(maxDiff(new int[]{1, 2, 3, 4, 5, 6})); diff --git a/src/main/java/com/rampatra/arrays/MaxMinWithMinComparisons.java b/src/me/ramswaroop/arrays/MaxMinWithMinComparisons.java similarity index 92% rename from src/main/java/com/rampatra/arrays/MaxMinWithMinComparisons.java rename to src/me/ramswaroop/arrays/MaxMinWithMinComparisons.java index 23e3e99d..7aaf304d 100644 --- a/src/main/java/com/rampatra/arrays/MaxMinWithMinComparisons.java +++ b/src/me/ramswaroop/arrays/MaxMinWithMinComparisons.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/31/15 + * @author: ramswaroop + * @date: 7/31/15 * @time: 3:16 PM */ public class MaxMinWithMinComparisons { @@ -53,7 +53,7 @@ public static int[] getMaxMinWithMinComparisons(int[] a) { return new int[]{min, max}; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getMaxMinWithMinComparisons(new int[]{2, 5, 1, 6, 7, 9, 0, 8, 10}))); } } diff --git a/src/main/java/com/rampatra/arrays/MaximumSizeSquareSubMatrix.java b/src/me/ramswaroop/arrays/MaximumSizeSquareSubMatrix.java similarity index 95% rename from src/main/java/com/rampatra/arrays/MaximumSizeSquareSubMatrix.java rename to src/me/ramswaroop/arrays/MaximumSizeSquareSubMatrix.java index 0c9c4419..251a6fc9 100644 --- a/src/main/java/com/rampatra/arrays/MaximumSizeSquareSubMatrix.java +++ b/src/me/ramswaroop/arrays/MaximumSizeSquareSubMatrix.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/4/15 + * @author: ramswaroop + * @date: 8/4/15 * @time: 11:48 PM */ public class MaximumSizeSquareSubMatrix { @@ -64,7 +64,7 @@ public static void printMaximumSizeSquareSubMatrix(int[][] a) { } } - public static void main(String[] args) { + public static void main(String a[]) { int[][] ar = new int[][]{{0, 1, 1, 1}, {1, 1, 0, 1}, {1, 0, 0, 1}, diff --git a/src/main/java/com/rampatra/arrays/MaximumSumNonAdjacentSubSequence.java b/src/me/ramswaroop/arrays/MaximumSumNonAdjacentSubsequence.java similarity index 86% rename from src/main/java/com/rampatra/arrays/MaximumSumNonAdjacentSubSequence.java rename to src/me/ramswaroop/arrays/MaximumSumNonAdjacentSubsequence.java index 9734aa29..d5b68b1b 100644 --- a/src/main/java/com/rampatra/arrays/MaximumSumNonAdjacentSubSequence.java +++ b/src/me/ramswaroop/arrays/MaximumSumNonAdjacentSubsequence.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/29/15 + * @author: ramswaroop + * @date: 7/29/15 * @time: 9:18 AM */ public class MaximumSumNonAdjacentSubSequence { @@ -17,7 +17,7 @@ public class MaximumSumNonAdjacentSubSequence { * Example: * 1) 3 2 7 10 should return 13 (sum of 3 and 10) * 2) 3 2 5 10 7 should return 15 (sum of 3, 5 and 7). - *

+ * * Here we maintain 2 variables incl and excl which is max sum till now (satisfying the constraint) * including the current element and excluding the current element respectively. * @@ -26,7 +26,7 @@ public class MaximumSumNonAdjacentSubSequence { */ public static int maximumSumNonAdjacentSubSequence(int[] a) { int incl = a[0], excl = 0, prevIncl = incl; // incl is max sum including the current element - // and excl is max sum excluding the current element + // and excl is max sum excluding the current element for (int i = 1; i < a.length; i++) { incl = excl + a[i]; // because we have to exclude the previous element if we consider the current element excl = Math.max(prevIncl, excl); // we are excluding the current element so we can consider the previous element or dont @@ -35,7 +35,7 @@ public static int maximumSumNonAdjacentSubSequence(int[] a) { return Math.max(incl, excl); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(maximumSumNonAdjacentSubSequence(new int[]{3, 2, 7, 10})); System.out.println(maximumSumNonAdjacentSubSequence(new int[]{3, 2, 5, 10, 7})); } diff --git a/src/main/java/com/rampatra/arrays/MedianOfStream.java b/src/me/ramswaroop/arrays/MedianOfStream.java similarity index 92% rename from src/main/java/com/rampatra/arrays/MedianOfStream.java rename to src/me/ramswaroop/arrays/MedianOfStream.java index 47781bc0..d92a002c 100644 --- a/src/main/java/com/rampatra/arrays/MedianOfStream.java +++ b/src/me/ramswaroop/arrays/MedianOfStream.java @@ -1,13 +1,13 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.base.MaxHeap; -import com.rampatra.base.MinHeap; +import me.ramswaroop.common.MaxHeap; +import me.ramswaroop.common.MinHeap; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/12/15 + * @author: ramswaroop + * @date: 9/12/15 * @time: 11:19 PM */ public class MedianOfStream { @@ -73,7 +73,7 @@ static int compare(int a, int b) { } } - public static void main(String[] args) { + public static void main(String a[]) { printMedianOfStream(new int[]{5, 15, 1, 3, 2, 8, 7, 9, 10, 6, 11, 4}); printMedianOfStream(new int[]{5, 15, 1}); printMedianOfStream(new int[]{5, 15, 10, 20}); diff --git a/src/main/java/com/rampatra/arrays/MedianOfTwoSortedArrays.java b/src/me/ramswaroop/arrays/MedianOfTwoSortedArrays.java similarity index 96% rename from src/main/java/com/rampatra/arrays/MedianOfTwoSortedArrays.java rename to src/me/ramswaroop/arrays/MedianOfTwoSortedArrays.java index d64ec757..24995176 100644 --- a/src/main/java/com/rampatra/arrays/MedianOfTwoSortedArrays.java +++ b/src/me/ramswaroop/arrays/MedianOfTwoSortedArrays.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/27/15 + * @author: ramswaroop + * @date: 7/27/15 * @time: 5:50 PM */ public class MedianOfTwoSortedArrays { @@ -94,7 +94,7 @@ public static int median(int[] a1, int[] a2) { } } - public static void main(String[] args) { + public static void main(String a[]) { // test cases System.out.println(median(new int[]{1, 2, 3, 6}, new int[]{4, 6, 8, 9})); System.out.println(median(new int[]{4, 6, 8, 9}, new int[]{1, 2, 3, 6})); diff --git a/src/main/java/com/rampatra/arrays/MergeArrayOfNIntoArrayOfMPlusN.java b/src/me/ramswaroop/arrays/MergeArrayOfNintoArrayOfMplusN.java similarity index 93% rename from src/main/java/com/rampatra/arrays/MergeArrayOfNIntoArrayOfMPlusN.java rename to src/me/ramswaroop/arrays/MergeArrayOfNintoArrayOfMplusN.java index e95c653a..51c1b72a 100644 --- a/src/main/java/com/rampatra/arrays/MergeArrayOfNIntoArrayOfMPlusN.java +++ b/src/me/ramswaroop/arrays/MergeArrayOfNintoArrayOfMplusN.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/27/15 + * @author: ramswaroop + * @date: 7/27/15 * @time: 12:15 PM */ public class MergeArrayOfNIntoArrayOfMPlusN { @@ -57,7 +57,7 @@ public static void merge(int[] mPlusN, int[] n) { } } - public static void main(String[] args) { + public static void main(String a[]) { int[] mPlusN = {2, NA, 12, NA, NA, 14, NA}; int[] n = {5, 7, 8, 10}; merge(mPlusN, n); diff --git a/src/main/java/com/rampatra/arrays/MinimumDistanceBetweenTwoNos.java b/src/me/ramswaroop/arrays/MinimumDistanceBetweenTwoNos.java similarity index 94% rename from src/main/java/com/rampatra/arrays/MinimumDistanceBetweenTwoNos.java rename to src/me/ramswaroop/arrays/MinimumDistanceBetweenTwoNos.java index 48edc1a9..560ab591 100644 --- a/src/main/java/com/rampatra/arrays/MinimumDistanceBetweenTwoNos.java +++ b/src/me/ramswaroop/arrays/MinimumDistanceBetweenTwoNos.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/6/15 + * @author: ramswaroop + * @date: 9/6/15 * @time: 10:53 PM */ public class MinimumDistanceBetweenTwoNos { @@ -45,7 +45,7 @@ public static int getMinimumDistanceBetweenTwoNos(int[] a, int x, int y) { return minDiff; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getMinimumDistanceBetweenTwoNos(new int[]{1, 2}, 1, 2)); System.out.println(getMinimumDistanceBetweenTwoNos(new int[]{3, 4, 5}, 3, 5)); System.out.println(getMinimumDistanceBetweenTwoNos(new int[]{3, 5, 4, 2, 6, 5, 6, 6, 5, 4, 8, 3}, 3, 6)); diff --git a/src/main/java/com/rampatra/arrays/MissingAndRepeatingElements.java b/src/me/ramswaroop/arrays/MissingAndRepeatingElements.java similarity index 92% rename from src/main/java/com/rampatra/arrays/MissingAndRepeatingElements.java rename to src/me/ramswaroop/arrays/MissingAndRepeatingElements.java index 5fe08bf2..a5b8a32f 100644 --- a/src/main/java/com/rampatra/arrays/MissingAndRepeatingElements.java +++ b/src/me/ramswaroop/arrays/MissingAndRepeatingElements.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/7/15 + * @author: ramswaroop + * @date: 9/7/15 * @time: 10:54 AM */ public class MissingAndRepeatingElements { @@ -38,7 +38,7 @@ public static int[] findMissingAndRepeatingElements(int[] a) { return result; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(findMissingAndRepeatingElements(new int[]{3, 1, 3}))); System.out.println(Arrays.toString(findMissingAndRepeatingElements(new int[]{4, 3, 6, 2, 1, 1}))); System.out.println(Arrays.toString(findMissingAndRepeatingElements(new int[]{4, 4, 6, 2, 5, 1}))); diff --git a/src/main/java/com/rampatra/arrays/MissingNumber.java b/src/me/ramswaroop/arrays/MissingNumber.java similarity index 92% rename from src/main/java/com/rampatra/arrays/MissingNumber.java rename to src/me/ramswaroop/arrays/MissingNumber.java index 6691f6db..504263f2 100644 --- a/src/main/java/com/rampatra/arrays/MissingNumber.java +++ b/src/me/ramswaroop/arrays/MissingNumber.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 5/28/15 + * @author: ramswaroop + * @date: 5/28/15 * @time: 4:34 PM */ @@ -48,7 +48,7 @@ public static int missingNumberUsingXOR(int a[], int n) { return nXOR ^ arrayXOR; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println("Missing No: " + missingNumber(new int[]{2, 3, 1, 4, 6, 7, 8}, 8)); System.out.println("Missing No using XOR: " + missingNumberUsingXOR(new int[]{2, 3, 1, 4, 6, 7, 8}, 8)); } diff --git a/src/main/java/com/rampatra/arrays/NextGreaterElement.java b/src/me/ramswaroop/arrays/NextGreaterElement.java similarity index 90% rename from src/main/java/com/rampatra/arrays/NextGreaterElement.java rename to src/me/ramswaroop/arrays/NextGreaterElement.java index 96c568f1..3039fb0a 100644 --- a/src/main/java/com/rampatra/arrays/NextGreaterElement.java +++ b/src/me/ramswaroop/arrays/NextGreaterElement.java @@ -1,13 +1,13 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.base.LinkedStack; -import com.rampatra.base.Stack; +import me.ramswaroop.common.LinkedStack; +import me.ramswaroop.common.Stack; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/26/15 + * @author: ramswaroop + * @date: 8/26/15 * @time: 12:35 PM */ public class NextGreaterElement { @@ -47,7 +47,7 @@ public static void nextGreaterElements(int[] a) { System.out.println(a[i] + "->" + -1); } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = new int[]{4, 5, 2, 25}; nextGreaterElements(ar); System.out.println("========="); diff --git a/src/main/java/com/rampatra/arrays/NextLargerNumber.java b/src/me/ramswaroop/arrays/NextLargerNumber.java similarity index 93% rename from src/main/java/com/rampatra/arrays/NextLargerNumber.java rename to src/me/ramswaroop/arrays/NextLargerNumber.java index 00e00b78..e937577a 100644 --- a/src/main/java/com/rampatra/arrays/NextLargerNumber.java +++ b/src/me/ramswaroop/arrays/NextLargerNumber.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.sorting.QuickSort; +import me.ramswaroop.arrays.sorting.QuickSort; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/30/15 + * @author: ramswaroop + * @date: 10/30/15 * @time: 11:01 AM * @see: http://www.geeksforgeeks.org/find-next-greater-number-set-digits/ */ @@ -44,7 +44,7 @@ public static int findNextLargerNumber(Integer n) { // digits are already in descending order, so return if (i <= 0) return -1; - + // find index of smallest no. greater than a[i-1] minIndex = i; int j = len - 1; @@ -84,7 +84,7 @@ private static void swap(int[] a, int index1, int index2) { a[index2] = temp; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(findNextLargerNumber(56)); System.out.println(findNextLargerNumber(65)); System.out.println(findNextLargerNumber(3451)); diff --git a/src/main/java/com/rampatra/arrays/NumberOccurringOddTimes.java b/src/me/ramswaroop/arrays/NumberOccurringOddTimes.java similarity index 74% rename from src/main/java/com/rampatra/arrays/NumberOccurringOddTimes.java rename to src/me/ramswaroop/arrays/NumberOccurringOddTimes.java index 81656dd1..71902bb0 100644 --- a/src/main/java/com/rampatra/arrays/NumberOccurringOddTimes.java +++ b/src/me/ramswaroop/arrays/NumberOccurringOddTimes.java @@ -1,21 +1,19 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 5/20/15 + * @author: ramswaroop + * @date: 5/20/15 * @time: 11:09 PM */ -import com.rampatra.bits.TwoNonRepeatingElements; - /** * Given an array of positive integers. All numbers occur * even number of times except one number which occurs odd * number of times. Find the number in O(n) time & constant space. - *

- * See {@link TwoNonRepeatingElements} for a more + * + * See {@link me.ramswaroop.bits.TwoNonRepeatingElements} for a more * complex problem which is solved in a similar approach. */ public class NumberOccurringOddTimes { @@ -28,7 +26,7 @@ public static int numberOccurringOddTimes(int a[]) { return res; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.print(numberOccurringOddTimes(new int[]{2, 3, 3, 3, 1, 2, 1})); } } diff --git a/src/main/java/com/rampatra/arrays/OccurrencesInSortedArray.java b/src/me/ramswaroop/arrays/OccurrencesInSortedArray.java similarity index 95% rename from src/main/java/com/rampatra/arrays/OccurrencesInSortedArray.java rename to src/me/ramswaroop/arrays/OccurrencesInSortedArray.java index fea37847..d4af1859 100644 --- a/src/main/java/com/rampatra/arrays/OccurrencesInSortedArray.java +++ b/src/me/ramswaroop/arrays/OccurrencesInSortedArray.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/31/15 + * @author: ramswaroop + * @date: 8/31/15 * @time: 2:52 PM */ public class OccurrencesInSortedArray { @@ -74,7 +74,7 @@ public static int getLastIndexOf(int[] a, int n, int low, int high) { } } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getOccurrencesInSortedArray(new int[]{1, 1, 2, 2, 2, 2, 3}, 1)); System.out.println(getOccurrencesInSortedArray(new int[]{1, 1, 1, 2, 2, 2, 2, 3}, 1)); System.out.println(getOccurrencesInSortedArray(new int[]{1, 1, 2, 2, 2, 2, 3}, 2)); diff --git a/src/main/java/com/rampatra/arrays/PairDiff.java b/src/me/ramswaroop/arrays/PairDiff.java similarity index 90% rename from src/main/java/com/rampatra/arrays/PairDiff.java rename to src/me/ramswaroop/arrays/PairDiff.java index 8fce2367..670d1656 100644 --- a/src/main/java/com/rampatra/arrays/PairDiff.java +++ b/src/me/ramswaroop/arrays/PairDiff.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 5/18/15 + * @author: ramswaroop + * @date: 5/18/15 * @time: 10:24 PM */ @@ -15,7 +15,7 @@ /** * Given an array ar[] of n numbers and another number x, determine whether * or not there exists two elements in ar[] whose difference is exactly x. - * This problem is similar to {@link PairSum}. + * This problem is similar to {@link me.ramswaroop.arrays.PairSum}. */ public class PairDiff { @@ -63,7 +63,7 @@ static boolean pairDiff(int ar[], int x, Map map) { return false; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(pairDiff(new int[]{-3, 4, -6, 1, 1}, -4)); System.out.println(pairDiff(new int[]{3, 1}, 2)); System.out.println(pairDiff(new int[]{-3, 4, -6, 1, 1}, -4, new HashMap())); diff --git a/src/main/java/com/rampatra/arrays/PairSum.java b/src/me/ramswaroop/arrays/PairSum.java similarity index 51% rename from src/main/java/com/rampatra/arrays/PairSum.java rename to src/me/ramswaroop/arrays/PairSum.java index 75ce7d63..380aaad8 100644 --- a/src/main/java/com/rampatra/arrays/PairSum.java +++ b/src/me/ramswaroop/arrays/PairSum.java @@ -1,16 +1,21 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; + +/** + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 5/18/15 + * @time: 10:24 PM + */ import java.util.Arrays; -import java.util.HashSet; -import java.util.Set; +import java.util.HashMap; +import java.util.Map; /** * Given an array ar[] of n numbers and * another number x, determine whether or not there * exists two elements in ar[] whose sum is exactly x. - * - * @author rampatra - * @since 5/18/15 */ public class PairSum { @@ -20,18 +25,18 @@ public class PairSum { * then O(n^2) in worst case. * * @param ar - * @param sum + * @param x * @return */ - static boolean pairSum(int[] ar, int sum) { + static boolean pairSum(int ar[], int x) { Arrays.sort(ar); int len = ar.length; for (int i = 0, j = len - 1; i < j; ) { - if (ar[i] + ar[j] == sum) { + if (ar[i] + ar[j] == x) { return true; - } else if (ar[i] + ar[j] < sum) { // approach towards larger elements + } else if (ar[i] + ar[j] < x) { // approach towards larger elements i++; } else { // approach towards smaller elements j--; @@ -41,30 +46,25 @@ static boolean pairSum(int[] ar, int sum) { } /** - * Using hashmap in O(n) time. + * Using hashmap in O(n) time * * @param ar - * @param sum - * @param numSet + * @param x + * @param map * @return */ - static boolean pairSum(int[] ar, int sum, Set numSet) { + static boolean pairSum(int ar[], int x, Map map) { for (int i = 0; i < ar.length; i++) { - if (numSet.contains(sum - ar[i])) { + if (map.containsKey(x - ar[i])) { return true; } - numSet.add(ar[i]); + map.put(ar[i], 1); } return false; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(pairSum(new int[]{-3, 4, -6, 1, 1}, -2)); - System.out.println(pairSum(new int[]{-3, 4, -6, 1, 1}, 5)); - System.out.println(pairSum(new int[]{-3, 4, -6, 1, 1}, 0)); - System.out.println("--------"); - System.out.println(pairSum(new int[]{-3, 4, -6, 1, 1}, -2, new HashSet<>())); - System.out.println(pairSum(new int[]{-3, 4, -6, 1, 1}, 5, new HashSet<>())); - System.out.println(pairSum(new int[]{-3, 4, -6, 1, 1}, 0, new HashSet<>())); + System.out.println(pairSum(new int[]{-3, 4, -6, 1, 1}, -2, new HashMap())); } } diff --git a/src/me/ramswaroop/arrays/PivotedBinarySearch.java b/src/me/ramswaroop/arrays/PivotedBinarySearch.java new file mode 100644 index 00000000..d1b2ea7f --- /dev/null +++ b/src/me/ramswaroop/arrays/PivotedBinarySearch.java @@ -0,0 +1,68 @@ +package me.ramswaroop.arrays; + +import me.ramswaroop.arrays.searching.BinarySearch; + +/** + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 5/31/15 + * @time: 10:44 PM + */ +public class PivotedBinarySearch { + + /** + * Search an element in a sorted pivoted array {@param a}. + *

+ * Example, + * 1) For array [3,4,5,1,2] pivot is 5 + * 2) For array [6,7,8,5,4] pivot is 8 + * + * @param a + * @param n + * @return + */ + public static int pivotedBinarySearch(int a[], int n) { + int pivot = findPivot(a, 0, a.length - 1); + + if (pivot == -1 || a[pivot] == n) { + return pivot; + } else if (n <= a[0]) { + return BinarySearch.binarySearch(a, n, pivot + 1, a.length - 1); + } else { + return BinarySearch.binarySearch(a, n, 0, pivot - 1); + } + } + + /** + * Finds the pivot element in array {@param a}. Pivot element is the only + * element for which next element to it is smaller than it. + * + * @param a + * @param low + * @param high + * @return + */ + public static int findPivot(int a[], int low, int high) { + if (low > high) return -1; + if (low == high) return low; + + int mid = (low + high) / 2; + + if (a[mid] > a[mid + 1] && a[mid] > a[mid - 1]) { + return mid; + } else if (a[mid] > a[mid - 1] && a[mid] < a[mid + 1]) { + return findPivot(a, mid + 1, a.length - 1); + } else { + return findPivot(a, 0, mid - 1); + } + } + + public static void main(String a[]) { + System.out.println("Pivot: " + findPivot(new int[]{1, 2, 3, 4, 5}, 0, 3)); + System.out.println("Index: " + pivotedBinarySearch(new int[]{1, 2, 3, 4, 5}, 4)); + + System.out.println("Pivot: " + findPivot(new int[]{5}, 0, 0)); + System.out.println("Index: " + pivotedBinarySearch(new int[]{5}, 5)); + } +} diff --git a/src/main/java/com/rampatra/arrays/ProductArrayPuzzle.java b/src/me/ramswaroop/arrays/ProductArrayPuzzle.java similarity index 95% rename from src/main/java/com/rampatra/arrays/ProductArrayPuzzle.java rename to src/me/ramswaroop/arrays/ProductArrayPuzzle.java index 23de1acc..6abe5a3e 100644 --- a/src/main/java/com/rampatra/arrays/ProductArrayPuzzle.java +++ b/src/me/ramswaroop/arrays/ProductArrayPuzzle.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/15/15 + * @author: ramswaroop + * @date: 8/15/15 * @time: 9:17 PM */ public class ProductArrayPuzzle { @@ -63,7 +63,7 @@ public static int[] getProductArray(int[] a) { return prod; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getProductArray(new int[]{10, 3, 5, 6, 2}))); System.out.println(Arrays.toString(getProductArray(new int[]{0, 0}))); System.out.println(Arrays.toString(getProductArray(new int[]{1}))); diff --git a/src/main/java/com/rampatra/arrays/ReservoirSampling.java b/src/me/ramswaroop/arrays/ReservoirSampling.java similarity index 93% rename from src/main/java/com/rampatra/arrays/ReservoirSampling.java rename to src/me/ramswaroop/arrays/ReservoirSampling.java index 050fb17f..b0b6c34d 100644 --- a/src/main/java/com/rampatra/arrays/ReservoirSampling.java +++ b/src/me/ramswaroop/arrays/ReservoirSampling.java @@ -1,4 +1,4 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; import java.util.Random; @@ -6,8 +6,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/21/15 + * @author: ramswaroop + * @date: 7/21/15 * @time: 2:52 PM */ public class ReservoirSampling { @@ -22,10 +22,10 @@ public class ReservoirSampling { * a) Generate a random number from 0 to i where i is index of current item in * stream[]. Let the generated random number is j. * b) If j is in range 0 to k-1, replace reservoir[j] with arr[i]. - *

+ * * In the above procedure, we are computing random number for each of the indexes greater than k * thereby giving all items an equal probability. - *

+ * * NOTE: When {@param k} is small enough we can use a simpler method as follows: * Create an array reservoir[] of maximum size k. One by one randomly select an * item from stream[0..n-1]. If the selected item is not previously selected, then @@ -58,7 +58,7 @@ public static int[] getKRandomNumbers(int[] stream, int k) { } - public static void main(String[] args) { + public static void main(String a[]) { int[] stream = {1, 2, 3, 4, 5, 6, 7, 8, 9}; System.out.println(Arrays.toString(getKRandomNumbers(stream, 4))); } diff --git a/src/main/java/com/rampatra/arrays/ReverseArray.java b/src/me/ramswaroop/arrays/ReverseArray.java similarity index 90% rename from src/main/java/com/rampatra/arrays/ReverseArray.java rename to src/me/ramswaroop/arrays/ReverseArray.java index 64550c58..eb9fabdc 100644 --- a/src/main/java/com/rampatra/arrays/ReverseArray.java +++ b/src/me/ramswaroop/arrays/ReverseArray.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/27/15 + * @author: ramswaroop + * @date: 7/27/15 * @time: 8:40 PM */ public class ReverseArray { @@ -43,7 +43,7 @@ public static void reverseRecursive(int[] a, int i, int j) { reverseRecursive(a, ++i, --j); } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = new int[]{1, 2, 3, 4, 5}; System.out.println(Arrays.toString(ar)); reverse(ar); diff --git a/src/main/java/com/rampatra/arrays/RotateArray.java b/src/me/ramswaroop/arrays/RotateArray.java similarity index 90% rename from src/main/java/com/rampatra/arrays/RotateArray.java rename to src/me/ramswaroop/arrays/RotateArray.java index f720dcf6..57a168bb 100644 --- a/src/main/java/com/rampatra/arrays/RotateArray.java +++ b/src/me/ramswaroop/arrays/RotateArray.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/28/15 + * @author: ramswaroop + * @date: 7/28/15 * @time: 10:53 AM */ public class RotateArray { @@ -46,10 +46,10 @@ public static void rotateNaiveApproach(int[] a, int k) { * Reverse B, we get ArBr = [2, 1, 7, 6, 5, 4, 3] * Reverse all, we get (ArBr)r = [3, 4, 5, 6, 7, 1, 2] * NOTE: Ar = Reverse of A - * See: http://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/ * * @param a * @param k + * @see: http://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/ */ public static void rotateReversal(int[] a, int k) { ReverseArray.reverseRecursive(a, 0, k - 1); @@ -59,10 +59,10 @@ public static void rotateReversal(int[] a, int k) { /** * Juggling algorithm for array rotation. - * See: http://www.geeksforgeeks.org/array-rotation/ * * @param a * @param k + * @see: http://www.geeksforgeeks.org/array-rotation/ */ public static void rotateGCD(int[] a, int k) { int gcd = gcd(a.length, k), temp, i, j, p; @@ -91,7 +91,7 @@ public static int gcd(int a, int b) { } } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = {1, 2, 3, 4, 5, 6, 7}; System.out.println(Arrays.toString(ar)); rotateNaiveApproach(ar, 2); diff --git a/src/main/java/com/rampatra/arrays/RotateMatrixBy90Degrees.java b/src/me/ramswaroop/arrays/RotateMatrixBy90Degrees.java similarity index 92% rename from src/main/java/com/rampatra/arrays/RotateMatrixBy90Degrees.java rename to src/me/ramswaroop/arrays/RotateMatrixBy90Degrees.java index ccff75ca..9d81e9d8 100644 --- a/src/main/java/com/rampatra/arrays/RotateMatrixBy90Degrees.java +++ b/src/me/ramswaroop/arrays/RotateMatrixBy90Degrees.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/22/15 + * @author: ramswaroop + * @date: 8/22/15 * @time: 4:03 PM */ public class RotateMatrixBy90Degrees { @@ -42,7 +42,7 @@ private static void print2DMatrix(int[][] a) { } } - public static void main(String[] args) { + public static void main(String a[]) { int[][] ar = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; print2DMatrix(ar); System.out.println("--------"); diff --git a/src/main/java/com/rampatra/arrays/SearchInSorted2DArray.java b/src/me/ramswaroop/arrays/SearchInSorted2DArray.java similarity index 97% rename from src/main/java/com/rampatra/arrays/SearchInSorted2DArray.java rename to src/me/ramswaroop/arrays/SearchInSorted2DArray.java index 8ab14269..aa02619a 100644 --- a/src/main/java/com/rampatra/arrays/SearchInSorted2DArray.java +++ b/src/me/ramswaroop/arrays/SearchInSorted2DArray.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/23/15 + * @author: ramswaroop + * @date: 8/23/15 * @time: 10:31 PM */ public class SearchInSorted2DArray { @@ -86,7 +86,7 @@ private static void print2DMatrix(int[][] a) { } } - public static void main(String[] args) { + public static void main(String a[]) { int[][] ar = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; print2DMatrix(ar); System.out.println(Arrays.toString(linearSearchNaive(ar, 0, 0, 1))); diff --git a/src/main/java/com/rampatra/arrays/Segregate0s1sAnd2s.java b/src/me/ramswaroop/arrays/Segregate0s1sAnd2s.java similarity index 92% rename from src/main/java/com/rampatra/arrays/Segregate0s1sAnd2s.java rename to src/me/ramswaroop/arrays/Segregate0s1sAnd2s.java index e64929f8..e0e767c5 100644 --- a/src/main/java/com/rampatra/arrays/Segregate0s1sAnd2s.java +++ b/src/me/ramswaroop/arrays/Segregate0s1sAnd2s.java @@ -1,26 +1,26 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/18/15 + * @author: ramswaroop + * @date: 8/18/15 * @time: 8:38 PM */ public class Segregate0s1sAnd2s { /** - * Segregates an array {@param a} consisting of only 0s, 1s and 2s. Based on + * Segregates an array {@param a} consisting of only 0s, 1s and 2s. Based on * Dutch National Flag (DNF) problem {@see: http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Flag/}. - * + * * @param a */ public static void segregate0s1sAnd2s(int[] a) { // assume low points to 0 and mid to 1 and high to 2 int low = 0, mid = 0, high = a.length - 1; - + while (mid <= high) { switch (a[mid]) { case 0: // mid points to 0 but it should point to 1 so swap it with low @@ -45,7 +45,7 @@ private static void swap(int[] a, int index1, int index2) { a[index2] = temp; } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = new int[]{0, 1, 2, 0, 1, 2}; segregate0s1sAnd2s(ar); System.out.println(Arrays.toString(ar)); diff --git a/src/main/java/com/rampatra/arrays/Segregate0sAnd1s.java b/src/me/ramswaroop/arrays/Segregate0sAnd1s.java similarity index 85% rename from src/main/java/com/rampatra/arrays/Segregate0sAnd1s.java rename to src/me/ramswaroop/arrays/Segregate0sAnd1s.java index e5f9634a..2e0f4e06 100644 --- a/src/main/java/com/rampatra/arrays/Segregate0sAnd1s.java +++ b/src/me/ramswaroop/arrays/Segregate0sAnd1s.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/31/15 + * @author: ramswaroop + * @date: 7/31/15 * @time: 5:13 PM */ public class Segregate0sAnd1s { @@ -27,7 +27,7 @@ public static void segregate0sAnd1s(int[] a) { } } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = new int[]{0, 1, 1, 1, 0, 0, 1}; segregate0sAnd1s(ar); System.out.println(Arrays.toString(ar)); diff --git a/src/main/java/com/rampatra/arrays/SegregateEvenAndOddNos.java b/src/me/ramswaroop/arrays/SegregateEvenAndOddNos.java similarity index 86% rename from src/main/java/com/rampatra/arrays/SegregateEvenAndOddNos.java rename to src/me/ramswaroop/arrays/SegregateEvenAndOddNos.java index 8cdaf6b6..aa79fd4a 100644 --- a/src/main/java/com/rampatra/arrays/SegregateEvenAndOddNos.java +++ b/src/me/ramswaroop/arrays/SegregateEvenAndOddNos.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/31/15 + * @author: ramswaroop + * @date: 7/31/15 * @time: 5:13 PM */ public class SegregateEvenAndOddNos { @@ -15,7 +15,7 @@ public class SegregateEvenAndOddNos { * Segregate even and odd numbers by traversing the * array {@param a} only once. *

- * This is similar to {@link Segregate0sAnd1s}. + * This is similar to {@link me.ramswaroop.arrays.Segregate0sAnd1s}. * * @param a */ @@ -39,7 +39,7 @@ public static void segregateEvenAndOddNos(int[] a) { } } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = new int[]{12, 34, 45, 9, 8, 90, 3}; segregateEvenAndOddNos(ar); System.out.println(Arrays.toString(ar)); diff --git a/src/main/java/com/rampatra/arrays/SmallestAndSecondSmallest.java b/src/me/ramswaroop/arrays/SmallestAndSecondSmallest.java similarity index 80% rename from src/main/java/com/rampatra/arrays/SmallestAndSecondSmallest.java rename to src/me/ramswaroop/arrays/SmallestAndSecondSmallest.java index 9e683caf..4519a539 100644 --- a/src/main/java/com/rampatra/arrays/SmallestAndSecondSmallest.java +++ b/src/me/ramswaroop/arrays/SmallestAndSecondSmallest.java @@ -1,16 +1,17 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/30/15 + * @author: ramswaroop + * @date: 7/30/15 + * @time: 11:13 PM */ public class SmallestAndSecondSmallest { - private static int[] getSmallestAndSecondSmallest(int[] a) { + public static int[] getSmallestAndSecondSmallest(int[] a) { int smallest = Integer.MAX_VALUE, secondSmallest = Integer.MAX_VALUE; for (int i = 0; i < a.length; i++) { @@ -25,7 +26,7 @@ private static int[] getSmallestAndSecondSmallest(int[] a) { return new int[]{smallest, secondSmallest}; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getSmallestAndSecondSmallest(new int[]{100, 1, 60, -10, -80, 85, 70, -80}))); System.out.println(Arrays.toString(getSmallestAndSecondSmallest(new int[]{100, 1, 60, 10, 80, 85, 70, 0}))); } diff --git a/src/main/java/com/rampatra/arrays/SmallestMissingNumber.java b/src/me/ramswaroop/arrays/SmallestMissingNumber.java similarity index 94% rename from src/main/java/com/rampatra/arrays/SmallestMissingNumber.java rename to src/me/ramswaroop/arrays/SmallestMissingNumber.java index 7b63a415..5a8cd2a6 100644 --- a/src/main/java/com/rampatra/arrays/SmallestMissingNumber.java +++ b/src/me/ramswaroop/arrays/SmallestMissingNumber.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/29/15 + * @author: ramswaroop + * @date: 8/29/15 * @time: 12:51 PM */ public class SmallestMissingNumber { @@ -45,7 +45,7 @@ public static int smallestMissingNumber(int[] a, int low, int high) { } } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(smallestMissingNumber(new int[]{0, 1}, 0, 1)); System.out.println(smallestMissingNumber(new int[]{0, 1, 2, 6, 9}, 0, 4)); System.out.println(smallestMissingNumber(new int[]{4, 5, 10, 11}, 0, 3)); diff --git a/src/main/java/com/rampatra/arrays/SortedSubSequence.java b/src/me/ramswaroop/arrays/SortedSubSequence.java similarity index 77% rename from src/main/java/com/rampatra/arrays/SortedSubSequence.java rename to src/me/ramswaroop/arrays/SortedSubSequence.java index b6cd1b5c..42893683 100644 --- a/src/main/java/com/rampatra/arrays/SortedSubSequence.java +++ b/src/me/ramswaroop/arrays/SortedSubSequence.java @@ -1,10 +1,11 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/12/15 + * @author: ramswaroop + * @date: 10/12/15 + * @time: 8:32 PM */ public class SortedSubSequence { @@ -12,24 +13,24 @@ public class SortedSubSequence { * Finds 3 elements such that a[i] < a[j] < a[k] and i < j < k in O(n) time * in an array of n integers. If there are multiple such triplets, then prints any * one of them. - *

+ * * Algorithm: * 1) Create an auxiliary array smaller[0..n-1]. smaller[i] should store the index of a number which is smaller than arr[i] and is on left side of arr[i]. smaller[i] should contain -1 if there is no such element. * 2) Create another auxiliary array greater[0..n-1]. greater[i] should store the index of a number which is greater than arr[i] and is on right side of arr[i]. greater[i] should contain -1 if there is no such element. * 3) Finally traverse both smaller[] and greater[] and find the index i for which both smaller[i] and greater[i] are not -1. * - * @param arr + * @param a */ - public static void printSortedSubSequenceOfSize3(int[] arr) { - int len = arr.length, min = arr[0], max = arr[len - 1]; + public static void printSortedSubSequenceOfSize3(int[] a) { + int len = a.length, min = a[0], max = a[len - 1]; int[] smaller = new int[len], larger = new int[len]; smaller[0] = -1; for (int i = 1; i < len; i++) { - if (arr[i] < min) { + if (a[i] < min) { smaller[i] = -1; - min = arr[i]; + min = a[i]; } else { smaller[i] = min; } @@ -37,9 +38,9 @@ public static void printSortedSubSequenceOfSize3(int[] arr) { larger[len - 1] = -1; for (int i = len - 2; i >= 0; i--) { - if (arr[i] > max) { + if (a[i] > max) { larger[i] = -1; - max = arr[i]; + max = a[i]; } else { larger[i] = max; } @@ -47,14 +48,14 @@ public static void printSortedSubSequenceOfSize3(int[] arr) { for (int i = 0; i < len; i++) { if (smaller[i] != -1 && larger[i] != -1) { - System.out.println(smaller[i] + "," + arr[i] + "," + larger[i]); + System.out.println(smaller[i] + "," + a[i] + "," + larger[i]); break; } } } - public static void main(String[] args) { + public static void main(String a[]) { printSortedSubSequenceOfSize3(new int[]{12, 11, 10, 5, 6, 2, 30}); printSortedSubSequenceOfSize3(new int[]{1, 2, 3, 4}); printSortedSubSequenceOfSize3(new int[]{4, 3, 2, 1}); diff --git a/src/main/java/com/rampatra/arrays/SubArrayOfSum.java b/src/me/ramswaroop/arrays/SubArrayOfSum.java similarity index 92% rename from src/main/java/com/rampatra/arrays/SubArrayOfSum.java rename to src/me/ramswaroop/arrays/SubArrayOfSum.java index 4e4f5c2e..78ded53f 100644 --- a/src/main/java/com/rampatra/arrays/SubArrayOfSum.java +++ b/src/me/ramswaroop/arrays/SubArrayOfSum.java @@ -1,10 +1,10 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/27/15 + * @author: ramswaroop + * @date: 9/27/15 * @time: 7:32 PM */ public class SubArrayOfSum { @@ -37,7 +37,7 @@ public static void printSubArrayOfSum(int[] a, int sum) { System.out.println("Sub-array with sum " + sum + " not found!"); } - public static void main(String[] args) { + public static void main(String a[]) { printSubArrayOfSum(new int[]{1, 4, 20, 3, 10, 5}, 33); printSubArrayOfSum(new int[]{1, 4, 20, 3, 10, 5}, 38); printSubArrayOfSum(new int[]{1, 4, 20, 3, 10, 5}, 13); diff --git a/src/main/java/com/rampatra/arrays/SubsetOfArray.java b/src/me/ramswaroop/arrays/SubsetOfArray.java similarity index 89% rename from src/main/java/com/rampatra/arrays/SubsetOfArray.java rename to src/me/ramswaroop/arrays/SubsetOfArray.java index 21d5ff2c..47e3154f 100644 --- a/src/main/java/com/rampatra/arrays/SubsetOfArray.java +++ b/src/me/ramswaroop/arrays/SubsetOfArray.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.sorting.QuickSort; +import me.ramswaroop.arrays.sorting.QuickSort; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/4/15 + * @author: ramswaroop + * @date: 9/4/15 * @time: 11:28 PM */ public class SubsetOfArray { @@ -17,7 +17,7 @@ public class SubsetOfArray { * Explanation: The below method uses sorting + merge method of merge sort. Time * complexity is O(mlogm + nlogn) where m and n are lengths of array a and b resp. * You could also have used sorting + binary search but this fails when array - * {@param b} has repeating elements for example, a={1,4,2} and b={1,4,4,2}. Time + * {@param b} has repeating elements for example, a={1,4,2} and b={1,4,4,2}. Time * complexity would be O(mlogm + nlogm). * * @param a @@ -48,7 +48,7 @@ public static boolean isSubsetOfArray(int[] a, int[] b) { } } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(isSubsetOfArray(new int[]{11, 1, 13, 21, 3, 7}, new int[]{11, 3, 7, 1})); System.out.println(isSubsetOfArray(new int[]{1, 2, 2, 3, 4, 5, 6}, new int[]{1, 2, 4})); System.out.println(isSubsetOfArray(new int[]{1, 2, 2, 3, 4, 5, 6}, new int[]{1, 2, 2, 4})); diff --git a/src/main/java/com/rampatra/arrays/SymmetricDifference.java b/src/me/ramswaroop/arrays/SymmetricDifference.java similarity index 93% rename from src/main/java/com/rampatra/arrays/SymmetricDifference.java rename to src/me/ramswaroop/arrays/SymmetricDifference.java index 9ae00478..dcd7fa98 100644 --- a/src/main/java/com/rampatra/arrays/SymmetricDifference.java +++ b/src/me/ramswaroop/arrays/SymmetricDifference.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/20/15 + * @author: ramswaroop + * @date: 10/20/15 * @time: 11:34 PM */ public class SymmetricDifference { @@ -51,7 +51,7 @@ public static int[] getSymmetricDifference(int[] a1, int[] a2) { return Arrays.copyOf(res, index); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getSymmetricDifference(new int[]{1, 2, 3, 4}, new int[]{2, 4, 5}))); System.out.println(Arrays.toString(getSymmetricDifference(new int[]{1, 2, 3, 4}, new int[]{5, 6, 7}))); System.out.println(Arrays.toString(getSymmetricDifference(new int[]{1, 2, 3, 4}, new int[]{5, 6, 7, 8}))); diff --git a/src/main/java/com/rampatra/arrays/TripletOfSum.java b/src/me/ramswaroop/arrays/TripletOfSum.java similarity index 87% rename from src/main/java/com/rampatra/arrays/TripletOfSum.java rename to src/me/ramswaroop/arrays/TripletOfSum.java index 91d47649..087cb343 100644 --- a/src/main/java/com/rampatra/arrays/TripletOfSum.java +++ b/src/me/ramswaroop/arrays/TripletOfSum.java @@ -1,14 +1,14 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.sorting.QuickSort; +import me.ramswaroop.arrays.sorting.QuickSort; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/28/15 + * @author: ramswaroop + * @date: 9/28/15 * @time: 10:39 PM */ public class TripletOfSum { @@ -42,7 +42,7 @@ public static int[] getTripletOfSum(int[] a, int sum) { return new int[]{-1}; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getTripletOfSum(new int[]{12, 3, 4, 5, 1, 6, 9}, 24))); System.out.println(Arrays.toString(getTripletOfSum(new int[]{12, 3, 4, 5, 1, 6, 9}, 19))); System.out.println(Arrays.toString(getTripletOfSum(new int[]{1, 2, 3}, 6))); diff --git a/src/main/java/com/rampatra/arrays/TwoElementsSumClosestToZero.java b/src/me/ramswaroop/arrays/TwoElementsSumClosestToZero.java similarity index 87% rename from src/main/java/com/rampatra/arrays/TwoElementsSumClosestToZero.java rename to src/me/ramswaroop/arrays/TwoElementsSumClosestToZero.java index e41a0f92..db1eb771 100644 --- a/src/main/java/com/rampatra/arrays/TwoElementsSumClosestToZero.java +++ b/src/me/ramswaroop/arrays/TwoElementsSumClosestToZero.java @@ -1,14 +1,14 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; -import com.rampatra.sorting.QuickSort; +import me.ramswaroop.arrays.sorting.QuickSort; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/30/15 + * @author: ramswaroop + * @date: 7/30/15 * @time: 5:44 PM */ public class TwoElementsSumClosestToZero { @@ -39,7 +39,7 @@ public static int[] getTwoElementsWhoseSumIsClosestToZero(int[] a) { return new int[]{n1, n2}; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getTwoElementsWhoseSumIsClosestToZero(new int[]{1, 60, -10, -80, 85, 70}))); System.out.println(Arrays.toString(getTwoElementsWhoseSumIsClosestToZero(new int[]{-3, -100, -10, -80, 85, 70}))); } diff --git a/src/main/java/com/rampatra/arrays/TwoRepeatingElements.java b/src/me/ramswaroop/arrays/TwoRepeatingElements.java similarity index 91% rename from src/main/java/com/rampatra/arrays/TwoRepeatingElements.java rename to src/me/ramswaroop/arrays/TwoRepeatingElements.java index a943a532..c1c9a4ae 100644 --- a/src/main/java/com/rampatra/arrays/TwoRepeatingElements.java +++ b/src/me/ramswaroop/arrays/TwoRepeatingElements.java @@ -1,21 +1,19 @@ -package com.rampatra.arrays; - -import com.rampatra.bits.TwoNonRepeatingElements; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/17/15 + * @author: ramswaroop + * @date: 8/17/15 * @time: 7:23 PM */ public class TwoRepeatingElements { /** * Finds the 2 repeating elements in an array {@param a} of 1 to n elements and n+2 length. This is - * similar to {@link TwoNonRepeatingElements}. + * similar to {@link me.ramswaroop.bits.TwoNonRepeatingElements}. *

* EXPLANATION: * Let the repeating numbers be X and Y, if we xor all the elements in the array and all integers from 1 to n, @@ -69,9 +67,9 @@ public static int[] getTwoRepeatingElements(int[] a) { * Once we encounter a element lets say 2 then we make the element in 2nd index -ve just * to mark that we have encountered 2. When we encounter 2 again and see that 2nd index * is already -ve we conclude that 2 is repeated. - *

- * Similar to {@link DuplicatesInArray#findDuplicatesInArray(int[])}. - * + * + * Similar to {@link me.ramswaroop.arrays.DuplicatesInArray#findDuplicatesInArray(int[])}. + * * @param a * @return */ @@ -88,7 +86,7 @@ public static int[] findTwoRepeatingElements(int[] a) { return repeatingElements; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getTwoRepeatingElements(new int[]{4, 2, 4, 5, 2, 3, 1}))); System.out.println(Arrays.toString(getTwoRepeatingElements(new int[]{2, 4, 5, 2, 3, 1, 6, 7, 7}))); System.out.println(Arrays.toString(getTwoRepeatingElements(new int[]{1, 2, 1, 2}))); diff --git a/src/main/java/com/rampatra/arrays/TwoStacksInOneArray.java b/src/me/ramswaroop/arrays/TwoStacksInOneArray.java similarity index 95% rename from src/main/java/com/rampatra/arrays/TwoStacksInOneArray.java rename to src/me/ramswaroop/arrays/TwoStacksInOneArray.java index b4e83806..f0e626a8 100644 --- a/src/main/java/com/rampatra/arrays/TwoStacksInOneArray.java +++ b/src/me/ramswaroop/arrays/TwoStacksInOneArray.java @@ -1,18 +1,18 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. - *

+ * * Implement two stacks using a single array with efficient use of space. * We could do this by dividing the array into two equal halves or storing stack * elements alternatively in the array but that wouldn't utilize the space fully. * So we stored stack1's elements at one end of the array and stack2's elements at * the other end. * - * @author rampatra - * @since 9/21/15 + * @author: ramswaroop + * @date: 9/21/15 * @time: 6:18 PM */ public class TwoStacksInOneArray { @@ -70,7 +70,7 @@ void printStack(int stack) { } } - public static void main(String[] args) { + public static void main(String a[]) { TwoStacksInOneArray twoStack = new TwoStacksInOneArray(5); twoStack.push(1, 3); twoStack.push(1, 4); diff --git a/src/main/java/com/rampatra/arrays/UnsortedSubArray.java b/src/me/ramswaroop/arrays/UnsortedSubArray.java similarity index 95% rename from src/main/java/com/rampatra/arrays/UnsortedSubArray.java rename to src/me/ramswaroop/arrays/UnsortedSubArray.java index 36aa4e12..ab24d03d 100644 --- a/src/main/java/com/rampatra/arrays/UnsortedSubArray.java +++ b/src/me/ramswaroop/arrays/UnsortedSubArray.java @@ -1,12 +1,12 @@ -package com.rampatra.arrays; +package me.ramswaroop.arrays; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/20/15 + * @author: ramswaroop + * @date: 8/20/15 * @time: 10:31 AM */ public class UnsortedSubArray { @@ -40,7 +40,7 @@ public static int[] getUnsortedSubArray(int[] a) { int[] unsortedArray; // 1(a) - for (int i = 0; i < a.length - 1; i++) { + for (int i = 0; i < a.length-1; i++) { if (a[i] > a[i + 1]) { start = i; break; @@ -89,7 +89,7 @@ public static int[] getUnsortedSubArray(int[] a) { return unsortedArray; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getUnsortedSubArray(new int[]{10, 12, 20, 30, 25, 40, 32, 31, 35, 50, 60}))); System.out.println(Arrays.toString(getUnsortedSubArray(new int[]{0, 1, 15, 25, 6, 7, 30, 40, 50}))); System.out.println(Arrays.toString(getUnsortedSubArray(new int[]{0, 1, 2, 3, 4, 5, 6, 7, 8}))); // fully sorted already diff --git a/src/me/ramswaroop/arrays/searching/BinarySearch.java b/src/me/ramswaroop/arrays/searching/BinarySearch.java new file mode 100644 index 00000000..9f330bf6 --- /dev/null +++ b/src/me/ramswaroop/arrays/searching/BinarySearch.java @@ -0,0 +1,54 @@ +package me.ramswaroop.arrays.searching; + +/** + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 9/1/15 + * @time: 4:56 PM + */ +public class BinarySearch { + + /** + * Searches an element {@param n} in a sorted array {@param a} + * and returns its index in O(log n) time. The Index may not + * correspond to the first occurrence of the element. + * + * @param a + * @param n + * @return + */ + public static int binarySearch(int a[], int n) { + return binarySearch(a, n, 0, a.length - 1); + } + + public static int binarySearch(int a[], int n, int low, int high) { + + if (low <= high) { + int mid = (low + high) / 2; + + if (n == a[mid]) { + return mid; + } else if (n < a[mid]) { + return binarySearch(a, n, 0, mid - 1); + } else { + return binarySearch(a, n, mid + 1, high); + } + } else { + return -1; + } + } + + /** + * Driver for testing. + * + * @param a + */ + public static void main(String a[]) { + System.out.println(binarySearch(new int[]{0, 2}, 2)); + System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 2)); + System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 3)); + System.out.println(binarySearch(new int[]{0, 2}, 0)); + System.out.println(binarySearch(new int[]{0, 1, 2, 2, 2, 3, 3}, 2)); // doesn't return index of first occurrence + } +} diff --git a/src/main/java/com/rampatra/searching/InterpolationSearch.java b/src/me/ramswaroop/arrays/searching/InterpolationSearch.java similarity index 89% rename from src/main/java/com/rampatra/searching/InterpolationSearch.java rename to src/me/ramswaroop/arrays/searching/InterpolationSearch.java index 20f76665..81169cfa 100644 --- a/src/main/java/com/rampatra/searching/InterpolationSearch.java +++ b/src/me/ramswaroop/arrays/searching/InterpolationSearch.java @@ -1,10 +1,10 @@ -package com.rampatra.searching; +package me.ramswaroop.arrays.searching; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/1/15 + * @author: ramswaroop + * @date: 9/1/15 * @time: 4:57 PM */ public class InterpolationSearch { @@ -36,7 +36,7 @@ public static int search(int[] a, int k) { } } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(search(new int[]{0, 2}, 2)); System.out.println(search(new int[]{0, 1}, 2)); System.out.println(search(new int[]{0, 1, 2, 3}, 2)); diff --git a/src/main/java/com/rampatra/sorting/CheckSorted.java b/src/me/ramswaroop/arrays/sorting/CheckSorted.java similarity index 93% rename from src/main/java/com/rampatra/sorting/CheckSorted.java rename to src/me/ramswaroop/arrays/sorting/CheckSorted.java index 0b9b6c3f..b7464176 100644 --- a/src/main/java/com/rampatra/sorting/CheckSorted.java +++ b/src/me/ramswaroop/arrays/sorting/CheckSorted.java @@ -1,10 +1,10 @@ -package com.rampatra.sorting; +package me.ramswaroop.arrays.sorting; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/23/15 + * @author: ramswaroop + * @date: 10/23/15 * @time: 8:30 AM */ public class CheckSorted { @@ -55,7 +55,7 @@ public static boolean isSorted(int[] a) { return true; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(isSorted(new int[]{1, 2, 3, 4, 5})); System.out.println(isSorted(new int[]{5, 4, 3, 2, 1})); System.out.println(isSorted(new int[]{})); diff --git a/src/main/java/com/rampatra/sorting/HeapSort.java b/src/me/ramswaroop/arrays/sorting/HeapSort.java similarity index 80% rename from src/main/java/com/rampatra/sorting/HeapSort.java rename to src/me/ramswaroop/arrays/sorting/HeapSort.java index 61f03802..b16f5b45 100644 --- a/src/main/java/com/rampatra/sorting/HeapSort.java +++ b/src/me/ramswaroop/arrays/sorting/HeapSort.java @@ -1,22 +1,22 @@ -package com.rampatra.sorting; +package me.ramswaroop.arrays.sorting; -import com.rampatra.base.MaxHeap; +import me.ramswaroop.common.MaxHeap; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/3/15 + * @author: ramswaroop + * @date: 8/3/15 + * @time: 3:13 PM */ public class HeapSort { /** * Heapsort. *

- * Time complexity: O(n log n) as maxHeapify has complexity O(log n), buildMaxHeap has complexity O(n) and we - * run maxHeapify n-1 times in heapSort function, therefore time complexity of heapSort function is O(n log n). + * Time complexity: O(n log n) * * @param a */ @@ -41,7 +41,7 @@ public static void heapSort(int[] a) { * @param index * @param end */ - public static void maxHeapify(int[] a, int index, int end) { + private static void maxHeapify(int[] a, int index, int end) { int largest = index; int leftIndex = 2 * index + 1; int rightIndex = 2 * index + 2; @@ -76,7 +76,7 @@ private static void swap(int[] a, int firstIndex, int secondIndex) { a[firstIndex] = a[firstIndex] - a[secondIndex]; } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = new int[]{2, 5, 1, 7, 9, 4}; System.out.println(Arrays.toString(ar)); heapSort(ar); diff --git a/src/main/java/com/rampatra/sorting/MergeSort.java b/src/me/ramswaroop/arrays/sorting/MergeSort.java similarity index 60% rename from src/main/java/com/rampatra/sorting/MergeSort.java rename to src/me/ramswaroop/arrays/sorting/MergeSort.java index eb95cf79..d5d8f024 100644 --- a/src/main/java/com/rampatra/sorting/MergeSort.java +++ b/src/me/ramswaroop/arrays/sorting/MergeSort.java @@ -1,38 +1,36 @@ -package com.rampatra.sorting; +package me.ramswaroop.arrays.sorting; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/29/15 + * @author: ramswaroop + * @date: 7/29/15 * @time: 8:47 PM */ public class MergeSort { /** - * Merge sort. Note that we are creating unnecessary arrays in each recursive - * call. This makes the algorithm simple but it occupies more space. Look at - * {@link MergeSortSpaceOptimized} instead. + * Merge sort. *

* Time complexity: O(n log n) * Space complexity: O(n) (also needs O(log n) stack space as it is recursive) * - * @param arr + * @param a * @return */ - public static int[] mergeSort(int[] arr) { - if (arr.length == 1) return arr; + public static int[] mergeSort(int[] a) { + if (a.length == 1) return a; - int[] x = mergeSort(Arrays.copyOfRange(arr, 0, arr.length / 2)); - int[] y = mergeSort(Arrays.copyOfRange(arr, arr.length / 2, arr.length)); + int[] x = mergeSort(Arrays.copyOfRange(a, 0, a.length / 2)); + int[] y = mergeSort(Arrays.copyOfRange(a, a.length / 2, a.length)); return merge(x, y); } /** - * Merges two sorted arrays {@code a} and {@code b}. + * Merges two sorted arrays {@param a} and {@param b}. * * @param a * @param b @@ -53,7 +51,7 @@ public static int[] merge(int[] a, int[] b) { return sortedArray; } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = new int[]{3, 5, 1, 6, 9, 8}; System.out.println(Arrays.toString(ar)); System.out.println(Arrays.toString(mergeSort(ar))); diff --git a/src/main/java/com/rampatra/sorting/PancakeSort.java b/src/me/ramswaroop/arrays/sorting/PancakeSort.java similarity index 95% rename from src/main/java/com/rampatra/sorting/PancakeSort.java rename to src/me/ramswaroop/arrays/sorting/PancakeSort.java index 81cd9943..6d229cdb 100644 --- a/src/main/java/com/rampatra/sorting/PancakeSort.java +++ b/src/me/ramswaroop/arrays/sorting/PancakeSort.java @@ -1,12 +1,12 @@ -package com.rampatra.sorting; +package me.ramswaroop.arrays.sorting; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/26/15 + * @author: ramswaroop + * @date: 10/26/15 * @time: 9:20 PM */ public class PancakeSort { @@ -58,7 +58,7 @@ public static void reverse(int[] a, int end) { } } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = {1, 2, 3, 4, 5, 6}; System.out.println(Arrays.toString(ar)); sort(ar); diff --git a/src/me/ramswaroop/arrays/sorting/QuickSort.java b/src/me/ramswaroop/arrays/sorting/QuickSort.java new file mode 100644 index 00000000..14320208 --- /dev/null +++ b/src/me/ramswaroop/arrays/sorting/QuickSort.java @@ -0,0 +1,87 @@ +package me.ramswaroop.arrays.sorting; + +import java.util.Arrays; + +/** + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 7/21/15 + * @time: 4:12 PM + * @see: http://www.csanimated.com/animation.php?t=Quicksort + */ +public class QuickSort { + + /** + * In-place partition method which moves all elements smaller than + * the pivot element to its left and all elements larger than the + * pivot element to its right and finally places the pivot element + * at its correct position. + * + * @param ar + * @param startIndex + * @param endIndex + * @return position of the pivot element + */ + public static int partition(int[] ar, int startIndex, int endIndex) { + int pivot = endIndex, temp; + + for (int i = startIndex; i < endIndex; i++) { + /** + * if ith element is smaller than pivot element then + * swap it with the last larger element known + */ + if (ar[i] < ar[pivot]) { + // swap a[startIndex] with a[i] + temp = ar[startIndex]; + ar[startIndex] = ar[i]; + ar[i] = temp; + startIndex++; + } + } + + // place the pivot element in its correct position + temp = ar[startIndex]; + ar[startIndex] = ar[pivot]; + ar[pivot] = temp; + + return startIndex; + } + + /** + * Recursive Quick sort. + * NOTE: This function is tail-recursive (doesn't use extra stack space per recursive call in many + * programming languages but not in Java as it doesn't support tail-recursive optimization). + *

+ * Time complexity: + * Best Case: O(nlogn) + * Worst Case: O(n*n) + * + * @param ar + * @param startIndex + * @param endIndex + */ + public static void quickSort(int[] ar, int startIndex, int endIndex) { + if (startIndex < endIndex) { + int partition = partition(ar, startIndex, endIndex); + quickSort(ar, startIndex, partition - 1); + quickSort(ar, partition + 1, endIndex); + } + } + + /** + * Wrapper method to quick sort the entire array. + * + * @param a + */ + public static void quickSort(int[] a) { + quickSort(a, 0, a.length - 1); + } + + public static void main(String a[]) { + int[] ar = {3, 2, 1, 6, 4, 9, 7, 8}; + System.out.println(Arrays.toString(ar)); + quickSort(ar); + System.out.println(Arrays.toString(ar)); + } +} diff --git a/src/main/java/com/rampatra/sorting/SelectionSort.java b/src/me/ramswaroop/arrays/sorting/SelectionSort.java similarity index 89% rename from src/main/java/com/rampatra/sorting/SelectionSort.java rename to src/me/ramswaroop/arrays/sorting/SelectionSort.java index fb1e2b0e..ef0b4bc5 100644 --- a/src/main/java/com/rampatra/sorting/SelectionSort.java +++ b/src/me/ramswaroop/arrays/sorting/SelectionSort.java @@ -1,12 +1,12 @@ -package com.rampatra.sorting; +package me.ramswaroop.arrays.sorting; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 8/22/15 + * @author: ramswaroop + * @date: 8/22/15 * @time: 12:28 PM */ public class SelectionSort { @@ -19,7 +19,7 @@ public class SelectionSort { * element is chosen and placed at the appropriate position and then again the * logic is applied on rest of the elements till the entire array is sorted. *

- * Time complexity: O(n^2) for all cases. Space complexity: O(1). + * Time complexity: O(n*n) for all cases. *

* NOTE: Advantage of this sort is that it requires minimum number of memory writes * like Cycle sort. @@ -53,7 +53,7 @@ private static void swap(int[] a, int index1, int index2) { a[index2] = temp; } - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = new int[]{3, 2, 1, 5, 6, 9, 7, 10}; selectionSort(ar); System.out.println(Arrays.toString(ar)); diff --git a/src/main/java/com/rampatra/backtracking/KnightTour.java b/src/me/ramswaroop/backtracking/KnightTour.java similarity index 94% rename from src/main/java/com/rampatra/backtracking/KnightTour.java rename to src/me/ramswaroop/backtracking/KnightTour.java index 64b58918..0d82b0b7 100644 --- a/src/main/java/com/rampatra/backtracking/KnightTour.java +++ b/src/me/ramswaroop/backtracking/KnightTour.java @@ -1,4 +1,4 @@ -package com.rampatra.backtracking; +package me.ramswaroop.backtracking; /** * Created by IntelliJ IDEA. @@ -7,11 +7,11 @@ * once. If the knight ends on a square that is one knight's move from the beginning square (so that it could tour the * board again immediately, following the same path), the tour is closed, otherwise it is open. * - * @author rampatra - * @since 10/15/15 + * @author: ramswaroop + * @date: 10/15/15 * @time: 11:56 PM * @see: https://en.wikipedia.org/wiki/Knight%27s_tour - * @see: RatInAMaze for a simpler version of this problem + * @see: me.ramswaroop.backtracking.RatInAMaze for a simpler version of this problem */ public class KnightTour { @@ -105,7 +105,7 @@ public static void print2DMatrix(int[][] array) { } } - public static void main(String[] args) { + public static void main(String a[]) { printKnightTour(0, 0, new int[]{8, 8}); } } diff --git a/src/main/java/com/rampatra/backtracking/RatInAMaze.java b/src/me/ramswaroop/backtracking/RatInAMaze.java similarity index 95% rename from src/main/java/com/rampatra/backtracking/RatInAMaze.java rename to src/me/ramswaroop/backtracking/RatInAMaze.java index bb8ea749..09aaf096 100644 --- a/src/main/java/com/rampatra/backtracking/RatInAMaze.java +++ b/src/me/ramswaroop/backtracking/RatInAMaze.java @@ -1,10 +1,10 @@ -package com.rampatra.backtracking; +package me.ramswaroop.backtracking; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/18/15 + * @author: ramswaroop + * @date: 10/18/15 * @time: 10:39 AM */ public class RatInAMaze { @@ -86,7 +86,7 @@ public static void print2DMatrix(int[][] array) { } } - public static void main(String[] args) { + public static void main(String a[]) { printMazePath(0, 0, new int[][]{{1, 1, 1, 1}, {0, 0, 1, 1}}); } } diff --git a/src/main/java/com/rampatra/bits/AbsWithoutBranching.java b/src/me/ramswaroop/bits/AbsWithoutBranching.java similarity index 86% rename from src/main/java/com/rampatra/bits/AbsWithoutBranching.java rename to src/me/ramswaroop/bits/AbsWithoutBranching.java index 53973b6a..cbe0c9b9 100644 --- a/src/main/java/com/rampatra/bits/AbsWithoutBranching.java +++ b/src/me/ramswaroop/bits/AbsWithoutBranching.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/9/15 + * @author: ramswaroop + * @date: 6/9/15 * @time: 12:26 PM */ public class AbsWithoutBranching { @@ -28,7 +28,7 @@ public static int abs(int n) { return (mask + n) ^ mask; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(abs(-5)); System.out.println(abs(5)); System.out.println(abs(0)); diff --git a/src/main/java/com/rampatra/bits/Addition.java b/src/me/ramswaroop/bits/Addition.java similarity index 96% rename from src/main/java/com/rampatra/bits/Addition.java rename to src/me/ramswaroop/bits/Addition.java index c120ecaa..75b3edd4 100644 --- a/src/main/java/com/rampatra/bits/Addition.java +++ b/src/me/ramswaroop/bits/Addition.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/10/15 + * @author: ramswaroop + * @date: 6/10/15 * @time: 12:55 PM */ public class Addition { @@ -95,7 +95,7 @@ public static int addByFlip(int n) { return n ^ mask; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(add(0, 0)); //0 System.out.println(add(12, 12)); //24 System.out.println(add(12, 5)); //17 diff --git a/src/main/java/com/rampatra/bits/BinaryGap.java b/src/me/ramswaroop/bits/BinaryGap.java similarity index 95% rename from src/main/java/com/rampatra/bits/BinaryGap.java rename to src/me/ramswaroop/bits/BinaryGap.java index a89c1a29..3694a31f 100644 --- a/src/main/java/com/rampatra/bits/BinaryGap.java +++ b/src/me/ramswaroop/bits/BinaryGap.java @@ -1,7 +1,7 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** - * Created by rampatra on 30/05/2016. + * Created by ramswaroop on 30/05/2016. */ public class BinaryGap { diff --git a/src/main/java/com/rampatra/bits/BooleanArrayPuzzle.java b/src/me/ramswaroop/bits/BooleanArrayPuzzle.java similarity index 84% rename from src/main/java/com/rampatra/bits/BooleanArrayPuzzle.java rename to src/me/ramswaroop/bits/BooleanArrayPuzzle.java index d3d87feb..f244d5ff 100644 --- a/src/main/java/com/rampatra/bits/BooleanArrayPuzzle.java +++ b/src/me/ramswaroop/bits/BooleanArrayPuzzle.java @@ -1,12 +1,12 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/12/15 + * @author: ramswaroop + * @date: 6/12/15 * @time: 3:31 PM */ public class BooleanArrayPuzzle { @@ -23,7 +23,7 @@ public static int[] change1To0InArray(int a[]) { return a; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(change1To0InArray(new int[]{0, 0}))); System.out.println(Arrays.toString(change1To0InArray(new int[]{0, 1}))); System.out.println(Arrays.toString(change1To0InArray(new int[]{1, 0}))); diff --git a/src/main/java/com/rampatra/bits/ConvertAToB.java b/src/me/ramswaroop/bits/ConvertAToB.java similarity index 83% rename from src/main/java/com/rampatra/bits/ConvertAToB.java rename to src/me/ramswaroop/bits/ConvertAToB.java index 07c162b8..86b50931 100644 --- a/src/main/java/com/rampatra/bits/ConvertAToB.java +++ b/src/me/ramswaroop/bits/ConvertAToB.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/7/15 + * @author: ramswaroop + * @date: 6/7/15 * @time: 1:53 PM */ public class ConvertAToB { @@ -21,7 +21,7 @@ public static int getBitsToConvertAToB(int a, int b) { return CountSetBits.countSetBits(a ^ b); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getBitsToConvertAToB(3, 4)); System.out.println(getBitsToConvertAToB(3, 5)); System.out.println(getBitsToConvertAToB(5, 3)); diff --git a/src/main/java/com/rampatra/bits/CountSetBits.java b/src/me/ramswaroop/bits/CountSetBits.java similarity index 93% rename from src/main/java/com/rampatra/bits/CountSetBits.java rename to src/me/ramswaroop/bits/CountSetBits.java index a2296e6e..21f9d541 100644 --- a/src/main/java/com/rampatra/bits/CountSetBits.java +++ b/src/me/ramswaroop/bits/CountSetBits.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; import java.util.Scanner; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 4/4/15 * Time: 8:52 PM * To change this template go to Preferences | IDE Settings | File and Code Templates @@ -30,14 +30,15 @@ static int countSetBits(int number) { /** * Optimized version. Works for -ve numbers as well. - *

+ * * Uses BRIAN KERNIGAN'S bit counting. Acc. to this, the right most/least significant set bit is unset * in each iteration. The time complexity is proportional to the number of bits set. * - * @param n - * @return * @link http://stackoverflow.com/questions/12380478/bits-counting-algorithm-brian-kernighan-in-an-integer-time-complexity * @link http://graphics.stanford.edu/~seander/bithacks.html#ParityNaive + * + * @param n + * @return */ static int countSetBits(long n) { int count = 0; @@ -48,7 +49,7 @@ static int countSetBits(long n) { return count; } - public static void main(String[] args) { + public static void main(String[] a) { Scanner in = new Scanner(System.in); long n = Long.parseLong(in.nextLine()); @@ -61,6 +62,8 @@ public static void main(String[] args) { } /** + * * Learn more: * http://javarevisited.blogspot.in/2014/06/how-to-count-number-of-set-bits-or-1s.html + * */ \ No newline at end of file diff --git a/src/main/java/com/rampatra/bits/CountSetBitsFromMinusNtoN.java b/src/me/ramswaroop/bits/CountSetBitsFromMinusNtoN.java similarity index 85% rename from src/main/java/com/rampatra/bits/CountSetBitsFromMinusNtoN.java rename to src/me/ramswaroop/bits/CountSetBitsFromMinusNtoN.java index a0aeb5e0..4ef484cc 100644 --- a/src/main/java/com/rampatra/bits/CountSetBitsFromMinusNtoN.java +++ b/src/me/ramswaroop/bits/CountSetBitsFromMinusNtoN.java @@ -1,17 +1,17 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/22/15 + * @author: ramswaroop + * @date: 7/22/15 * @time: 12:42 PM */ public class CountSetBitsFromMinusNtoN { /** * Explanation: - *

+ * * -3: 101 * -2: 110 * -1: 111 @@ -19,7 +19,7 @@ public class CountSetBitsFromMinusNtoN { * 1: 001 * 2: 010 * 3: 110 - *

+ * * If you fold the above representation between -1 and 0, the total no. of set bits from -3 to 2 * will be equal to the total no. of bits in nos. from -3 to 2. * @@ -30,7 +30,7 @@ public static int countSetBitsFromMinusNtoN(int n) { return n * 32 + CountSetBits.countSetBits((long) n); // 32 because int is of 32 bits in java } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(countSetBitsFromMinusNtoN(3)); System.out.println(countSetBitsFromMinusNtoN(0)); System.out.println(countSetBitsFromMinusNtoN(9)); diff --git a/src/main/java/com/rampatra/bits/ElementOccurringOnce.java b/src/me/ramswaroop/bits/ElementOccurringOnce.java similarity index 92% rename from src/main/java/com/rampatra/bits/ElementOccurringOnce.java rename to src/me/ramswaroop/bits/ElementOccurringOnce.java index 4621209c..0d295186 100644 --- a/src/main/java/com/rampatra/bits/ElementOccurringOnce.java +++ b/src/me/ramswaroop/bits/ElementOccurringOnce.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/14/15 + * @author: ramswaroop + * @date: 6/14/15 * @time: 12:37 AM */ public class ElementOccurringOnce { @@ -30,7 +30,7 @@ public static int getElementOccurringOnceInElementsRepeatedThreeTimes(int a[]) { return result; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getElementOccurringOnceInElementsRepeatedThreeTimes(new int[]{12, 12, 6, 6, 2, 12, 6})); System.out.println(getElementOccurringOnceInElementsRepeatedThreeTimes(new int[]{5, 5, 45, 45, 456, 5, 45})); System.out.println(getElementOccurringOnceInElementsRepeatedThreeTimes(new int[]{12, 12, 34, 34, 6, 12, 34})); @@ -48,12 +48,12 @@ public static void main(String[] args) { * 6 = 0110 * ------------- * res = 0010 - *

+ * * 1st bit of res = (0+0+0+0+0+0+0) % 3 = 0 * 2nd bit of res = (0+0+1+1+1+0+1) % 3 = 1 * 3rd bit of res = (1+1+1+1+0+1+1) % 3 = 0 * 4th bit of res = (1+1+0+0+0+1+0) % 3 = 0 - *

+ * * NOTE: Sum of bits at a particular position will not be divisible * by 3 if the no. occurring once has a set bit at that position. */ diff --git a/src/main/java/com/rampatra/bits/FlippingBits.java b/src/me/ramswaroop/bits/FlippingBits.java similarity index 87% rename from src/main/java/com/rampatra/bits/FlippingBits.java rename to src/me/ramswaroop/bits/FlippingBits.java index 48c891ad..2b5cf332 100644 --- a/src/main/java/com/rampatra/bits/FlippingBits.java +++ b/src/me/ramswaroop/bits/FlippingBits.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/5/15 + * @author: ramswaroop + * @date: 6/5/15 * @time: 3:50 PM */ public class FlippingBits { @@ -31,7 +31,7 @@ public static int getNumberByFlippingBits_V1(int n) { return ~n; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getNumberByFlippingBits(5)); System.out.println(getNumberByFlippingBits_V1(5)); } @@ -39,11 +39,11 @@ public static void main(String[] args) { /** * EXPLANATION: - *

+ * * For input: 5 - *

+ * * Binary: 000.....101 * Inverted: 111.....010 (which is the 2's compliment of -6) - *

+ * * Therefore, result is -6. */ diff --git a/src/main/java/com/rampatra/bits/IntegerOverflow.java b/src/me/ramswaroop/bits/IntegerOverflow.java similarity index 92% rename from src/main/java/com/rampatra/bits/IntegerOverflow.java rename to src/me/ramswaroop/bits/IntegerOverflow.java index 6d214ac8..48e71f59 100644 --- a/src/main/java/com/rampatra/bits/IntegerOverflow.java +++ b/src/me/ramswaroop/bits/IntegerOverflow.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/4/15 + * @author: ramswaroop + * @date: 6/4/15 * @time: 4:28 PM */ public class IntegerOverflow { @@ -43,7 +43,7 @@ public static int add_V1(int a, int b) throws Exception { } } - public static void main(String[] args) { + public static void main(String a[]) { try { System.out.println(add(2, 3)); System.out.println(add(2147483647, 999999999)); diff --git a/src/main/java/com/rampatra/bits/LittleAndBigEndian.java b/src/me/ramswaroop/bits/LittleAndBigEndian.java similarity index 77% rename from src/main/java/com/rampatra/bits/LittleAndBigEndian.java rename to src/me/ramswaroop/bits/LittleAndBigEndian.java index 86ca46e9..35d2452f 100644 --- a/src/main/java/com/rampatra/bits/LittleAndBigEndian.java +++ b/src/me/ramswaroop/bits/LittleAndBigEndian.java @@ -1,12 +1,12 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; import java.nio.ByteOrder; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/5/15 + * @author: ramswaroop + * @date: 6/5/15 * @time: 3:10 PM * @link http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Data/endian.html */ @@ -16,7 +16,7 @@ public static boolean isLittleEndian() { return ByteOrder.nativeOrder().equals(ByteOrder.LITTLE_ENDIAN); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(isLittleEndian()); } } diff --git a/src/main/java/com/rampatra/bits/MaxWithoutBranching.java b/src/me/ramswaroop/bits/MaxWithoutBranching.java similarity index 93% rename from src/main/java/com/rampatra/bits/MaxWithoutBranching.java rename to src/me/ramswaroop/bits/MaxWithoutBranching.java index f2669829..1407998b 100644 --- a/src/main/java/com/rampatra/bits/MaxWithoutBranching.java +++ b/src/me/ramswaroop/bits/MaxWithoutBranching.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/8/15 + * @author: ramswaroop + * @date: 6/8/15 * @time: 5:41 PM * @link: http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax */ @@ -18,7 +18,7 @@ public static int getMaxWithoutBranching(int a, int b) { return a ^ ((a ^ b) & -((a < b) ? 1 : 0)); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getMinWithoutBranching(5, 6)); System.out.println(getMinWithoutBranching(-5, -6)); System.out.println(getMinWithoutBranching(-5, 6)); diff --git a/src/main/java/com/rampatra/bits/Modulo.java b/src/me/ramswaroop/bits/Modulo.java similarity index 75% rename from src/main/java/com/rampatra/bits/Modulo.java rename to src/me/ramswaroop/bits/Modulo.java index d220f3a8..bca0e00e 100644 --- a/src/main/java/com/rampatra/bits/Modulo.java +++ b/src/me/ramswaroop/bits/Modulo.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/8/15 + * @author: ramswaroop + * @date: 6/8/15 * @time: 11:28 PM */ public class Modulo { @@ -21,7 +21,7 @@ public static int getNmoduloD(int n, int d) { return n & (d - 1); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getNmoduloD(18, 8)); System.out.println(getNmoduloD(18, 4)); System.out.println(getNmoduloD(13, 4)); @@ -33,8 +33,8 @@ public static void main(String[] args) { /** * Consider example, for 18 % 8 - *

+ * * 18 = 10010 - * 7 = 00111 (8 = 2 ^ 3, therefore mask has to have three 1's) - * 2 = 00010 (remainder = 18 & (8-1)) + * 7 = 00111 (8 = 2 ^ 3, therefore mask has to have three 1's) + * 2 = 00010 (remainder = 18 & (8-1)) */ diff --git a/src/main/java/com/rampatra/bits/MultipleOf3.java b/src/me/ramswaroop/bits/MultipleOf3.java similarity index 91% rename from src/main/java/com/rampatra/bits/MultipleOf3.java rename to src/me/ramswaroop/bits/MultipleOf3.java index 87af5c1d..cfcd9304 100644 --- a/src/main/java/com/rampatra/bits/MultipleOf3.java +++ b/src/me/ramswaroop/bits/MultipleOf3.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/3/15 + * @author: ramswaroop + * @date: 6/3/15 * @time: 1:18 PM */ public class MultipleOf3 { @@ -39,7 +39,7 @@ public static boolean isMultipleOf3(long n) { } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(isMultipleOf3(0)); System.out.println(isMultipleOf3(1)); System.out.println(isMultipleOf3(2)); @@ -52,9 +52,9 @@ public static void main(String[] args) { /** * Old School Method: - *

+ * * If sum of digits in a number is multiple of 3 then number is multiple of * 3 e.g., for 612 sum of digits is 9 so it’s a multiple of 3. But this solution - * is not efficient. You have to get all decimal digits one by one, add them and + * is not efficient. You have to get all decimal digits one by one, add them and * then check if sum is multiple of 3. */ \ No newline at end of file diff --git a/src/main/java/com/rampatra/bits/Multiply.java b/src/me/ramswaroop/bits/Multiply.java similarity index 94% rename from src/main/java/com/rampatra/bits/Multiply.java rename to src/me/ramswaroop/bits/Multiply.java index edc2e421..9e3115d3 100644 --- a/src/main/java/com/rampatra/bits/Multiply.java +++ b/src/me/ramswaroop/bits/Multiply.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/3/15 + * @author: ramswaroop + * @date: 6/3/15 * @time: 11:35 PM */ @@ -60,7 +60,7 @@ public static long multiplyWith8(long n) { return (n << 3); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(multiplyWith3point5(3)); System.out.println(multiplyWith3point5(4)); System.out.println(multiplyWith3point5(6)); diff --git a/src/main/java/com/rampatra/bits/NextHigherNumber.java b/src/me/ramswaroop/bits/NextHigherNumber.java similarity index 92% rename from src/main/java/com/rampatra/bits/NextHigherNumber.java rename to src/me/ramswaroop/bits/NextHigherNumber.java index 444dcf99..8130a96a 100644 --- a/src/main/java/com/rampatra/bits/NextHigherNumber.java +++ b/src/me/ramswaroop/bits/NextHigherNumber.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/10/15 + * @author: ramswaroop + * @date: 6/10/15 * @time: 6:08 PM */ public class NextHigherNumber { @@ -13,10 +13,10 @@ public class NextHigherNumber { * The main logic is to flip the bits in the first '01' bit pattern * of {@param n} from the right and then push all 1 bits to the right * of '01' to the extreme right. - *

- *

+ * + * * For example, - *

+ * * 3 (0000011) = 5 (0000101) * 6 (0000110) = 9 (0001001) * 23 (0010111) = 27 (0011011) @@ -47,7 +47,7 @@ public static int getNextHigherNumberWithSameSetBits(int n) { return (n << count) | (leftPattern << count) | (rightPattern >> 1); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getNextHigherNumberWithSameSetBits(0));//doesn't work for 0 System.out.println(getNextHigherNumberWithSameSetBits(4));//8 System.out.println(getNextHigherNumberWithSameSetBits(5));//6 diff --git a/src/main/java/com/rampatra/bits/NextPowerOf2.java b/src/me/ramswaroop/bits/NextPowerOf2.java similarity index 97% rename from src/main/java/com/rampatra/bits/NextPowerOf2.java rename to src/me/ramswaroop/bits/NextPowerOf2.java index 44c04491..1002f2a8 100644 --- a/src/main/java/com/rampatra/bits/NextPowerOf2.java +++ b/src/me/ramswaroop/bits/NextPowerOf2.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/2/15 + * @author: ramswaroop + * @date: 6/2/15 * @time: 5:08 PM */ public class NextPowerOf2 { @@ -100,7 +100,7 @@ public static long nextLowerPowerOf2(long n) { return (n > 1) ? p >> 1 : n; // check for n = 0 or 1; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(nextHigherPowerOf2(2)); System.out.println(nextHigherPowerOf2(3)); diff --git a/src/main/java/com/rampatra/bits/OppositeSign.java b/src/me/ramswaroop/bits/OppositeSign.java similarity index 75% rename from src/main/java/com/rampatra/bits/OppositeSign.java rename to src/me/ramswaroop/bits/OppositeSign.java index 919d2137..0da348ec 100644 --- a/src/main/java/com/rampatra/bits/OppositeSign.java +++ b/src/me/ramswaroop/bits/OppositeSign.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/14/15 + * @author: ramswaroop + * @date: 6/14/15 * @time: 12:24 AM */ public class OppositeSign { @@ -13,7 +13,7 @@ public static int isOppositeSign(int a, int b) { return (a ^ b) >>> 31; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(isOppositeSign(-5, -3)); System.out.println(isOppositeSign(-5, 3)); System.out.println(isOppositeSign(5, -3)); diff --git a/src/main/java/com/rampatra/bits/Parity.java b/src/me/ramswaroop/bits/Parity.java similarity index 94% rename from src/main/java/com/rampatra/bits/Parity.java rename to src/me/ramswaroop/bits/Parity.java index 673ba5b3..7c1e0ace 100644 --- a/src/main/java/com/rampatra/bits/Parity.java +++ b/src/me/ramswaroop/bits/Parity.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/3/15 + * @author: ramswaroop + * @date: 6/3/15 * @time: 3:50 PM */ @@ -19,7 +19,7 @@ public class Parity { /** * Uses BRIAN KERNIGAN'S bit counting. Acc. to this, the right most/least significant set bit is unset * in each iteration. The time complexity is proportional to the number of bits set. - *

+ * * {@see http://stackoverflow.com/questions/12380478/bits-counting-algorithm-brian-kernighan-in-an-integer-time-complexity} * {@see http://graphics.stanford.edu/~seander/bithacks.html#ParityNaive} * @@ -54,7 +54,7 @@ public static boolean isEvenParityByCountingSetBits(long n) { return setBitsCount % 2 == 0; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(isEvenParity(0)); System.out.println(isEvenParity(1)); System.out.println(isEvenParity(5)); diff --git a/src/main/java/com/rampatra/bits/PowerOf2.java b/src/me/ramswaroop/bits/PowerOf2.java similarity index 93% rename from src/main/java/com/rampatra/bits/PowerOf2.java rename to src/me/ramswaroop/bits/PowerOf2.java index 04a1d9dd..a796a086 100644 --- a/src/main/java/com/rampatra/bits/PowerOf2.java +++ b/src/me/ramswaroop/bits/PowerOf2.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/2/15 + * @author: ramswaroop + * @date: 6/2/15 * @time: 12:18 PM */ public class PowerOf2 { @@ -40,7 +40,7 @@ public static boolean isPowerOf2FromRandomClass(long n) { return n != 0 && (n & -n) == n; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(isPowerOf2(18)); System.out.println(isPowerOf2UsingANDoperator(18)); System.out.println(isPowerOf2FromRandomClass(18)); diff --git a/src/main/java/com/rampatra/bits/PowerOf4.java b/src/me/ramswaroop/bits/PowerOf4.java similarity index 89% rename from src/main/java/com/rampatra/bits/PowerOf4.java rename to src/me/ramswaroop/bits/PowerOf4.java index 5b75c4a2..5f9ec7ec 100644 --- a/src/main/java/com/rampatra/bits/PowerOf4.java +++ b/src/me/ramswaroop/bits/PowerOf4.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/9/15 + * @author: ramswaroop + * @date: 6/9/15 * @time: 12:56 PM */ public class PowerOf4 { @@ -31,7 +31,7 @@ public static boolean isPowerOf4(int n) { return false; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(isPowerOf4(0)); System.out.println(isPowerOf4(1)); System.out.println(isPowerOf4(4)); diff --git a/src/main/java/com/rampatra/bits/ReverseBits.java b/src/me/ramswaroop/bits/ReverseBits.java similarity index 95% rename from src/main/java/com/rampatra/bits/ReverseBits.java rename to src/me/ramswaroop/bits/ReverseBits.java index 04f8cc3b..3d188f4f 100644 --- a/src/main/java/com/rampatra/bits/ReverseBits.java +++ b/src/me/ramswaroop/bits/ReverseBits.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/5/15 + * @author: ramswaroop + * @date: 6/5/15 * @time: 4:26 PM * @link: http://stackoverflow.com/questions/746171/best-algorithm-for-bit-reversal-from-msb-lsb-to-lsb-msb-in-c * @link: http://graphics.stanford.edu/~seander/bithacks.html#BitReverseObvious @@ -82,7 +82,7 @@ public static int getNumberByReversingBitsV2(int n) { return reverse; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getNumberByReversingBits(79876)); System.out.println(getNumberByReversingBitsV1(79876)); System.out.println(getNumberByReversingBitsV2(79876)); diff --git a/src/main/java/com/rampatra/bits/RightmostSetBit.java b/src/me/ramswaroop/bits/RightmostSetBit.java similarity index 93% rename from src/main/java/com/rampatra/bits/RightmostSetBit.java rename to src/me/ramswaroop/bits/RightmostSetBit.java index 1916ed64..73757c3b 100644 --- a/src/main/java/com/rampatra/bits/RightmostSetBit.java +++ b/src/me/ramswaroop/bits/RightmostSetBit.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/3/15 + * @author: ramswaroop + * @date: 6/3/15 * @time: 11:56 PM */ public class RightmostSetBit { @@ -34,7 +34,7 @@ public static long unsetRightmostSetBit(long n) { return n & (n - 1); // brian kerningham's algorithm } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getRightmostSetBitPosition(0)); System.out.println(getRightmostSetBitPosition(1)); System.out.println(getRightmostSetBitPosition(2)); diff --git a/src/main/java/com/rampatra/bits/RotateBits.java b/src/me/ramswaroop/bits/RotateBits.java similarity index 88% rename from src/main/java/com/rampatra/bits/RotateBits.java rename to src/me/ramswaroop/bits/RotateBits.java index 9712b028..92cde5fc 100644 --- a/src/main/java/com/rampatra/bits/RotateBits.java +++ b/src/me/ramswaroop/bits/RotateBits.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/8/15 + * @author: ramswaroop + * @date: 6/8/15 * @time: 5:12 PM *

* A ROTATION (OR CIRCULAR SHIFT) is an operation similar to @@ -25,7 +25,7 @@ public static int rightRotateBits(int n, int times) { return n >>> times | n << (32 - times); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(leftRotateBits(5, 3)); System.out.println(leftRotateBits(234324, 3)); System.out.println(rightRotateBits(5, 3)); diff --git a/src/main/java/com/rampatra/bits/SmallestOf3Integers.java b/src/me/ramswaroop/bits/SmallestOf3Integers.java similarity index 90% rename from src/main/java/com/rampatra/bits/SmallestOf3Integers.java rename to src/me/ramswaroop/bits/SmallestOf3Integers.java index 63e542a9..b122140d 100644 --- a/src/main/java/com/rampatra/bits/SmallestOf3Integers.java +++ b/src/me/ramswaroop/bits/SmallestOf3Integers.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/12/15 + * @author: ramswaroop + * @date: 6/12/15 * @time: 6:18 PM */ public class SmallestOf3Integers { @@ -50,7 +50,7 @@ public static int getSmallest_V1(int a[]) { return c; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getSmallest(new int[]{4, 5, 6})); System.out.println(getSmallest_V1(new int[]{4, 5, 6})); } diff --git a/src/main/java/com/rampatra/bits/StrCmp.java b/src/me/ramswaroop/bits/StrCmp.java similarity index 96% rename from src/main/java/com/rampatra/bits/StrCmp.java rename to src/me/ramswaroop/bits/StrCmp.java index 4b1be36f..f7820d29 100644 --- a/src/main/java/com/rampatra/bits/StrCmp.java +++ b/src/me/ramswaroop/bits/StrCmp.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/15/15 + * @author: ramswaroop + * @date: 6/15/15 * @time: 10:38 AM */ public class StrCmp { @@ -48,7 +48,7 @@ public static int compareStringIgnoreCase(String s1, String s2) { return n1 - n2; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(compareStringIgnoreCase("ram", "ram")); System.out.println(compareStringIgnoreCase("ram", "Ram")); System.out.println(compareStringIgnoreCase("", "")); diff --git a/src/main/java/com/rampatra/bits/SubBit.java b/src/me/ramswaroop/bits/SubBit.java similarity index 84% rename from src/main/java/com/rampatra/bits/SubBit.java rename to src/me/ramswaroop/bits/SubBit.java index f91a4dd8..2d954c2d 100644 --- a/src/main/java/com/rampatra/bits/SubBit.java +++ b/src/me/ramswaroop/bits/SubBit.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/4/15 + * @author: ramswaroop + * @date: 6/4/15 * @time: 10:54 PM */ public class SubBit { @@ -22,7 +22,7 @@ public static int getNumberFromSubBits(int num, int start, int end) { return num << (32 - end) >>> (start - end + 31); // more intuitive (start - 1 + 32 - end) } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getNumberFromSubBits(5, 1, 2)); } } diff --git a/src/main/java/com/rampatra/bits/SwapBits.java b/src/me/ramswaroop/bits/SwapBits.java similarity index 95% rename from src/main/java/com/rampatra/bits/SwapBits.java rename to src/me/ramswaroop/bits/SwapBits.java index 40fbb613..fc5113b0 100644 --- a/src/main/java/com/rampatra/bits/SwapBits.java +++ b/src/me/ramswaroop/bits/SwapBits.java @@ -1,10 +1,10 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/13/15 + * @author: ramswaroop + * @date: 6/13/15 * @time: 4:45 PM */ public class SwapBits { @@ -71,7 +71,7 @@ public static int swapBitRangeInNumber(int n, int pos1, int pos2, int length) { // (this logic is similar to swapping bits using XOR) } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(swapEvenOddBits(23)); System.out.println(swapEvenOddBits(0)); System.out.println(swapEvenOddBits(5)); diff --git a/src/main/java/com/rampatra/bits/TwoNonRepeatingElements.java b/src/me/ramswaroop/bits/TwoNonRepeatingElements.java similarity index 74% rename from src/main/java/com/rampatra/bits/TwoNonRepeatingElements.java rename to src/me/ramswaroop/bits/TwoNonRepeatingElements.java index a3b47f08..3aca1ebf 100644 --- a/src/main/java/com/rampatra/bits/TwoNonRepeatingElements.java +++ b/src/me/ramswaroop/bits/TwoNonRepeatingElements.java @@ -1,12 +1,12 @@ -package com.rampatra.bits; +package me.ramswaroop.bits; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/7/15 + * @author: ramswaroop + * @date: 6/7/15 * @time: 2:46 PM * @link: http://www.geeksforgeeks.org/find-two-non-repeating-elements-in-an-array-of-repeating-elements/ */ @@ -36,7 +36,7 @@ public static int[] getTwoNonRepeatingElementsInArray(int a[]) { return new int[]{x, y}; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(Arrays.toString(getTwoNonRepeatingElementsInArray(new int[]{2, 3, 4, 2, 3, 4, 5, 6}))); } } @@ -45,13 +45,13 @@ public static void main(String[] args) { * EXPLANATION: * Consider input arr[] = {2, 4, 7, 9, 2, 4} * 1) Get the XOR of all the elements. - * xor = 2^4^7^9^2^4 = 14 (1110) + * xor = 2^4^7^9^2^4 = 14 (1110) * 2) Get a number which has only one set bit of the xor. - * Since we can easily get the rightmost set bit, let us use it. - * set_bit_no = xor & ~(xor-1) = (1110) & ~(1101) = 0010 - * Now set_bit_no will have only set as rightmost set bit of xor. + * Since we can easily get the rightmost set bit, let us use it. + * set_bit_no = xor & ~(xor-1) = (1110) & ~(1101) = 0010 + * Now set_bit_no will have only set as rightmost set bit of xor. * 3) Now divide the elements in two sets and do xor of - * elements in each set, and we get the non-repeating - * elements 7 and 9. Please see implementation for this - * step. + * elements in each set, and we get the non-repeating + * elements 7 and 9. Please see implementation for this + * step. */ diff --git a/src/main/java/com/rampatra/base/AVLTree.java b/src/me/ramswaroop/common/AVLTree.java similarity index 64% rename from src/main/java/com/rampatra/base/AVLTree.java rename to src/me/ramswaroop/common/AVLTree.java index 61999cd0..b995d78f 100644 --- a/src/main/java/com/rampatra/base/AVLTree.java +++ b/src/me/ramswaroop/common/AVLTree.java @@ -1,10 +1,10 @@ -package com.rampatra.base; +package me.ramswaroop.common; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 4/25/15 + * @author: ramswaroop + * @date: 4/25/15 * @time: 10:25 AM */ public class AVLTree> extends Tree { diff --git a/src/main/java/com/rampatra/base/BinaryNode.java b/src/me/ramswaroop/common/BinaryNode.java similarity index 73% rename from src/main/java/com/rampatra/base/BinaryNode.java rename to src/me/ramswaroop/common/BinaryNode.java index 6e57530e..a572f57e 100644 --- a/src/main/java/com/rampatra/base/BinaryNode.java +++ b/src/me/ramswaroop/common/BinaryNode.java @@ -1,8 +1,8 @@ -package com.rampatra.base; +package me.ramswaroop.common; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 4/11/15 * Time: 7:11 PM * To change this template go to Preferences | IDE Settings | File and Code Templates @@ -10,10 +10,10 @@ public class BinaryNode> { public E value; - public BinaryNode left; - public BinaryNode right; + public BinaryNode left; + public BinaryNode right; - public BinaryNode(E value, BinaryNode left, BinaryNode right) { + public BinaryNode(E value, BinaryNode left, BinaryNode right) { this.value = value; this.left = left; this.right = right; diff --git a/src/main/java/com/rampatra/base/BinarySearchTree.java b/src/me/ramswaroop/common/BinarySearchTree.java similarity index 75% rename from src/main/java/com/rampatra/base/BinarySearchTree.java rename to src/me/ramswaroop/common/BinarySearchTree.java index 644f1e7d..1333eaef 100644 --- a/src/main/java/com/rampatra/base/BinarySearchTree.java +++ b/src/me/ramswaroop/common/BinarySearchTree.java @@ -1,20 +1,15 @@ -package com.rampatra.base; +package me.ramswaroop.common; import java.util.NoSuchElementException; import static java.lang.System.out; /** - * A binary search tree is a binary tree in which every node fits a specific ordering property: all left - * descendents <= n < all right descendents. This must be true for each node n. - *

- * Note: The definition of a binary search tree can vary slightly with respect to equality. Under some definitions, the - * tree cannot have duplicate values. In others, the duplicate values will be on the right or can be on either side. All - * are valid definitions, but you should clarify this with your interviewer - * - * @author rampatra - * @since 4/19/15 - * @param + * Created by IntelliJ IDEA. + * User: ramswaroop + * Date: 4/19/15 + * Time: 6:36 PM + * To change this template go to Preferences | IDE Settings | File and Code Templates */ public class BinarySearchTree> extends BinaryTree { diff --git a/src/main/java/com/rampatra/base/BinaryTree.java b/src/me/ramswaroop/common/BinaryTree.java similarity index 74% rename from src/main/java/com/rampatra/base/BinaryTree.java rename to src/me/ramswaroop/common/BinaryTree.java index e420d7c0..b7102d01 100644 --- a/src/main/java/com/rampatra/base/BinaryTree.java +++ b/src/me/ramswaroop/common/BinaryTree.java @@ -1,26 +1,14 @@ -package com.rampatra.base; - -import com.rampatra.trees.BFSUsingQueue; +package me.ramswaroop.common; import static java.lang.System.out; /** - * Basic binary tree functions like put, delete, height, traversals, etc. - * An example of a binary tree: - * - * 5 ------> depth 0, level 1 (depth + 1) - * / \ - * 3 8 -----> depth 1, level 2 - * / \ / \ - * 2 4 9 7 ----> depth 2, level 3 + * Created by IntelliJ IDEA. * - * Root of the tree: 5 - * Height: 2 - * - * @author rampatra - * @since 4/19/15 - * @link https://www.cs.cmu.edu/~adamchik/15-121/lectures/Trees/trees.html - * @link http://typeocaml.com/2014/11/26/height-depth-and-level-of-a-tree/ + * @author: ramswaroop + * @date: 4/19/15 + * @time: 6:35 PM + * @see: https://www.cs.bu.edu/teaching/c/tree/breadth-first/ */ public class BinaryTree> extends Tree { @@ -56,12 +44,10 @@ public BinaryNode put(BinaryNode node, E value) { return node; } + /** + * Traversals. + */ - /*********************************** - * - * Tree Traversals. - * - ***********************************/ /** * Prints the pre-order traversal of the tree. @@ -74,7 +60,7 @@ public void preOrder(BinaryNode node) { if (node == null) { return; } - out.print("->" + node.value); + out.print(node.value); preOrder(node.left); preOrder(node.right); } @@ -92,7 +78,7 @@ public void inOrder(BinaryNode node) { return; } inOrder(node.left); - out.print("->" + node.value); + out.print(node.value); inOrder(node.right); } @@ -110,7 +96,7 @@ public void postOrder(BinaryNode node) { } postOrder(node.left); postOrder(node.right); - out.print("->" + node.value); + out.print(node.value); } @@ -119,16 +105,15 @@ public void postOrder(BinaryNode node) { *

* DEF: Breadth-first search (BFS) is an algorithm for traversing or searching tree * or graph data structures. It starts at the tree root (or some arbitrary node of a - * graph, sometimes referred to as a `search key'[1]) and explores the neighboring nodes - * first, before moving to the next level neighbors. See {@link BFSUsingQueue} for a O(n) - * solution. - *

- * Time complexity: O(h^2) where, h is the height of the tree + * graph, sometimes referred to as a `search key'[1]) and explores the neighbor nodes + * first, before moving to the next level neighbors. See {@link me.ramswaroop.trees.BFSUsingQueue} + * for a O(n) solution. + * + * Time complexity: O(n^2) */ public void breadthFirstTraversal() { - int height = height(root); - // assuming level starts at one - for (int level = 1; level <= height + 1; level++) { + // assuming level starts at zero + for (int level = 0; level < height(root); level++) { printLevel(root, level); } } @@ -137,9 +122,9 @@ public void printLevel(BinaryNode node, int level) { if (node == null) return; // print the starting node - if (level == 1) { + if (level == 0) { printValue(node); - } else { // print the immediate child nodes + } else { // print the neighbour nodes printLevel(node.left, level - 1); printLevel(node.right, level - 1); } @@ -177,28 +162,25 @@ public void deleteChildren(BinaryNode node) { /** - * Height of the tree is the number of edges from the root to its farthest leaf. - * Note: The height of binary tree with single node is taken as zero. + * Return the height of the tree. * - * @return the height of the tree. + * @return */ public int height() { return height(root); } public int height(BinaryNode node) { - if (node == null || (node.left == null && node.right == null)) { - return 0; - } + if (node == null) return 0; return Math.max(height(node.left), height(node.right)) + 1; } /** - * Size of tree. + * Returns the number of nodes currently in the tree. * - * @return the number of nodes currently in the tree. + * @return */ public int size() { return size(root); @@ -272,7 +254,7 @@ public void printValue(BinaryNode node) { } // test cases - public static void main(String[] args) { + public static void main(String[] a) { BinaryTree bt = new BinaryTree<>(); bt.put(1); bt.put(2); @@ -282,15 +264,8 @@ public static void main(String[] args) { bt.put(6); bt.put(7); bt.put(8); - - out.print("BFS: "); bt.breadthFirstTraversal(); - out.print("\nPre Order: "); - bt.preOrder(); - out.print("\nIn Order: "); + out.println(); bt.inOrder(); - out.print("\nPost Order: "); - bt.postOrder(); - out.println("\nHeight of tree: " + bt.height()); } } diff --git a/src/main/java/com/rampatra/base/CircularSingleLinkedList.java b/src/me/ramswaroop/common/CircularSingleLinkedList.java similarity index 99% rename from src/main/java/com/rampatra/base/CircularSingleLinkedList.java rename to src/me/ramswaroop/common/CircularSingleLinkedList.java index cdf37470..a496d347 100644 --- a/src/main/java/com/rampatra/base/CircularSingleLinkedList.java +++ b/src/me/ramswaroop/common/CircularSingleLinkedList.java @@ -1,4 +1,4 @@ -package com.rampatra.base; +package me.ramswaroop.common; import java.util.NoSuchElementException; @@ -7,8 +7,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/16/15 + * @author: ramswaroop + * @date: 6/16/15 * @time: 1:00 PM */ public class CircularSingleLinkedList> implements LinkedList { diff --git a/src/main/java/com/rampatra/base/DoubleLinkedList.java b/src/me/ramswaroop/common/DoubleLinkedList.java similarity index 99% rename from src/main/java/com/rampatra/base/DoubleLinkedList.java rename to src/me/ramswaroop/common/DoubleLinkedList.java index e905725c..73c5191c 100644 --- a/src/main/java/com/rampatra/base/DoubleLinkedList.java +++ b/src/me/ramswaroop/common/DoubleLinkedList.java @@ -1,4 +1,4 @@ -package com.rampatra.base; +package me.ramswaroop.common; import java.util.NoSuchElementException; @@ -7,8 +7,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/16/15 + * @author: ramswaroop + * @date: 6/16/15 * @time: 1:00 PM */ public class DoubleLinkedList> implements LinkedList { diff --git a/src/main/java/com/rampatra/base/DoubleLinkedNode.java b/src/me/ramswaroop/common/DoubleLinkedNode.java similarity index 86% rename from src/main/java/com/rampatra/base/DoubleLinkedNode.java rename to src/me/ramswaroop/common/DoubleLinkedNode.java index 7da01c20..9ad9ec35 100644 --- a/src/main/java/com/rampatra/base/DoubleLinkedNode.java +++ b/src/me/ramswaroop/common/DoubleLinkedNode.java @@ -1,10 +1,10 @@ -package com.rampatra.base; +package me.ramswaroop.common; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/18/15 + * @author: ramswaroop + * @date: 6/18/15 * @time: 2:42 PM */ public class DoubleLinkedNode> { diff --git a/src/main/java/com/rampatra/base/LinkedList.java b/src/me/ramswaroop/common/LinkedList.java similarity index 95% rename from src/main/java/com/rampatra/base/LinkedList.java rename to src/me/ramswaroop/common/LinkedList.java index cd45a2d5..1819496e 100644 --- a/src/main/java/com/rampatra/base/LinkedList.java +++ b/src/me/ramswaroop/common/LinkedList.java @@ -1,10 +1,11 @@ -package com.rampatra.base; +package me.ramswaroop.common; /** - * A generic interface for LinkedList. + * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/16/15 + * @author: ramswaroop + * @date: 6/16/15 + * @time: 12:53 PM */ public interface LinkedList> { diff --git a/src/main/java/com/rampatra/base/LinkedQueue.java b/src/me/ramswaroop/common/LinkedQueue.java similarity index 81% rename from src/main/java/com/rampatra/base/LinkedQueue.java rename to src/me/ramswaroop/common/LinkedQueue.java index 3e4c472d..64763e0c 100644 --- a/src/main/java/com/rampatra/base/LinkedQueue.java +++ b/src/me/ramswaroop/common/LinkedQueue.java @@ -1,12 +1,13 @@ -package com.rampatra.base; +package me.ramswaroop.common; import java.util.NoSuchElementException; /** - * Queue implementation using a singly linked list with two pointers. - * - * @author rampatra - * @since 4/12/15 + * Created by IntelliJ IDEA. + * User: ramswaroop + * Date: 4/12/15 + * Time: 11:07 AM + * To change this template go to Preferences | IDE Settings | File and Code Templates */ public class LinkedQueue implements Queue { @@ -31,7 +32,7 @@ public E add(E item) { @Override public E remove() { - if (front == null) { + if (rear.next == front) { throw new NoSuchElementException(); } E item = element(); @@ -50,7 +51,7 @@ public E element() { @Override public int size() { int count = 0; - if (front == null) return count; + if (rear.next == front) return count; for (Node node = front; node != rear; node = node.next) { count++; } @@ -59,14 +60,14 @@ public int size() { @Override public boolean isEmpty() { - return front == null; + return rear.next == front; } @Override public void print() { Node node; System.out.print("["); - if (front == null) { + if (rear.next == front) { System.out.println("]"); return; } diff --git a/src/main/java/com/rampatra/base/LinkedStack.java b/src/me/ramswaroop/common/LinkedStack.java similarity index 87% rename from src/main/java/com/rampatra/base/LinkedStack.java rename to src/me/ramswaroop/common/LinkedStack.java index d41c8945..55b78fe6 100644 --- a/src/main/java/com/rampatra/base/LinkedStack.java +++ b/src/me/ramswaroop/common/LinkedStack.java @@ -1,13 +1,21 @@ -package com.rampatra.base; +package me.ramswaroop.common; + import java.util.EmptyStackException; /** - * Stack implementation using a singly linked list. + * Created by IntelliJ IDEA. + * User: ramswaroop + * Date: 3/24/15 + * Time: 3:02 PM + * To change this template go to Preferences | IDE Settings | File and Code Templates + */ + +/** + * Stack implementation using + * a singly linked list. * - * @param the data type to be stored in the stack - * @author rampatra - * @since 3/24/15 + * @param */ public class LinkedStack implements Stack { diff --git a/src/main/java/com/rampatra/base/MaxHeap.java b/src/me/ramswaroop/common/MaxHeap.java similarity index 91% rename from src/main/java/com/rampatra/base/MaxHeap.java rename to src/me/ramswaroop/common/MaxHeap.java index 22b36cfa..77bf10a7 100644 --- a/src/main/java/com/rampatra/base/MaxHeap.java +++ b/src/me/ramswaroop/common/MaxHeap.java @@ -1,10 +1,10 @@ -package com.rampatra.base; - -import com.rampatra.sorting.HeapSort; +package me.ramswaroop.common; import java.util.Arrays; /** + * Created by IntelliJ IDEA. + *

* A HEAP is a specialized tree-based ABSTRACT DATA TYPE that satisfies the heap property: * min-heap: All non-leaf elements are either smaller than or equal to their left and right child. * max-heap: All non-leaf elements are either greater than or equal to their left and right child. @@ -17,10 +17,11 @@ * Therefore, buildMaxHeap() would take O(n log n) time BUT IF OBSERVED CAREFULLY IT TAKES 0(N) TIME. *

* Used in the HeapSort algorithm. Also can be used to implement a PriorityQueue. - * Learn more * - * @author rampatra - * @since 8/2/15 + * @author: ramswaroop + * @date: 8/2/15 + * @time: 11:57 AM + * @see: http://staff.ustc.edu.cn/~csli/graduate/algorithms/book6/chap07.htm */ public class MaxHeap { @@ -31,12 +32,12 @@ public MaxHeap(int[] heap) { this.size = heap.length; this.heap = Arrays.copyOf(heap, size); } - + /** * Makes the array {@param a} satisfy the max heap property starting from * {@param index} till the end of array. *

- * See {@link HeapSort#maxHeapify} for a modified + * See {@link me.ramswaroop.arrays.sorting.HeapSort#maxHeapify} for a modified * version of maxHeapify. *

* Time complexity: O(log n). @@ -75,11 +76,11 @@ public void buildMaxHeap() { /** * Insert a new element into the heap satisfying * the heap property. - *

- * Time complexity: O(log n) where 'n' is total no. of + * + * Time complexity: O(log n) where 'n' is total no. of * elements in heap or O(h) where 'h' is the height of * heap. - * + * * @param elem */ public void insert(int elem) { diff --git a/src/main/java/com/rampatra/base/MinHeap.java b/src/me/ramswaroop/common/MinHeap.java similarity index 87% rename from src/main/java/com/rampatra/base/MinHeap.java rename to src/me/ramswaroop/common/MinHeap.java index 6e7b7df1..be1f3312 100644 --- a/src/main/java/com/rampatra/base/MinHeap.java +++ b/src/me/ramswaroop/common/MinHeap.java @@ -1,8 +1,10 @@ -package com.rampatra.base; +package me.ramswaroop.common; import java.util.Arrays; /** + * Created by IntelliJ IDEA. + *

* A HEAP is a specialized tree-based ABSTRACT DATA TYPE that satisfies the heap property: * min-heap: All non-leaf elements are either smaller than or equal to their left and right child. * max-heap: All non-leaf elements are either greater than or equal to their left and right child. @@ -15,15 +17,16 @@ * Therefore, buildMinHeap() would take O(n log n) time BUT IF OBSERVED CAREFULLY IT TAKES 0(N) TIME. *

* Used in the HeapSort algorithm. Also can be used to implement a PriorityQueue. - * Learn more * - * @author rampatra - * @since 8/2/15 + * @author: ramswaroop + * @date: 8/2/15 + * @time: 11:57 AM + * @see: http://staff.ustc.edu.cn/~csli/graduate/algorithms/book6/chap07.htm */ public class MinHeap { - private int[] heap; - private int size; + int[] heap; + int size; public MinHeap(int[] heap) { this.size = heap.length; @@ -39,20 +42,20 @@ public MinHeap(int[] heap) { * @param index */ public void minHeapify(int index) { - int minIndex = index; + int smallest = index; int leftIndex = 2 * index + 1; int rightIndex = 2 * index + 2; if (leftIndex < size && heap[index] > heap[leftIndex]) { - minIndex = leftIndex; + smallest = leftIndex; } - if (rightIndex < size && heap[minIndex] > heap[rightIndex]) { - minIndex = rightIndex; + if (rightIndex < size && heap[smallest] > heap[rightIndex]) { + smallest = rightIndex; } - if (minIndex != index) { - swap(index, minIndex); - minHeapify(minIndex); + if (smallest != index) { + swap(index, smallest); + minHeapify(smallest); } } @@ -140,4 +143,4 @@ public static void main(String[] args) { minHeap.insert(0); minHeap.printHeap(); } -} \ No newline at end of file +} diff --git a/src/main/java/com/rampatra/base/Queue.java b/src/me/ramswaroop/common/Queue.java similarity index 80% rename from src/main/java/com/rampatra/base/Queue.java rename to src/me/ramswaroop/common/Queue.java index 660fcb90..999a7a9a 100644 --- a/src/main/java/com/rampatra/base/Queue.java +++ b/src/me/ramswaroop/common/Queue.java @@ -1,10 +1,11 @@ -package com.rampatra.base; +package me.ramswaroop.common; /** - * A generic interface for a queue. - * - * @author rampatra - * @since 4/12/15 + * Created by IntelliJ IDEA. + * User: ramswaroop + * Date: 4/12/15 + * Time: 10:39 AM + * To change this template go to Preferences | IDE Settings | File and Code Templates */ public interface Queue { @@ -54,6 +55,7 @@ public interface Queue { /** * Prints the content of the queue. + * */ public void print(); diff --git a/src/main/java/com/rampatra/base/SingleLinkedList.java b/src/me/ramswaroop/common/SingleLinkedList.java similarity index 99% rename from src/main/java/com/rampatra/base/SingleLinkedList.java rename to src/me/ramswaroop/common/SingleLinkedList.java index d52484cb..4b5b09e1 100644 --- a/src/main/java/com/rampatra/base/SingleLinkedList.java +++ b/src/me/ramswaroop/common/SingleLinkedList.java @@ -1,4 +1,4 @@ -package com.rampatra.base; +package me.ramswaroop.common; import java.util.NoSuchElementException; @@ -7,8 +7,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/16/15 + * @author: ramswaroop + * @date: 6/16/15 * @time: 1:00 PM */ public class SingleLinkedList> implements LinkedList { diff --git a/src/main/java/com/rampatra/base/SingleLinkedNode.java b/src/me/ramswaroop/common/SingleLinkedNode.java similarity index 83% rename from src/main/java/com/rampatra/base/SingleLinkedNode.java rename to src/me/ramswaroop/common/SingleLinkedNode.java index 97cd9a05..3e8076d7 100644 --- a/src/main/java/com/rampatra/base/SingleLinkedNode.java +++ b/src/me/ramswaroop/common/SingleLinkedNode.java @@ -1,10 +1,10 @@ -package com.rampatra.base; +package me.ramswaroop.common; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/18/15 + * @author: ramswaroop + * @date: 6/18/15 * @time: 2:37 PM */ public class SingleLinkedNode> { diff --git a/src/main/java/com/rampatra/base/Stack.java b/src/me/ramswaroop/common/Stack.java similarity index 81% rename from src/main/java/com/rampatra/base/Stack.java rename to src/me/ramswaroop/common/Stack.java index 3761052a..2a15f154 100644 --- a/src/main/java/com/rampatra/base/Stack.java +++ b/src/me/ramswaroop/common/Stack.java @@ -1,10 +1,11 @@ -package com.rampatra.base; +package me.ramswaroop.common; /** - * A generic interface for a stack. - * - * @author rampatra - * @since 4/3/15 + * Created by IntelliJ IDEA. + * User: ramswaroop + * Date: 4/3/15 + * Time: 9:47 AM + * To change this template go to Preferences | IDE Settings | File and Code Templates */ public interface Stack { /** diff --git a/src/main/java/com/rampatra/base/Tree.java b/src/me/ramswaroop/common/Tree.java similarity index 80% rename from src/main/java/com/rampatra/base/Tree.java rename to src/me/ramswaroop/common/Tree.java index 56c8b338..93fb207e 100644 --- a/src/main/java/com/rampatra/base/Tree.java +++ b/src/me/ramswaroop/common/Tree.java @@ -1,8 +1,8 @@ -package com.rampatra.base; +package me.ramswaroop.common; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 4/19/15 * Time: 6:30 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/me/ramswaroop/common/Trie.java b/src/me/ramswaroop/common/Trie.java new file mode 100644 index 00000000..75afdcc3 --- /dev/null +++ b/src/me/ramswaroop/common/Trie.java @@ -0,0 +1,105 @@ +package me.ramswaroop.common; + +import java.util.HashMap; + +/** + * Created by IntelliJ IDEA. + *

+ * Trie also called digital tree and sometimes radix tree or prefix tree (as they can be + * searched by prefixes), is an ordered tree data structure that is used to store a dynamic + * set or associative array where the keys are usually strings. + *

+ * You can think it as HashMap of HashMap of HashMap and so on. Each key in the HashMap is a + * single digit/letter of the data you want to store and {@code data} is the final full word + * you want to save in trie. + * + * @author: ramswaroop + * @date: 9/22/15 + * @time: 8:19 PM + * @see: https://en.wikipedia.org/wiki/Trie + * @see: https://www.topcoder.com/community/data-science/data-science-tutorials/using-tries + */ +public class Trie { + + TrieNode root; + + Trie() { + root = new TrieNode<>(null, new HashMap>()); + } + + /** + * Inserts {@param data} in trie. + * + * @param data + */ + public void insert(E data) { + + int i = 0; + String str = data.toString(); + TrieNode curr = root; + + while (i < str.length()) { + if (curr.children.get(str.substring(i, i + 1)) != null) { + curr = curr.children.get(str.substring(i, i + 1)); + i++; + } else { + break; + } + } + + while (i < str.length()) { + curr.children.put(str.substring(i, i + 1), new TrieNode<>(null, new HashMap>())); + curr = curr.children.get(str.substring(i, i + 1)); + i++; + } + + curr.data = data; + } + + /** + * Searches {@param data} in trie. + * + * @param data + * @return {@code true} if {@param data} is present, {@code false} otherwise. + */ + public boolean search(E data) { + + int i = 0; + String str = data.toString(); + TrieNode curr = root; + + while (i < str.length()) { + if (curr.children.get(str.substring(i, i + 1)) == null) { + return false; + } + curr = curr.children.get(str.substring(i, i + 1)); + i++; + } + + return curr.data != null && curr.data.equals(data); + } + + private class TrieNode { + E data; // stores the complete string (required to determine whether the string is in the trie) + HashMap> children; + + TrieNode(E data, HashMap> children) { + this.data = data; + this.children = children; + } + } + + // unit testing + public static void main(String[] a) { + Trie trie = new Trie<>(); + trie.insert("ram"); + trie.insert("r"); + trie.insert("rama"); + trie.insert("ramswaroop"); + System.out.println(trie.search("ram")); + System.out.println(trie.search("r")); + System.out.println(trie.search("ra")); + System.out.println(trie.search("raz")); + System.out.println(trie.search("ramswaroop")); + } +} diff --git a/src/main/java/com/rampatra/dynamicprogramming/FibonacciNumbers.java b/src/me/ramswaroop/dynamicprogramming/FibonacciNumbers.java similarity index 68% rename from src/main/java/com/rampatra/dynamicprogramming/FibonacciNumbers.java rename to src/me/ramswaroop/dynamicprogramming/FibonacciNumbers.java index 8d102ef7..dac48fb4 100644 --- a/src/main/java/com/rampatra/dynamicprogramming/FibonacciNumbers.java +++ b/src/me/ramswaroop/dynamicprogramming/FibonacciNumbers.java @@ -1,4 +1,4 @@ -package com.rampatra.dynamicprogramming; +package me.ramswaroop.dynamicprogramming; import java.util.Arrays; @@ -7,13 +7,14 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/10/15 + * @author: ramswaroop + * @date: 9/10/15 + * @time: 3:57 PM */ public class FibonacciNumbers { /** - * Computes first {@code k} fibonacci numbers using + * Computes first {@param k} fibonacci numbers using * bottom-up DP approach. *

* Time complexity: O(k) @@ -21,9 +22,9 @@ public class FibonacciNumbers { * @param k */ public static int[] getFirstKFibonacciNumbers(int k) { - int[] fib = new int[k]; + int[] fib = new int[k + 1]; int i = 1; - while (i < k) { + while (i <= k) { if (i == 1 || i == 2) { fib[i] = 1; } else { @@ -34,8 +35,7 @@ public static int[] getFirstKFibonacciNumbers(int k) { return fib; } - public static void main(String[] args) { - out.println(Arrays.toString(getFirstKFibonacciNumbers(0))); + public static void main(String a[]) { out.println(Arrays.toString(getFirstKFibonacciNumbers(10))); out.println(Arrays.toString(getFirstKFibonacciNumbers(46))); } diff --git a/src/main/java/com/rampatra/dynamicprogramming/LongestIncreasingSubSequence.java b/src/me/ramswaroop/dynamicprogramming/LongestIncreasingSubsequence.java similarity index 79% rename from src/main/java/com/rampatra/dynamicprogramming/LongestIncreasingSubSequence.java rename to src/me/ramswaroop/dynamicprogramming/LongestIncreasingSubsequence.java index 7372a9a8..77a7a0d5 100644 --- a/src/main/java/com/rampatra/dynamicprogramming/LongestIncreasingSubSequence.java +++ b/src/me/ramswaroop/dynamicprogramming/LongestIncreasingSubsequence.java @@ -1,8 +1,11 @@ -package com.rampatra.dynamicprogramming; +package me.ramswaroop.dynamicprogramming; /** - * @author rampatra - * @since 9/29/15 + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 9/29/15 + * @time: 10:15 PM */ public class LongestIncreasingSubSequence { @@ -11,23 +14,23 @@ public class LongestIncreasingSubSequence { * The Longest Increasing SubSequence (LIS) problem is to find the length of * the longest sub-sequence of a given sequence such that all elements of the * sub-sequence are sorted in increasing order. - *

- * For example, - * Length of LIS for { 10, 22, 9, 33, 21, 50, 41, 60, 80 } is 6 and LIS + * + * For example, + * Length of LIS for { 10, 22, 9, 33, 21, 50, 41, 60, 80 } is 6 and LIS * is {10, 22, 33, 50, 60, 80}. - *

+ * * Optimal Substructure: * Let arr[0..n-1] be the input array and L(i) be the length of the LIS till index i such that arr[i] is part * of LIS and arr[i] is the last element in LIS, then L(i) can be recursively written as. * L(i) = { 1 + Max ( L(j) ) } where j < i and arr[j] < arr[i] and if there is no such j then L(i) = 1 - * To get LIS of a given array, we need to return max(L(i)) where 0 < i < n So the LIS problem has optimal - * substructure property as the main problem can be solved using solutions to sub-problems. - * - * @param arr + * To get LIS of a given array, we need to return max(L(i)) where 0 < i < n So the LIS problem has optimal + * substructure property as the main problem can be solved using solutions to sub-problems. + * + * @param a * @return */ - public static int getLongestIncreasingSubSequenceLength(int[] arr) { - int len = arr.length, maxLisLength = 0; + public static int getLongestIncreasingSubSequenceLength(int[] a) { + int len = a.length, maxLisLength = 0; int[] lis = new int[len]; for (int i = 0; i < len; i++) { @@ -36,7 +39,7 @@ public static int getLongestIncreasingSubSequenceLength(int[] arr) { for (int i = 1; i < len; i++) { for (int j = 0; j < i; j++) { - if (arr[i] > arr[j] && lis[i] < lis[j] + 1) + if (a[i] > a[j] && lis[i] < lis[j] + 1) lis[i] = lis[j] + 1; } } @@ -50,7 +53,7 @@ public static int getLongestIncreasingSubSequenceLength(int[] arr) { return maxLisLength; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getLongestIncreasingSubSequenceLength(new int[]{2, 3, 7, 8, 15})); System.out.println(getLongestIncreasingSubSequenceLength(new int[]{2, 20, 7, 8, 1})); System.out.println(getLongestIncreasingSubSequenceLength(new int[]{20, 10, 5})); diff --git a/src/main/java/com/rampatra/dynamicprogramming/MinimumJumpsToReachEnd.java b/src/me/ramswaroop/dynamicprogramming/MinimumJumpsToReachEnd.java similarity index 94% rename from src/main/java/com/rampatra/dynamicprogramming/MinimumJumpsToReachEnd.java rename to src/me/ramswaroop/dynamicprogramming/MinimumJumpsToReachEnd.java index bbc6a40f..074ccaf3 100644 --- a/src/main/java/com/rampatra/dynamicprogramming/MinimumJumpsToReachEnd.java +++ b/src/me/ramswaroop/dynamicprogramming/MinimumJumpsToReachEnd.java @@ -1,10 +1,10 @@ -package com.rampatra.dynamicprogramming; +package me.ramswaroop.dynamicprogramming; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/20/15 + * @author: ramswaroop + * @date: 9/20/15 * @time: 1:18 PM */ public class MinimumJumpsToReachEnd { @@ -43,7 +43,7 @@ public static int getMinimumJumpsToReachEndNaive(int[] a, int l, int h) { // TODO dp approach - public static void main(String[] args) { + public static void main(String a[]) { int[] ar = new int[]{1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}; System.out.println(getMinimumJumpsToReachEndNaive(ar, 0, ar.length - 1)); ar = new int[]{5, 4, 3, 2, 1}; diff --git a/src/main/java/com/rampatra/linkedlists/AddNumbersInTwoLists.java b/src/me/ramswaroop/linkedlists/AddNumbersInTwoLists.java similarity index 74% rename from src/main/java/com/rampatra/linkedlists/AddNumbersInTwoLists.java rename to src/me/ramswaroop/linkedlists/AddNumbersInTwoLists.java index e32e3336..5abf935f 100644 --- a/src/main/java/com/rampatra/linkedlists/AddNumbersInTwoLists.java +++ b/src/me/ramswaroop/linkedlists/AddNumbersInTwoLists.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/2/15 + * @author: ramswaroop + * @date: 7/2/15 * @time: 1:20 PM */ public class AddNumbersInTwoLists { @@ -98,38 +98,7 @@ public static SingleLinkedList addWithNode1MSD(SingleLinkedList - * Example: - *

- * Input: - * First List: 5->6->3 // represents number 365 - * Second List: 8->4->2 // represents number 248 - * Output: - * 613 // represents number 613 - * - * @param l1 - * @param l2 - */ - private static void printSumWithNode1LSD(SingleLinkedList l1, SingleLinkedList l2) { - System.out.println(convertToInt(l1) + convertToInt(l2)); - } - - private static int convertToInt(SingleLinkedList list) { - int num = 0; - int baseValue = 1; - SingleLinkedNode temp = list.head; - while (temp != null) { - num += (temp.item * baseValue); - baseValue *= 10; - temp = temp.next; - } - return num; - } - - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList1 = new SingleLinkedList<>(); linkedList1.add(7); linkedList1.add(5); @@ -142,9 +111,6 @@ public static void main(String[] args) { linkedList2.add(4); linkedList2.printList(); addWithNode1LSD(linkedList1, linkedList2).printList(); - System.out.println("--------------"); addWithNode1MSD(linkedList1, linkedList2).printList(); - System.out.println("--------------"); - printSumWithNode1LSD(linkedList1, linkedList2); } } diff --git a/src/main/java/com/rampatra/linkedlists/CloneWithRandPointers.java b/src/me/ramswaroop/linkedlists/CloneWithRandPointers.java similarity index 76% rename from src/main/java/com/rampatra/linkedlists/CloneWithRandPointers.java rename to src/me/ramswaroop/linkedlists/CloneWithRandPointers.java index 53795113..b8490ace 100644 --- a/src/main/java/com/rampatra/linkedlists/CloneWithRandPointers.java +++ b/src/me/ramswaroop/linkedlists/CloneWithRandPointers.java @@ -1,13 +1,15 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.DoubleLinkedList; -import com.rampatra.base.DoubleLinkedNode; +import me.ramswaroop.common.DoubleLinkedList; +import me.ramswaroop.common.DoubleLinkedNode; /** - * Find the question here. + * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/20/15 + * @author: ramswaroop + * @date: 6/20/15 + * @time: 1:00 PM + * @see: http://www.geeksforgeeks.org/a-linked-list-with-next-and-arbit-pointer/ */ public class CloneWithRandPointers { @@ -25,7 +27,8 @@ public static > DoubleLinkedList clone(DoubleLinkedLi // copy each node and insert after it while (curr != null) { - curr.next = new DoubleLinkedNode<>(null, curr.item, curr.next); + DoubleLinkedNode newNode = new DoubleLinkedNode<>(null, curr.item, curr.next); + curr.next = newNode; curr = curr.next.next; } @@ -42,7 +45,7 @@ public static > DoubleLinkedList clone(DoubleLinkedLi DoubleLinkedNode dupNode; while (curr != null && curr.next != null) { dupNode = curr.next; - curr.next = dupNode.next; + curr.next = (dupNode != null) ? dupNode.next : null; dupNode.next = (curr.next != null) ? curr.next.next : null; curr = curr.next; } @@ -50,12 +53,12 @@ public static > DoubleLinkedList clone(DoubleLinkedLi return DoubleLinkedList.getLinkedList(cloneHead); } - public static void main(String[] args) { + public static void main(String a[]) { DoubleLinkedList linkedList = new DoubleLinkedList<>(); - linkedList.add(0); - linkedList.add(1); - linkedList.add(2); - linkedList.add(3); + linkedList.add(00); + linkedList.add(11); + linkedList.add(22); + linkedList.add(33); linkedList.getNode(0).prev = null; linkedList.getNode(1).prev = linkedList.getNode(2); linkedList.getNode(2).prev = linkedList.getNode(0); diff --git a/src/main/java/com/rampatra/linkedlists/DeleteAlternateNodes.java b/src/me/ramswaroop/linkedlists/DeleteAlternateNodes.java similarity index 59% rename from src/main/java/com/rampatra/linkedlists/DeleteAlternateNodes.java rename to src/me/ramswaroop/linkedlists/DeleteAlternateNodes.java index 45670941..0cde7dd1 100644 --- a/src/main/java/com/rampatra/linkedlists/DeleteAlternateNodes.java +++ b/src/me/ramswaroop/linkedlists/DeleteAlternateNodes.java @@ -1,13 +1,14 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** - * Delete alternate nodes in a single linked list. + * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/27/15 + * @author: ramswaroop + * @date: 6/27/15 + * @time: 5:27 PM */ public class DeleteAlternateNodes { @@ -23,14 +24,14 @@ public static > void deleteAlternateNodes(SingleLinkedNo deleteAlternateNodes(node.next); } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); - linkedList.add(0); - linkedList.add(1); - linkedList.add(2); - linkedList.add(3); - linkedList.add(4); - linkedList.add(5); + linkedList.add(00); + linkedList.add(11); + linkedList.add(22); + linkedList.add(33); + linkedList.add(44); + linkedList.add(55); linkedList.printList(); deleteAlternateNodes(linkedList); linkedList.printList(); diff --git a/src/main/java/com/rampatra/linkedlists/DeleteLesserNodes.java b/src/me/ramswaroop/linkedlists/DeleteLesserNodes.java similarity index 88% rename from src/main/java/com/rampatra/linkedlists/DeleteLesserNodes.java rename to src/me/ramswaroop/linkedlists/DeleteLesserNodes.java index 0dbc734a..45edc0ab 100644 --- a/src/main/java/com/rampatra/linkedlists/DeleteLesserNodes.java +++ b/src/me/ramswaroop/linkedlists/DeleteLesserNodes.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/30/15 + * @author: ramswaroop + * @date: 6/30/15 * @time: 5:13 PM */ public class DeleteLesserNodes { @@ -57,7 +57,7 @@ public static > void deleteLesserNodes(SingleLinkedList< /** - * Recursive version of {@link #deleteLesserNodes(SingleLinkedList)}. + * Recursive version of {@link #deleteLesserNodes(me.ramswaroop.common.SingleLinkedList)}. * * @param node * @param @@ -76,7 +76,7 @@ public static > SingleLinkedNode deleteLesserNodes(Si } } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/DeleteMnodesAfterNnodes.java b/src/me/ramswaroop/linkedlists/DeleteMnodesAfterNnodes.java similarity index 88% rename from src/main/java/com/rampatra/linkedlists/DeleteMnodesAfterNnodes.java rename to src/me/ramswaroop/linkedlists/DeleteMnodesAfterNnodes.java index 005aef06..991139e5 100644 --- a/src/main/java/com/rampatra/linkedlists/DeleteMnodesAfterNnodes.java +++ b/src/me/ramswaroop/linkedlists/DeleteMnodesAfterNnodes.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/6/15 + * @author: ramswaroop + * @date: 7/6/15 * @time: 7:43 PM */ public class DeleteMnodesAfterNnodes { @@ -44,7 +44,7 @@ public static > void deleteMnodesAfterNnodes(SingleLinke } } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(7); linkedList.add(5); diff --git a/src/main/java/com/rampatra/linkedlists/DeleteNode.java b/src/me/ramswaroop/linkedlists/DeleteNode.java similarity index 67% rename from src/main/java/com/rampatra/linkedlists/DeleteNode.java rename to src/me/ramswaroop/linkedlists/DeleteNode.java index 82d8c3d7..7f9248f6 100644 --- a/src/main/java/com/rampatra/linkedlists/DeleteNode.java +++ b/src/me/ramswaroop/linkedlists/DeleteNode.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/18/15 + * @author: ramswaroop + * @date: 6/18/15 * @time: 2:35 PM */ public class DeleteNode { @@ -24,11 +24,11 @@ public static > void deleteNode(SingleLinkedNode node node.next = node.next.next; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); - linkedList.add(0); - linkedList.add(1); - linkedList.add(2); + linkedList.add(00); + linkedList.add(11); + linkedList.add(22); linkedList.printList(); deleteNode(linkedList.getNode(1)); linkedList.printList(); diff --git a/src/me/ramswaroop/linkedlists/DetectAndRemoveLoop.java b/src/me/ramswaroop/linkedlists/DetectAndRemoveLoop.java new file mode 100644 index 00000000..e180d455 --- /dev/null +++ b/src/me/ramswaroop/linkedlists/DetectAndRemoveLoop.java @@ -0,0 +1,85 @@ +package me.ramswaroop.linkedlists; + +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; + +/** + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 7/1/15 + * @time: 12:39 PM + */ +public class DetectAndRemoveLoop { + + /** + * Detects loop if any in {@param list} and removes it. + * + * Algorithm: + * + * 1) Use Floyd's cycle detection algorithm to detect loop. + * 2) Acc. to FCD, once the fast pointer meets the slow pointer we conclude that there is a loop. + * 3) Now compute the length 'l' of the loop. + * 4) Move the fast pointer length 'l' from head. + * 5) Now move both slow and fast pointer at same pace and where they meet is the starting point of the loop. + * 6) Lastly, to remove the loop make the next of the node (before the starting point of loop) to null. + * + * @param list + * @param + * @return {@code true} if loop exists {@code false} otherwise. + */ + public static > boolean detectAndRemoveLoop(SingleLinkedList list) { + int i = 0, length = 0; + boolean isLoopPresent = false; + SingleLinkedNode slow = list.head, fast = slow.next; + + while (fast != null && fast.next != null) { + if (slow == fast) { + isLoopPresent = true; + break; + } + slow = slow.next; + fast = fast.next.next; + } + + if (isLoopPresent == false) return false; + + // compute length of loop + while (fast.next != slow) { + fast = fast.next; + length++; + } + + // move fast pointer from head by the length of loop + slow = fast = list.head; + while (i <= length) { + fast = fast.next; + i++; + } + + // move both pointers at same pace to determine the starting node of loop + while (true) { + slow = slow.next; + fast = fast.next; + if (slow.next == fast.next) { + fast.next = null; + break; + } + } + + return isLoopPresent; + } + + public static void main(String a[]) { + SingleLinkedList linkedList = new SingleLinkedList<>(); + linkedList.add(00); + linkedList.add(11); + linkedList.add(22); + linkedList.add(33); + linkedList.add(44); + linkedList.add(55); + linkedList.getNode(1).next = linkedList.getNode(0); + System.out.println(detectAndRemoveLoop(linkedList)); + linkedList.printList(); + } +} diff --git a/src/main/java/com/rampatra/linkedlists/DetectLoop.java b/src/me/ramswaroop/linkedlists/DetectLoop.java similarity index 70% rename from src/main/java/com/rampatra/linkedlists/DetectLoop.java rename to src/me/ramswaroop/linkedlists/DetectLoop.java index 45bd6b6f..f2063f07 100644 --- a/src/main/java/com/rampatra/linkedlists/DetectLoop.java +++ b/src/me/ramswaroop/linkedlists/DetectLoop.java @@ -1,15 +1,16 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; import java.util.HashMap; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/19/15 + * @author: ramswaroop + * @date: 6/19/15 + * @time: 9:24 AM */ public class DetectLoop { @@ -23,21 +24,20 @@ public class DetectLoop { * there is a loop. If pointers do not meet * then linked list does not have loop. *

- * Level: Easy - * Time Complexity: O(n) - * Space Complexity: O(1) + * Time: O(n) + * Space: O(1) * * @param list * @return */ public static > boolean isLoopPresent(SingleLinkedList list) { - SingleLinkedNode slow = list.head, fast = list.head; + SingleLinkedNode slow = list.head, fast = slow.next; while (fast != null && fast.next != null) { - slow = slow.next; - fast = fast.next.next; if (slow == fast) { return true; } + slow = slow.next; + fast = fast.next.next; } return false; } @@ -45,8 +45,8 @@ public static > boolean isLoopPresent(SingleLinkedList - * Time Complexity: O(n) - * Space Complexity: O(n) + * Time: O(n) + * Space: O(n) * * @param node * @return @@ -55,7 +55,7 @@ public static > boolean isLoopPresentUsingHashMap(Single HashMap, Boolean> map = new HashMap<>(); SingleLinkedNode curr = node; while (curr != null) { - if (map.get(curr) != null && map.get(curr)) { + if (map.get(curr) != null && map.get(curr) == true) { return true; } map.put(curr, true); @@ -64,15 +64,15 @@ public static > boolean isLoopPresentUsingHashMap(Single return false; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); - linkedList.add(0); - linkedList.add(1); - linkedList.add(2); - linkedList.add(3); - linkedList.add(4); - linkedList.add(5); + linkedList.add(00); + linkedList.add(11); + linkedList.add(22); + linkedList.add(33); + linkedList.add(44); + linkedList.add(55); linkedList.getNode(4).next = linkedList.getNode(3); System.out.println(isLoopPresent(linkedList)); } -} \ No newline at end of file +} diff --git a/src/main/java/com/rampatra/linkedlists/DivideCircularListIntoTwo.java b/src/me/ramswaroop/linkedlists/DivideCircularListIntoTwo.java similarity index 83% rename from src/main/java/com/rampatra/linkedlists/DivideCircularListIntoTwo.java rename to src/me/ramswaroop/linkedlists/DivideCircularListIntoTwo.java index b19af007..d7eeca8a 100644 --- a/src/main/java/com/rampatra/linkedlists/DivideCircularListIntoTwo.java +++ b/src/me/ramswaroop/linkedlists/DivideCircularListIntoTwo.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.CircularSingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.CircularSingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/23/15 + * @author: ramswaroop + * @date: 6/23/15 * @time: 6:01 PM */ public class DivideCircularListIntoTwo> extends CircularSingleLinkedList { @@ -24,7 +24,7 @@ public static > CircularSingleLinkedList[] divideIntoTwo return new CircularSingleLinkedList[]{getLinkedList(list.head), getLinkedList(secondHead)}; } - public static void main(String[] args) { + public static void main(String a[]) { CircularSingleLinkedList linkedList = new CircularSingleLinkedList<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/FlattenMultiLevelLinkedList.java b/src/me/ramswaroop/linkedlists/FlattenMultiLevelLinkedList.java similarity index 94% rename from src/main/java/com/rampatra/linkedlists/FlattenMultiLevelLinkedList.java rename to src/me/ramswaroop/linkedlists/FlattenMultiLevelLinkedList.java index 5f9434ed..eb600bbf 100644 --- a/src/main/java/com/rampatra/linkedlists/FlattenMultiLevelLinkedList.java +++ b/src/me/ramswaroop/linkedlists/FlattenMultiLevelLinkedList.java @@ -1,14 +1,15 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.DoubleLinkedNode; +import me.ramswaroop.common.DoubleLinkedNode; import static java.lang.System.out; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/26/15 + * @author: ramswaroop + * @date: 7/26/15 + * @time: 12:08 PM */ public class FlattenMultiLevelLinkedList { @@ -16,7 +17,7 @@ public class FlattenMultiLevelLinkedList { * Flattens a multilevel linked list into a single level linked list. You can * {@see http://www.geeksforgeeks.org/flatten-a-linked-list-with-next-and-child-pointers/} for * clarity on question. - *

+ * * Solution: * 1) Take "cur" pointer, which will point to head of the fist level of the list * 2) Take "tail" pointer, which will point to end of the first level of the list @@ -78,7 +79,7 @@ public static > void printList(DoubleLinkedNode node) out.println(curr.item.toString() + "]"); } - public static void main(String[] args) { + public static void main(String a[]) { // 1st level DoubleLinkedNode head = new DoubleLinkedNode<>(1); head.next = new DoubleLinkedNode<>(5); diff --git a/src/main/java/com/rampatra/linkedlists/InsertInSortedCircularLinkedList.java b/src/me/ramswaroop/linkedlists/InsertInSortedCircularLinkedList.java similarity index 87% rename from src/main/java/com/rampatra/linkedlists/InsertInSortedCircularLinkedList.java rename to src/me/ramswaroop/linkedlists/InsertInSortedCircularLinkedList.java index a04b48bc..94bad85d 100644 --- a/src/main/java/com/rampatra/linkedlists/InsertInSortedCircularLinkedList.java +++ b/src/me/ramswaroop/linkedlists/InsertInSortedCircularLinkedList.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.CircularSingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.CircularSingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/29/15 + * @author: ramswaroop + * @date: 6/29/15 * @time: 6:16 PM */ public class InsertInSortedCircularLinkedList> extends CircularSingleLinkedList { @@ -41,7 +41,7 @@ public void insert(E item) { } while (node != head); } - public static void main(String[] args) { + public static void main(String a[]) { InsertInSortedCircularLinkedList linkedList = new InsertInSortedCircularLinkedList<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/InsertInSortedList.java b/src/me/ramswaroop/linkedlists/InsertInSortedList.java similarity index 85% rename from src/main/java/com/rampatra/linkedlists/InsertInSortedList.java rename to src/me/ramswaroop/linkedlists/InsertInSortedList.java index fc0bd2b1..00cd94af 100644 --- a/src/main/java/com/rampatra/linkedlists/InsertInSortedList.java +++ b/src/me/ramswaroop/linkedlists/InsertInSortedList.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/21/15 + * @author: ramswaroop + * @date: 6/21/15 * @time: 10:20 PM */ public class InsertInSortedList> extends SingleLinkedList { @@ -33,7 +33,7 @@ public void insert(E item) { } } - public static void main(String[] args) { + public static void main(String a[]) { InsertInSortedList linkedList = new InsertInSortedList<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/IntersectionAndUnionOf2Lists.java b/src/me/ramswaroop/linkedlists/IntersectionAndUnionOf2Lists.java similarity index 89% rename from src/main/java/com/rampatra/linkedlists/IntersectionAndUnionOf2Lists.java rename to src/me/ramswaroop/linkedlists/IntersectionAndUnionOf2Lists.java index f8fd3a79..b5e10a84 100644 --- a/src/main/java/com/rampatra/linkedlists/IntersectionAndUnionOf2Lists.java +++ b/src/me/ramswaroop/linkedlists/IntersectionAndUnionOf2Lists.java @@ -1,22 +1,23 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/7/15 + * @author: ramswaroop + * @date: 7/7/15 * @time: 1:04 PM */ public class IntersectionAndUnionOf2Lists { /** + * * @param list1 * @param list2 * @param - * @return an array of list consisting of intersection and union of two sorted + * @return an array of list consisting of intersection and union of two sorted * list {@param list1} and {@param list2} respectively. */ public static > SingleLinkedList[] getIntersectionAndUnion(SingleLinkedList list1, @@ -41,7 +42,7 @@ public static > SingleLinkedList[] getIntersectionAnd curr1 = curr1.next; } else if (curr1.item.compareTo(curr2.item) > 0) { unionList.add(curr2.item); - curr2 = curr2.next; + curr2=curr2.next; } else { unionList.add(curr1.item); intersectionList.add(curr1.item); @@ -53,7 +54,7 @@ public static > SingleLinkedList[] getIntersectionAnd return new SingleLinkedList[]{intersectionList, unionList}; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList1 = new SingleLinkedList<>(); linkedList1.add(00); linkedList1.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/IntersectionOf2SortedLists.java b/src/me/ramswaroop/linkedlists/IntersectionOf2SortedLists.java similarity index 90% rename from src/main/java/com/rampatra/linkedlists/IntersectionOf2SortedLists.java rename to src/me/ramswaroop/linkedlists/IntersectionOf2SortedLists.java index 0213a3b9..3f591564 100644 --- a/src/main/java/com/rampatra/linkedlists/IntersectionOf2SortedLists.java +++ b/src/me/ramswaroop/linkedlists/IntersectionOf2SortedLists.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/27/15 + * @author: ramswaroop + * @date: 6/27/15 * @time: 11:13 AM */ public class IntersectionOf2SortedLists { @@ -42,7 +42,7 @@ public static > SingleLinkedList getIntersectionList( return intersectedList; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList1 = new SingleLinkedList<>(); linkedList1.add(00); linkedList1.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/IntersectionPointOfTwoLists.java b/src/me/ramswaroop/linkedlists/IntersectionPointOfTwoLists.java similarity index 78% rename from src/main/java/com/rampatra/linkedlists/IntersectionPointOfTwoLists.java rename to src/me/ramswaroop/linkedlists/IntersectionPointOfTwoLists.java index 705da489..c2276c20 100644 --- a/src/main/java/com/rampatra/linkedlists/IntersectionPointOfTwoLists.java +++ b/src/me/ramswaroop/linkedlists/IntersectionPointOfTwoLists.java @@ -1,13 +1,14 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/18/15 + * @author: ramswaroop + * @date: 6/18/15 + * @time: 10:34 PM */ public class IntersectionPointOfTwoLists { @@ -50,17 +51,17 @@ public static > SingleLinkedNode getIntersectionNode( return null; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList1 = new SingleLinkedList<>(); - linkedList1.add(0); - linkedList1.add(1); - linkedList1.add(2); - linkedList1.add(3); - linkedList1.add(4); - linkedList1.add(5); - linkedList1.add(6); - linkedList1.add(7); - linkedList1.add(8); + linkedList1.add(00); + linkedList1.add(11); + linkedList1.add(22); + linkedList1.add(33); + linkedList1.add(44); + linkedList1.add(55); + linkedList1.add(66); + linkedList1.add(77); + linkedList1.add(88); SingleLinkedList linkedList2 = new SingleLinkedList<>(); linkedList2.add(56); linkedList2.add(78); diff --git a/src/main/java/com/rampatra/linkedlists/Identical.java b/src/me/ramswaroop/linkedlists/IsIdentical.java similarity index 59% rename from src/main/java/com/rampatra/linkedlists/Identical.java rename to src/me/ramswaroop/linkedlists/IsIdentical.java index a4aa0d1c..cc2ceae6 100644 --- a/src/main/java/com/rampatra/linkedlists/Identical.java +++ b/src/me/ramswaroop/linkedlists/IsIdentical.java @@ -1,15 +1,16 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/29/15 + * @author: ramswaroop + * @date: 6/29/15 + * @time: 9:42 AM */ -public class Identical { +public class IsIdentical { /** * Returns {@code true} if linked list {@param list1} and {@param list2} @@ -21,13 +22,13 @@ public class Identical { * @param * @return */ - private static > boolean isIdentical(SingleLinkedList list1, + public static > boolean isIdentical(SingleLinkedList list1, SingleLinkedList list2) { // base cases if (list1.size != list2.size) { return false; - } else if (list1.size == 0) { + } else if (list1.size == 0 && list2.size == 0) { return true; } @@ -44,24 +45,24 @@ private static > boolean isIdentical(SingleLinkedList return true; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList1 = new SingleLinkedList<>(); - linkedList1.add(0); - linkedList1.add(1); - linkedList1.add(2); - linkedList1.add(3); - linkedList1.add(4); - linkedList1.add(5); - linkedList1.add(6); + linkedList1.add(00); + linkedList1.add(11); + linkedList1.add(22); + linkedList1.add(33); + linkedList1.add(44); + linkedList1.add(55); + linkedList1.add(66); linkedList1.printList(); SingleLinkedList linkedList2 = new SingleLinkedList<>(); - linkedList2.add(0); - linkedList2.add(1); - linkedList2.add(2); - linkedList2.add(3); - linkedList2.add(4); - linkedList2.add(5); - linkedList2.add(6); + linkedList2.add(00); + linkedList2.add(11); + linkedList2.add(22); + linkedList2.add(33); + linkedList2.add(44); + linkedList2.add(55); + linkedList2.add(66); linkedList2.printList(); System.out.println(isIdentical(linkedList1, linkedList2)); } diff --git a/src/main/java/com/rampatra/linkedlists/Palindrome.java b/src/me/ramswaroop/linkedlists/IsPalindrome.java similarity index 63% rename from src/main/java/com/rampatra/linkedlists/Palindrome.java rename to src/me/ramswaroop/linkedlists/IsPalindrome.java index 1f85b35d..d2ed1fa8 100644 --- a/src/main/java/com/rampatra/linkedlists/Palindrome.java +++ b/src/me/ramswaroop/linkedlists/IsPalindrome.java @@ -1,26 +1,27 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.LinkedStack; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; -import com.rampatra.base.Stack; +import me.ramswaroop.common.LinkedStack; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; +import me.ramswaroop.common.Stack; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/18/15 + * @author: ramswaroop + * @date: 6/18/15 + * @time: 2:35 PM */ -public class Palindrome> extends SingleLinkedList { +public class IsPalindrome> extends SingleLinkedList { /** * Uses Stack to test whether a linked list starting * from {@param node} is palindrome or not. * * @param list - * @return {@code true} if linked list palindrome, {@code false} otherwise. + * @return */ - private static > boolean isPalindrome(SingleLinkedList list) { + public static > boolean isPalindrome(SingleLinkedList list) { SingleLinkedNode head = list.getNode(0); SingleLinkedNode curr = head; Stack> stack = new LinkedStack<>(); @@ -51,7 +52,7 @@ private static > boolean isPalindrome(SingleLinkedList node) { + public boolean isPalindromeRecursive(SingleLinkedNode node) { if (node == null) return true; boolean isPalindrome = isPalindromeRecursive(node.next); @@ -64,13 +65,13 @@ private boolean isPalindromeRecursive(SingleLinkedNode node) { } } - public static void main(String[] args) { - Palindrome linkedList = new Palindrome<>(); - linkedList.add(0); - linkedList.add(1); - linkedList.add(2); - linkedList.add(1); - linkedList.add(0); + public static void main(String a[]) { + IsPalindrome linkedList = new IsPalindrome<>(); + linkedList.add(00); + linkedList.add(11); + linkedList.add(22); + linkedList.add(11); + linkedList.add(00); linkedList.printList(); System.out.println(isPalindrome(linkedList)); linkedList.printList(); diff --git a/src/me/ramswaroop/linkedlists/LRUCache.java b/src/me/ramswaroop/linkedlists/LRUCache.java new file mode 100644 index 00000000..c7192260 --- /dev/null +++ b/src/me/ramswaroop/linkedlists/LRUCache.java @@ -0,0 +1,63 @@ +package me.ramswaroop.linkedlists; + +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * Created by IntelliJ IDEA. + *

+ * A simple LRU cache using {@link java.util.LinkedHashMap}. + * + * @author: ramswaroop + * @date: 7/8/15 + * @time: 5:40 PM + * @see: http://javarticles.com/2012/06/linkedhashmap.html + */ +public class LRUCache { + + LinkedHashMap linkedHashMap; + + // initialize cache + LRUCache(final int size) { + this.linkedHashMap = new LinkedHashMap(size, .75f, true) { + @Override + protected boolean removeEldestEntry(Map.Entry eldest) { + return size() > size; + } + }; + } + + void add(E item) { + linkedHashMap.put(item, null); + printCache(); + } + + E get(E item) { + E itemFromCache = (E) linkedHashMap.get(item); + if (itemFromCache == null) { + add(item); + return item; + } + printCache(); + return itemFromCache; + } + + void printCache() { + Iterator iterator = linkedHashMap.keySet().iterator(); + while (iterator.hasNext()) { + System.out.print(iterator.next() + ((iterator.hasNext()) ? "," : "\n")); + } + } + + public static void main(String a[]) { + LRUCache cache = new LRUCache<>(3); + cache.add(1); + cache.add(2); + cache.add(3); + cache.get(null); + cache.add(4); + cache.add(5); + cache.get(null); + } +} diff --git a/src/main/java/com/rampatra/linkedlists/MaximumSumLinkedList.java b/src/me/ramswaroop/linkedlists/MaximumSumLinkedList.java similarity index 93% rename from src/main/java/com/rampatra/linkedlists/MaximumSumLinkedList.java rename to src/me/ramswaroop/linkedlists/MaximumSumLinkedList.java index cb51fe73..b58725f4 100644 --- a/src/main/java/com/rampatra/linkedlists/MaximumSumLinkedList.java +++ b/src/me/ramswaroop/linkedlists/MaximumSumLinkedList.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/15/15 + * @author: ramswaroop + * @date: 7/15/15 * @time: 12:12 AM */ public class MaximumSumLinkedList { @@ -75,7 +75,7 @@ public static > SingleLinkedNode maximumSumLinkedList return head; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList1 = new SingleLinkedList<>(); linkedList1.add(00); linkedList1.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/MergeSort.java b/src/me/ramswaroop/linkedlists/MergeSort.java similarity index 91% rename from src/main/java/com/rampatra/linkedlists/MergeSort.java rename to src/me/ramswaroop/linkedlists/MergeSort.java index 3ad4ad65..d168d247 100644 --- a/src/main/java/com/rampatra/linkedlists/MergeSort.java +++ b/src/me/ramswaroop/linkedlists/MergeSort.java @@ -1,20 +1,20 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/7/15 + * @author: ramswaroop + * @date: 7/7/15 * @time: 4:34 PM */ public class MergeSort { /** * Merge sort for linked list starting at {@param node}. - *

+ * * Time complexity: O(n log n) * Space complexity: O(log n) stack space as it is recursive * @@ -66,7 +66,7 @@ public static > SingleLinkedNode divideInTwoHalves(Si * Merges two sorted lists starting at {@param node1} and {@param node2} * into one and returns its starting node. *

- * This method is similar to {@link MergeTwoSortedLists#mergeTwoSortedLists} + * This method is similar to {@link me.ramswaroop.linkedlists.MergeTwoSortedLists#mergeTwoSortedLists} * * @param node1 * @param node2 @@ -111,7 +111,7 @@ public static > SingleLinkedNode mergeTwoSortedLists( return head.next; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(21); linkedList.add(33); diff --git a/src/main/java/com/rampatra/linkedlists/MergeSortDoubleLinkedList.java b/src/me/ramswaroop/linkedlists/MergeSortDoubleLinkedList.java similarity index 94% rename from src/main/java/com/rampatra/linkedlists/MergeSortDoubleLinkedList.java rename to src/me/ramswaroop/linkedlists/MergeSortDoubleLinkedList.java index 1adab868..d4899567 100644 --- a/src/main/java/com/rampatra/linkedlists/MergeSortDoubleLinkedList.java +++ b/src/me/ramswaroop/linkedlists/MergeSortDoubleLinkedList.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.DoubleLinkedList; -import com.rampatra.base.DoubleLinkedNode; +import me.ramswaroop.common.DoubleLinkedList; +import me.ramswaroop.common.DoubleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/7/15 + * @author: ramswaroop + * @date: 7/7/15 * @time: 4:34 PM */ public class MergeSortDoubleLinkedList { @@ -117,7 +117,7 @@ public static > DoubleLinkedNode mergeTwoSortedLists( return head.next; } - public static void main(String[] args) { + public static void main(String a[]) { DoubleLinkedList linkedList = new DoubleLinkedList<>(); linkedList.add(21); linkedList.add(33); diff --git a/src/main/java/com/rampatra/linkedlists/MergeTwoLinkedListAlternatively.java b/src/me/ramswaroop/linkedlists/MergeTwoLinkedListAlternatively.java similarity index 90% rename from src/main/java/com/rampatra/linkedlists/MergeTwoLinkedListAlternatively.java rename to src/me/ramswaroop/linkedlists/MergeTwoLinkedListAlternatively.java index e94c08e8..29418da2 100644 --- a/src/main/java/com/rampatra/linkedlists/MergeTwoLinkedListAlternatively.java +++ b/src/me/ramswaroop/linkedlists/MergeTwoLinkedListAlternatively.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/13/15 + * @author: ramswaroop + * @date: 7/13/15 * @time: 12:54 PM */ public class MergeTwoLinkedListAlternatively { @@ -49,7 +49,7 @@ public static > SingleLinkedNode mergeTwoLinkedListAl } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList1 = new SingleLinkedList<>(); linkedList1.add(00); linkedList1.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/MergeTwoSortedLists.java b/src/me/ramswaroop/linkedlists/MergeTwoSortedLists.java similarity index 95% rename from src/main/java/com/rampatra/linkedlists/MergeTwoSortedLists.java rename to src/me/ramswaroop/linkedlists/MergeTwoSortedLists.java index 1c4eaf93..aaf3c235 100644 --- a/src/main/java/com/rampatra/linkedlists/MergeTwoSortedLists.java +++ b/src/me/ramswaroop/linkedlists/MergeTwoSortedLists.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/27/15 + * @author: ramswaroop + * @date: 6/27/15 * @time: 8:47 PM */ public class MergeTwoSortedLists { @@ -95,7 +95,7 @@ public static > SingleLinkedNode mergeTwoSortedLists( } } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList1 = new SingleLinkedList<>(); linkedList1.add(00); linkedList1.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/MiddleNode.java b/src/me/ramswaroop/linkedlists/MiddleNode.java similarity index 77% rename from src/main/java/com/rampatra/linkedlists/MiddleNode.java rename to src/me/ramswaroop/linkedlists/MiddleNode.java index 72318998..1a8a07af 100644 --- a/src/main/java/com/rampatra/linkedlists/MiddleNode.java +++ b/src/me/ramswaroop/linkedlists/MiddleNode.java @@ -1,13 +1,14 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/18/15 + * @author: ramswaroop + * @date: 6/18/15 + * @time: 10:34 PM */ public class MiddleNode { @@ -20,7 +21,7 @@ public static > SingleLinkedNode getMiddleNode(Single return slow; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/MoveLastNodeToFirst.java b/src/me/ramswaroop/linkedlists/MoveLastNodeToFirst.java similarity index 78% rename from src/main/java/com/rampatra/linkedlists/MoveLastNodeToFirst.java rename to src/me/ramswaroop/linkedlists/MoveLastNodeToFirst.java index 5f79e936..ed4b531f 100644 --- a/src/main/java/com/rampatra/linkedlists/MoveLastNodeToFirst.java +++ b/src/me/ramswaroop/linkedlists/MoveLastNodeToFirst.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/23/15 + * @author: ramswaroop + * @date: 6/23/15 * @time: 7:52 PM */ public class MoveLastNodeToFirst { @@ -25,7 +25,7 @@ public static > void moveLastNodeToFirst(SingleLinkedLis list.head = curr; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/me/ramswaroop/linkedlists/NthNodeFromLast.java b/src/me/ramswaroop/linkedlists/NthNodeFromLast.java new file mode 100644 index 00000000..b86a4194 --- /dev/null +++ b/src/me/ramswaroop/linkedlists/NthNodeFromLast.java @@ -0,0 +1,43 @@ +package me.ramswaroop.linkedlists; + +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; + +/** + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 6/18/15 + * @time: 6:49 PM + */ +public class NthNodeFromLast { + + public static > SingleLinkedNode getNthNodeFromLast(SingleLinkedList list, int n) { + SingleLinkedNode slow = list.getNode(0); + SingleLinkedNode fast = list.getNode(0); + // move the fast reference ahead of slow reference by 'n' nodes + for (int i = 0; i < n; i++) { + // assert length of linkedlist > n + fast = fast.next; + } + while (fast != null) { + slow = slow.next; + fast = fast.next; + } + return slow; + } + + public static void main(String a[]) { + SingleLinkedList linkedList = new SingleLinkedList<>(); + linkedList.add(00); + linkedList.add(11); + linkedList.add(22); + linkedList.add(33); + linkedList.add(44); + linkedList.add(55); + linkedList.add(66); + linkedList.add(77); + linkedList.add(88); + System.out.println(getNthNodeFromLast(linkedList, 3).item); + } +} diff --git a/src/main/java/com/rampatra/linkedlists/PairWiseSwap.java b/src/me/ramswaroop/linkedlists/PairWiseSwap.java similarity index 83% rename from src/main/java/com/rampatra/linkedlists/PairWiseSwap.java rename to src/me/ramswaroop/linkedlists/PairWiseSwap.java index 3adc98b5..67b45bf7 100644 --- a/src/main/java/com/rampatra/linkedlists/PairWiseSwap.java +++ b/src/me/ramswaroop/linkedlists/PairWiseSwap.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/24/15 + * @author: ramswaroop + * @date: 6/24/15 * @time: 3:48 PM */ public class PairWiseSwap { @@ -33,7 +33,7 @@ public static > SingleLinkedNode pairWiseSwap(SingleL return nextNode; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(11); linkedList.add(22); diff --git a/src/main/java/com/rampatra/linkedlists/QuickSort.java b/src/me/ramswaroop/linkedlists/QuickSort.java similarity index 92% rename from src/main/java/com/rampatra/linkedlists/QuickSort.java rename to src/me/ramswaroop/linkedlists/QuickSort.java index 5808fdcb..5f6cb957 100644 --- a/src/main/java/com/rampatra/linkedlists/QuickSort.java +++ b/src/me/ramswaroop/linkedlists/QuickSort.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/21/15 + * @author: ramswaroop + * @date: 7/21/15 * @time: 11:43 PM */ public class QuickSort { @@ -75,7 +75,7 @@ public static > SingleLinkedNode getLastNode(SingleLi return curr; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(23); linkedList.add(4); diff --git a/src/main/java/com/rampatra/linkedlists/RandomNode.java b/src/me/ramswaroop/linkedlists/RandomNode.java similarity index 79% rename from src/main/java/com/rampatra/linkedlists/RandomNode.java rename to src/me/ramswaroop/linkedlists/RandomNode.java index 97aafdec..19f0e768 100644 --- a/src/main/java/com/rampatra/linkedlists/RandomNode.java +++ b/src/me/ramswaroop/linkedlists/RandomNode.java @@ -1,24 +1,23 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.arrays.ReservoirSampling; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; import java.util.Random; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/21/15 + * @author: ramswaroop + * @date: 7/21/15 * @time: 12:57 PM */ public class RandomNode { /** * Returns a random node from linked list with each node having an equal probability. - *

- * This method uses the simplified version of Reservoir Sampling ({@link ReservoirSampling}) + * + * This method uses the simplified version of Reservoir Sampling ({@link me.ramswaroop.arrays.ReservoirSampling}) * where k = 1. * * @param node @@ -39,7 +38,7 @@ public static > SingleLinkedNode getRandomNode(Single return result; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/RemoveDuplicates.java b/src/me/ramswaroop/linkedlists/RemoveDuplicates.java similarity index 53% rename from src/main/java/com/rampatra/linkedlists/RemoveDuplicates.java rename to src/me/ramswaroop/linkedlists/RemoveDuplicates.java index 7471f231..c25f364f 100644 --- a/src/main/java/com/rampatra/linkedlists/RemoveDuplicates.java +++ b/src/me/ramswaroop/linkedlists/RemoveDuplicates.java @@ -1,16 +1,16 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; -import java.util.HashSet; -import java.util.Set; +import java.util.HashMap; +import java.util.Map; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/18/15 + * @author: ramswaroop + * @date: 6/18/15 * @time: 2:35 PM */ public class RemoveDuplicates { @@ -24,11 +24,13 @@ public class RemoveDuplicates { */ public static > void removeDuplicates(SingleLinkedList list) { SingleLinkedNode curr = list.getNode(0); + int index = 0; while (curr != null) { // inner while loop for removing multiple duplicates while (curr.next != null && curr.item == curr.next.item) { - curr.next = curr.next.next; + list.remove(index + 1); } + index++; curr = curr.next; } } @@ -36,7 +38,7 @@ public static > void removeDuplicates(SingleLinkedList - * This method uses {@link HashSet}, another + * This method uses {@link java.util.HashMap}, another * way is that you can sort it using merge sort and then * call {@link #removeDuplicates}. * @@ -45,48 +47,48 @@ public static > void removeDuplicates(SingleLinkedList> void removeDuplicatesFromUnsortedList(SingleLinkedList list) { SingleLinkedNode curr = list.getNode(0); - SingleLinkedNode prev = curr; - Set itemsInList = new HashSet<>(); + Map map = new HashMap<>(); + int index = 0; while (curr != null) { - if (itemsInList.contains(curr.item)) { - itemsInList.add(curr.item); - } else { // delete duplicate element - prev.next = curr.next; + if (map.get(curr.item) == null) { + map.put(curr.item, true); + index++; + } else { + list.remove(index); } - prev = curr; curr = curr.next; } } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); - linkedList.add(0); - linkedList.add(0); - linkedList.add(0); - linkedList.add(1); - linkedList.add(1); - linkedList.add(2); - linkedList.add(2); - linkedList.add(2); - linkedList.add(2); - linkedList.add(3); - linkedList.add(3); - linkedList.add(3); - linkedList.add(3); + linkedList.add(00); + linkedList.add(00); + linkedList.add(00); + linkedList.add(11); + linkedList.add(11); + linkedList.add(22); + linkedList.add(22); + linkedList.add(22); + linkedList.add(22); + linkedList.add(33); + linkedList.add(33); + linkedList.add(33); + linkedList.add(33); linkedList.printList(); removeDuplicates(linkedList); linkedList.printList(); SingleLinkedList linkedList2 = new SingleLinkedList<>(); - linkedList2.add(0); - linkedList2.add(0); - linkedList2.add(2); - linkedList2.add(1); - linkedList2.add(4); - linkedList2.add(2); - linkedList2.add(6); - linkedList2.add(7); - linkedList2.add(6); + linkedList2.add(00); + linkedList2.add(00); + linkedList2.add(22); + linkedList2.add(11); + linkedList2.add(44); + linkedList2.add(22); + linkedList2.add(66); + linkedList2.add(77); + linkedList2.add(66); linkedList2.printList(); removeDuplicatesFromUnsortedList(linkedList2); linkedList2.printList(); diff --git a/src/main/java/com/rampatra/linkedlists/RemoveMiddlePointsFromLineSegments.java b/src/me/ramswaroop/linkedlists/RemoveMiddlePointsFromLineSegments.java similarity index 93% rename from src/main/java/com/rampatra/linkedlists/RemoveMiddlePointsFromLineSegments.java rename to src/me/ramswaroop/linkedlists/RemoveMiddlePointsFromLineSegments.java index d4099eed..43905c5d 100644 --- a/src/main/java/com/rampatra/linkedlists/RemoveMiddlePointsFromLineSegments.java +++ b/src/me/ramswaroop/linkedlists/RemoveMiddlePointsFromLineSegments.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/23/15 + * @author: ramswaroop + * @date: 7/23/15 * @time: 11:18 PM */ public class RemoveMiddlePointsFromLineSegments { @@ -53,7 +53,7 @@ public static void removeMiddlePointsFromLineSegments(SingleLinkedNode no } } - public static void main(String[] args) { + public static void main(String a[]) { // test case 1 SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(new Point(0, 10)); diff --git a/src/main/java/com/rampatra/linkedlists/ReverseAlternateNodesAndAppendAtEnd.java b/src/me/ramswaroop/linkedlists/ReverseAlternateNodesAndAppendAtEnd.java similarity index 85% rename from src/main/java/com/rampatra/linkedlists/ReverseAlternateNodesAndAppendAtEnd.java rename to src/me/ramswaroop/linkedlists/ReverseAlternateNodesAndAppendAtEnd.java index 70b005d2..ba9b752c 100644 --- a/src/main/java/com/rampatra/linkedlists/ReverseAlternateNodesAndAppendAtEnd.java +++ b/src/me/ramswaroop/linkedlists/ReverseAlternateNodesAndAppendAtEnd.java @@ -1,25 +1,25 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/14/15 + * @author: ramswaroop + * @date: 7/14/15 * @time: 12:16 PM */ public class ReverseAlternateNodesAndAppendAtEnd { /** * Reverse alternate nodes and append them to end of the list. - *

+ * * Example, - *

+ * * Input List: 1->2->3->4->5->6 * Output List: 1->3->5->6->4->2 - *

+ * * Input List: 12->14->16->18->20 * Output List: 12->16->20->18->14 * @@ -49,7 +49,7 @@ public static > SingleLinkedNode reverseAlternateNode return node; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(11); linkedList.add(22); diff --git a/src/main/java/com/rampatra/linkedlists/ReverseDoubleLinkedList.java b/src/me/ramswaroop/linkedlists/ReverseDoubleLinkedList.java similarity index 82% rename from src/main/java/com/rampatra/linkedlists/ReverseDoubleLinkedList.java rename to src/me/ramswaroop/linkedlists/ReverseDoubleLinkedList.java index 466c6ac4..7608fbd7 100644 --- a/src/main/java/com/rampatra/linkedlists/ReverseDoubleLinkedList.java +++ b/src/me/ramswaroop/linkedlists/ReverseDoubleLinkedList.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.DoubleLinkedList; -import com.rampatra.base.DoubleLinkedNode; +import me.ramswaroop.common.DoubleLinkedList; +import me.ramswaroop.common.DoubleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/19/15 + * @author: ramswaroop + * @date: 6/19/15 * @time: 9:24 AM */ public class ReverseDoubleLinkedList { @@ -35,7 +35,7 @@ public static > void reverseList(DoubleLinkedList lis } } - public static void main(String[] args) { + public static void main(String a[]) { DoubleLinkedList linkedList = new DoubleLinkedList<>(); linkedList.add(11); linkedList.add(22); diff --git a/src/main/java/com/rampatra/linkedlists/ReverseLinkedListInAlternateGroups.java b/src/me/ramswaroop/linkedlists/ReverseLinkedListInAlternateGroups.java similarity index 86% rename from src/main/java/com/rampatra/linkedlists/ReverseLinkedListInAlternateGroups.java rename to src/me/ramswaroop/linkedlists/ReverseLinkedListInAlternateGroups.java index 68a3b81f..58e3b766 100644 --- a/src/main/java/com/rampatra/linkedlists/ReverseLinkedListInAlternateGroups.java +++ b/src/me/ramswaroop/linkedlists/ReverseLinkedListInAlternateGroups.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/30/15 + * @author: ramswaroop + * @date: 6/30/15 * @time: 9:33 AM */ public class ReverseLinkedListInAlternateGroups> extends SingleLinkedList { @@ -15,7 +15,7 @@ public class ReverseLinkedListInAlternateGroups> extends /** * Reverses the linked list in groups alternatively. *

- * It is similar to {@link ReverseLinkedListInGroups} but + * It is similar to {@link me.ramswaroop.linkedlists.ReverseLinkedListInGroups} but * does alternatively. *

* Example: @@ -61,7 +61,7 @@ public SingleLinkedNode reverseLinkedListInAltGroups(SingleLinkedNode node return prev; } - public static void main(String[] args) { + public static void main(String a[]) { ReverseLinkedListInAlternateGroups linkedList = new ReverseLinkedListInAlternateGroups<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/ReverseLinkedListInGroups.java b/src/me/ramswaroop/linkedlists/ReverseLinkedListInGroups.java similarity index 62% rename from src/main/java/com/rampatra/linkedlists/ReverseLinkedListInGroups.java rename to src/me/ramswaroop/linkedlists/ReverseLinkedListInGroups.java index 1935356e..4dbfa08b 100644 --- a/src/main/java/com/rampatra/linkedlists/ReverseLinkedListInGroups.java +++ b/src/me/ramswaroop/linkedlists/ReverseLinkedListInGroups.java @@ -1,25 +1,25 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/29/15 + * @author: ramswaroop + * @date: 6/29/15 * @time: 2:32 PM */ public class ReverseLinkedListInGroups { /** * Reverses the linked list in groups. - *

+ * * Example: - *

+ * * Inputs: 1->2->3->4->5->6->7->8 and k = 3 * Output: 3->2->1->6->5->4->8->7. - *

+ * * Inputs: 1->2->3->4->5->6->7->8 and k = 5 * Output: 5->4->3->2->1->8->7->6. * @@ -43,26 +43,26 @@ public static > SingleLinkedNode reverseLinkedListInG // recursively call for the rest of the nodes in the linked list if (next != null) { - node.next = reverseLinkedListInGroups(curr, k); + node.next = reverseLinkedListInGroups(next, k); } return prev; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); - linkedList.add(0); - linkedList.add(1); - linkedList.add(2); - linkedList.add(3); - linkedList.add(4); - linkedList.add(5); - linkedList.add(6); - linkedList.add(7); - linkedList.add(8); - linkedList.add(9); - linkedList.add(10); + linkedList.add(00); + linkedList.add(11); + linkedList.add(22); + linkedList.add(33); + linkedList.add(44); + linkedList.add(55); + linkedList.add(66); + linkedList.add(77); + linkedList.add(88); + linkedList.add(99); + linkedList.add(100); linkedList.printList(); - SingleLinkedList.printList(reverseLinkedListInGroups(linkedList.head, 3)); + linkedList.printList(reverseLinkedListInGroups(linkedList.head, 3)); } } diff --git a/src/main/java/com/rampatra/linkedlists/ReverseSingleLinkedList.java b/src/me/ramswaroop/linkedlists/ReverseSingleLinkedList.java similarity index 83% rename from src/main/java/com/rampatra/linkedlists/ReverseSingleLinkedList.java rename to src/me/ramswaroop/linkedlists/ReverseSingleLinkedList.java index de474417..ce6fb603 100644 --- a/src/main/java/com/rampatra/linkedlists/ReverseSingleLinkedList.java +++ b/src/me/ramswaroop/linkedlists/ReverseSingleLinkedList.java @@ -1,14 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** - * This is for reversing a linked list, both iteratively and recursively. If you - * want to reverse linked list in groups then see {@link ReverseLinkedListInGroups}. + * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/19/15 + * @author: ramswaroop + * @date: 6/19/15 * @time: 9:24 AM */ public class ReverseSingleLinkedList { @@ -66,7 +65,7 @@ public static > void printListInReverse(SingleLinkedNode System.out.print(node.item + ","); } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(11); linkedList.add(22); diff --git a/src/main/java/com/rampatra/linkedlists/RotateLinkedList.java b/src/me/ramswaroop/linkedlists/RotateLinkedList.java similarity index 89% rename from src/main/java/com/rampatra/linkedlists/RotateLinkedList.java rename to src/me/ramswaroop/linkedlists/RotateLinkedList.java index 15d28211..8bbdbe84 100644 --- a/src/main/java/com/rampatra/linkedlists/RotateLinkedList.java +++ b/src/me/ramswaroop/linkedlists/RotateLinkedList.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/3/15 + * @author: ramswaroop + * @date: 7/3/15 * @time: 3:07 PM */ public class RotateLinkedList { @@ -60,7 +60,7 @@ public static > void rotateClockwise(SingleLinkedList } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/SegregateEvenOddNumbers.java b/src/me/ramswaroop/linkedlists/SegregateEvenOddNumbers.java similarity index 91% rename from src/main/java/com/rampatra/linkedlists/SegregateEvenOddNumbers.java rename to src/me/ramswaroop/linkedlists/SegregateEvenOddNumbers.java index 1bdcb4db..acccfb46 100644 --- a/src/main/java/com/rampatra/linkedlists/SegregateEvenOddNumbers.java +++ b/src/me/ramswaroop/linkedlists/SegregateEvenOddNumbers.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/30/15 + * @author: ramswaroop + * @date: 6/30/15 * @time: 10:32 PM */ public class SegregateEvenOddNumbers { @@ -68,7 +68,7 @@ public static > void segregateEvenOddNumbers(SingleLinke } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(00); linkedList.add(11); diff --git a/src/main/java/com/rampatra/linkedlists/SortAlternativelySortedLinkedList.java b/src/me/ramswaroop/linkedlists/SortAlternativelySortedLinkedList.java similarity index 87% rename from src/main/java/com/rampatra/linkedlists/SortAlternativelySortedLinkedList.java rename to src/me/ramswaroop/linkedlists/SortAlternativelySortedLinkedList.java index 79842cc4..6fcfb671 100644 --- a/src/main/java/com/rampatra/linkedlists/SortAlternativelySortedLinkedList.java +++ b/src/me/ramswaroop/linkedlists/SortAlternativelySortedLinkedList.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/20/15 + * @author: ramswaroop + * @date: 7/20/15 * @time: 3:03 PM */ public class SortAlternativelySortedLinkedList { @@ -16,9 +16,9 @@ public class SortAlternativelySortedLinkedList { * Given a Linked List which is in alternating ascending and descending orders. In other words, nodes * at even indexes are in ascending order whereas the nodes at odd indexes are in descending order. * Sort the list efficiently in O(n) time complexity. - *

+ * * Example: - *

+ * * Input List: 10->40->53->30->67->12->89->NULL * Output List: 10->12->30->43->53->67->89->NULL * @@ -44,7 +44,7 @@ public static > SingleLinkedNode sort(SingleLinkedNod return MergeSort.mergeTwoSortedLists(node, secondList); } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(21); linkedList.add(67); diff --git a/src/main/java/com/rampatra/linkedlists/SortLinkedListOf0s1s2s.java b/src/me/ramswaroop/linkedlists/SortLinkedListOf0s1s2s.java similarity index 84% rename from src/main/java/com/rampatra/linkedlists/SortLinkedListOf0s1s2s.java rename to src/me/ramswaroop/linkedlists/SortLinkedListOf0s1s2s.java index 6b5c08c1..c1dc3a9e 100644 --- a/src/main/java/com/rampatra/linkedlists/SortLinkedListOf0s1s2s.java +++ b/src/me/ramswaroop/linkedlists/SortLinkedListOf0s1s2s.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/5/15 + * @author: ramswaroop + * @date: 7/5/15 * @time: 1:47 PM */ public class SortLinkedListOf0s1s2s { @@ -39,7 +39,7 @@ public static void sort(SingleLinkedList list) { } } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(0); linkedList.add(1); diff --git a/src/main/java/com/rampatra/linkedlists/SortedDLLToBBST.java b/src/me/ramswaroop/linkedlists/SortedDLLToBBST.java similarity index 90% rename from src/main/java/com/rampatra/linkedlists/SortedDLLToBBST.java rename to src/me/ramswaroop/linkedlists/SortedDLLToBBST.java index 6b050d0c..fb279314 100644 --- a/src/main/java/com/rampatra/linkedlists/SortedDLLToBBST.java +++ b/src/me/ramswaroop/linkedlists/SortedDLLToBBST.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.DoubleLinkedList; -import com.rampatra.base.DoubleLinkedNode; +import me.ramswaroop.common.DoubleLinkedList; +import me.ramswaroop.common.DoubleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/24/15 + * @author: ramswaroop + * @date: 7/24/15 * @time: 3:16 PM */ public class SortedDLLToBBST { @@ -30,6 +30,7 @@ static > int getLength(DoubleLinkedNode node) { } /** + * * @param node * @param */ @@ -69,7 +70,7 @@ public static > DoubleLinkedNode sortedDLLToBBST(Doub return root; } - public static void main(String[] args) { + public static void main(String a[]) { DoubleLinkedList linkedList = new DoubleLinkedList<>(); linkedList.add(11); linkedList.add(22); diff --git a/src/main/java/com/rampatra/linkedlists/StackWithOperationOnMiddleElement.java b/src/me/ramswaroop/linkedlists/StackWithOperationOnMiddleElement.java similarity index 94% rename from src/main/java/com/rampatra/linkedlists/StackWithOperationOnMiddleElement.java rename to src/me/ramswaroop/linkedlists/StackWithOperationOnMiddleElement.java index bbcc4193..6c6d48b7 100644 --- a/src/main/java/com/rampatra/linkedlists/StackWithOperationOnMiddleElement.java +++ b/src/me/ramswaroop/linkedlists/StackWithOperationOnMiddleElement.java @@ -1,6 +1,6 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.DoubleLinkedNode; +import me.ramswaroop.common.DoubleLinkedNode; import java.util.EmptyStackException; @@ -9,8 +9,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/24/15 + * @author: ramswaroop + * @date: 7/24/15 * @time: 1:06 PM *

*

@@ -20,7 +20,7 @@ * 3) findMiddle() which will return middle element of the stack. * 4) deleteMiddle() which will delete the middle element. * Push and pop are standard stack operations. - *

+ * * The idea is to use a double linked list to represent a stack with pointer pointing to the middle node. */ public class StackWithOperationOnMiddleElement> { @@ -94,7 +94,7 @@ public void print() { out.println(curr.item.toString() + "]"); } - public static void main(String[] args) { + public static void main(String a[]) { StackWithOperationOnMiddleElement stack = new StackWithOperationOnMiddleElement<>(); stack.push(2); stack.push(3); diff --git a/src/main/java/com/rampatra/linkedlists/SwapKthNode.java b/src/me/ramswaroop/linkedlists/SwapKthNode.java similarity index 89% rename from src/main/java/com/rampatra/linkedlists/SwapKthNode.java rename to src/me/ramswaroop/linkedlists/SwapKthNode.java index 44f12da7..6cd05ad7 100644 --- a/src/main/java/com/rampatra/linkedlists/SwapKthNode.java +++ b/src/me/ramswaroop/linkedlists/SwapKthNode.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/13/15 + * @author: ramswaroop + * @date: 7/13/15 * @time: 12:25 PM */ public class SwapKthNode { @@ -60,7 +60,7 @@ public static > SingleLinkedNode swapKthNodeFromStart } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(11); linkedList.add(22); diff --git a/src/main/java/com/rampatra/linkedlists/SwapNodes.java b/src/me/ramswaroop/linkedlists/SwapNodes.java similarity index 89% rename from src/main/java/com/rampatra/linkedlists/SwapNodes.java rename to src/me/ramswaroop/linkedlists/SwapNodes.java index ffb50332..80d712a0 100644 --- a/src/main/java/com/rampatra/linkedlists/SwapNodes.java +++ b/src/me/ramswaroop/linkedlists/SwapNodes.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/12/15 + * @author: ramswaroop + * @date: 7/12/15 * @time: 1:23 PM */ public class SwapNodes { @@ -58,7 +58,7 @@ public static > SingleLinkedNode swap(SingleLinkedNod return head.next; } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList = new SingleLinkedList<>(); linkedList.add(11); linkedList.add(22); diff --git a/src/main/java/com/rampatra/linkedlists/TripletFromThreeLinkedLists.java b/src/me/ramswaroop/linkedlists/TripletFromThreeLinkedLists.java similarity index 90% rename from src/main/java/com/rampatra/linkedlists/TripletFromThreeLinkedLists.java rename to src/me/ramswaroop/linkedlists/TripletFromThreeLinkedLists.java index 1addeb69..350518d7 100644 --- a/src/main/java/com/rampatra/linkedlists/TripletFromThreeLinkedLists.java +++ b/src/me/ramswaroop/linkedlists/TripletFromThreeLinkedLists.java @@ -1,13 +1,13 @@ -package com.rampatra.linkedlists; +package me.ramswaroop.linkedlists; -import com.rampatra.base.SingleLinkedList; -import com.rampatra.base.SingleLinkedNode; +import me.ramswaroop.common.SingleLinkedList; +import me.ramswaroop.common.SingleLinkedNode; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 7/9/15 + * @author: ramswaroop + * @date: 7/9/15 * @time: 4:00 PM */ public class TripletFromThreeLinkedLists { @@ -53,7 +53,7 @@ public static SingleLinkedNode findTripletWithSumEqualsTo(SingleLinkedN } - public static void main(String[] args) { + public static void main(String a[]) { SingleLinkedList linkedList1 = new SingleLinkedList<>(); linkedList1.add(2); SingleLinkedList linkedList2 = new SingleLinkedList<>(); diff --git a/src/main/java/com/rampatra/misc/BotTesting.java b/src/me/ramswaroop/misc/BotTesting.java similarity index 97% rename from src/main/java/com/rampatra/misc/BotTesting.java rename to src/me/ramswaroop/misc/BotTesting.java index 398e60b6..903491cb 100644 --- a/src/main/java/com/rampatra/misc/BotTesting.java +++ b/src/me/ramswaroop/misc/BotTesting.java @@ -1,8 +1,8 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 2/26/15 * Time: 4:16 PM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/rampatra/misc/BreakParagraph.java b/src/me/ramswaroop/misc/BreakParagraph.java similarity index 95% rename from src/main/java/com/rampatra/misc/BreakParagraph.java rename to src/me/ramswaroop/misc/BreakParagraph.java index fc63912c..bc60c1b6 100644 --- a/src/main/java/com/rampatra/misc/BreakParagraph.java +++ b/src/me/ramswaroop/misc/BreakParagraph.java @@ -1,4 +1,4 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; import java.text.BreakIterator; import java.util.Locale; @@ -6,8 +6,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/22/15 + * @author: ramswaroop + * @date: 9/22/15 * @time: 10:02 AM */ public class BreakParagraph { diff --git a/src/main/java/com/rampatra/misc/CollectionIteration.java b/src/me/ramswaroop/misc/CollectionIteration.java similarity index 79% rename from src/main/java/com/rampatra/misc/CollectionIteration.java rename to src/me/ramswaroop/misc/CollectionIteration.java index 54edc937..dadf5e06 100644 --- a/src/main/java/com/rampatra/misc/CollectionIteration.java +++ b/src/me/ramswaroop/misc/CollectionIteration.java @@ -1,10 +1,6 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; +import java.util.*; import static java.lang.System.out; @@ -12,15 +8,14 @@ * Created by IntelliJ IDEA. *

* All possible ways of iterating different collections in Java. - * Level: Basics * - * @author rampatra - * @since 10/16/15 + * @author: ramswaroop + * @date: 10/16/15 * @time: 9:24 AM */ public class CollectionIteration { - public static void main(String[] args) { + public static void main(String a[]) { List list = new ArrayList<>(); list.add(1); list.add(2); @@ -41,14 +36,14 @@ public static void main(String[] args) { hashMap.put("three", 3); // 1st way Iterator> iterator1 = hashMap.entrySet().iterator(); // iterator only iterates on - // lists or set and not on maps + // lists or set and not on maps while (iterator1.hasNext()) { Map.Entry entry = iterator1.next(); out.println("HashMap: " + entry.getKey() + "->" + entry.getValue()); } // 2nd way for (Map.Entry entry : hashMap.entrySet()) { // entrySet() returns a Set of Entry objects - // stored in HashMap + // stored in HashMap out.println("HashMap: " + entry.getKey() + "->" + entry.getValue()); } } diff --git a/src/me/ramswaroop/misc/DivideByZero.java b/src/me/ramswaroop/misc/DivideByZero.java new file mode 100644 index 00000000..64778ae5 --- /dev/null +++ b/src/me/ramswaroop/misc/DivideByZero.java @@ -0,0 +1,15 @@ +package me.ramswaroop.misc; + +/** + * Created by IntelliJ IDEA. + * User: ramswaroop + * Date: 4/18/15 + * Time: 2:50 PM + * To change this template go to Preferences | IDE Settings | File and Code Templates + */ +public class DivideByZero { + public static void main(String[] a) { + System.out.println(5.0/0); // doesn't throw any exception + System.out.println(5/0); // throws runtime exception (arithmetic exception) + } +} diff --git a/src/main/java/com/rampatra/misc/Equals.java b/src/me/ramswaroop/misc/Equals.java similarity index 84% rename from src/main/java/com/rampatra/misc/Equals.java rename to src/me/ramswaroop/misc/Equals.java index 9987a957..1f032256 100644 --- a/src/main/java/com/rampatra/misc/Equals.java +++ b/src/me/ramswaroop/misc/Equals.java @@ -1,14 +1,14 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/14/15 * Time: 4:38 PM * To change this template go to Preferences | IDE Settings | File and Code Templates */ public class Equals { - public static void main(String[] args) { + public static void main(String[] a) { Short i = new Short((short) 12); Short j = new Short((short) 12); System.out.print(j == i); // prints false as compiler compares 2 references instead of their values diff --git a/src/main/java/com/rampatra/misc/GarbageCollection.java b/src/me/ramswaroop/misc/GarbageCollection.java similarity index 85% rename from src/main/java/com/rampatra/misc/GarbageCollection.java rename to src/me/ramswaroop/misc/GarbageCollection.java index 1ed15635..fd280a7e 100644 --- a/src/main/java/com/rampatra/misc/GarbageCollection.java +++ b/src/me/ramswaroop/misc/GarbageCollection.java @@ -1,10 +1,10 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/2/15 + * @author: ramswaroop + * @date: 10/2/15 * @time: 12:44 AM */ public class GarbageCollection { diff --git a/src/main/java/com/rampatra/misc/GenericNonGenericMix.java b/src/me/ramswaroop/misc/GenericNonGenericMix.java similarity index 87% rename from src/main/java/com/rampatra/misc/GenericNonGenericMix.java rename to src/me/ramswaroop/misc/GenericNonGenericMix.java index b13b0392..826cffd7 100644 --- a/src/main/java/com/rampatra/misc/GenericNonGenericMix.java +++ b/src/me/ramswaroop/misc/GenericNonGenericMix.java @@ -1,11 +1,11 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; import java.util.ArrayList; import java.util.List; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 3/26/15 * Time: 3:06 PM * To change this template go to Preferences | IDE Settings | File and Code Templates @@ -17,7 +17,7 @@ static List add(ArrayList list) { return list; } - public static void main(String[] args) { + public static void main(String[] a) { ArrayList stringArrayList = new ArrayList<>(); stringArrayList.add("ram"); add(stringArrayList); diff --git a/src/main/java/com/rampatra/misc/HitCount.java b/src/me/ramswaroop/misc/HitCount.java similarity index 82% rename from src/main/java/com/rampatra/misc/HitCount.java rename to src/me/ramswaroop/misc/HitCount.java index 97f946ec..7d0afe04 100644 --- a/src/main/java/com/rampatra/misc/HitCount.java +++ b/src/me/ramswaroop/misc/HitCount.java @@ -1,24 +1,19 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; -import java.util.ArrayList; -import java.util.Collections; -import java.util.Comparator; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/16/15 + * @author: ramswaroop + * @date: 10/16/15 * @time: 8:40 AM */ public class HitCount { public static String getIPWithMaxHitCount(List inputList) { HashMap hashMap = new HashMap<>(); - + for (int i = 0; i < inputList.size(); i++) { String input = inputList.get(i); String ip = input.substring(0, input.indexOf(" ")); @@ -28,7 +23,7 @@ public static String getIPWithMaxHitCount(List inputList) { hashMap.put(ip, hashMap.get(ip) + 1); } } - + List> list = new ArrayList<>(hashMap.entrySet()); Collections.sort(list, new Comparator>() { @Override @@ -36,11 +31,11 @@ public int compare(Map.Entry o1, Map.Entry o2) return o2.getValue().compareTo(o1.getValue()); // desc order } }); - - return list.get(0).getKey(); + + return list.get(0).getKey(); } - public static void main(String[] args) { + public static void main(String a[]) { List inputList = new ArrayList<>(); inputList.add("10.1.2.23 http://we.sdfdsf.sdf"); inputList.add("10.1.2.24 http://we.sdfdsf.sdf"); diff --git a/src/main/java/com/rampatra/misc/MethodLocalVSInner.java b/src/me/ramswaroop/misc/MethodLocalVSInner.java similarity index 92% rename from src/main/java/com/rampatra/misc/MethodLocalVSInner.java rename to src/me/ramswaroop/misc/MethodLocalVSInner.java index 6eebd6c6..359e9cf1 100644 --- a/src/main/java/com/rampatra/misc/MethodLocalVSInner.java +++ b/src/me/ramswaroop/misc/MethodLocalVSInner.java @@ -1,8 +1,8 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 4/14/15 * Time: 11:39 AM * To change this template go to Preferences | IDE Settings | File and Code Templates diff --git a/src/main/java/com/rampatra/misc/MethodOverloading.java b/src/me/ramswaroop/misc/MethodOverloading.java similarity index 93% rename from src/main/java/com/rampatra/misc/MethodOverloading.java rename to src/me/ramswaroop/misc/MethodOverloading.java index bdd30522..83e9c465 100644 --- a/src/main/java/com/rampatra/misc/MethodOverloading.java +++ b/src/me/ramswaroop/misc/MethodOverloading.java @@ -1,10 +1,10 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 5/8/15 + * @author: ramswaroop + * @date: 5/8/15 * @time: 12:08 PM */ class MethodOverloading { diff --git a/src/main/java/com/rampatra/misc/Outer.java b/src/me/ramswaroop/misc/Outer.java similarity index 87% rename from src/main/java/com/rampatra/misc/Outer.java rename to src/me/ramswaroop/misc/Outer.java index b767e2b7..96ad1124 100644 --- a/src/main/java/com/rampatra/misc/Outer.java +++ b/src/me/ramswaroop/misc/Outer.java @@ -1,10 +1,10 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/30/15 + * @author: ramswaroop + * @date: 9/30/15 * @time: 9:37 AM */ class BigOuter { diff --git a/src/main/java/com/rampatra/misc/OuterClassAccess.java b/src/me/ramswaroop/misc/OuterClassAccess.java similarity index 87% rename from src/main/java/com/rampatra/misc/OuterClassAccess.java rename to src/me/ramswaroop/misc/OuterClassAccess.java index 6c6f53ed..9c299823 100644 --- a/src/main/java/com/rampatra/misc/OuterClassAccess.java +++ b/src/me/ramswaroop/misc/OuterClassAccess.java @@ -1,10 +1,10 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 11/13/15 + * @author: ramswaroop + * @date: 11/13/15 * @time: 11:39 AM */ public class OuterClassAccess { diff --git a/src/main/java/com/rampatra/stacks/BalancingParenthesis.java b/src/me/ramswaroop/misc/Parenthesis.java similarity index 93% rename from src/main/java/com/rampatra/stacks/BalancingParenthesis.java rename to src/me/ramswaroop/misc/Parenthesis.java index c6e2851d..8c7ab982 100644 --- a/src/main/java/com/rampatra/stacks/BalancingParenthesis.java +++ b/src/me/ramswaroop/misc/Parenthesis.java @@ -1,4 +1,4 @@ -package com.rampatra.stacks; +package me.ramswaroop.misc; import java.io.BufferedReader; import java.io.FileReader; @@ -8,10 +8,11 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/15/15 + * @author: ramswaroop + * @date: 9/15/15 + * @time: 11:15 PM */ -public class BalancingParenthesis { +public class Parenthesis { private static final char L_PAREN = '('; private static final char R_PAREN = ')'; @@ -54,7 +55,7 @@ public static boolean isWellFormed(String input) { return stack.isEmpty(); } - + /** * Reads the file specified in {@param filePath} line by line * and checks if parenthesis are well-formed or not. @@ -79,10 +80,11 @@ public static void readFile(String filePath) { /** * Starting point of the program. * - * @param args + * @param a */ - public static void main(String[] args) { - readFile(args[0]); + public static void main(String a[]) { + readFile(a[0]); + System.exit(0); } } diff --git a/src/main/java/com/rampatra/misc/RandomTest.java b/src/me/ramswaroop/misc/RandomTest.java similarity index 87% rename from src/main/java/com/rampatra/misc/RandomTest.java rename to src/me/ramswaroop/misc/RandomTest.java index 5c9590cc..820477f4 100644 --- a/src/main/java/com/rampatra/misc/RandomTest.java +++ b/src/me/ramswaroop/misc/RandomTest.java @@ -1,10 +1,13 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; import java.util.Random; /** - * @author rampatra - * @since 2/23/15 + * Created by IntelliJ IDEA. + * User: ramswaroop + * Date: 2/23/15 + * Time: 12:48 PM + * To change this template go to Preferences | IDE Settings | File and Code Templates */ public class RandomTest { public static void main(String[] args) { diff --git a/src/main/java/com/rampatra/misc/RecursiveWarmup.java b/src/me/ramswaroop/misc/RecursiveWarmup.java similarity index 96% rename from src/main/java/com/rampatra/misc/RecursiveWarmup.java rename to src/me/ramswaroop/misc/RecursiveWarmup.java index ad99d0c3..db47ed0a 100644 --- a/src/main/java/com/rampatra/misc/RecursiveWarmup.java +++ b/src/me/ramswaroop/misc/RecursiveWarmup.java @@ -1,4 +1,4 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; import java.util.ArrayList; import java.util.List; @@ -6,8 +6,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/28/15 + * @author: ramswaroop + * @date: 9/28/15 * @time: 8:37 PM */ public class RecursiveWarmup { @@ -87,7 +87,7 @@ public List reverseRecursive(List input) { * * @param a */ - public static void main(String[] args) { + public static void main(String a[]) { RecursiveWarmup RecursiveWarmup = new RecursiveWarmup(); List list1 = new ArrayList<>(); list1.add(1); diff --git a/src/main/java/com/rampatra/misc/RegexValidateLatLong.java b/src/me/ramswaroop/misc/Regex.java similarity index 83% rename from src/main/java/com/rampatra/misc/RegexValidateLatLong.java rename to src/me/ramswaroop/misc/Regex.java index e8d8d2d6..285f257a 100644 --- a/src/main/java/com/rampatra/misc/RegexValidateLatLong.java +++ b/src/me/ramswaroop/misc/Regex.java @@ -1,14 +1,17 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; import java.util.Scanner; import java.util.regex.Matcher; import java.util.regex.Pattern; /** - * @author rampatra - * @since 9/12/15 + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 9/12/15 + * @time: 1:49 PM */ -public class RegexValidateLatLong { +public class Regex { /** * Validates latitude/longitude in the form (+75, 180) etc. @@ -26,7 +29,7 @@ public static String validateLatLong(String s) { return "Invalid"; } - public static void main(String[] args) { + public static void main(String a[]) { Scanner in = new Scanner(System.in); int t = Integer.parseInt(in.nextLine()); diff --git a/src/main/java/com/rampatra/misc/RegexReplaceAllSpaces.java b/src/me/ramswaroop/misc/ReplaceAll.java similarity index 54% rename from src/main/java/com/rampatra/misc/RegexReplaceAllSpaces.java rename to src/me/ramswaroop/misc/ReplaceAll.java index 04b33db6..7db7a4f1 100644 --- a/src/main/java/com/rampatra/misc/RegexReplaceAllSpaces.java +++ b/src/me/ramswaroop/misc/ReplaceAll.java @@ -1,16 +1,19 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; /** - * @author rampatra - * @since 11/3/15 + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 11/3/15 + * @time: 2:21 PM */ -public class RegexReplaceAllSpaces { +public class ReplaceAll { public static String replaceAll(String str, String regex, String replacement) { return str.replaceAll(regex, replacement); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(replaceAll("ram s", "\\s+", "")); } } diff --git a/src/main/java/com/rampatra/misc/ReverseAndAdd.java b/src/me/ramswaroop/misc/ReverseAndAdd.java similarity index 92% rename from src/main/java/com/rampatra/misc/ReverseAndAdd.java rename to src/me/ramswaroop/misc/ReverseAndAdd.java index 56713796..029d7905 100644 --- a/src/main/java/com/rampatra/misc/ReverseAndAdd.java +++ b/src/me/ramswaroop/misc/ReverseAndAdd.java @@ -1,4 +1,4 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; import java.io.BufferedReader; import java.io.FileReader; @@ -8,15 +8,15 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/16/15 + * @author: ramswaroop + * @date: 9/16/15 * @time: 10:53 PM */ public class ReverseAndAdd { /** * Reverses the number {@param n}. - * + * * @param n * @return the reverse of the number {@param n}. */ @@ -26,7 +26,7 @@ public static BigInteger getReverse(BigInteger n) { /** * Checks if {@param n} is palindrome. - * + * * @param n * @return {@code true} if {@param n} is palindrome. */ @@ -36,7 +36,7 @@ public static boolean isPalindrome(BigInteger n) { /** * Checks if {@param n} is negative. - * + * * @param n * @return {@code true} if {@param n} is negative, {@code false} otherwise. */ @@ -47,7 +47,7 @@ public static boolean isNegative(BigInteger n) { /** * Reverses the number {@param n}, adds to itself and then checks * for palindrome. - * + * * @param n * @return an array of {@code BigInteger} with number of additions and final palindrome number respectively. */ @@ -74,7 +74,7 @@ public static BigInteger[] reverseAddAndCheck(String n) { /** * Reads the input file mentioned in {@param filePath} line by line * and calls {@code reverseAddAndCheck()} for every line. - * + * * @param filePath */ public static void readFile(String filePath) { @@ -95,11 +95,11 @@ public static void readFile(String filePath) { /** * Starting point of the program. - * - * @param args + * + * @param a */ - public static void main(String[] args) { - readFile(args[0]); + public static void main(String a[]) { + readFile(a[0]); System.exit(0); } } diff --git a/src/main/java/com/rampatra/bits/RightShiftOperator.java b/src/me/ramswaroop/misc/RightShiftOperator.java similarity index 86% rename from src/main/java/com/rampatra/bits/RightShiftOperator.java rename to src/me/ramswaroop/misc/RightShiftOperator.java index 3eafd7b6..c5c52b9e 100644 --- a/src/main/java/com/rampatra/bits/RightShiftOperator.java +++ b/src/me/ramswaroop/misc/RightShiftOperator.java @@ -1,17 +1,20 @@ -package com.rampatra.bits; +package me.ramswaroop.misc; /** - * {@code >>} shifts bits to right filling left bits with the left most - * bit (most significant bit). Also called signed right shift. - * {@code >>>} shifts bits to the right filling left bits - * with 0. Also called unsigned right shift. + * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/2/15 + * @author: ramswaroop + * @date: 6/2/15 + * @time: 3:26 PM + */ + +/** + * {@code >>} shifts bits to right filling left bits with the left most bit (most significant bit) + * {@code >>>} shifts bits to the right filling left bits with 0 */ public class RightShiftOperator { - public static void main(String[] args) { + public static void main(String a[]) { int n = -4; System.out.printf("n: %32d\n", n); System.out.printf("n: %32s\n", Integer.toBinaryString(n)); @@ -44,4 +47,4 @@ public static void main(String[] args) { System.out.printf("n>>2: %32s\n", Integer.toBinaryString(n >> 2)); System.out.printf("n>>>2: %32s\n", Integer.toBinaryString(n >>> 2)); } -} \ No newline at end of file +} diff --git a/src/me/ramswaroop/misc/SPOJ1.java b/src/me/ramswaroop/misc/SPOJ1.java new file mode 100644 index 00000000..6c80f409 --- /dev/null +++ b/src/me/ramswaroop/misc/SPOJ1.java @@ -0,0 +1,31 @@ +package me.ramswaroop.misc; + +import java.util.ArrayList; +import java.util.List; +import java.util.Scanner; + +/** + * Created by IntelliJ IDEA. + * User: ramswaroop + * Date: 4/22/15 + * Time: 7:40 PM + * To change this template go to Preferences | IDE Settings | File and Code Templates + */ +class SPOJ1 { + + public static void main(String[] args) { + Scanner in = new Scanner(System.in); + + List inputList = new ArrayList<>(); + int input; + for (; ;) { + input = Integer.parseInt(in.nextLine()); + if (input == 42) break; + inputList.add(input); + } + + for (long i : inputList) { + System.out.println(i); + } + } +} diff --git a/src/main/java/com/rampatra/misc/TreeList.java b/src/me/ramswaroop/misc/TreeList.java similarity index 99% rename from src/main/java/com/rampatra/misc/TreeList.java rename to src/me/ramswaroop/misc/TreeList.java index fd9059f4..978bc2a2 100644 --- a/src/main/java/com/rampatra/misc/TreeList.java +++ b/src/me/ramswaroop/misc/TreeList.java @@ -1,9 +1,9 @@ -package com.rampatra.misc; +package me.ramswaroop.misc; /** * Created by IntelliJ IDEA. * - * @since 5/4/15 + * @date: 5/4/15 * @time: 8:17 PM */ // TreeList.java diff --git a/src/main/java/com/rampatra/misc/parenthesis.txt b/src/me/ramswaroop/misc/parenthesis.txt similarity index 100% rename from src/main/java/com/rampatra/misc/parenthesis.txt rename to src/me/ramswaroop/misc/parenthesis.txt diff --git a/src/main/java/com/rampatra/misc/reverseandadd.txt b/src/me/ramswaroop/misc/reverseandadd.txt similarity index 100% rename from src/main/java/com/rampatra/misc/reverseandadd.txt rename to src/me/ramswaroop/misc/reverseandadd.txt diff --git a/src/main/java/com/rampatra/strings/AnagramsTogether.java b/src/me/ramswaroop/strings/AnagramsTogether.java similarity index 54% rename from src/main/java/com/rampatra/strings/AnagramsTogether.java rename to src/me/ramswaroop/strings/AnagramsTogether.java index 87ee6569..9fd15ad3 100644 --- a/src/main/java/com/rampatra/strings/AnagramsTogether.java +++ b/src/me/ramswaroop/strings/AnagramsTogether.java @@ -1,34 +1,29 @@ -package com.rampatra.strings; +package me.ramswaroop.strings; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/23/15 + * @author: ramswaroop + * @date: 9/23/15 + * @time: 8:11 PM */ public class AnagramsTogether { /** - * Prints all the anagrams together from the string array {@code strings}. - *

- * Anagrams are words consisting of the same letters but in the same or different - * order. For example, "cat" and "tac" are anagrams. Same as "god" and "dog". + * Prints all the anagrams together from the string + * array {@param s}. * - * @param strings + * @param s */ - private static void printAnagramsTogether(String[] strings) { + public static void printAnagramsTogether(String[] s) { // each key holds all the indexes of a anagram HashMap> hashMap = new HashMap<>(); - for (int i = 0; i < strings.length; i++) { - char[] chars = strings[i].toCharArray(); + for (int i = 0; i < s.length; i++) { + char[] chars = s[i].toCharArray(); Arrays.sort(chars); List indexes = hashMap.get(String.valueOf(chars)); @@ -41,14 +36,14 @@ private static void printAnagramsTogether(String[] strings) { for (Map.Entry> entry : hashMap.entrySet()) { for (int i = 0; i < entry.getValue().size(); i++) { - System.out.println(strings[entry.getValue().get(i)]); + System.out.println(s[entry.getValue().get(i)]); } System.out.println("------"); } } - public static void main(String[] args) { + public static void main(String a[]) { printAnagramsTogether(new String[]{"cat", "dog", "tac", "god", "act"}); printAnagramsTogether(new String[]{"cat", "tac", "act", "god", "dog"}); } -} \ No newline at end of file +} diff --git a/src/main/java/com/rampatra/strings/AnagramsTogetherLexicographically.java b/src/me/ramswaroop/strings/AnagramsTogetherLexicographically.java similarity index 57% rename from src/main/java/com/rampatra/strings/AnagramsTogetherLexicographically.java rename to src/me/ramswaroop/strings/AnagramsTogetherLexicographically.java index c1390646..160f0a35 100644 --- a/src/main/java/com/rampatra/strings/AnagramsTogetherLexicographically.java +++ b/src/me/ramswaroop/strings/AnagramsTogetherLexicographically.java @@ -1,36 +1,40 @@ -package com.rampatra.strings; +package me.ramswaroop.strings; import java.util.*; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/11/15 + * @author: ramswaroop + * @date: 10/11/15 + * @time: 7:56 PM */ public class AnagramsTogetherLexicographically { /** - * Takes an array of String {@code strings} and prints anagrams in groups where the groups + * Takes an array of String {@param s} and prints anagrams in groups where the groups * are arranged lexicographically and the strings within each group are also arranged * lexicographically. * - * @param strings + * @param s */ - public static void printAnagramsTogether(String[] strings) { + public static void printAnagramsTogether(String[] s) { HashMap> hashMap = new HashMap<>(); - TreeSet> treeSet = new TreeSet<>((Comparator) (o1, o2) -> { - if (o1 instanceof List && o2 instanceof List) { - return ((List) o1).get(0).compareTo(((List) o2).get(0)); - } else { - return 0; + TreeSet> treeSet = new TreeSet<>(new Comparator() { + @Override + public int compare(Object o1, Object o2) { + if (o1 instanceof List && o2 instanceof List) { + return ((List) o1).get(0).compareTo(((List) o2).get(0)); + } else { + return 0; + } } }); - for (int i = 0; i < strings.length; i++) { - String spaceRemovedStr = strings[i].replaceAll("\\s+", ""); - char[] chars = spaceRemovedStr.toCharArray(); + for (int i = 0; i < s.length; i++) { + String removeSpaces = s[i].replaceAll("\\s+", ""); + char[] chars = removeSpaces.toCharArray(); Arrays.sort(chars); List indexes = hashMap.get(String.valueOf(chars)); @@ -46,26 +50,28 @@ public static void printAnagramsTogether(String[] strings) { List anagrams = new ArrayList<>(); for (int i = 0; i < entry.getValue().size(); i++) { - anagrams.add(strings[entry.getValue().get(i)]); + anagrams.add(s[entry.getValue().get(i)]); } Collections.sort(anagrams); // arrange anagrams lexicographically within a single line treeSet.add(anagrams); // sort the entire output lexicographically } - treeSet.stream().flatMap(Collection::stream).forEach(System.out::println); + Iterator iterator = treeSet.iterator(); + while (iterator.hasNext()) { + System.out.println(iterator.next()); + } } /** * Take list of strings from console and print anagrams in groups. * - * @param args + * @param a */ - public static void main(String[] args) { + public static void main(String a[]) { Scanner in = new Scanner(System.in); List strings = new ArrayList<>(); String s; - System.out.println("Input string in separate lines (blank string to stop):"); // you should use in.hasNextLine() while (!(s = in.nextLine()).trim().equals("")) { strings.add(s); diff --git a/src/main/java/com/rampatra/strings/RemoveExtraSpaces.java b/src/me/ramswaroop/strings/RemoveExtraSpaces.java similarity index 92% rename from src/main/java/com/rampatra/strings/RemoveExtraSpaces.java rename to src/me/ramswaroop/strings/RemoveExtraSpaces.java index 3c5b6954..1ea76b42 100644 --- a/src/main/java/com/rampatra/strings/RemoveExtraSpaces.java +++ b/src/me/ramswaroop/strings/RemoveExtraSpaces.java @@ -1,12 +1,12 @@ -package com.rampatra.strings; +package me.ramswaroop.strings; import java.util.Arrays; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/25/15 + * @author: ramswaroop + * @date: 10/25/15 * @time: 9:44 PM */ public class RemoveExtraSpaces { @@ -19,10 +19,10 @@ public class RemoveExtraSpaces { * @return */ public static String removeExtraSpaces(String s) { - + char[] c = s.toCharArray(); int j = c.length; - + for (int i = 1; i < c.length; i++) { // check for two or more consecutive spaces if (c[i] == ' ' && c[i - 1] == ' ') { @@ -33,7 +33,7 @@ public static String removeExtraSpaces(String s) { while (i < c.length && c[i] == ' ') { i++; } - + // if reached end of string then stop if (i == c.length) break; } @@ -52,7 +52,7 @@ public static String removeExtraSpaces(String s) { return String.valueOf(Arrays.copyOf(c, j)); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(removeExtraSpaces("ram swaroop is a good boy.")); System.out.println(removeExtraSpaces("ram swaroop is a good boy.")); System.out.println(removeExtraSpaces(" ram swaroop is a good boy.")); diff --git a/src/main/java/com/rampatra/permutations/StringPermutations.java b/src/me/ramswaroop/strings/StringPermutations.java similarity index 57% rename from src/main/java/com/rampatra/permutations/StringPermutations.java rename to src/me/ramswaroop/strings/StringPermutations.java index 302d14f9..ea3a5688 100644 --- a/src/main/java/com/rampatra/permutations/StringPermutations.java +++ b/src/me/ramswaroop/strings/StringPermutations.java @@ -1,23 +1,23 @@ -package com.rampatra.permutations; +package me.ramswaroop.strings; /** - * Prints all the permutations of a string by using the characters in the - * input only once. + * Created by IntelliJ IDEA. * - * @author rampatra - * @link http://www.ericleschinski.com/c/java_permutations_recursion/ - * @link http://introcs.cs.princeton.edu/java/23recursion/Permutations.java.html - * @link me.rampatra.strings.StringPermutationCount for a modification of this problem - * @since 9/24/15 + * @author: ramswaroop + * @date: 9/24/15 + * @time: 2:27 PM + * @see: http://www.ericleschinski.com/c/java_permutations_recursion/ + * @see: http://introcs.cs.princeton.edu/java/23recursion/Permutations.java.html + * @see: me.ramswaroop.strings.StringPermutationCount for a modification of this problem */ public class StringPermutations { /** - * Generates and prints all possible permutations (in order) + * Generates and prints all possible permutations (in order) * of string {@param s}. - * - * @param prefix empty string, needed for the recursive method - * @param s input string with no repeated characters + * + * @param prefix + * @param s */ public static void printAllPermutations(String prefix, String s) { int len = s.length(); @@ -30,7 +30,7 @@ public static void printAllPermutations(String prefix, String s) { } } - public static void main(String[] args) { + public static void main(String a[]) { printAllPermutations("", "a"); System.out.println("-------"); printAllPermutations("", "ab"); diff --git a/src/main/java/com/rampatra/permutations/StringPermutationsCount.java b/src/me/ramswaroop/strings/StringPermutationsCount.java similarity index 84% rename from src/main/java/com/rampatra/permutations/StringPermutationsCount.java rename to src/me/ramswaroop/strings/StringPermutationsCount.java index c5916a07..6ddc020c 100644 --- a/src/main/java/com/rampatra/permutations/StringPermutationsCount.java +++ b/src/me/ramswaroop/strings/StringPermutationsCount.java @@ -1,4 +1,4 @@ -package com.rampatra.permutations; +package me.ramswaroop.strings; /** * Created by IntelliJ IDEA. @@ -6,10 +6,10 @@ * You have 2 string, one smaller, one larger. Write an algorithm to figure out how many permutations of the * smaller string exist in the bigger string. * - * @author rampatra - * @since 10/15/15 + * @author: ramswaroop + * @date: 10/15/15 * @time: 10:32 AM - * @see: StringPermutations for a simpler version + * @see: me.ramswaroop.strings.StringPermutations for a simpler version */ public class StringPermutationsCount { @@ -34,7 +34,7 @@ public static int getStringPermutationsCount(String prefix, String s1, String s2 return count; } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println(getStringPermutationsCount("", "abc", "abcba", 0)); System.out.println(getStringPermutationsCount("", "abc", "abcbacb", 0)); } diff --git a/src/main/java/com/rampatra/strings/StringRotation.java b/src/me/ramswaroop/strings/StringRotation.java similarity index 60% rename from src/main/java/com/rampatra/strings/StringRotation.java rename to src/me/ramswaroop/strings/StringRotation.java index 0ab15138..e46306d3 100644 --- a/src/main/java/com/rampatra/strings/StringRotation.java +++ b/src/me/ramswaroop/strings/StringRotation.java @@ -1,12 +1,12 @@ -package com.rampatra.strings; +package me.ramswaroop.strings; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/21/15 + * @author: ramswaroop + * @date: 10/21/15 * @time: 10:06 AM - * @see: me.rampatra.strings.SubString for a similar problem. + * @see: me.ramswaroop.strings.SubString for a similar problem. */ public class StringRotation { @@ -41,13 +41,13 @@ public static boolean isStringRotation(String s1, String s2) { return false; } - public static void main(String[] args) { - System.out.println(isStringRotation("rampatra", "swaroopram")); - System.out.println(isStringRotation("rampatra", "swaroopramramram")); - System.out.println(isStringRotation("rampatra", "mswaroopra")); - System.out.println(isStringRotation("rampatra", "swarooppram")); - System.out.println(isStringRotation("rampatra", "")); - System.out.println(isStringRotation("mswaroopra", "rampatra")); + public static void main(String a[]) { + System.out.println(isStringRotation("ramswaroop", "swaroopram")); + System.out.println(isStringRotation("ramswaroop", "swaroopramramram")); + System.out.println(isStringRotation("ramswaroop", "mswaroopra")); + System.out.println(isStringRotation("ramswaroop", "swarooppram")); + System.out.println(isStringRotation("ramswaroop", "")); + System.out.println(isStringRotation("mswaroopra", "ramswaroop")); System.out.println(isStringRotation("amam", "mama")); } } diff --git a/src/main/java/com/rampatra/strings/SubStringCheck.java b/src/me/ramswaroop/strings/SubStringCheck.java similarity index 57% rename from src/main/java/com/rampatra/strings/SubStringCheck.java rename to src/me/ramswaroop/strings/SubStringCheck.java index 63786967..77f79a83 100644 --- a/src/main/java/com/rampatra/strings/SubStringCheck.java +++ b/src/me/ramswaroop/strings/SubStringCheck.java @@ -1,12 +1,12 @@ -package com.rampatra.strings; +package me.ramswaroop.strings; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/20/15 + * @author: ramswaroop + * @date: 10/20/15 * @time: 1:15 PM - * @see: StringRotation for a similar problem. + * @see: me.ramswaroop.strings.StringRotation for a similar problem. */ public class SubStringCheck { @@ -36,12 +36,12 @@ public static boolean isSubString(String s1, String s2) { return false; } - public static void main(String[] args) { - System.out.println(isSubString("rampatra", "rampatra")); - System.out.println(isSubString("rampatra", "")); - System.out.println(isSubString("rampatra", "ram")); - System.out.println(isSubString("rampatra", "rams")); - System.out.println(isSubString("rampatra", "ramss")); - System.out.println(isSubString("rampatra", "ar")); + public static void main(String a[]) { + System.out.println(isSubString("ramswaroop", "ramswaroop")); + System.out.println(isSubString("ramswaroop", "")); + System.out.println(isSubString("ramswaroop", "ram")); + System.out.println(isSubString("ramswaroop", "rams")); + System.out.println(isSubString("ramswaroop", "ramss")); + System.out.println(isSubString("ramswaroop", "ar")); } } diff --git a/src/main/java/com/rampatra/strings/SubStrings.java b/src/me/ramswaroop/strings/SubStrings.java similarity index 90% rename from src/main/java/com/rampatra/strings/SubStrings.java rename to src/me/ramswaroop/strings/SubStrings.java index 792830c9..d5e085d2 100644 --- a/src/main/java/com/rampatra/strings/SubStrings.java +++ b/src/me/ramswaroop/strings/SubStrings.java @@ -1,10 +1,10 @@ -package com.rampatra.strings; +package me.ramswaroop.strings; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 10/22/15 + * @author: ramswaroop + * @date: 10/22/15 * @time: 11:16 AM */ public class SubStrings { @@ -36,7 +36,7 @@ public static void printAllSubStringsRecursive(String s) { printAllSubStrings(s.substring(1)); } - public static void main(String[] args) { + public static void main(String a[]) { System.out.println("----Iterative----"); printAllSubStrings("ram"); System.out.println("--------"); diff --git a/src/main/java/com/rampatra/permutations/UppercaseLowercasePermutations.java b/src/me/ramswaroop/strings/UppercaseLowercasePermutations.java similarity index 89% rename from src/main/java/com/rampatra/permutations/UppercaseLowercasePermutations.java rename to src/me/ramswaroop/strings/UppercaseLowercasePermutations.java index fec104a6..fd229bf1 100644 --- a/src/main/java/com/rampatra/permutations/UppercaseLowercasePermutations.java +++ b/src/me/ramswaroop/strings/UppercaseLowercasePermutations.java @@ -1,10 +1,10 @@ -package com.rampatra.permutations; +package me.ramswaroop.strings; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 9/26/15 + * @author: ramswaroop + * @date: 9/26/15 * @time: 4:43 PM */ public class UppercaseLowercasePermutations { @@ -26,12 +26,14 @@ public static void printUppercaseLowercasePermutations(String prefix, String s) return; } - if (isNumber(s.charAt(0))) { - printUppercaseLowercasePermutations(prefix + s.charAt(0), s.substring(1)); - } else { + if (!isNumber(s.charAt(0))) { printUppercaseLowercasePermutations(prefix + Character.toUpperCase(s.charAt(0)), s.substring(1)); printUppercaseLowercasePermutations(prefix + Character.toLowerCase(s.charAt(0)), s.substring(1)); + } else { + printUppercaseLowercasePermutations(prefix + s.charAt(0), s.substring(1)); + } + } public static boolean isNumber(char s) { @@ -43,7 +45,7 @@ public static boolean isNumber(char s) { return true; } - public static void main(String[] args) { + public static void main(String a[]) { printUppercaseLowercasePermutations("", "0ab"); System.out.println("========"); printUppercaseLowercasePermutations("", "01"); diff --git a/src/main/java/com/rampatra/threads/Basics.java b/src/me/ramswaroop/threads/Basics.java similarity index 91% rename from src/main/java/com/rampatra/threads/Basics.java rename to src/me/ramswaroop/threads/Basics.java index 52d443da..2f6a35fc 100644 --- a/src/main/java/com/rampatra/threads/Basics.java +++ b/src/me/ramswaroop/threads/Basics.java @@ -1,14 +1,14 @@ -package com.rampatra.threads; +package me.ramswaroop.threads; /** * Created by IntelliJ IDEA. - * User: rampatra + * User: ramswaroop * Date: 4/15/15 * Time: 11:27 PM * To change this template go to Preferences | IDE Settings | File and Code Templates */ public class Basics { - public static void main(String[] args) { + public static void main(String[] a) { Runnable r = new Runnable() { @Override public void run() { diff --git a/src/main/java/com/rampatra/threads/NamePrint.java b/src/me/ramswaroop/threads/NamePrint.java similarity index 78% rename from src/main/java/com/rampatra/threads/NamePrint.java rename to src/me/ramswaroop/threads/NamePrint.java index 05e19820..663f5773 100644 --- a/src/main/java/com/rampatra/threads/NamePrint.java +++ b/src/me/ramswaroop/threads/NamePrint.java @@ -1,10 +1,13 @@ -package com.rampatra.threads; +package me.ramswaroop.threads; /** - * Problem Description: Print first name and last name (in order) using two different threads 1000 times. + * Created by IntelliJ IDEA. + *

+ * Question: Print first name and last name (in order) using two different threads multiple times. * - * @author rampatra - * @since 10/6/15 + * @author: ramswaroop + * @date: 10/6/15 + * @time: 7:10 PM */ public class NamePrint { @@ -18,9 +21,7 @@ public void run() { for (int i = 0; i < 1000; i++) { try { // wait if first name is printed but not the last name - if (isFirstNamePrinted) { - lock.wait(); - } + if (isFirstNamePrinted) lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } @@ -39,9 +40,7 @@ public void run() { for (int i = 0; i < 1000; i++) { try { // wait if first name is not printed - if (!isFirstNamePrinted) { - lock.wait(); - } + if(!isFirstNamePrinted) lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } @@ -64,7 +63,7 @@ public void printNameUsingMultipleThreads() { secondThread.start(); } - public static void main(String[] args) { + public static void main(String a[]) { NamePrint obj = new NamePrint(); obj.printNameUsingMultipleThreads(); } diff --git a/src/me/ramswaroop/trees/BFSUsingQueue.java b/src/me/ramswaroop/trees/BFSUsingQueue.java new file mode 100644 index 00000000..992f2e17 --- /dev/null +++ b/src/me/ramswaroop/trees/BFSUsingQueue.java @@ -0,0 +1,61 @@ +package me.ramswaroop.trees; + +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinaryTree; +import me.ramswaroop.common.LinkedQueue; +import me.ramswaroop.common.Queue; + +import java.util.NoSuchElementException; + +import static java.lang.System.out; + +/** + * Created by IntelliJ IDEA. + * + * @author: ramswaroop + * @date: 6/26/15 + * @time: 7:34 PM + */ +public class BFSUsingQueue { + + /** + * Breadth first traversal (Level-order traversal using Queue). + */ + public static > void breadthFirstTraversalUsingQueue(BinaryNode node) { + Queue> queue = new LinkedQueue<>(); + breadthFirstTraversalUsingQueue(node, queue); + } + + public static > void breadthFirstTraversalUsingQueue(BinaryNode node, + Queue> queue) { + + if (node != null) { + printValue(node); + queue.add(node.left); + queue.add(node.right); + } + + try { + breadthFirstTraversalUsingQueue(queue.remove(), queue); + } catch (NoSuchElementException e) { + return; + } + } + + public static > void printValue(BinaryNode node) { + if (node == null) return; + + out.print(node.value); + } + + public static void main(String a[]) { + BinaryTree bt = new BinaryTree<>(); + bt.put(6); + bt.put(3); + bt.put(5); + bt.put(7); + bt.put(8); + bt.put(9); + breadthFirstTraversalUsingQueue(bt.root); + } +} diff --git a/src/main/java/com/rampatra/trees/CheckForBST.java b/src/me/ramswaroop/trees/CheckForBST.java similarity index 83% rename from src/main/java/com/rampatra/trees/CheckForBST.java rename to src/me/ramswaroop/trees/CheckForBST.java index aea4bc19..07f16c46 100644 --- a/src/main/java/com/rampatra/trees/CheckForBST.java +++ b/src/me/ramswaroop/trees/CheckForBST.java @@ -1,23 +1,19 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinarySearchTree; -import com.rampatra.base.BinaryTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinarySearchTree; +import me.ramswaroop.common.BinaryTree; import java.util.List; import static java.lang.System.out; /** - * A binary search tree is a binary tree in which every node fits a specific ordering property: all left - * descendents <= n < all right descendents. This must be true for each node n. - *

- * Note: The definition of a binary search tree can vary slightly with respect to equality. Under some definitions, the - * tree cannot have duplicate values. In others, the duplicate values will be on the right or can be on either side. All - * are valid definitions, but you should clarify this with your interviewer + * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 + * @time: 7:14 PM */ public class CheckForBST { @@ -99,7 +95,7 @@ public static > boolean isBST(BinaryNode node, E minV return isBST(node.left, minValue, node.value) && isBST(node.right, node.value, maxValue); } - public static void main(String[] args) { + public static void main(String a[]) { // in-order approach BinarySearchTree binarySearchTree = new BinarySearchTree<>(); binarySearchTree.put(6); @@ -110,7 +106,7 @@ public static void main(String[] args) { binarySearchTree.put(9); out.println("1) Is BST: "); out.println(isBST(binarySearchTree.root, new BinaryNode<>(null))); // should be true - + BinaryTree binaryTree = new BinaryTree<>(); binaryTree.put(6); binaryTree.put(4); @@ -121,7 +117,7 @@ public static void main(String[] args) { binaryTree.put(10); out.println("2) Is BST: "); out.println(isBST(binaryTree.root, new BinaryNode<>(null))); // should be false - + // min max approach out.println("3) Is BST: "); out.println(isBST(binarySearchTree.root, Integer.MIN_VALUE, Integer.MAX_VALUE)); // should be true diff --git a/src/main/java/com/rampatra/trees/ChildrenSum.java b/src/me/ramswaroop/trees/ChildrenSum.java similarity index 93% rename from src/main/java/com/rampatra/trees/ChildrenSum.java rename to src/me/ramswaroop/trees/ChildrenSum.java index 232e1554..28e90a6c 100644 --- a/src/main/java/com/rampatra/trees/ChildrenSum.java +++ b/src/me/ramswaroop/trees/ChildrenSum.java @@ -1,15 +1,15 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinaryTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinaryTree; import static java.lang.System.out; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 7:01 PM */ public class ChildrenSum { @@ -81,7 +81,7 @@ private static > void increment(BinaryNode node, int } } - public static void main(String[] args) { + public static void main(String a[]) { BinaryTree bt = new BinaryTree<>(); bt.put(6); bt.put(3); diff --git a/src/main/java/com/rampatra/trees/ConstructTreeFromInOrderAndPreOrder.java b/src/me/ramswaroop/trees/ConstructTreeFromInorderAndPreorder.java similarity index 73% rename from src/main/java/com/rampatra/trees/ConstructTreeFromInOrderAndPreOrder.java rename to src/me/ramswaroop/trees/ConstructTreeFromInorderAndPreorder.java index f9eddac0..4ad7cc38 100644 --- a/src/main/java/com/rampatra/trees/ConstructTreeFromInOrderAndPreOrder.java +++ b/src/me/ramswaroop/trees/ConstructTreeFromInorderAndPreorder.java @@ -1,14 +1,14 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; +import me.ramswaroop.common.BinaryNode; import java.util.List; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 5:34 PM */ public class ConstructTreeFromInOrderAndPreOrder { @@ -20,7 +20,7 @@ public > void constructTreeWithInOrderAndPreOrder(List> void doubleTree(BinaryNode node) { @@ -32,7 +32,7 @@ public static > void doubleTree(BinaryNode node) { doubleTree(node.right); } - public static void main(String[] args) { + public static void main(String a[]) { BinaryTree bt = new BinaryTree<>(); bt.put(6); bt.put(3); diff --git a/src/main/java/com/rampatra/trees/HeightBalanced.java b/src/me/ramswaroop/trees/HeightBalanced.java similarity index 66% rename from src/main/java/com/rampatra/trees/HeightBalanced.java rename to src/me/ramswaroop/trees/HeightBalanced.java index 20e24201..10152c63 100644 --- a/src/main/java/com/rampatra/trees/HeightBalanced.java +++ b/src/me/ramswaroop/trees/HeightBalanced.java @@ -1,16 +1,15 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.ctci.treesandgraphs.TreeNode; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinarySearchTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinarySearchTree; import static java.lang.System.out; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 7:07 PM */ public class HeightBalanced> extends BinarySearchTree { @@ -20,11 +19,7 @@ public class HeightBalanced> extends BinarySearchTree * 1) Left subtree of T is balanced * 2) Right subtree of T is balanced * 3) The difference between heights of left subtree and right subtree is not more than 1. - * - * This approach is simple but we are traversing each node multiple times while calculating the height. For a more - * optimized approach see {@link com.ctci.treesandgraphs.CheckBalanced#isBalancedOptimized(TreeNode)} where while - * calculating the height of tree we check whether it is balanced or not simultaneously. - * + * * @return True if tree is height balanced otherwise false. */ public boolean isHeightBalanced() { @@ -41,7 +36,7 @@ public boolean isHeightBalanced(BinaryNode node) { return isHeightBalanced(node.left) && isHeightBalanced(node.right); } - public static void main(String[] args) { + public static void main(String a[]) { HeightBalanced bst = new HeightBalanced<>(); bst.put(6); bst.put(3); diff --git a/src/main/java/com/rampatra/trees/IdenticalTrees.java b/src/me/ramswaroop/trees/IdenticalTrees.java similarity index 85% rename from src/main/java/com/rampatra/trees/IdenticalTrees.java rename to src/me/ramswaroop/trees/IdenticalTrees.java index 221aeb24..1af666e0 100644 --- a/src/main/java/com/rampatra/trees/IdenticalTrees.java +++ b/src/me/ramswaroop/trees/IdenticalTrees.java @@ -1,15 +1,15 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinarySearchTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinarySearchTree; import static java.lang.System.out; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 5:36 PM */ public class IdenticalTrees { @@ -34,7 +34,7 @@ public static > boolean isIdentical(BinaryNode node1, } } - public static void main(String[] args) { + public static void main(String a[]) { BinarySearchTree bst = new BinarySearchTree<>(); bst.put(6); bst.put(3); diff --git a/src/main/java/com/rampatra/trees/InOrderUsingStack.java b/src/me/ramswaroop/trees/InOrderUsingStack.java similarity index 81% rename from src/main/java/com/rampatra/trees/InOrderUsingStack.java rename to src/me/ramswaroop/trees/InOrderUsingStack.java index 15ef82d0..f9eb8dbf 100644 --- a/src/main/java/com/rampatra/trees/InOrderUsingStack.java +++ b/src/me/ramswaroop/trees/InOrderUsingStack.java @@ -1,17 +1,17 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinarySearchTree; -import com.rampatra.base.LinkedStack; -import com.rampatra.base.Stack; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinarySearchTree; +import me.ramswaroop.common.LinkedStack; +import me.ramswaroop.common.Stack; import static java.lang.System.out; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 7:31 PM */ public class InOrderUsingStack { @@ -43,7 +43,7 @@ public static > void inOrderUsingStack(BinaryNode nod } } - public static void main(String[] args) { + public static void main(String a[]) { BinarySearchTree bst = new BinarySearchTree<>(); bst.put(6); bst.put(3); diff --git a/src/main/java/com/rampatra/trees/InOrderWithoutStackAndRecursion.java b/src/me/ramswaroop/trees/InorderWithoutStackAndRecursion.java similarity index 92% rename from src/main/java/com/rampatra/trees/InOrderWithoutStackAndRecursion.java rename to src/me/ramswaroop/trees/InorderWithoutStackAndRecursion.java index 5663986e..2664cc8b 100644 --- a/src/main/java/com/rampatra/trees/InOrderWithoutStackAndRecursion.java +++ b/src/me/ramswaroop/trees/InorderWithoutStackAndRecursion.java @@ -1,13 +1,13 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinarySearchTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinarySearchTree; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 7:23 PM */ public class InOrderWithoutStackAndRecursion> extends BinarySearchTree { @@ -67,7 +67,7 @@ public void inOrderWithoutStackAndRecursion(BinaryNode node) { } } - public static void main(String[] args) { + public static void main(String a[]) { InOrderWithoutStackAndRecursion bst = new InOrderWithoutStackAndRecursion<>(); bst.put(6); bst.put(3); diff --git a/src/main/java/com/rampatra/trees/LeafNodes.java b/src/me/ramswaroop/trees/LeafNodes.java similarity index 79% rename from src/main/java/com/rampatra/trees/LeafNodes.java rename to src/me/ramswaroop/trees/LeafNodes.java index bc3d271e..0c9f3f61 100644 --- a/src/main/java/com/rampatra/trees/LeafNodes.java +++ b/src/me/ramswaroop/trees/LeafNodes.java @@ -1,13 +1,13 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinaryTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinaryTree; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 6:08 PM */ public class LeafNodes { @@ -27,7 +27,7 @@ public static > int countLeafNodes(BinaryNode node) { } } - public static void main(String[] args) { + public static void main(String a[]) { BinaryTree bt = new BinaryTree<>(); bt.put(6); bt.put(3); diff --git a/src/main/java/com/rampatra/trees/LeastCommonAncestorInBST.java b/src/me/ramswaroop/trees/LeastCommonAncestor.java similarity index 81% rename from src/main/java/com/rampatra/trees/LeastCommonAncestorInBST.java rename to src/me/ramswaroop/trees/LeastCommonAncestor.java index 1d195b90..c8bb3a04 100644 --- a/src/main/java/com/rampatra/trees/LeastCommonAncestorInBST.java +++ b/src/me/ramswaroop/trees/LeastCommonAncestor.java @@ -1,18 +1,18 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinarySearchTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinarySearchTree; import java.util.NoSuchElementException; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 7:38 PM */ -public class LeastCommonAncestorInBST { +public class LeastCommonAncestor { public void leastCommonAncestor() { @@ -42,9 +42,7 @@ public void leastCommonAncestor() { * @return */ public static > BinaryNode leastCommonAncestor(BinaryNode node, E value1, E value2) { - if (node == null || value1 == null || value2 == null || value1.compareTo(value2) > 0) { - throw new NoSuchElementException(); - } + if (node == null || value1.compareTo(value2) > 0) throw new NoSuchElementException(); if (value1.compareTo(node.value) <= 0 && value2.compareTo(node.value) >= 0) { return node; @@ -55,7 +53,7 @@ public static > BinaryNode leastCommonAncestor(Binary } } - public static void main(String[] args) { + public static void main(String a[]) { BinarySearchTree bst = new BinarySearchTree<>(); bst.put(6); bst.put(3); diff --git a/src/main/java/com/rampatra/trees/MirrorTree.java b/src/me/ramswaroop/trees/MirrorTree.java similarity index 85% rename from src/main/java/com/rampatra/trees/MirrorTree.java rename to src/me/ramswaroop/trees/MirrorTree.java index 421e2241..479c92cb 100644 --- a/src/main/java/com/rampatra/trees/MirrorTree.java +++ b/src/me/ramswaroop/trees/MirrorTree.java @@ -1,13 +1,13 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinaryTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinaryTree; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 7:03 PM */ public class MirrorTree { @@ -35,7 +35,7 @@ public static > void mirror(BinaryNode node) { node.right = tempNode; } - public static void main(String[] args) { + public static void main(String a[]) { BinaryTree bt = new BinaryTree<>(); bt.put(6); bt.put(3); diff --git a/src/main/java/com/rampatra/trees/RootToLeafPaths.java b/src/me/ramswaroop/trees/RootToLeafPaths.java similarity index 94% rename from src/main/java/com/rampatra/trees/RootToLeafPaths.java rename to src/me/ramswaroop/trees/RootToLeafPaths.java index a42ca4b6..593f6472 100644 --- a/src/main/java/com/rampatra/trees/RootToLeafPaths.java +++ b/src/me/ramswaroop/trees/RootToLeafPaths.java @@ -1,7 +1,7 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinaryTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinaryTree; import java.util.ArrayList; import java.util.List; @@ -11,8 +11,8 @@ /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 5:52 PM */ public class RootToLeafPaths> extends BinaryTree { @@ -106,7 +106,7 @@ public boolean rootToLeafPathsSum(BinaryNode node, List pathList, int path } } - public static void main(String[] args) { + public static void main(String a[]) { RootToLeafPaths bt = new RootToLeafPaths<>(); bt.put(6); bt.put(3); diff --git a/src/main/java/com/rampatra/trees/SpiralTraversal.java b/src/me/ramswaroop/trees/SpiralTraversal.java similarity index 92% rename from src/main/java/com/rampatra/trees/SpiralTraversal.java rename to src/me/ramswaroop/trees/SpiralTraversal.java index fa313e1c..d159931e 100644 --- a/src/main/java/com/rampatra/trees/SpiralTraversal.java +++ b/src/me/ramswaroop/trees/SpiralTraversal.java @@ -1,17 +1,17 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinaryTree; -import com.rampatra.base.LinkedStack; -import com.rampatra.base.Stack; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinaryTree; +import me.ramswaroop.common.LinkedStack; +import me.ramswaroop.common.Stack; import java.util.EmptyStackException; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 5:14 PM */ public class SpiralTraversal> extends BinaryTree { @@ -98,7 +98,7 @@ public void spiralTraversalUsingStacks(BinaryNode node) { } } - public static void main(String[] args) { + public static void main(String a[]) { SpiralTraversal bt = new SpiralTraversal<>(); bt.put(6); bt.put(3); diff --git a/src/main/java/com/rampatra/trees/TreeToList.java b/src/me/ramswaroop/trees/TreeToList.java similarity index 90% rename from src/main/java/com/rampatra/trees/TreeToList.java rename to src/me/ramswaroop/trees/TreeToList.java index 26256b30..6f10d83c 100644 --- a/src/main/java/com/rampatra/trees/TreeToList.java +++ b/src/me/ramswaroop/trees/TreeToList.java @@ -1,13 +1,13 @@ -package com.rampatra.trees; +package me.ramswaroop.trees; -import com.rampatra.base.BinaryNode; -import com.rampatra.base.BinarySearchTree; +import me.ramswaroop.common.BinaryNode; +import me.ramswaroop.common.BinarySearchTree; /** * Created by IntelliJ IDEA. * - * @author rampatra - * @since 6/26/15 + * @author: ramswaroop + * @date: 6/26/15 * @time: 4:38 PM */ public class TreeToList> extends BinarySearchTree { @@ -59,7 +59,7 @@ private static > BinaryNode addToList(BinaryNode a return aList; } - public static void main(String[] args) { + public static void main(String a[]) { BinarySearchTree bst = new BinarySearchTree<>(); bst.put(6); bst.put(3);