thiscodeWorks - Saving, organizing & sharing the best of code online

vector<int> bin(int num) 
{
    vector<int> binaryNum;
    if (num == 0) {
        binaryNum.push_back(0);
        return binaryNum;
    }
     while (num > 0) {
        binaryNum.push_back(num % 2);
        num = num / 2;
    }
    reverse(binaryNum.begin(), binaryNum.end());
    return binaryNum;
}

#html

Fonts , Styling

@AYWEB

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Fonts</title> 
    <style>
        @import url('https://fonts.googleapis.com/css2?family=Baloo+Bhai+2&family=Poppins:wght@300&display=swap');
        h1 {
            font-family: 'Poppins', 'Lucida Sans', 'Lucida Sans Regular', 'Lucida Grande', 'Lucida Sans Unicode', Geneva, Verdana, sans-serif
        }

        p {
            /* font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; */
            font-family: 'Baloo Bhai 2', sans-serif;
            font-size: 20px; 
            /* font-style:italic;
            font-weight: 500;  */
            
        }
        h2{
            text-align: center;
            text-transform: uppercase;
            text-decoration: underline;
            text-decoration-color: blue;//to change color of underline
            /* text-decoration-style: dotted; */
            text-decoration-thickness: 7px ;
            /* text-indent: 45px; */
        }
        .lorem{
            border: 2px solid red;
            width: 145px;
            word-break: break-all;
            /* text-overflow: ellipsis;
            overflow: hidden; */

        }
    </style>
</head>

<body>
    <div>
        <!-- https://codepen.io/web-dot-dev/pen/yLojraG -->
        <h1>Fonts</h1>
        <h2>about Fonts</h2>
        <p>This is a video on fonts</p>
        <p class="lorem">Lorem ipsum dolor sit amet consectetur adipisicing elit. Quos sequi accusamus quas itaque molestias dolorem quisquam quod, adipisci maxime dolore, mollitia illo officia deserunt voluptatem iure qui. Fugit aliquam possimus aperiam commodi eum amet veniam at vel. Necessitatibus asperiores eos amet laborum dolor, ipsum porro!</p>
    </div>
</body>

</html>

#c

Hex digits return

@meanaspotato

#include <stdio.h>

int is_hex_digit(char input)
{
    if((input>='0'&&input<='9')||(input>='a'&&input<='z')||(input>='A'&&input<='F'))
    {
        return 1;
    }
    else
    {
        return 0;
    }
    
}

int main(void)
{
    char input;
    printf("> ");
    scanf(" %c",&input);
    
    int output = is_hex_digit(input);
    
    printf("%d",output);
    
    return 0;
}

#html

Margin,Border,Padding

@AYWEB

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>CSS Boxmodel</title>
    <style>
        *{
            margin: 0;
            padding: 0;
        }

        .box {
            background-color: aqua;
        }
        .box1{
            color: yellow;
            padding: 10px;
            margin:35px;
            border: 2px solid blue;
            height: 200px;
            box-sizing: border-box;
        }
        .box2{
            color:red;
            padding: 10px;
            margin:25px;
            border: 2px solid black;
            height: 200px;
            box-sizing: border-box;
        }
    </style>
</head>

<body>
    <div class="box box1">I am a box</div>
    <div class="box box2">I am another box</div>
</body>

</html>

#html

Selectors

@AYWEB

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>CSS Selectors</title>
    <style>
        /* Element Selector  */
        div{
            /* background-color: red; */
        }

        /* Class Selector  */
        .red{
            background-color: red;
        }

        /* Id Selector */
        #green{
            background-color: green;
        }

        /* Child Selectors  */
        div > p {
            color: blue;
            background-color: brown;
        }

        /* Descendant Selector  */
        div p {
            color: blue;
            background-color: brown;
        }

        /* Universal Selector */
        * {
            margin:0;
            padding: 0;
        }

        /* Pseudo Selector  */
        a:visited{
            color: yellow
        }

        a:link {
            color: green;
        }

        a:active{
            background-color: red;
        }

        a:hover{
            background-color: yellow;
        }


        p:first-child{
            background-color: aqua;
        }

    </style>
</head>
<body>
    <main class="one">
        <p>I am first</p>
        <p>I am second</p>
    </main>
    <div class="red">
        I am a div
        <article>

            <p>I am a para inside div</p>
        </article>
    </div>

    <div id="green">
        I am another div
    </div>
    <a href="https://www.google.com">Go to Google</a>
    <a href="https://www.facebook2.com">Go to Facebook</a>
</body>
</html>

#c

Find Minimum Value

@meanaspotato

#include <stdio.h>

int identify_minimum_value(int input_1, int input_2)
{
    int minimum_value;
    
    if(input_1<input_2)
    {
        minimum_value = input_1;
    }
    else
    {
        minimum_value = input_2;
    }
    
    return minimum_value;
}

int main (void)
{
    int input_1;
    int input_2;
    printf("Please input number 1:\n");
    scanf("%d",&input_1);
    printf("Please input number 2:\n");
    scanf("%d",&input_2);
   int minimum_value = identify_minimum_value(input_1,input_2);
    
    printf("The minimum number of %d and %d is %d",input_1,input_2,minimum_value);
    return 0;
}

PR template

## What

Jira ticket: 

## Why

## How

## Screenshots
Before | After
--- | ---

## Tech links

Pipes

@login

#include <sys/wait.h> /* wait */
#include <stdio.h>
#include <stdlib.h>   /* exit functions */
#include <unistd.h>   /* read, write, pipe, _exit */
#include <string.h>

#define ReadEnd  0
#define WriteEnd 1

void report_and_exit(const char* msg) {
  perror(msg);
  exit(-1);    /** failure **/
}

