rea
Reverse engineer anything with agents, from app behavior down to native binaries.
- 472k
- TypeScript
- MIT
- 4 h ago
The maintainer has not written a description at the source.
Repo binaryshrey/DSA, read from GitHub 23 h ago. binaryshrey has not joined Take My Repo.
binaryshrey/DSA is a public repo on GitHub by binaryshrey. It declares no license on GitHub. Public does not mean open source: without a license, nobody is granted the right to reuse it. It is written mainly in Java, has 4 stars and last changed on 2022-12-17. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-20.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
A beginner's guide to getting started with Data Structures and Algorithms with JAVA.
$ sudo apt update $ sudo apt install openjdk-8-jdk $ java -version
import java.util.*;
import java.lang.*;
import java.io.*;
class HelloWorld
{
public static void main (String[] args) throws java.lang.Exception
{
System.out.println("Hello World");
}
}
Procedure Oriented Programming is a programming paradigm (top-down approach), where a program is written as a sequence of procedures or functions therby divinding a large program into smaller programs with specific functionality. In POP, the major emphasis is on procedure (function) and not on the data and most functions share data defined at global level. POP languages are high-level languages such as BASIC, C, COBOL are machine-independent and we can develop program logic without having a knowledge about computer's architecture.
An OOP is a design philosophy or programming paradigm, that models software design around data or objects rather than functions and logic. An object is referred to as a data field that has unique attributes and behavior and it also provides reusablity feature to develop productive logic, which means more emphasis is given on data.
Byte Code is an intermediate code in form of .class file which is generated as soon as a Java program is compiled and is then acted upon by JVM making it platform independent. JAVA is a HLL. The program written in java is compiled to an intermediate code called Byte Code. This code is independent of the machine on which the program is to run. When the code is to be run on any machine, an Intepretor known as JVM converts the Byte Code to MLL.
The conversion of HLL to MLL can be done in two ways
The Java Development Kit (JDK) is a software development environment used for developing Java applications and applets. It includes the Java Runtime Environment (JRE), an interpreter/loader (Java), a compiler (javac), an archiver (jar), a documentation generator (Javadoc) and other tools needed in Java development.
JRE stands for “Java Runtime Environment” and may also be written as “Java RTE.” The Java Runtime Environment provides the minimum requirements for executing a Java application; it consists of the Java Virtual Machine (JVM), core classes, and supporting files.
JVM(Java Virtual Machine) acts as a run-time engine to run Java applications. JVM is the one that actually calls the main method present in a java code. JVM is a part of JRE(Java Runtime Environment).
When we compile a .java file, .class files(contains byte-code) with the same class names present in .java file are generated by the Java compiler. This .class file goes into various steps when we run it. These steps together describe the whole JVM.
Class Loader Subsystem
JVM Memory
Execution Engine
Java Native Interface (JNI)
Native Method Libraries
Garbage Collector destroys un-referenced objects. Main objective of Garbage Collector is to free heap memory by destroying unreachable objects. An object is said to be eligible for GC(garbage collection) iff it is unreachable.
Just before destroying an object, Garbage Collector calls finalize() method on the object to perform cleanup activities. Once finalize() method completes, Garbage Collector destroys that object. finalize() method is present in Object class with following prototype.
protected void finalize() throws Throwable
The finalize() method called by Garbage Collector not JVM. The finalize() method is never invoked more than once for any given object.
An object is said to be eligible for GC(garbage collection) iff it is unreachable.
Integer i = new Integer(4);
i = null;
| Data type | Size | Value Range | Precision |
|---|---|---|---|
| boolean | 1bit | 0 or 1 | |
| byte | 1byte | -128 to 127 | |
| char | 2byte | 0 to 65,535 | |
| short | 2byte | -32,768 to 32,767 | |
| int | 4byte | -2^31 to 2^31-1 | |
| long | 8byte | -2^63 to 2^63-1 | |
| float | 4byte | -3.4E+38 to 3.4E+38 | 6 digits |
| double | 8byte | -1.7E+308 to 1.7E+308 | 15 digits |
A Variable is a named memory location that holds a value. There are three types of variables in Java:
Local Variables :
Instance Variables:
Static Variables:
A mechamism of encapsulating a group of classes, interfaces or sub-packages
Built-in
User-Defined
package myPackage;
public class Hello{
public void getNames(String s)
{
System.out.println(s);
}
}
import myPackage.Hello;
public class PrintName
{
public static void main(String args[])
{
String name = "Welcome to JAVA";
Hello obj = new Hello();
obj.getNames(name);
}
}
class Format
{
public static void main(String args[])
{
int x = 100;
System.out.printf("%d\n", x); //100
// this will print it upto 2 decimal places
System.out.printf("%.2f\n", Math.PI); //3.14
float n = 5.2f;
// automatically appends zero to the rightmost part of decimal
System.out.printf("%.4f\n", n); //5.2000
}
}
import java.text.DecimalFormat;
class Format
{
public static void main(String args[])
{
double num = 123.4567;
// prints only numeric part of a floating number
DecimalFormat ft = new DecimalFormat("####");
System.out.println(ft.format(num)); //123
// this will print it upto 2 decimal places
ft = new DecimalFormat("#.##");
System.out.println(ft.format(num)); //123.45
// automatically appends zero to the rightmost part of decimal
// instead of #,we use digit 0
ft = new DecimalFormat("#.000000");
System.out.println(ft.format(num)); //123.456700
// automatically appends zero to the leftmost of decimal number
// instead of #,we use digit 0
ft = new DecimalFormat("00000.00");
System.out.println(ft.format(num)); //00123.45
// formatting money in dollars
double income = 23456.789;
ft = new DecimalFormat("$###,###.##");
System.out.println(ft.format(income)); //$23,456.79
}
}
StringBuilder st1 = new StringBuilder("Hello");
StringBuilder st2 = new StringBuilder();
int n = Integer.parseInt(str);
String str = Integer.toString(n);
A data structure is a storage that is used to store and organize data. It is a way of arranging data so that it can be accessed and updated efficiently.
class Test
{
public static void main(String args[])
{
int arr[] = {3, 1, 2, 5, 4};
sum(arr);
}
public static void sum(int[] arr)
{
int sum = 0;
for (int i = 0; i < arr.length; i++)
sum+=arr[i];
System.out.println("sum of array values : " + sum);
}
}
class Test
{
public static void main(String args[])
{
int arr[] = m1();
for (int i = 0; i < arr.length; i++)
System.out.print(arr[i]+" ");
}
public static int[] m1()
{
return new int[]{1,2,3};
}
}
When you clone a single dimensional array, such as Object[], a “deep copy” is performed with the new array containing copies of the original array’s elements as opposed to references.
class Test
{
public static void main(String args[])
{
int intArray[] = {1,2,3};
int cloneArray[] = intArray.clone();
System.out.println(intArray == cloneArray); //false
for (int i = 0; i < cloneArray.length; i++) {
System.out.print(cloneArray[i]+" "); //1 2 3
}
}
}
A clone of a multidimensional array (like Object[][]) is a “shallow copy” however, which is to say that it creates only a single new array with each element array a reference to an original element array but subarrays are shared.
class Test
{
public static void main(String args[])
{
int intArray[][] = {{1,2,3},{4,5}};
int cloneArray[][] = intArray.clone();
System.out.println(intArray == cloneArray); //false
System.out.println(intArray[0] == cloneArray[0]); //true
System.out.println(intArray[1] == cloneArray[1]); //true
}
}
A tree whose elements have at most 2 children is called a binary tree. Since each element in a binary tree can have only 2 children, we typically name them the left and right child. A Binary Tree node contains following parts:
Unlike Arrays, Linked Lists, Stack and queues, which are linear data structures, trees are hierarchical data structures.
class Node
{
int key;
Node left, right;
public Node(int item)
{
key = item;
left = right = null;
}
}
Following two are the most commonly used representations of a graph.
Collections in Java is a framework that provides an architecture to store and manipulate the group of objects.
Iterable
^
|
|
Collection
|
--------------------------------------------
| | |
| | |
List Queue Set
| | |
- ArrayList - Queue (Priority Queue) - SortedSet (TreeSet)
- LinkedList - Deque (Array Dequeue) - Set (HashSet, LinkedHashSet)
- Vector (Stack)
.add
.addAll
.remove
.removeAll
.size
.contains
.toArray
.isEmpty
Iterator interface provides the facility of iterating the elements in a forward direction only.
.hasNext()
.next()
.remove()
Iterator<String> itr=coll.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
ArrayList<String> list=new ArrayList<String>();//Creating arraylist
list.add("Ravi");
list.add("Vijay");
list.add("Ravi");
list.add("Ajay");
//Traversing list through Iterator
Iterator itr=list.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
for (int i = 0; i < list.size(); i++)
System.out.print(list.get(i) + " ");
}
LinkedList<String> al=new LinkedList<String>();
al.add("Ravi");
al.add("Vijay");
al.add("Ravi");
al.add("Ajay");
Iterator<String> itr=al.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
Vector<String> v=new Vector<String>();
v.add("Ayush");
v.add("Amit");
v.add("Ashish");
v.add("Garima");
Iterator<String> itr=v.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
Stack<String> stack = new Stack<String>();
stack.push("Ayush");
stack.push("Garvit");
stack.push("Amit");
stack.push("Ashish");
stack.push("Garima");
stack.pop();
Iterator<String> itr=stack.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
// Creating empty priority queue
PriorityQueue<Integer> pQueue = new PriorityQueue<Integer>();
// Adding items to the pQueue using add()
pQueue.add(10);
pQueue.add(20);
pQueue.add(15);
// Printing the top element of PriorityQueue
System.out.println(pQueue.peek());
// Printing the top element and removing it
System.out.println(pQueue.poll());
// Printing the top element again
System.out.println(pQueue.peek());
// Initializing an deque
ArrayDeque<Integer> de_que = new ArrayDeque<Integer>(10);
// add() method to insert
de_que.add(10);
de_que.add(20);
de_que.add(30);
de_que.add(40);
de_que.add(50);
System.out.println(de_que);
// clear() method
de_que.clear();
// addFirst() method to insert the
// elements at the head
de_que.addFirst(564);
de_que.addFirst(291);
// addLast() method to insert the
// elements at the tail
de_que.addLast(24);
de_que.addLast(14);
System.out.println(de_que);
HashSet<String> set=new HashSet<String>();
set.add("Ravi");
set.add("Vijay");
set.add("Ravi");
set.add("Ajay");
//Traversing elements
Iterator<String> itr=set.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
LinkedHashSet<String> set=new LinkedHashSet<String>();
set.add("Ravi");
set.add("Vijay");
set.add("Ravi");
set.add("Ajay");
Iterator<String> itr=set.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
//Creating and adding elements
TreeSet<String> set=new TreeSet<String>();
set.add("Ravi");
set.add("Vijay");
set.add("Ravi");
set.add("Ajay");
//traversing elements
Iterator<String> itr=set.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
An algorithm is a finite sequence of logically related instructions to solve a computational problem.
Fact(n)
{
for i = 1 to n
fact = fact * i;
return fact;
}
Fact(n)
{
if n = 1
return 1;
else
return n * fact(n-1);
}
Asymptotic Analysis : mesauring order of growth of an algorithm in terms of input size
C < loglog(n) < log(n) < n^1/3 < n^1/2 < n < n^2 < n^3 < 2^n < n^n
Best Case − Minimum time required for program execution.
Average Case − Average time required for program execution.
Worst Case − Maximum time required for program execution.
The function f(n) = O(g(n)) if and only if there exist positive constants c, n0 such that
f(n) ≤ cg(n), ∀n ≥ n0 .
Big-oh can be used to denote all upper bounds on the time complexity of an algorithm. Big-oh also captures the worst case analysis of an algorithm.
The function f (n) = Ω(g(n)) if and only if there exist positive constants c, n0 such that f(n) ≥
c.g(n), ∀n ≥ n0.
Omega can be used to denote all lower bounds of an algorithm. Omega notation also denotes the best case analysis of an algorithm.
The function f (n) = Θ(g(n)) if and only if there exist positive constants c1 , c2 , n0 such that
c1 g(n) ≤ f (n) ≤ c2 g(n), ∀n ≥ n0 .
Theta can be used to denote tight bounds of an algorithm.
Master Theorem :
Let a≥1 and b>1 be constants, let f(n) be a non negative function,
and let T(n) be defined on the non-negative integers by the recurrence
T(n) = aT(n/b) + f(n)
Then T(n) has the following asymptotic bounds:
Case 1: If f(n) = O(n log b a−e ) for some constant e>0 Then T(n) = θ(n log b a )
Case 2: If f(n) = θ(n log b a ) then T(n) = θ(n log b a * log n)
Case 3: If f(n) = Ω(n log b a+e ) for some constant e>0, and if af (n/b) ≤ cf (n) for
some constant c<1 and all sufficiently large n, then T(n) = θ(f(n)).
for (int i = 1; i <= n; i += c) {
// some O(1) expressions
}
for (int i = n; i > 0; i -= c) {
// some O(1) expressions
}
for (int i = 1; i <=n; i += c) {
for (int j = 1; j <=n; j += c) {
// some O(1) expressions
}
}
for (int i = n; i > 0; i -= c) {
for (int j = i+1; j <=n; j += c) {
// some O(1) expressions
}
for (int i = 1; i <=n; i *= c) {
// some O(1) expressions
}
for (int i = n; i > 0; i /= c) {
// some O(1) expressions
}
for (int i = 2; i <=n; i = pow(i, c)) {
// some O(1) expressions
}
for (int i = n; i > 1; i = fun(i)) {
// some O(1) expressions
}
binaryshrey/DSA is a public repo on GitHub by binaryshrey. Its maker has not written a description.
It declares no license on GitHub. Public does not mean open source: without a license, nobody is granted the right to reuse it.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2022-12-17. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Reverse engineer anything with agents, from app behavior down to native binaries.

:books: 技术面试必备基础知识、Leetcode、计算机操作系统、计算机网络、系统设计
Java 面试 & 后端通用面试指南,覆盖计算机基础、数据库、分布式、高并发、系统设计与 AI 应用开发
#1 PDF Application on GitHub that lets you edit PDFs on any device anywhere

mall项目是一套电商系统,包括前台商城系统及后台管理系统,基于Spring Boot+MyBatis实现,采用Docker容器化部署。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。

:eyeglasses: A curated list of awesome android projects by open-source contributors.
🤖 Your Personalised AI Chat Companion With 50+ Avatars Over 10+ Categories - Powered by OpenAI's GPT-3 / ChatGPT-3.5 Turbo / GPT-4, Google's Bard-AI, Pygmalion's 6B & StabilityAI's Stable-Diffusion models
Dice 🎲 is a minimalistic, intuitive and an ad-free dice roll application


🌦️ Stay ahead of the storm with our minimalist weather tracker app and get notified for weather alerts!
DeepFlick : Popular Movies app made as Part of Udacity's Android Nanodegree