text stringlengths 183 150k | path stringlengths 15 112 | bucket stringclasses 4
values | source stringclasses 14
values | group stringclasses 121
values | spdx stringclasses 11
values | repo_license stringclasses 11
values | commit stringclasses 13
values | lang stringclasses 4
values | def_heavy bool 1
class | comment_ratio float64 0 1 | restricted bool 2
classes | fresh bool 1
class | n_bytes int64 183 150k | n_tokens int64 -1 -1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
/*
I walk through the grids and record the path numbers at the
same time.
By using a 2D array called paths, it will add up possible so
urce path and save the number.
Noted that:
if the destination has obstacle, we can't reach it
the first grid (paths[0][0]) always set as 1 our previous
path source i... | thealgorithms-c/leetcode/src/63.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.053 | false | false | 1,255 | -1 |
int compare(const int* i, const int* j)
{
return *i - *j;
}
// Sorting.
// Runtime: O(n*log(n))
// Space: O(n)
int maximumBags(int* capacity, int capacitySize, int* rocks, int rocksSize, int additionalRocks) {
int* capacityLeft = malloc(capacitySize * sizeof(int));
for (int i = 0; i < capacitySize; i++) {
... | thealgorithms-c/leetcode/src/2279.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.125 | false | false | 731 | -1 |
/**
* @file
* @brief File used to test the malloc_dbg, calloc_dbg and free_dbg functions.
* @details
* This file only have a main function that calls malloc, calloc and free.
* When the program exits, memory leaks must be printed.
* @author [tinouduart33](https://github.com/tinouduart33)
* @see malloc_dbg.c, mal... | thealgorithms-c/developer_tools/test_malloc_dbg.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.731 | false | false | 915 | -1 |
#include <stdio.h>
#include <stdlib.h>
int fibMonaccianSearch(int arr[], int x, int n)
{
/* Initialize fibonacci numbers */
int fibMMm2 = 0; // (m-2)'th Fibonacci No.
int fibMMm1 = 1; // (m-1)'th Fibonacci No.
int fibM = fibMMm2 + fibMMm1; // m'th Fibonacci
/* fibM is ... | thealgorithms-c/searching/fibonacci_search.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.213 | false | false | 1,957 | -1 |
/**
* 905. Sort Array By Parity
* Given an array A of non-negative integers, return an array consisting of
* all the even elements of A, followed by all the odd elements of A.
* You may return any answer array that satisfies this condition.
* Example 1:
* Input: [3,1,2,4]
* Output: [2,4,3,1]
* The outputs [4,2,... | thealgorithms-c/leetcode/src/905.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.394 | false | false | 916 | -1 |
/**
* @file jump_search.c
* @brief Implementation of [jump
* search](https://en.wikipedia.org/wiki/Jump_search) algorithm.
*/
#include <assert.h>
#include <math.h>
#include <stdio.h>
/**
* @brief Macro to return the minimum of two values
*/
#define min(X, Y) ((X) < (Y) ? (X) : (Y))
/**
* @brief Implement Jump-... | thealgorithms-c/searching/jump_search.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.359 | false | false | 1,624 | -1 |
// Sorting of array list using pancake sort
#include <stdio.h>
#include <stdlib.h>
/* Reverses the array */
void flip(int arr[], int i)
{
int temp, start = 0;
while (start < i)
{
temp = arr[start];
arr[start] = arr[i];
arr[i] = temp;
start++;
i--;
}
}
// Return... | thealgorithms-c/sorting/pancake_sort.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.224 | false | false | 1,825 | -1 |
#include <stdio.h>
#include <stdlib.h>
#define SIZE 40
// Assume max size of graph is 40 nodes
struct queue
{
int items[SIZE];
int front;
int rear;
};
// Some declarations
struct queue *createQueue();
void enqueue(struct queue *q, int);
int dequeue(struct queue *q);
void display(struct queue *q);
int isEmp... | thealgorithms-c/data_structures/graphs/bfs.c | algorithms | thealgorithms-c | thealgorithms-c/data_structures/graphs | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.133 | false | false | 4,720 | -1 |
#ifndef WORD_COUNT_H
#define WORD_COUNT_H
#define MAX_WORDS 20 // at most MAX_WORDS can be found in the test input string
#define MAX_WORD_LENGTH 50 // no individual word can exceed this length
// results structure
typedef struct word_count_word
{
char text[MAX_WORD_LENGTH];
int count;
} word_count_word_t;
... | thealgorithms-c/exercism/word_count/word_count.h | algorithms | thealgorithms-c | thealgorithms-c/exercism/word_count | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.739 | false | false | 914 | -1 |
/**
* \file
* \brief [Problem 10](https://projecteuler.net/problem=10) solution
* \author [Krishna Vedala](https://github.com/kvedala)
*/
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
/** Function to check if a number is prime */
char is_prime(unsigned long n)
{
for (unsigned long i = 2; i < sqrtl(n... | thealgorithms-c/project_euler/problem_10/sol1.c | algorithms | thealgorithms-c | thealgorithms-c/project_euler/problem_10 | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.324 | false | false | 937 | -1 |
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
int* nextLargerNodes(struct ListNode* head, int* returnSize)
{
int *output, count = 0;
struct ListNode *tmp = head, *tmp2;
for (; tmp != NULL; tmp = tmp->next, count++)
;
outpu... | thealgorithms-c/leetcode/src/1019.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.286 | false | false | 709 | -1 |
/*
Randomised quick sort implementation in C language.
In normal quick sort, pivot chosen to partition is either the first or the last
element of the array. This can take time O(n*n) to sort in the worst case. Now
in randomised quick sort, pivot is randomly chosen and then recursively sort the
left and right sub-arrays... | thealgorithms-c/sorting/random_quick_sort.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.151 | false | false | 2,491 | -1 |
//////////////////////////////////////////////////////////////////////////////////////
/// INCLUDES
#include <stdio.h>
#include <stdlib.h>
////////////////////////////////////////////////////////////////////////////////
// DATA STRUCTURES
/**
* Defining the structure of the node which contains 'data' (type : integer)... | thealgorithms-c/data_structures/queue/include.h | algorithms | thealgorithms-c | thealgorithms-c/data_structures/queue | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.5 | false | false | 671 | -1 |
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
#include <limits.h>
typedef struct
{
int *values;
int CurrentIndex;
int NumberOfNodes;
} BSTIterator;
void TraverseAndAssign(struct TreeNode *root, BSTIter... | thealgorithms-c/leetcode/src/173.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.157 | false | false | 1,722 | -1 |
int maxcmp(int a, int b) { return (a >= b) ? a : b; }
/* max subarray problem by using Kadane's Algorithm
*/
int maxProfit(int *prices, int pricesSize)
{
/* maxCur: current maximum
* maxSoFar: found maximum for subarray so far
*/
int maxCur = 0, maxSoFar = 0;
for (int i = 1; i < pricesSize; i++)... | thealgorithms-c/leetcode/src/121.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.312 | false | false | 465 | -1 |
#include <math.h>
#include <stdio.h>
int main()
{
float a, b, c, a1, a2, a3, b1, b2, b3, c1, c2, c3, d1, d2, d3, x1, x2, x3;
printf("Enter values of eq1:");
scanf("%f%f%f%f", &a1, &a2, &a3, &d1);
printf("Enter values of eq2:");
scanf("%f%f%f%f", &b1, &b2, &b3, &d2);
printf("Enter values of eq3... | thealgorithms-c/numerical_methods/gauss_seidel_method.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.08 | false | false | 778 | -1 |
int cmpval(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int *findDuplicates(int *nums, int numsSize, int *returnSize)
{
int i;
qsort(nums, numsSize, sizeof(int), cmpval);
int *retArr = malloc(numsSize * sizeof(int));
*returnSize = 0;
for (i = 0; i < numsSize - 1;)
{
i... | thealgorithms-c/leetcode/src/442.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.091 | false | false | 559 | -1 |
/**
* \file
* \brief [Problem 21](https://projecteuler.net/problem=21) solution
* \author [Krishna Vedala](https://github.com/kvedala)
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/**
* function to return the sum of proper divisors of N
*/
unsigned long sum_of_divisors(unsigned int N)
{
unsign... | thealgorithms-c/project_euler/problem_21/sol1.c | algorithms | thealgorithms-c | thealgorithms-c/project_euler/problem_21 | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.378 | false | false | 2,236 | -1 |
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
int pairSum(struct ListNode* head)
{
struct ListNode* dup = head;
int count = 0, i = 0, max = 0;
while (head != NULL)
{
count++;
head = head->next;
}
int* arr =... | thealgorithms-c/leetcode/src/2130.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.241 | false | false | 600 | -1 |
#include <math.h>
#include <stdio.h>
// Converts octal number to decimal
int convertValue(int num, int i) { return num * pow(8, i); }
long long toDecimal(int octal_value)
{
int decimal_value = 0, i = 0;
while (octal_value)
{
// Extracts right-most digit and then multiplies by 8^i
decimal_... | thealgorithms-c/conversions/octal_to_decimal.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.2 | false | false | 692 | -1 |
int hammingWeight(uint32_t n)
{
int TotalBits = 32;
int i, weight = 0;
for (i = 0; i < TotalBits; i++)
{
if (n &
(UINT32_C(1)
<< i)) // if the bit on the ith position of 32 bit input is 1,
// then proceed Further note the use of UINT32_C to
... | thealgorithms-c/leetcode/src/191.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.188 | false | false | 521 | -1 |
/**
* @file
* @brief Functions related to 3D quaternions and Euler angles.
* @author Krishna Vedala
*/
#include <stdio.h>
#ifdef __arm__ // if compiling for ARM-Cortex processors
#define LIBQUAT_ARM
#include <arm_math.h>
#else
#include <math.h>
#endif
#include <assert.h>
#include "geometry_datatypes.h"
/**
* @... | thealgorithms-c/geometry/quaternions.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.503 | false | false | 5,441 | -1 |
#include <stdbool.h>
#include <stdio.h>
#include "Graph.h"
// Return the number of vertices that v is
// connected to
int degree(Graph g, int nV, Vertex v)
{
int deg = 0;
Vertex w;
for (w = 0; w < nV; w++)
if (adjacent(g, v, w))
deg++;
return deg;
}
// If start from vertex v, decid... | thealgorithms-c/data_structures/graphs/euler.c | algorithms | thealgorithms-c | thealgorithms-c/data_structures/graphs | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.341 | false | false | 2,927 | -1 |
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void swap(int *a, int *b)
{
int t;
t = *a;
*a = *b;
*b = t;
}
int part(int a[], int l, int r, int n, int pivot, int pindex)
{
int p1 = l, p2 = r;
while (p2 > p1)
{
if (a[p1] > pivot && a[p2] < pivot)
{
swap(... | thealgorithms-c/misc/rselect.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.068 | false | false | 1,421 | -1 |
/**
* @file
* @brief Implementation of the [ZigZag
* Conversion](https://leetcode.com/problems/zigzag-conversion/) Leetcode
* problem
* @details
* A decent solution to the ZigZag conversion problem.
* Take advantage of the fact that the maximum gap between the chars is 2 times
* the depth(the number of rows).
... | thealgorithms-c/leetcode/src/6.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.311 | false | false | 3,922 | -1 |
void processTraversal(struct TreeNode *root, int *res, int *size)
{
if (!root)
return;
processTraversal(root->left, res, size);
res[*size] = root->val;
*size = *size + 1;
processTraversal(root->right, res, size);
}
int *inorderTraversal(struct TreeNode *root, int *returnSize)
{
int *res... | thealgorithms-c/leetcode/src/94.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.125 | false | false | 434 | -1 |
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode *reverse(struct ListNode *head)
{
struct ListNode *res = NULL;
while (head)
{
struct ListNode *pre_node = head;
head = head->next;
pre_node->next = ... | thealgorithms-c/leetcode/src/234.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.171 | false | false | 846 | -1 |
#include <stdio.h>
#include <stdlib.h>
#define MAX 20
#define INF 999
int mat[MAX][MAX];
int V;
int dist[MAX];
int q[MAX];
int qp = 0;
void enqueue(int v) { q[qp++] = v; }
int cf(void *a, void *b)
{
int *x = (int *)a;
int *y = (int *)b;
return *y - *x;
}
int dequeue()
{
qsort(q, qp, sizeof(int), ... | thealgorithms-c/greedy_approach/dijkstra.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.055 | false | false | 1,390 | -1 |
/**
* PID Controller
*
* The PID controller is a linear control algorithm that has three terms:
* - Proportional: A simple scaling of the error value by a gain kP
* - Integral: Integration of the error value over time, then multipled by gain
* kI
* - Derivative: Rate of change of the error value over time, mu... | thealgorithms-c/misc/pid.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.513 | false | false | 2,927 | -1 |
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode *middleNode(struct ListNode *head)
{
struct ListNode *fast, *slow;
fast = slow = head;
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next... | thealgorithms-c/leetcode/src/876.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.389 | false | false | 353 | -1 |
/*
* Iterative approach
*/
struct ListNode *mergeTwoLists(struct ListNode *l1, struct ListNode *l2)
{
struct ListNode *list = NULL;
struct ListNode *tmp = NULL;
if (!l1)
return l2;
if (!l2)
return l1;
if (l1 && l2)
{
if (l1->val < l2->val)
{
list =... | thealgorithms-c/leetcode/src/21.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.092 | false | false | 1,268 | -1 |
#include <stdio.h>
#include <stdlib.h>
/*Displays the array, passed to this method*/
void display(int arr[], int n)
{
int i;
for (i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
/*Swap function to swap two values*/
void swap(int *first, int *second)
{
int temp = *first;
... | thealgorithms-c/sorting/quick_sort.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.173 | false | false | 2,312 | -1 |
// Prefix sum.
// - Calculate whole nums sum.
// - Calculate currIndex sum.
// - Compare averages
// Runtime: O(n)
// Space: O(1)
int minimumAverageDifference(int* nums, int numsSize){
long numsSum = 0;
for (int i = 0; i < numsSize; i++){
numsSum += nums[i];
}
long currSum = 0;
long mi... | thealgorithms-c/leetcode/src/2256.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.2 | false | false | 956 | -1 |
/**
* \file
* \brief [Adaptive Linear Neuron
* (ADALINE)](https://en.wikipedia.org/wiki/ADALINE) implementation
* \details
* <img
* src="https://upload.wikimedia.org/wikipedia/commons/b/be/Adaline_flow_chart.gif"
* width="200px">
* [source](https://commons.wikimedia.org/wiki/File:Adaline_flow_chart.gif)
* ADAL... | thealgorithms-c/machine_learning/adaline_learning.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.373 | false | false | 12,960 | -1 |
#define max(a,b) (((a)>(b))?(a):(b))
int compare(const int* i, const int* j)
{
return *i - *j;
}
// Sort + prefix sum + windows sliding
// Runtime: O(n*log(n))
// Space: O(n)
int maxFrequency(int* nums, int numsSize, int k){
qsort(nums, numsSize, sizeof (int), (int(*) (const void*, const void*)) compare);
... | thealgorithms-c/leetcode/src/1838.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.143 | false | false | 1,061 | -1 |
/**
* @file
* @brief Program to print the nth term of the Fibonacci series.
* @details
* Fibonacci series generally starts from 0 and 1. Every next term in
* the series is equal to the sum of the two preceding terms.
* For further info: https://en.wikipedia.org/wiki/Fibonacci_sequence
*
* @author [Luiz Carlos ... | thealgorithms-c/math/fibonacci.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.411 | false | false | 3,274 | -1 |
/**
* \file
* \brief [Problem 3](https://projecteuler.net/problem=3) solution
*
* Problem:
*
* The prime factors of 13195 are 5,7,13 and 29. What is the largest prime
* factor of a given number N? e.g. for 10, largest prime factor = 5. For 17,
* largest prime factor = 17.
*/
#include <math.h>
#include <stdio.h... | thealgorithms-c/project_euler/problem_3/sol1.c | algorithms | thealgorithms-c | thealgorithms-c/project_euler/problem_3 | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.184 | false | false | 1,559 | -1 |
/**
* @file
* @brief [Insertion sort](https://en.wikipedia.org/wiki/Insertion_sort)
* algorithm implementation.
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/**
* @addtogroup sorting Sorting algorithms
* @{
*/
/**
* Insertion sort algorithm implements using Recursion
* @par... | thealgorithms-c/sorting/insertion_sort_recursive.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.439 | false | false | 1,452 | -1 |
/**
* \file
*
* \brief Implementation of [Collatz'
* conjecture](https://en.wikipedia.org/wiki/Collatz_conjecture)
*
* Collatz conjecture: a series for a number \f$n\f$ in which if \f$n\f$ even
* then the next number is \f$\frac{n}{2}\f$ ,but if n is odd then the next
* number is \f$3n+1\f$. This series continu... | thealgorithms-c/math/collatz.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.361 | false | false | 1,097 | -1 |
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* deleteMiddle(struct ListNode* head)
{
if (head == NULL || head->next == NULL)
return NULL;
struct ListNode *fast, *slow, *prev;
int n = 0;
fast = head;
slo... | thealgorithms-c/leetcode/src/2095.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.189 | false | false | 775 | -1 |
/*****Decimal to Hexadecimal conversion*******************/
#include <stdio.h>
void decimal2Hexadecimal(long num);
int main()
{
long decimalnum;
printf("Enter decimal number: ");
scanf("%ld", &decimalnum);
decimal2Hexadecimal(decimalnum);
return 0;
}
/********function for convert decimal number... | thealgorithms-c/conversions/decimal_to_hexa.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.139 | false | false | 925 | -1 |
/**
* \file
* \authors [Krishna Vedala](https://github.com/kvedala)
* \brief Solve a multivariable first order [ordinary differential equation
* (ODEs)](https://en.wikipedia.org/wiki/Ordinary_differential_equation) using
* [semi implicit Euler
* method](https://en.wikipedia.org/wiki/Semi-implicit_Euler_method)
*... | thealgorithms-c/numerical_methods/ode_semi_implicit_euler.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.5 | false | false | 5,756 | -1 |
// Program to convert decimal number to octal (Using Reccursion)
// This program only works for integer decimals
// Created by Aromal Anil
#include <stdio.h>
int decimal_to_octal(int decimal)
{
if ((decimal < 8) && (decimal > 0))
{
return decimal;
}
else if (decimal == 0)
{
return 0... | thealgorithms-c/conversions/decimal_to_octal_recursion.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.143 | false | false | 684 | -1 |
#include <stdio.h>
#include "hash_set.h"
int main()
{
hash_set_t *set = init_hash_set();
int v1 = 10, v2 = 20, v3 = 30, v4 = 40, v5 = 50, v6 = 60, v7 = 70;
printf("Value %d was add ? %d\n", v1, add(set, &v1));
printf("Value %d was add ? %d\n", v1, add(set, &v1));
printf("contains %d ? %d\n", v1,... | thealgorithms-c/data_structures/hash_set/main.c | algorithms | thealgorithms-c | thealgorithms-c/data_structures/hash_set | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.069 | false | false | 1,372 | -1 |
bool isAnagram(char *s, char *t)
{
int n = strlen(s);
int m = strlen(t);
int cnt_s[1000], cnt_t[1000];
for (int c = 97; c < 97 + 26; c++) cnt_s[c] = cnt_t[c] = 0;
for (int i = 0; i < n; i++) cnt_s[s[i]]++;
for (int i = 0; i < m; i++) cnt_t[t[i]]++;
for (int c = 97; c < 97 + 26; c++)
... | thealgorithms-c/leetcode/src/242.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0 | false | false | 396 | -1 |
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
struct TreeNode* findKthSmallest(struct TreeNode* node, int* k){
if (node == NULL){
return NULL;
}
struct TreeNode* resultNode = findKthSmallest... | thealgorithms-c/leetcode/src/230.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.429 | false | false | 666 | -1 |
/**
* @brief Octal to binay conversion by scanning user input
* @details
* The octalTobinary function take the octal number as long
* return a long binary nuber after conversion
* @author [Vishnu P](https://github.com/vishnu0pothan)
*/
#include <math.h>
#include <stdio.h>
/**
* @brief Converet octal number to ... | thealgorithms-c/conversions/octal_to_binary.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.5 | false | false | 1,446 | -1 |
/**
* \file
* \brief [Problem 6](https://projecteuler.net/problem=6) solution
*/
#include <stdio.h>
/** Main function */
int main(void)
{
unsigned s1 = 0, s2 = 0, i;
for (i = 1; i <= 100; i++)
{
s1 += i * i;
s2 += i;
}
unsigned ans = s2 * s2 - s1;
printf("%u\n", ans);
ret... | thealgorithms-c/project_euler/problem_6/sol.c | algorithms | thealgorithms-c | thealgorithms-c/project_euler/problem_6 | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.333 | false | false | 329 | -1 |
/**
* Find longest palindrome by traversing the string and checking how
* long palindrome can be constructed from each element by going left and right.
* Checking palindromes of types '..aa..' and '..bab..'
*/
#include <stdlib.h> /// for allocating new string via malloc()
#include <string.h> /// for copying the co... | thealgorithms-c/leetcode/src/5.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.152 | false | false | 1,573 | -1 |
double powPositive(double x, int n){
if (n == 1){
return x;
}
double val = powPositive(x, n / 2);
double result = val * val;
// if n is odd
if (n & 1 > 0){
result *= x;
}
return result;
}
// Divide and conquer.
// Runtime: O(log(n))
// Space: O(1)
double myPow(dou... | thealgorithms-c/leetcode/src/50.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.226 | false | false | 765 | -1 |
/**
* @file
* \brief Library functions to compute [QR
* decomposition](https://en.wikipedia.org/wiki/QR_decomposition) of a given
* matrix.
* \author [Krishna Vedala](https://github.com/kvedala)
*/
#ifndef QR_DECOMPOSE_H
#define QR_DECOMPOSE_H
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef _OPE... | thealgorithms-c/numerical_methods/qr_decompose.h | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.543 | false | false | 5,764 | -1 |
/**
* @file k_means_clustering.c
* @brief K Means Clustering Algorithm implemented
* @details
* This file has K Means algorithm implemmented
* It prints test output in eps format
*
* Note:
* Though the code for clustering works for all the
* 2D data points and can be extended for any size vector
* by making t... | thealgorithms-c/machine_learning/k_means_clustering.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.381 | false | false | 11,431 | -1 |
int numcmp(const void *a, const void *b) { return *(int *)a - *(int *)b; }
bool containsDuplicate(int *nums, int numsSize)
{
int i;
qsort(nums, numsSize, sizeof(int), numcmp);
for (i = 0; i < numsSize - 1; i++)
{
if (nums[i] == nums[i + 1])
return 1;
}
return 0;
}
| thealgorithms-c/leetcode/src/217.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0 | false | false | 310 | -1 |
/**
* @file
* @brief Convert a positive integer to string (non-standard function)
* representation.
*/
#include <assert.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
/**
* Converts an integer value to a null-terminated string using the specified
* base and ... | thealgorithms-c/conversions/int_to_string.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.427 | false | false | 2,472 | -1 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"
void print_list(char **array)
{
int i;
for (i = 0; array[i]; i++) printf("%s", array[i]);
printf("\n");
}
int main()
{
List_T list1, list2, list3;
char **str1 = (char **)malloc(100 * sizeof(char *));
... | thealgorithms-c/data_structures/list/main.c | algorithms | thealgorithms-c | thealgorithms-c/data_structures/list | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.161 | false | false | 865 | -1 |
bool isValid(char *s)
{
int i, k = 0, len = strlen(s);
char *store = calloc(len, sizeof(char));
for (i = 0; s[i] != '\0'; i++)
{
switch (s[i])
{
case '(':
case '{':
case '[':
store[k++] = s[i];
break;
case ')':
if (k < ... | thealgorithms-c/leetcode/src/20.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0 | false | false | 678 | -1 |
/**
* @file
* @author [Carlos Rafael](https://github.com/CarlosZoft)
* @author [Herick Lima](https://github.com/hericklima22)
* @brief [naval_battle](https://en.wikipedia.org/wiki/Battleship_(game))
* implementation in C using only the stdio.h for Standard Input and Output.
* @details Naval battle is a game, to ... | thealgorithms-c/games/naval_battle.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.118 | false | false | 22,577 | -1 |
/**
* \file
* \brief [Exponential Search](https://github.com/TheAlgorithms/Algorithms-Explanation/blob/master/en/Search%20Algorithms/Exponential%20Search.md)
* \author [Alessio Farinelli](https://github.com/faridevnz)
*/
#include <assert.h> /// for assert
#include <inttypes.h> /// for int64_t, uint16_t
#incl... | thealgorithms-c/searching/exponential_search.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.563 | false | false | 4,438 | -1 |
/*
* convert from any base to decimal
*/
#include <ctype.h>
#include <stdio.h>
int main(void)
{
int base, i, j;
char number[100];
unsigned long decimal = 0;
printf("Enter the base: ");
scanf("%d", &base);
printf("Enter the number: ");
scanf("%s", &number[0]);
for (i = 0; number[i] ... | thealgorithms-c/conversions/to_decimal.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.135 | false | false | 842 | -1 |
#include <stdio.h>
#include <stdlib.h>
struct node
{
int info;
struct node *link;
};
struct node *top = NULL, *temp;
void push(struct node *);
void pop(struct node *);
void display(struct node *);
int main()
{
int x = 0, item;
printf("\t****stack using linked list****\n");
while (x != 4)
{
... | thealgorithms-c/data_structures/linked_list/stack_using_linked_lists.c | algorithms | thealgorithms-c | thealgorithms-c/data_structures/linked_list | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.038 | false | false | 1,599 | -1 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SIZE 100
struct node
{
char data;
struct node *link;
};
int c = 0; // c used as counter to check if stack is empty or not
struct node *head; // declaring head pointer globally assigned to NULL
void push(char x) ... | thealgorithms-c/data_structures/stack/parenthesis.c | algorithms | thealgorithms-c | thealgorithms-c/data_structures/stack | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.094 | false | false | 2,464 | -1 |
/**
* @file
* @brief [Matrix Chain
* Order](https://en.wikipedia.org/wiki/Matrix_chain_multiplication)
* @details
* From Wikipedia: Matrix chain multiplication (or the matrix chain ordering
* problem) is an optimization problem concerning the most efficient way to
* multiply a given sequence of matrices. The pro... | thealgorithms-c/dynamic_programming/matrix_chain_order.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.4 | false | false | 2,964 | -1 |
/**
* \file
* \brief Recoding the original atoi function in stdlib.h
* \author [Mohammed YMIK](https://github.com/medymik)W
* The function convert a string passed to an integer
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* the function take a string and return an integer... | thealgorithms-c/conversions/c_atoi_str_to_integer.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.312 | false | false | 1,927 | -1 |
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a[10], n, i, j, temp;
float mean, median;
printf("Enter no. for Random Numbers :");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
a[i] = rand() % 100;
}
printf("Random Numbers Generated are :\n");
for (i... | thealgorithms-c/numerical_methods/median.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.064 | false | false | 922 | -1 |
int findMaxConsecutiveOnes(int* nums, int numsSize){
int i=0;
int maxCount=0;
int count = 0;
while(i<numsSize){
while(i<numsSize && nums[i]!=0){
count++;
i++;
}
if(maxCount<=count){
maxCount = count;
}
... | thealgorithms-c/leetcode/src/14.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0 | false | false | 448 | -1 |
/**
* @file
* @brief [Infix to Postfix converter](https://www.includehelp.com/c/infix-to-postfix-conversion-using-stack-with-c-program.aspx) implementation
* @details
* The input infix expression is of type string upto 24 characters.
* Supported operations- '+', '-', '/', '*', '%'
* @author [Kumar Yash](https://g... | thealgorithms-c/conversions/infix_to_postfix2.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.39 | false | false | 4,456 | -1 |
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
// The list for TreeNodes.
struct ListItem {
struct TreeNode* node; // TreeNode pointer
struct ListItem* next; // Pointer to the next ListItem
};
bool findTarge... | thealgorithms-c/leetcode/src/236.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.2 | false | false | 1,990 | -1 |
#include <stdio.h>
#include <stdlib.h>
// A vertex of the graph
struct node
{
int vertex;
struct node *next;
};
// Some declarations
struct node *createNode(int v);
struct Graph
{
int numVertices;
int *visited;
struct node *
*adjLists; // we need int** to store a two dimensional array. Sim... | thealgorithms-c/data_structures/graphs/dfs.c | algorithms | thealgorithms-c | thealgorithms-c/data_structures/graphs | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.137 | false | false | 3,448 | -1 |
/**
* @addtogroup quaternions Library for 3D Vectors & Quaternions
* @{
* @file
* @brief Generic header that provides data types for 3D vectors and quaternions
* @author Krishna Vedala
*/
#ifndef __LIBQUAT_H_
#define __LIBQUAT_H_
/** Minimum recognizable value. Any value less than this is considered to be
* @f... | thealgorithms-c/geometry/geometry_datatypes.h | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.394 | false | false | 2,464 | -1 |
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
// Count one's from right. Each step from right side decrease for one for each 1's and increase from left:
// 1001*0101 -> left: 4 + 1, right: 2 + 4
// 10010*101 -> left: (4+1) + (1+1), right: (2-1) + (4-1)
// Runtime: O(n)
// Space: O... | thealgorithms-c/leetcode/src/1769.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.273 | false | false | 1,100 | -1 |
/**
* @file
* @brief This is a vector implemenation in C. A vector is an expandable array.
* @details This vector implementation in C comes with some wrapper functions that lets the user work with data without having to worrying about memory.
*/
#include <stdio.h> /// for IO operations
#include <stdlib.h> /... | thealgorithms-c/data_structures/vector.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.471 | false | false | 4,130 | -1 |
/*****Decimal to octal conversion*******************/
#include <stdio.h>
void decimal2Octal(long decimalnum);
int main()
{
long decimalnum;
printf("Enter the decimal number: ");
scanf("%ld", &decimalnum);
decimal2Octal(decimalnum);
return 0;
}
/********function for convert decimal numbers to oc... | thealgorithms-c/conversions/decimal_to_octal.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.12 | false | false | 675 | -1 |
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
// Depth-First Search
// Runtime: O(n)
// Space: O(1)
struct TreeNode* trimBST(struct TreeNode* root, int low, int high){
if (root == NULL){
return NULL;
... | thealgorithms-c/leetcode/src/669.c | algorithms | thealgorithms-c | thealgorithms-c/leetcode/src | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.44 | false | false | 614 | -1 |
#ifndef __HASH_SET__
#define __HASH_SET__
#define DEFAULT_HASH_SET_CAPACITY 1 << 10
typedef struct
{
unsigned capacity;
unsigned length;
void **values;
void **keys;
} hash_set_t;
extern hash_set_t *init_hash_set();
extern unsigned add(hash_set_t *set, void *value);
unsigned put(hash_set_t *set, lon... | thealgorithms-c/data_structures/hash_set/hash_set.h | algorithms | thealgorithms-c | thealgorithms-c/data_structures/hash_set | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.19 | false | false | 717 | -1 |
#include <stdio.h>
int main()
{
int n, sum = 0, i, num;
printf("Enter number: ");
scanf("%d", &n);
num = n;
while (n != 0)
{
i = n % 10;
sum = sum + (i * i * i);
n = n / 10;
}
if (sum == num)
{
printf("%d is an armstrong number!\n", num);
}
el... | thealgorithms-c/math/is_armstrong.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.043 | false | false | 408 | -1 |
/**
* \file
* \brief [Shell sort algorithm](https://en.wikipedia.org/wiki/Shell_sort)
* implementation.
* \author [Krishna Vedala](https://github.com/kvedala)
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/**
* @addtogroup sorting Sorting algorithms
* @{
*/
/** Helper function to print array valu... | thealgorithms-c/sorting/shell_sort2.c | algorithms | thealgorithms-c | thealgorithms-c | GPL-3.0 | GPL-3.0 | e5dad3fa8def3726ec850ca66a7f51521f8ad393 | c | false | 0.373 | false | false | 2,360 | -1 |
\begin{aosachaptertoc}{VisTrails}{s:vistrails}{Juliana Freire, David Koop, Emanuele Santos, \\ Carlos Scheidegger, Claudio Silva, and Huy T.\ Vo}{Juliana Freire, David Koop, Emanuele Santos, \\ \hspace*{0.9cm} Carlos Scheidegger, Claudio Silva, and Huy T.\ Vo}
VisTrails\footnote{\url{http://www.vistrails.org}} is an o... | aosa/src/v1/tex/en/vistrails.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.005 | false | false | 59,882 | -1 |
\begin{aosachapter}{Warp}{s:warp}{Kazu Yamamoto, Michael Snoyman, and Andreas Voellmy}
Warp is a high-performance HTTP server library written in Haskell, a
purely functional programming language. Both Yesod, a web application
framework, and \texttt{mighty}, an HTTP server, are implemented over
Warp. According to our t... | aosa/src/posa/tex/warp.tex | books | aosa | aosa/src/posa | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0 | false | false | 45,135 | -1 |
\begin{aosachapter}{Eclipse}{s:eclipse}{Kim Moir}
Implementing software modularity is a notoriously difficult task.
Interoperability with a large code base written by a diverse community
is also difficult to manage. At Eclipse, we have managed to succeed on
both counts. In June 2010, the Eclipse Foundation made availa... | aosa/src/v1/tex/en/eclipse.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.004 | false | false | 55,408 | -1 |
\begin{aosachapter}{Graphite}{s:graphite}{Chris Davis}
Graphite\footnote{\url{http://launchpad.net/graphite}} performs two
pretty simple tasks: storing numbers that change over time and
graphing them. There has been a lot of software written over the years
to do these same tasks. What makes Graphite unique is that it... | aosa/src/v1/tex/en/graphite.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0 | false | false | 31,264 | -1 |
\begin{aosachapter}{GDB}{s:gdb}{Stan Shebs}
GDB, the GNU Debugger, was among the first programs to be written for
the Free Software Foundation, and it has been a staple of free and
open source software systems ever since. Originally designed as a
plain Unix source-level debugger, it has since been expanded to a wide
... | aosa/src/v2/tex/en/gdb.tex | books | aosa | aosa/src/v2 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.004 | false | false | 43,150 | -1 |
\documentclass{book}
\usepackage[table]{xcolor}
\usepackage{booktabs}
\definecolor{TableBorder}{rgb}{0.0078,0.6824,0.7882}
\def \tablegradient {0.95}
\definecolor{TableEven}{rgb}{\tablegradient,\tablegradient,\tablegradient}
\definecolor{TableOdd}{rgb}{1,1,1}
% \rowcolors{2}{TableOdd}{TableEven}
%% PANDOC SYNTAX HIGHL... | aosa/src/500lines/tex/500L.template.tex | books | aosa | aosa/src/500lines | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.312 | false | false | 9,755 | -1 |
\begin{aosachapter}{Introduction}{s:intro}{Amy Brown and Greg Wilson}
In the introduction to Volume 1 of this series, we wrote:
\begin{quotation}
Building architecture and software architecture have a lot in common,
but there is one crucial difference. While architects study thousands
of buildings in their training ... | aosa/src/v2/tex/en/intro.tex | books | aosa | aosa/src/v2 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0 | false | false | 17,606 | -1 |
\begin{aosachapter}{The NoSQL Ecosystem}{s:nosql}{Adam Marcus}
Unlike most of the other projects in this book, NoSQL is not a tool, but
an ecosystem composed of several complimentary and competing tools.
The tools branded with the NoSQL monicker provide an alternative to
SQL-based relational database systems for stori... | aosa/src/v1/tex/en/nosql.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0 | false | false | 65,309 | -1 |
\begin{aosachapter}{Sendmail}{s:sendmail}{Eric Allman}
Most people think of electronic mail as the program that they interact
with---their mail client, technically known as a Mail User Agent
(MUA). But another important part of electronic mail is the software
that actually transfers the mail from the sender to the
re... | aosa/src/v1/tex/en/sendmail.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0 | false | false | 70,948 | -1 |
\begin{chapter}*{Colophon}
The image on the cover is a photograph of Chris Denison's \emph{48
Free Street Mural} in Portland, Maine, taken by Peter Dutton.\\
\noindent
The cover font is Junction by Caroline Hadilaksono. The text font is \TeX
Gyre Termes and the heading font is \TeX Gyre Heros, both by Bogus\l{}aw
Ja... | aosa/src/v1/tex/en/colophon.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.083 | false | false | 528 | -1 |
\begin{aosachapter}{Thousand Parsec}{s:thousandparsec}{Alan Laudicina and Aaron Mavrinac}
A vast star empire encompasses a hundred worlds, stretching a thousand
parsecs across space. Unlike some other areas of the galaxy, few
warriors live here; this is an intellectual people, with a rich
cultural and academic traditi... | aosa/src/v1/tex/en/thousandparsec.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0 | false | false | 56,596 | -1 |
\begin{aosachaptertoc}{The Hadoop Distributed File System}{s:hdfs}{Robert Chansler, Hairong Kuang, Sanjay Radia, \\ Konstantin Shvachko, and Suresh Srinivas}{Robert Chansler, Hairong Kuang, Sanjay Radia, \\ \hspace*{0.9cm} Konstantin Shvachko, and Suresh Srinivas}
The Hadoop Distributed File System (HDFS) is designed ... | aosa/src/v1/tex/en/hdfs.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0 | false | false | 43,413 | -1 |
\begin{aosachapter}{Moodle}{s:moodle}{Tim Hunt}
Moodle is a web application used in educational settings. While this chapter will
try to give an overview of all aspects of how Moodle works, it
focuses on those areas where Moodle's design is particularly
interesting:
\begin{aosaitemize}
\item The way the application ... | aosa/src/v2/tex/en/moodle.tex | books | aosa | aosa/src/v2 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.002 | false | false | 44,456 | -1 |
\begin{chapter}*{Colophon}
\noindent The cover font is Museo from the exljibris foundry, by Jos
Buivenga. The text font is \TeX Gyre Termes and the heading font is \TeX Gyre
Heros, both by Bogus\l{}aw Jackowski and Janusz M. Nowacki. The code font is
Inconsolata by Raph Levien.
The front cover photo is composed of... | aosa/src/500lines/minutiae/pdf/colophon.tex | books | aosa | aosa/src/500lines | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.067 | false | false | 751 | -1 |
\begin{aosachapter}{SocialCalc}{s:socialcalc}{Audrey Tang}
The history of spreadsheets spans more than 30 years. The first
spreadsheet program, VisiCalc, was conceived by Dan Bricklin in 1978
and shipped in 1979. The original concept was quite straightforward:
a table that spans infinitely in two dimensions, its cel... | aosa/src/v1/tex/en/socialcalc.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.032 | false | false | 37,040 | -1 |
\begin{chapter}*{Colophon}
\noindent The cover font is Museo from the exljibris foundry, by Jos
Buivenga. The text font is \TeX Gyre Termes and the heading font is \TeX Gyre
Heros, both by Bogus\l{}aw Jackowski and Janusz M. Nowacki. The code font is
Inconsolata by Raph Levien.
The front cover photo is of the form... | aosa/src/posa/tex/colophon.tex | books | aosa | aosa/src/posa | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.062 | false | false | 837 | -1 |
\begin{aosachapter}{Selenium WebDriver}{s:selenium}{Simon Stewart}
Selenium is a browser automation tool, commonly used for writing
end-to-end tests of web applications. A browser automation tool
does exactly what you would expect: automate the control of a
browser so that repetitive tasks can be automated. It sounds ... | aosa/src/v1/tex/en/selenium.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.001 | false | false | 77,016 | -1 |
\begin{aosachapter}{SnowFlock}{s:snowflock}{Roy Bryant and Andr\'e{s} Lagar-Cavilla}
Cloud computing provides an attractively affordable computing
platform. Instead of buying and configuring a physical server, with
all the associated time, effort and up front costs, users can rent
``servers'' in the cloud with a few ... | aosa/src/v1/tex/en/snowflock.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0 | false | false | 35,284 | -1 |
\addtocontents{toc}{\vspace{\baselineskip}}
\begin{aosachapter}{Mercurial}{s:mercurial}{Dirkjan Ochtman}
Mercurial is a modern distributed version control system (VCS), written
mostly in Python with bits and pieces in C for performance. In this
chapter, I will discuss some of the decisions involved in designing
Mercur... | aosa/src/v1/tex/en/mercurial.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0 | false | false | 41,338 | -1 |
\documentclass{book}
\usepackage{graphicx}
\usepackage{epstopdf}
\usepackage{url} % this package doesn't make proper clickable links, but
% \usepackage{hyperref} % this package breaks the build.
\usepackage{microtype}
\usepackage{amssymb}
\usepackage{framed} % for sidebars
\usepackage[includefoot]{geometry} % for marg... | aosa/src/v1/tex/en/aosa.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.142 | false | false | 6,128 | -1 |
\begin{aosachapter}{Processing.js}{s:pjs}{Mike Kamermans}
%% British English spellings used (en-gb)
Originally developed by Ben Fry and Casey Reas, the Processing
programming language started as an open source programming language
(based on Java) to help the electronic arts and visual design
communities learn the bas... | aosa/src/v2/tex/en/pjs.tex | books | aosa | aosa/src/v2 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.012 | false | false | 55,532 | -1 |
\begin{aosachapter}{Yesod}{s:yesod}{Michael Snoyman}
Yesod is a web framework written in the Haskell programming
language. While many popular web frameworks exploit the dynamic nature
of their host languages, Yesod exploits the static nature of Haskell
to produce safer, faster code.
Development began about two years ... | aosa/src/v2/tex/en/yesod.tex | books | aosa | aosa/src/v2 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.006 | false | false | 45,140 | -1 |
\begin{aosachapter}{Introduction}{s:intro}{Tavish Armstrong}
It's commonplace to say that
computer hardware is now so fast
that most developers don't have to worry about performance.
In fact,
Douglas Crockford declined to write a chapter for this book for that reason:
\begin{quote}
If I were to write a chapter, it w... | aosa/src/posa/tex/intro.tex | books | aosa | aosa/src/posa | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.009 | false | false | 11,152 | -1 |
\begin{aosachapter}{Audacity}{s:audacity}{James Crook}
Audacity is a popular sound recorder and audio editor. It is a
capable program while still being easy to use. The majority of users
are on Windows but the same Audacity source code compiles to run on
Linux and Mac too.
Dominic Mazzoni wrote the original version... | aosa/src/v1/tex/en/audacity.tex | books | aosa | aosa/src/v1 | CC-BY-3.0 | CC-BY-3.0 | 12308deff812eb3a4fa4e210ae5496e154961311 | doc | false | 0.003 | false | false | 39,157 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.