int main() {
  int pipeFDs[2]; /* two file descriptors */
  char buf;       /* 1-byte buffer */
  const char* msg = "Nature's first green is gold\n"; /* bytes to write */

  if (pipe(pipeFDs) < 0) report_and_exit("pipeFD");
  pid_t cpid = fork();                                /* fork a child process */
  if (cpid < 0) report_and_exit("fork");              /* check for failure */

  if (0 == cpid) {    /*** child ***/                 /* child process */
    close(pipeFDs[WriteEnd]);                         /* child reads, doesn't write */

    while (read(pipeFDs[ReadEnd], &buf, 1) > 0)       /* read until end of byte stream */
      write(STDOUT_FILENO, &buf, sizeof(buf));        /* echo to the standard output */

    close(pipeFDs[ReadEnd]);                          /* close the ReadEnd: all done */
    _exit(0);                                         /* exit and notify parent at once  */
  }
  else {              /*** parent ***/
    close(pipeFDs[ReadEnd]);                          /* parent writes, doesn't read */

    write(pipeFDs[WriteEnd], msg, strlen(msg));       /* write the bytes to the pipe */
    close(pipeFDs[WriteEnd]);                         /* done writing: generate eof */

    wait(NULL);                                       /* wait for child to exit */
    exit(0);                                          /* exit normally */
  }
  return 0;
}

Bankers (with values)

@login

#include<stdio.h>  
int main()  
{  
    // P0 , P1 , P2 , P3 , P4 are the Process names here  
    int n , m , i , j , k;  
    n = 5; // Number of processes  
    m = 3; // Number of resources  
    int alloc[ 5 ] [ 3 ] = { { 0 , 1 , 0 }, // P0 // Allocation Matrix  
                        { 2 , 0 , 0 } , // P1  
                        { 3 , 0 , 2 } , // P2  
                        { 2 , 1 , 1 } , // P3  
                        { 0 , 0 , 2 } } ; // P4  
    int max[ 5 ] [ 3 ] = { { 7 , 5 , 3 } , // P0 // MAX Matrix  
                    { 3 , 2 , 2 } , // P1  
                    { 9 , 0 , 2 } , // P2  
                    { 2 , 2 , 2 } , // P3  
                    { 4 , 3 , 3 } } ; // P4  
    int avail[3] = { 3 , 3 , 2 } ; // Available Resources  
    int f[n] , ans[n] , ind = 0 ;  
    for (k = 0; k < n; k++) {  
        f[k] = 0;  
    }  
    int need[n][m];  
    for (i = 0; i < n; i++) {  
        for (j = 0; j < m; j++)  
            need[i][j] = max[i][j] - alloc[i][j] ;  
    }  
    int y = 0;  
    for (k = 0; k < 5; k++){  
        for (i = 0; i < n; i++){  
            if (f[i] == 0){  
                int flag = 0;  
                for (j = 0; j < m; j++) {  
                    if(need[i][j] > avail[j]){  
                        flag = 1;  
                        break;  
                    }  
                }  
                if ( flag == 0 ) {  
                    ans[ind++] = i;  
                    for (y = 0; y < m; y++)  
                        avail[y] += alloc[i][y] ;  
                    f[i] = 1;  
                }  
            }  
        }  
    }  
    int flag = 1;   
    for(int i=0;i<n;i++)  
    {  
    if(f[i] == 0)  
    {  
        flag = 0;  
        printf(" The following system is not safe ");  
        break;  
    }  
    }  
    if (flag == 1)  
    {  
    printf(" Following is the SAFE Sequence \ n ");  
    for (i = 0; i < n - 1; i++)  
        printf(" P%d -> " , ans[i]);  
    printf(" P%d ", ans[n - 1]);  
    }  
    return(0);  
}

FCFS cpu scheduling

@login

#include<stdio.h>
 int main()
 {
    int n,bt[20],wt[20],tat[20],avwt=0,avtat=0,i,j;
    printf("Enter total number of processes(maximum 20):");
    scanf("%d",&n);
    printf("nEnter Process Burst Timen");
    for(i=0;i<n;i++)
    {
        printf("P[%d]:",i+1);
        scanf("%d",&bt[i]);
    }
    wt[0]=0;   
    for(i=1;i<n;i++)
    {
        wt[i]=0;
        for(j=0;j<i;j++)
            wt[i]+=bt[j];
    }
    printf("nProcessttBurst TimetWaiting TimetTurnaround Time");
    for(i=0;i<n;i++)
    {
        tat[i]=bt[i]+wt[i];
        avwt+=wt[i];
        avtat+=tat[i];
        printf("nP[%d]tt%dtt%dtt%d",i+1,bt[i],wt[i],tat[i]);
    }
    avwt/=i;
    avtat/=i;
    printf("nnAverage Waiting Time:%d",avwt);
    printf("nAverage Turnaround Time:%d",avtat);
    return 0;
}

#frontend #bootstrap

Bootstrap 5 crash course

@Joe_Devs

https://www.youtube.com/watch?v=Jyvffr3aCp0&t=1863s&ab_channel=WebDevSimplified

#java

Streams Collection

@chatgpt

import java.util.*;

import java.util.stream.*;

public class CollectingDemo {

    public static void main(String[] args) {

        ArrayList<Integer> al = new ArrayList<>();

        al.add(5);

        al.add(7);

        al.add(7);

        al.add(30);

        al.add(49);

        al.add(100);

        System.out.println("Actual List: " + al);

        Stream<Integer> odds = al.stream().filter(n -> n % 2 == 1);

        System.out.print("Odd Numbers: ");

        odds.forEach(n -> System.out.print(n + " "));

        System.out.println();

        List<Integer> oddList = al.stream().filter(n -> n % 2 == 1).collect(Collectors.toList());

        System.out.println("The list: " + oddList);

        Set<Integer> oddSet = al.stream().filter(n -> n % 2 == 1).collect(Collectors.toSet());

        System.out.println("The set: " + oddSet);

    }

}

#java

Streams Mapping

@chatgpt

import java.util.*;

import java.util.stream.*;

public class MappingDemo {

    public static void main(String[] args) {

        ArrayList<Integer> al = new ArrayList<>();

        al.add(5);

        al.add(16);

        al.add(25);

        al.add(30);

        al.add(49);

        al.add(100);

        System.out.println("Actual List: " + al);

        Stream<Double> sqr = al.stream().map(n -> Math.sqrt(n));

        System.out.print("Square roots: ");

        sqr.forEach(n -> System.out.print("[" + n + "] "));

        System.out.println();

    }

}

#java

Streams Reduction

@chatgpt

import java.util.*;

import java.util.stream.*;

public class ReductionDemo {

    public static void main(String[] args) {

        ArrayList<Integer> al = new ArrayList<>();

        al.add(10);

        al.add(20);

        al.add(30);

        al.add(40);

        al.add(50);

        System.out.println("Contents of the collection: " + al);

        System.out.println();

        Optional<Integer> obj1 = al.stream().reduce((x, y) -> (x + y));

        if(obj1.isPresent())

            System.out.println("Total is: " + obj1.get());

        System.out.println();

        long product = al.stream().reduce(1, (x, y) -> (x * y));

        System.out.println("Product is: " + product);

    }

}

#java

Streams Demo

@chatgpt

import java.util.*;

import java.util.stream.*;

public class StreamDemo {

    public static void main(String[] args) {

        ArrayList<Integer> al = new ArrayList<>();

        al.add(7);

        al.add(18);

        al.add(10);

        al.add(24);

        al.add(17);

        al.add(5);

        System.out.println("Actual List: " + al);

        Stream<Integer> stm = al.stream();  // get a stream; factory method

        Optional<Integer> least = stm.min(Integer::compare);   // Integer class implements Comparator [compare(obj1, obj2) static method]

        if(least.isPresent())

            System.out.println("Minimum integer: " + least.get());

        // min is a terminal operation, get the stream again

        /* 

        Optional<T> is a generic class packaged in java.util package.

        An Optional class instance can either contains a value of type T or is empty.

        Use method isPresent() to check if a value is present. Obtain the value by calling get() 

        */

        stm = al.stream();

        System.out.println("Available values: " + stm.count());

        stm = al.stream();

        Optional<Integer> higher = stm.max(Integer::compare);

        if(higher.isPresent())

            System.out.println("Maximum integer: " + higher.get());

        // max is a terminal operation, get stream again

        Stream<Integer> sortedStm = al.stream().sorted();    // sorted() is intermediate operation

        // here, we obtain a sorted stream

        System.out.print("Sorted stream: ");

        sortedStm.forEach(n -> System.out.print(n + " "));   // lambda expression

        System.out.println();

        /* 

        Consumer<T> is a generic functional interface declared in java.util.function

        Its abstract method is: void accept(T obj)

        The lambda expression in the call to forEach() provides the implementation of accept() method.

        */

        Stream<Integer> odds = al.stream().sorted().filter(n -> (n % 2) == 1);

        System.out.print("Odd values only: ");

        odds.forEach(n -> System.out.print(n + " "));

        System.out.println();

        /* 

        Predicate<T> is a generic functional interface defined in java.util.function

        and its abstract method is test(): boolean test(T obj)

        Returns true if object for test() satisfies the predicate and false otherwise.

        The lambda expression passed to the filter() implements this method.

        */

        odds = al.stream().sorted().filter(n -> (n % 2) == 1).filter(n -> n > 5);   // possible to chain the filters

        System.out.print("Odd values bigger than 5 only: ");

        odds.forEach(n -> System.out.print(n + " "));

        System.out.println();

    }

}

Optimal

@Asadullah69

#include<stdio.h>
int n;
int main()
{
int seq[30],fr[5],pos[5],find,flag,max,i,j,m,k,t,s;
int count=1,pf=0,p=0;
float pfr;
printf("Enter maximum limit of the sequence: ");
scanf("%d",&max);
printf("\nEnter the sequence: ");
 for(i=0;i<max;i++)
scanf("%d",&seq[i]);
 printf("\nEnter no. of frames: ");
 scanf("%d",&n);
fr[0]=seq[0];
pf++;
printf("%d\t",fr[0]);
i=1;
while(count<n)
{
flag=1; p++;
for(j=0;j<i;j++)
{
if(seq[i]==seq[j]) flag=0;
}
if(flag!=0)
{
 fr[count]=seq[i];
 printf("%d\t",fr[count]);
 count++;
pf++;

}
i++;
}
 
printf("\n");
for(i=p;i<max;i++)
{
flag=1;
for(j=0;j<n;j++)
{
if(seq[i]==fr[j])
flag=0;
}
if(flag!=0)

{
for(j=0;j<n;j++)
{
m=fr[j];
for(k=i;k<max;k++)
{
if(seq[k]==m)
{
    pos[j]=k;
     break;

 }
else
pos[j]=1;

}
}
for(k=0;k<n;k++)
{
if(pos[k]==1)
flag=0;
}
if(flag!=0)
s=findmax(pos);
 if(flag==0)
{
for(k=0;k<n;k++)
{
if(pos[k]==1)
{
s=k;
 break;
}
}
}
fr[s]=seq[i];
for(k=0;k<n;k++)
printf("%d\t",fr[k]);
pf++;
printf("\n");
}
}
pfr=(float)pf/(float)max;
printf("\nThe no. of page faults are %d",pf);
printf("\nPage fault rate %f",pfr);
getch();
}
int findmax(int a[])
{
int max,i,k=0;
max=a[0];
for(i=0;i<n;i++)
{
if(max<a[i])
{
  max=a[i];
   k=i;
}
}
return k;
}

Segmentation

@login

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_SEGMENTS 5
#define MEMORY_SIZE 1024  // Total size of physical memory

typedef struct {
    int base;
    int limit;
} Segment;

Segment segment_table[MAX_SEGMENTS];
int memory[MEMORY_SIZE];

int main() {
    // Initialize segments (base and limit for each segment)
    segment_table[0] = (Segment){.base = 0, .limit = 100};
    segment_table[1] = (Segment){.base = 100, .limit = 200};
    segment_table[2] = (Segment){.base = 300, .limit = 150};
    segment_table[3] = (Segment){.base = 450, .limit = 250};
    segment_table[4] = (Segment){.base = 700, .limit = 150};

    // Display segment table
    printf("Segment Table:\n");
    for (int i = 0; i < MAX_SEGMENTS; i++) {
        printf("Segment %d: Base = %d, Limit = %d\n", i, segment_table[i].base, segment_table[i].limit);
    }

    // Accessing memory
    int segment_number, offset;
    printf("Enter segment number to access (0-%d): ", MAX_SEGMENTS - 1);
    scanf("%d", &segment_number);
    printf("Enter offset within segment: ");
    scanf("%d", &offset);

    if (segment_number < 0 || segment_number >= MAX_SEGMENTS || offset < 0 || offset >= segment_table[segment_number].limit) {
        printf("Invalid segment number or offset!\n");
    } else {
        int physical_address = segment_table[segment_number].base + offset;
        printf("Segment number %d with offset %d maps to physical address %d\n", segment_number, offset, physical_address);
    }

    return 0;
}

Paging

@login

#include <stdio.h>
#include <stdlib.h>

#define PAGE_SIZE 256  // Size of a page
#define FRAME_SIZE 256  // Size of a frame
#define NUM_PAGES 16  // Number of pages
#define NUM_FRAMES 8  // Number of frames

int main() {
    int page_table[NUM_PAGES];
    int memory[NUM_FRAMES * FRAME_SIZE];

    // Initialize page table with invalid frame number (-1)
    for (int i = 0; i < NUM_PAGES; i++) {
        page_table[i] = -1;
    }

    // Load pages into frames
    for (int i = 0; i < NUM_PAGES; i++) {
        page_table[i] = i % NUM_FRAMES;  // Simple mapping for demonstration
        printf("Page %d is loaded into Frame %d\n", i, page_table[i]);
    }

    // Accessing memory
    int logical_address;
    printf("Enter logical address to access (0-%d): ", NUM_PAGES * PAGE_SIZE - 1);
    scanf("%d", &logical_address);

    int page_number = logical_address / PAGE_SIZE;
    int offset = logical_address % PAGE_SIZE;
    int frame_number = page_table[page_number];

    if (frame_number == -1) {
        printf("Page fault!\n");
    } else {
        int physical_address = frame_number * FRAME_SIZE + offset;
        printf("Logical address %d maps to physical address %d\n", logical_address, physical_address);
    }

    return 0;
}

Lru

@Asadullah69

#include<stdio.h>
#include<conio.h>
void main()
{
int i, j , k, min, rs[25], m[10], count[10], flag[25], n, f, pf=0, next=1;
//clrscr();
printf("Enter the length of reference string -- ");
 scanf("%d",&n);
printf("Enter the reference string -- ");
 for(i=0;i<n;i++)
{
scanf("%d",&rs[i]);
flag[i]=0;
}
printf("Enter the number of frames -- ");
 scanf("%d",&f);
for(i=0;i<f;i++)

{
count[i]=0;
m[i]=-1;
}
printf("\nThe Page Replacement process is -- \n");
 for(i=0;i<n;i++)
{
for(j=0;j<f;j++)
{
if(m[j]==rs[i])
{
flag[i]=1;
count[j]=next;
 next++;
}

}
if(flag[i]==0)
{

if(i<f)
{  m[i]=rs[i];
   count[i]=next;
   next++;
 }
else
{ min=0;
for(j=1;j<f;j++)
if(count[min] > count[j])
  min=j;

m[min]=rs[i];
 count[min]=next;
  next++;


}
pf++;
}

for(j=0;j<f;j++)
printf("%d\t", m[j]);
 if(flag[i]==0)
printf("PF No. -- %d" , pf);
 printf("\n");
}
printf("\nThe number of page faults using LRU are %d",pf);
 getch();
}

Fcfs page replacement

@Asadullah69

#include<stdio.h>
#include<conio.h>
int main()
{
int i, j, k, f, pf=0, count=0, rs[25], m[10], n;
printf("\n Enter the length of reference string -- ");
scanf("%d",&n);
printf("\n Enter the reference string -- ");
 for(i=0;i<n;i++)
scanf("%d",&rs[i]);
 printf("\n Enter no. of frames -- ");
 scanf("%d",&f);
for(i=0;i<f;i++)
m[i]=-1;

printf("\n The Page Replacement Process is -- \n");
 for(i=0;i<n;i++)
{
for(k=0;k<f;k++)
{
  if(m[k]==rs[i])
  break;

}
if(k==f)
{
m[count++]=rs[i];
pf++;

}

for(j=0;j<f;j++)
printf("\t%d",m[j]);
if(k==f)
printf("\tPF No. %d",pf);
printf("\n");
if(count==f)
count=0;
}
printf("\n The number of Page Faults using FIFO are %d",pf);
getch();
}

Shared memory reader

@login

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    key_t key;
    int shmid;
    char *str;

    // Generate unique key
    key = ftok("shmfile", 65);
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Locate the shared memory segment
    shmid = shmget(key, 1024, 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    // Attach shared memory segment
    str = (char*) shmat(shmid, NULL, 0);
    if (str == (char*) -1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    // Read from shared memory
    printf("Data read from memory: %s\n", str);

    // Detach shared memory segment
    if (shmdt(str) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }

    // Remove the shared memory segment
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl");
        exit(EXIT_FAILURE);
    }

    return 0;
}

Shared memory writer

@login

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main() {
    key_t key;
    int shmid;
    char *str;

    // Generate unique key
    key = ftok("shmfile", 65);
    if (key == -1) {
        perror("ftok");
        exit(EXIT_FAILURE);
    }

    // Create shared memory segment
    shmid = shmget(key, 1024, 0666 | IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    // Attach shared memory segment
    str = (char*) shmat(shmid, NULL, 0);
    if (str == (char*) -1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    // Write to shared memory
    printf("Write Data: ");
    fgets(str, 1024, stdin);

    // Detach shared memory segment
    if (shmdt(str) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }

    return 0;
}

Priority scheduling

@Asadullah69

#include<stdio.h>
 
int main()
{
    int bt[20],p[20],wt[20],tat[20],pr[20],i,j,n,total=0,pos,temp,avg_wt,avg_tat;
    printf("Enter Total Number of Process:");
    scanf("%d",&n);
 
    printf("\nEnter Burst Time and Priority\n");
    for(i=0;i<n;i++)
    {
        printf("\nP[%d]\n",i+1);
        printf("Burst Time:");
        scanf("%d",&bt[i]);
        printf("Priority:");
        scanf("%d",&pr[i]);
        p[i]=i+1;    
    }
 

    for(i=0;i<n;i++)
    {
        pos=i;
        for(j=i+1;j<n;j++)
        {
            if(pr[j]<pr[pos])
                pos=j;
        }
 
        temp=pr[i];
        pr[i]=pr[pos];
        pr[pos]=temp;
 
        temp=bt[i];
        bt[i]=bt[pos];
        bt[pos]=temp;
 
        temp=p[i];
        p[i]=p[pos];
        p[pos]=temp;
    }
 
    wt[0]=0;	
 

    for(i=1;i<n;i++)
    {
        wt[i]=0;
        for(j=0;j<i;j++)
            wt[i]+=bt[j];
 
        total+=wt[i];
    }
 
    avg_wt=total/n;
    total=0;
 
    printf("\nProcess\t    Burst Time    \tWaiting Time\tTurnaround Time");
    for(i=0;i<n;i++)
    {
        tat[i]=bt[i]+wt[i];
        total+=tat[i];
        printf("\nP[%d]\t\t  %d\t\t    %d\t\t\t%d",p[i],bt[i],wt[i],tat[i]);
    }
 
    avg_tat=total/n;
    printf("\n\nAverage Waiting Time=%d",avg_wt);
    printf("\nAverage Turnaround Time=%d\n",avg_tat);
 
	return 0;
}

Message queue reciever

@login

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>

struct msgbuf {
    long mtype;
    char mtext[100];
};

int main() {
    key_t key;
    int msgid;
    struct msgbuf received;

    // Generate unique key
    key = ftok("progfile", 65);

    // Create message queue and return identifier
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    // Receive the message
    if (msgrcv(msgid, &received, sizeof(received.mtext), 1, 0) == -1) {
        perror("msgrcv");
        exit(EXIT_FAILURE);
    }

    printf("Message received: %s\n", received.mtext);

    // Destroy the message queue
    if (msgctl(msgid, IPC_RMID, NULL) == -1) {
        perror("msgctl");
        exit(EXIT_FAILURE);
    }

    return 0;
}

Message queue sender

@login

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct msgbuf {
    long mtype;
    char mtext[100];
};

int main() {
    key_t key;
    int msgid;
    struct msgbuf message;

    // Generate unique key
    key = ftok("progfile", 65);

    // Create message queue and return identifier
    msgid = msgget(key, 0666 | IPC_CREAT);
    if (msgid == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    // Prepare the message
    message.mtype = 1;  // Message type
    strcpy(message.mtext, "Hello from sender!");

    // Send the message
    if (msgsnd(msgid, &message, sizeof(message.mtext), 0) == -1) {
        perror("msgsnd");
        exit(EXIT_FAILURE);
    }

    printf("Message sent: %s\n", message.mtext);
    return 0;
}

WireGuard: fast, modern, secure VPN tunnel

@curtisbarry

[Interface]
PrivateKey = gI6EdUSYvn8ugXOt8QQD6Yc+JyiZxIhp3GInSWRfWGE=
ListenPort = 21841

[Peer]
PublicKey = HIgo9xNzJMWLKASShiTqIybxZ0U3wGLiUeJ1PKf8ykw=
Endpoint = 192.95.5.69:51820
AllowedIPs = 0.0.0.0/0

WireGuard: fast, modern, secure VPN tunnel

@curtisbarry

[Interface]
PrivateKey = yAnz5TF+lXXJte14tji3zlMNq+hd2rYUIgJBgB3fBmk=
ListenPort = 51820

[Peer]
PublicKey = xTIBA5rboUvnH4htodjb6e697QjLERt1NAB4mZqp8Dg=
AllowedIPs = 10.192.122.3/32, 10.192.124.1/24

[Peer]
PublicKey = TrMvSoP4jYQlY6RIzBgbssQqY3vxI2Pi+y71lOWWXX0=
AllowedIPs = 10.192.122.4/32, 192.168.0.0/16

[Peer]
PublicKey = gN65BkIKy1eCE9pP1wdc8ROUtkHLF2PfAqYdyYBz6EA=
AllowedIPs = 10.10.10.230/32

FIFO reader

@login

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

#define FIFO_PATH "/tmp/myfifo"
#define BUFFER_SIZE 100

int main() {
    int fd;
    char buffer[BUFFER_SIZE];
    
    // Open the FIFO for reading
    fd = open(FIFO_PATH, O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // Read from the FIFO
    read(fd, buffer, BUFFER_SIZE);

    // Print the received message
    printf("Received: %s\n", buffer);

    // Close the FIFO
    close(fd);

    return 0;
}

FIFO Writer

@login

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>

#define FIFO_PATH "/tmp/myfifo"

int main() {
    int fd;
    char *message = "Hello from writer process!";
    
    // Open the FIFO for writing
    fd = open(FIFO_PATH, O_WRONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // Write to the FIFO
    write(fd, message, strlen(message) + 1);

    // Close the FIFO
    close(fd);

    return 0;
}

IPC pipe

@login

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUFFER_SIZE 100

int main() {
    int fd[2]; // File descriptors for the pipe
    pid_t pid;
    char write_msg[BUFFER_SIZE] = "Hello from parent process!";
    char read_msg[BUFFER_SIZE];

    // Create the pipe
    if (pipe(fd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // Fork a child process
    pid = fork();

    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid > 0) { // Parent process
        close(fd[0]); // Close the read end of the pipe

        // Write to the pipe
        write(fd[1], write_msg, strlen(write_msg) + 1);

        close(fd[1]); // Close the write end of the pipe
    } else { // Child process
        close(fd[1]); // Close the write end of the pipe

        // Read from the pipe
        read(fd[0], read_msg, BUFFER_SIZE);

        printf("Child process received message: %s\n", read_msg);

        close(fd[0]); // Close the read end of the pipe
    }

    return 0;
}

IPC pipe

@login

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define BUFFER_SIZE 100

int main() {
    int fd[2]; // File descriptors for the pipe
    pid_t pid;
    char write_msg[BUFFER_SIZE] = "Hello from parent process!";
    char read_msg[BUFFER_SIZE];

    // Create the pipe
    if (pipe(fd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // Fork a child process
    pid = fork();

    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid > 0) { // Parent process
        close(fd[0]); // Close the read end of the pipe

        // Write to the pipe
        write(fd[1], write_msg, strlen(write_msg) + 1);

        close(fd[1]); // Close the write end of the pipe
    } else { // Child process
        close(fd[1]); // Close the write end of the pipe

        // Read from the pipe
        read(fd[0], read_msg, BUFFER_SIZE);

        printf("Child process received message: %s\n", read_msg);

        close(fd[0]); // Close the read end of the pipe
    }

    return 0;
}

game

@custard

1import pygame
2import random
3
4# Initialize Pygame
5pygame.init()
6
7# Set up the game window
8screen_width = 800
9screen_height = 600
10screen = pygame.display.set_mode((screen_width, screen_height))
11
12# Set up the title of the game
13pygame.display.set_caption("Football Frenzy")
14
15# Define some colors
16WHITE = (255, 255, 255)
17BLACK = (0, 0, 0)
18
19# Define the player class
20class Player(pygame.sprite.Sprite):
21    def __init__(self, name, position, speed):
22        super().__init__()
23        self.name = name
24        self.position = position
25        self.speed = speed
26        self.image = pygame.Surface((20, 20))
27        self.image.fill(WHITE)
28        self.rect = self.image.get_rect()
29        self.rect.center = position
30
31    def move(self, direction):
32        if direction == "up":
33            self.rect.y -= self.speed
34        elif direction == "down":
35            self.rect.y += self.speed
36        elif direction == "left":
37            self.rect.x -= self.speed
38        elif direction == "right":
39            self.rect.x += self.speed
40
41# Define the ball class
42class Ball(pygame.sprite.Sprite):
43    def __init__(self):
44        super().__init__()
45        self.image = pygame.Surface((10, 10))
46        self.image.fill(WHITE)
47        self.rect = self.image.get_rect()
48        self.rect.center = (screen_width / 2, screen_height / 2)
49        self.speed_x = random.choice([-5, 5])
50        self.speed_y = random.choice([-5, 5])
51
52    def move(self):
53        self.rect.x += self.speed_x
54        self.rect.y += self.speed_y
55
56        if self.rect.left < 0 or self.rect.right > screen_width:
57            self.speed_x *= -1
58        if self.rect.top < 0 or self.rect.bottom > screen_height:
59            self.speed_y *= -1
60
61# Create the players
62players = []
63for i in range(11):
64    name = f"Player {i+1}"
65    position = (random.randint(0, screen_width), random.randint(0, screen_height))
66    speed = 5
67    player = Player(name, position, speed)
68    players.append(player)
69
70# Create the ball
71ball = Ball()
72
73# Create the game loop
74while True:
75    # Handle events
76    for event in pygame.event.get():
77        if event.type == pygame.QUIT:
78            pygame.quit()
79            sys.exit()
80
81    # Move the players
82    for player in players:
83        keys = pygame.key.get_pressed()
84        if keys[pygame.K_UP]:
85            player.move("up")
86        if keys[pygame.K_DOWN]:
87            player.move("down")
88        if keys[pygame.K_LEFT]:
89            player.move("left")
90        if keys[pygame.K_RIGHT]:
91            player.move("right")
92
93    # Move the ball
94    ball.move()
95
96    # Draw everything
97    screen.fill(BLACK)
98    for player in players:
99        screen.blit(player.image, player.rect)
100    screen.blit(ball.image, ball.rect)
101
102    # Update the screen
103    pygame.display.flip()
104    pygame.time.Clock().tick(60)

wireguard-apple - iOS and macOS apps for WireGuard

@curtisbarry

$ git clone https://git.zx2c4.com/wireguard-apple
$ cd wireguard-apple

wireguard-apple - iOS and macOS apps for WireGuard

@curtisbarry

$ open WireGuard.xcodeproj

Privacy Policy · Tailscale

@curtisbarry

By phone: +1 (415) 886-9844

Privacy Policy · Tailscale

@curtisbarry

The California “Shine the Light” law gives residents of California the right under certain circumstances to request information from us regarding the manner in which we disclose certain categories of personal information (as defined in the Shine the Light law) with third parties for their direct marketing purposes. We do not disclose your personal information with third parties for their own direct marketing purposes.

WireGuard: fast, modern, secure VPN tunnel

@curtisbarry

[Interface]
PrivateKey = gI6EdUSYvn8ugXOt8QQD6Yc+JyiZxIhp3GInSWRfWGE=
ListenPort = 21841

[Peer]
PublicKey = HIgo9xNzJMWLKASShiTqIybxZ0U3wGLiUeJ1PKf8ykw=
Endpoint = 192.95.5.69:51820
AllowedIPs = 0.0.0.0/0

WireGuard: fast, modern, secure VPN tunnel

@curtisbarry

[Interface]
PrivateKey = yAnz5TF+lXXJte14tji3zlMNq+hd2rYUIgJBgB3fBmk=
ListenPort = 51820

[Peer]
PublicKey = xTIBA5rboUvnH4htodjb6e697QjLERt1NAB4mZqp8Dg=
AllowedIPs = 10.192.122.3/32, 10.192.124.1/24

[Peer]
PublicKey = TrMvSoP4jYQlY6RIzBgbssQqY3vxI2Pi+y71lOWWXX0=
AllowedIPs = 10.192.122.4/32, 192.168.0.0/16

[Peer]
PublicKey = gN65BkIKy1eCE9pP1wdc8ROUtkHLF2PfAqYdyYBz6EA=
AllowedIPs = 10.10.10.230/32

hicstuff command line interface demo — hicstuff 3.2.1 documentation

@jkirangw

hicstuff pipeline --genome genome.fa \
                  --outdir results \
                  forward.fq \
                  reverse.fq

lexema

@gabriellesoares

%{
#include <stdio.h>
%}

/* Definições de padrões */
letra      [a-zA-Z]
dígito     [0-9]
número     {dígito}+
identificador   {letra}({letra}|{dígito})*
operador   (\+|\-|\*|\/|\=|\<|\>|\!\=|\=\=|\>\=|\<\=)
palavra_reservada   (if|else|while|for|return|int|float|void|char)
pontuação  [\(\)\{\}\[\]\;\,\.]
comentário /\*([^*]|\*+[^*/])*\*+/

%%

{número}            { printf("Número: %s\n", yytext); }
{identificador}     { printf("Identificador: %s\n", yytext); }
{operador}          { printf("Operador: %s\n", yytext); }
{palavra_reservada} { printf("Palavra Reservada: %s\n", yytext); }
{pontuação}         { printf("Pontuação: %s\n", yytext); }
{comentário}        { /* Ignorar comentários */ }

[ \t\n]+            { /* Ignorar espaços em branco */ }
.                   { printf("Caractere não reconhecido: %s\n", yytext); }

%%

int main(int argc, char **argv) {
    yylex();
    return 0;
}

int yywrap() {
    return 1;
}

Add-Ons :: DigitalOcean Documentation

@curtisbarry

 Glossary
 App Platform61
 Backups2
 Container Registry8
 Custom Images7
 Paperspace Deployments31
 DNS20
 Droplets26
 Firewalls8
 Functions9
 IPv68
 Kubernetes30
 Load Balancers20
 Paperspace Machines44
 Marketplace12
 MongoDB18
 Monitoring13
 MySQL28
 Paperspace Notebooks40
 PostgreSQL28
 Projects3
 Redis25
 Reserved IPs5
 Snapshots1
 Spaces18
 Uptime8
 Volumes7
 VPC7

Download · Tailscale

@curtisbarry

tailscale ip -4

Download · Tailscale

@curtisbarry

sudo tailscale up

Download · Tailscale

@curtisbarry

curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/focal.noarmor.gpg | sudo tee /usr/share/keyrings/tailscale-archive-keyring.gpg >/dev/null
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/focal.tailscale-keyring.list | sudo tee /etc/apt/sources.list.d/tailscale.list

Download · Tailscale

@curtisbarry

sudo apt-get update
sudo apt-get install tailscale

scripts/installer.sh: remove unnecessary escaping in grep (#11950) · tailscale/tailscale@13e1355

@curtisbarry

Cleaning up orphan processes

#java

Refer Demo

@chatgpt

interface Refer{
    String m(String s);
}

class StringOperation{
    public String reverse(String s){
        String r = "";
        for(int i = s.length()-1;i>=0;i--)
            r+=s.charAt(i);
        return r;
    }
}

public class ReferDemo{
    public static String m(Refer r, String s){
        return r.m(s);
    }
    
    public static void main(String[] args){
        String s = "hello";
        System.out.println(m((new StringOperation()::reverse), s));
    }
}

#java

AVL trees

@chatgpt

import java.util.Scanner;

public class AVLTree<T extends Comparable<T>> {
    class Node {
        T value;
        Node left, right;
        int height = 0;
        int bf = 0;

        public Node(T ele) {
            this.value = ele;
            this.left = this.right = null;
        }
    }

    private Node root;

    public boolean contains(T ele) {
        if (ele == null) {
            return false;
        }
        return contains(root, ele);
    }
    private boolean contains(Node node, T ele) {
        if(node == null) return false;
        int cmp = ele.compareTo(node.value);
        if (cmp > 0)
            return contains(node.right, ele);
        else if (cmp < 0)
            return contains(node.left, ele);
        return true;
    }

    public boolean insert(T ele) {
        if (ele == null || contains(ele))
            return false;
        root = insert(root, ele);
        return true;
    }
    private Node insert(Node node, T ele) {
        if (node == null)
            return new Node(ele);
        int cmp = ele.compareTo(node.value);
        if (cmp < 0)
            node.left = insert(node.left, ele);
        else
            node.right = insert(node.right, ele);
        update(node);
        return balance(node);
    }

    public boolean delete(T ele) {
        if (ele == null || !contains(ele))
            return false;

        root = delete(root, ele);
        return true;
    }
    private Node delete(Node node, T ele) {
        int cmp = ele.compareTo(node.value);
        if (cmp > 0)
            node.right = delete(node.right, ele);
        else if (cmp < 0)
            node.left = delete(node.left, ele);
        else {
            if (node.right == null)
                return node.left;
            else if (node.left == null)
                return node.right;
            if (node.left.height > node.right.height) {
                T successor = findMax(node.left);
                node.value = successor;
                node.left = delete(node.left, successor);
            } else {
                T successor = findMin(node.right);
                node.value = successor;
                node.right = delete(node.right, successor);
            }
        }
        update(node);
        return balance(node);
    }

    private T findMax(Node node) {
        while (node.right != null) {
            node = node.right;
        }
        return node.value;
    }
    private T findMin(Node node) {
        while (node.left != null) {
            node = node.left;
        }
        return node.value;
    }

    private void update(Node node) {
        int leftSubTreeHeight = (node.left == null) ? -1 : node.left.height;
        int rightSubTreeHeight = (node.right == null) ? -1 : node.right.height;

        node.height = 1 + Math.max(leftSubTreeHeight, rightSubTreeHeight);
        node.bf = leftSubTreeHeight - rightSubTreeHeight;
    }

    private Node balance(Node node) {
        if (node.bf == 2) {
            if (node.left.bf >= 0) {
                return leftLeftRotation(node);
            } else {
                return leftRightRotation(node);
            }
        } else if (node.bf == -2) {
            if (node.right.bf >= 0) {
                return rightLeftRotation(node);
            } else {
                return rightRightRotation(node);
            }
        }
        return node;
    }

    private Node leftLeftRotation(Node node) {
        Node newParent = node.left;
        node.left = newParent.right;
        newParent.right = node;
        update(node);
        update(newParent);
        return newParent;
    }
    private Node rightRightRotation(Node node) {
        Node newParent = node.right;
        node.right = newParent.left;
        newParent.left = node;
        update(node);
        update(newParent);
        return newParent;
    }
    private Node leftRightRotation(Node node) {
        node.left = rightRightRotation(node.left);
        return leftLeftRotation(node);
    }
    private Node rightLeftRotation(Node node) {
        node.right = leftLeftRotation(node.right);
        return rightRightRotation(node);
    }

    public void inorder() {
        if (root == null)
            return;
        inorder(root);
        System.out.println();
    }
    private void inorder(Node node) {
        if(node == null) return;
        inorder(node.left);
        System.out.print(node.value + " ");
        inorder(node.right);
    }
    
    public void preorder() {
        if (root == null)
        return;
        preorder(root);
        System.out.println();
    }
    private void preorder(Node node) {
        if(node == null) return;
        System.out.print(node.value + " ");
        preorder(node.left);
        preorder(node.right);
    }
    
    public void postorder() {
        if (root == null)
        return;
        postorder(root);
        System.out.println();
    }
    private void postorder(Node node) {
        if(node == null) return;
        postorder(node.left);
        postorder(node.right);
        System.out.print(node.value + " ");
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        AVLTree<Integer> avl = new AVLTree<>();
        int ch;
        do {
            System.out.println("1. Insert a value");
            System.out.println("2. Delete a value");
            System.out.println("3. Display");
            System.out.println("4. Exit");
            System.out.print("Enter choice: ");
            ch = sc.nextInt();
            switch (ch) {
                case 1:
                    System.out.print("Enter value: ");
                    int ele = sc.nextInt();
                    if(!avl.insert(ele)) {
                        System.out.println("Invalid input");
                    }
                    break;
                case 2:
                    System.out.print("Enter value: ");
                    if(!avl.delete(sc.nextInt())) {
                        System.out.println("Invalid input");
                    }
                    break;
                case 3:
                    avl.preorder();
                    break;
                case 4:
                    System.exit(0);
                    break;
            
                default:
                    break;
            }
        } while(ch != 4);
        sc.close();
    }
}

#java

Priority Queue using ArrayList

@chatgpt

//PriorityQueue using ArrayList

import java.util.*;

public class PriorityQueueDemo<K extends Comparable<K>, V>{
    static class Entry<K extends Comparable<K>, V>{
        private K key;
        private V value;
        
        public Entry(K key, V value){
            this.key = key;
            this.value = value;
        }
        
        public K getKey(){
            return this.key;
        }
        
        public V getValue(){
            return this.value;
        }
        
        
    }
    
    private ArrayList<Entry<K,V>> list = new ArrayList<>();
    
    public void insert(K key, V value){
        Entry<K,V> entry = new Entry<>(key,value);
        int insertIndex = 0;
        for(int i=0;i<list.size();i++){
            if(list.get(i).getKey().compareTo(key)>0)
                break;
            insertIndex++;
        }
        list.add(insertIndex, entry);
    }
    
    public K getMinKey(){
        return list.get(0).getKey();
    }
    
    public V getMinValue(){
        return list.get(0).getValue();
    }
    
     public static void main(String[] args){
        PriorityQueueDemo<Integer, String> p = new PriorityQueueDemo<>();
        p.insert(5,"hello");
        p.insert(2,"java");
        p.insert(1, "programming");
        p.insert(3, "welcome");
        
        System.out.println("Minimum Key: "+p.getMinKey());
        System.out.println("Minimum Value: "+p.getMinValue());
    }
}

#java

Priority Queue using TreeMap

@chatgpt

//Priority Queue using TreeMap

import java.util.*;
public class PriorityQueueDemo<K, V>{
    private TreeMap<K, V> tm;
    
    public PriorityQueueDemo(){
        tm = new TreeMap();
    }
    
    public void insert(K key, V value){
        tm.put(key, value);
    }
    
    
    public K getMinKey(){
        return tm.firstEntry().getKey();
    }
    
    public V getMinValue(){
        return tm.firstEntry().getValue();
    }
    
    public static void main(String[] args){
        PriorityQueueDemo<Integer, String> p = new PriorityQueueDemo<>();
        p.insert(5,"hello");
        p.insert(2,"java");
        p.insert(1, "programming");
        p.insert(3, "welcome");
        
        System.out.println("Minimum Key: "+p.getMinKey());
        System.out.println("Minimum Value: "+p.getMinValue());
    }
}

Binary

Fonts , Styling

Hex digits return

Margin,Border,Padding

Selectors

Find Minimum Value

PR template

Pipes

Bankers (with values)

FCFS cpu scheduling

Bootstrap 5 crash course

Streams Collection

Streams Mapping

Streams Reduction

Streams Demo

Optimal

Segmentation

Paging

Lru

Fcfs page replacement

Shared memory reader

Shared memory writer

Priority scheduling

Message queue reciever

Message queue sender

WireGuard: fast, modern, secure VPN tunnel

WireGuard: fast, modern, secure VPN tunnel

FIFO reader

FIFO Writer

IPC pipe

IPC pipe

game

wireguard-apple - iOS and macOS apps for WireGuard

wireguard-apple - iOS and macOS apps for WireGuard

Privacy Policy · Tailscale

Privacy Policy · Tailscale

WireGuard: fast, modern, secure VPN tunnel

WireGuard: fast, modern, secure VPN tunnel

hicstuff command line interface demo — hicstuff 3.2.1 documentation

lexema

Add-Ons :: DigitalOcean Documentation

Download · Tailscale

Download · Tailscale

Download · Tailscale

Download · Tailscale

scripts/installer.sh: remove unnecessary escaping in grep (#11950) · tailscale/tailscale@13e1355

Refer Demo

AVL trees

Priority Queue using ArrayList

Priority Queue using TreeMap

Save snippets that work with our extensions