SBD
BAN USER- 3 Answers github link on resume
I'm wondering whether to link to my github account on my resume/CV
- SBD February 09, 2014
It's got half a dozen historical small projects I've done over the years, some complete, others not so. The oldest stuff dates back to 1994. There's one project in progress. My followers/starred/following counts are at 0.
Would an interviewer even bother to go and look at it?
I was thinking of putting something like:
github[link] includes: X86/SPARC interpreter, Android game, Python Kivy game, irc bot| Flag | PURGE
Seems suitable for bash...
taller_input:
6 2 "A"
1 4 "B"
11 0 "C"
5 1 "D"
10 0 "E"
4 0 "F"
taller.sh:
#!/bin/bash
while read height numberTaller name
do
i=0
while [[ -n "${output[$i]}" || $numberTaller -gt 0 ]]
do
if [[ -z "${output[$i]}" ]]
then
numberTaller=$(($numberTaller-1))
fi
i=$((i+1))
done
output[$i]=$name
done < <(cat $1 | sort -n)
echo ${output[@]}
$ ./taller.sh taller_input
"F" "E" "D" "C" "B" "A"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
bool replaceWithAndCheck(char replace, char fillchar, char **grid, int posy, int posx, int sizey, int sizex)
{
if(posy<0 || posx<0 || posy>=sizey || posx>=sizex)
{
return false;
}
char *line=grid[posy];
if(line[posx]!=replace)
{
return true;
}
line[posx]=fillchar;
if(!replaceWithAndCheck(replace,fillchar,grid,posy,posx+1,sizey,sizex)) return false;
if(!replaceWithAndCheck(replace,fillchar,grid,posy,posx-1,sizey,sizex)) return false;
if(!replaceWithAndCheck(replace,fillchar,grid,posy+1,posx,sizey,sizex)) return false;
return replaceWithAndCheck(replace,fillchar,grid,posy-1,posx,sizey,sizex);
}
void enclose_grid(char **grid, int sizey, int sizex)
{
for(int y=1; y<sizey; y++)
{
for(int x=1; x<sizex; x++)
{
char *line=grid[y];
if(line[x]=='O')
{
//Found a gap
//printf("(%d,%d)\n",x,y);
char *lineprevious=grid[y-1];
if(line[x-1]=='X' && lineprevious[x]=='X')
{
//Ok, we are enclosed to the left and above
//If it had been a O then we know that there is no
//way it this spot can be enclosed, as it would already
//have been filled.
bool result = replaceWithAndCheck('O','T',grid,y,x+1,sizey,sizex);
//printf("res=%d\n",result);
//It worked, so turn the Ts to Xs
if(result)
replaceWithAndCheck('T','X',grid,y,x,sizey,sizex);
}
}
}
}
//Finally, turn all the remaining Ts back to Os
for(int y=0; y<sizey; y++)
{
for(int x=0; x<sizex; x++)
{
char *line=grid[y];
if(line[x]=='T')
{
line[x]='O';
}
}
}
return;
}
void print_grid(char **grid, int sizey, int sizex)
{
for(int y=0; y<sizey; y++)
{
printf("%s\n", grid[y]);
}
printf("\n");
}
int main(void)
{
char **grid = new char*[12]();
for(int x=0; x<12;x++)
{
grid[x] = new char[8]();
}
strcpy(grid[0],"XXXXXXOX");
strcpy(grid[1],"XXOOXXOX");
strcpy(grid[2],"OOXXXXOX");
strcpy(grid[3],"XXOOXXXX");
strcpy(grid[4],"XXOXXXOO");
strcpy(grid[5],"XXXOOOXX");
strcpy(grid[6],"XXXXXOXX");
strcpy(grid[7],"XOOOXOXX");
strcpy(grid[8],"XXXXXOXX");
strcpy(grid[9],"XXOOOOXX");
strcpy(grid[10],"XXXXXXXX");
strcpy(grid[11],"XXXOXXXX");
print_grid(grid,12,8);
enclose_grid(grid,12,8);
print_grid(grid,12,8);
}
In C++, with optimisation for inserting when the next item is less than the last item inserted.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
class Node
{
public:
int item;
Node *left;
Node *right;
Node(int _item)
{
item=_item;
left = NULL;
right = NULL;
}
//Returns the node that was inserted.
//under some uses might want to add asserts to confirm is a binary tree at each itteration.
Node *insertNodeIntoBinaryTree(int value)
{
Node *currentNode = this;
while(1)
{
if(value<currentNode->item)
{
if(currentNode->left==NULL)
{
currentNode->left = new Node(value);
return currentNode->left;
}
currentNode=currentNode->left;
}
else if(value>currentNode->item)
{
if(currentNode->right==NULL)
{
currentNode->right = new Node(value);
return currentNode->right;
}
currentNode=currentNode->right;
}
else
{
//Curious. In this example, we should never get here.
//But in the real world we'd want to be able to cover trying
//to add a value that already exists.
//But unlike the returns above, this node might NOT be a leaf node.
//In other uses for this function, we might want to indicate this
//happened somehow.
return currentNode;
}
}
}
//Dumps in preorder. Not the best way to validate our tree, but it'll do
void dump()
{
printf("%d\n",item);
if(left!=NULL) left->dump();
if(right!=NULL) right->dump();
}
};
Node *createBinaryTreeFromPreOrderTraversal(int *values, int size)
{
if(size==0) return 0;
assert(values!=NULL);
Node *root = new Node(values[0]);
Node *currentNode = root;
for(int valueIndex=1; valueIndex<size; valueIndex++)
{
if(values[valueIndex]<currentNode->item)
{
//Can add to the left of current node (which we know to be a leaf)
currentNode->left=new Node(values[valueIndex]);
currentNode=currentNode->left;
}
else
{
//otherwise parse from the top of the tree
//An way would be for each node to hold the parent node.
//This way we could parse backwards from current node
//However, that's much more complicated and probably not any quicker
assert(values[valueIndex]!=currentNode->item);
currentNode=root->insertNodeIntoBinaryTree(values[valueIndex]);
}
}
return root;
}
int main(void)
{
int values[] = { 8,3,1,6,4,7,10,14,13 };
Node *root=createBinaryTreeFromPreOrderTraversal(values,9);
root->dump();
return 0;
}
Or, python version that destroys the input list...
#!/usr/bin/python
class Interval(object):
def __init__(self,lower,upper):
self.lower=lower
self.upper=upper
def __str__(self):
return ("[{0}, {1}]".format(self.lower,self.upper))
def __repr__(self):
return(self.__str__())
def merge(self,other):
if other.lower > self.upper:
return False
elif other.upper <= self.upper:
return True
else:
self.upper=other.upper
return True
def mergeIntervals(left, right):
if left==[] and right==[]:
return []
elif left==[]:
return right
elif right==[]:
return left
ret=[]
if left[0].lower<right[0].lower:
ret.append(left.pop(0))
else:
ret.append(right.pop(0))
while left!=[] or right!=[]:
if right==[] or (left!=[] and left[0].lower<right[0].lower):
item=left.pop(0)
else:
item=right.pop(0)
if False == ret[-1].merge(item):
ret.append(item)
return ret
left = [ Interval(1,2),Interval(3,4),Interval(5,6),Interval(7,8),Interval(9,10) ]
right = [ Interval(4,7),Interval(9,12),Interval(13,14) ]
print left
print right
print mergeIntervals(left,right)
print
left2 = [ Interval(0,1),Interval(111,222) ]
right2 = [ Interval(1,2),Interval(3,4),Interval(9,14) ]
print left2
print right2
print mergeIntervals(left2,right2)
Standard C version that preserves the input list. I'm not keen on the realloc call, but it seemed easist to malloc the max size, then reduce at the end.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
struct Interval
{
int lower;
int upper;
};
void print_intervals(Interval* intervals, int size)
{
printf("Intervals: ");
for(int i=0; i<size; i++)
{
printf("{%d,%d} ",intervals[i].lower,intervals[i].upper);
}
printf("\n");
}
bool mergeSingleInterval(Interval* dest, Interval* next)
{
if(dest->upper>=next->lower)
{
if(dest->upper<next->upper)
{
dest->upper=next->upper;
}
return false;
}
else
{
//Ugly
dest[1].lower=next->lower;
dest[1].upper=next->upper;
return true;
}
}
Interval *merge_intervals(Interval* left, int leftSize, Interval* right, int rightSize, int *retSize)
{
*retSize=0;
//Check for both empty
if(leftSize==0 && rightSize==0)
{
return NULL;
}
//Get max memory we'll require.
Interval *ret = (Interval*)malloc(sizeof(Interval)*(leftSize+rightSize));
//One side empty, then return it
if(leftSize==0)
{
memcpy(ret,right,rightSize*sizeof(Interval));
*retSize=rightSize;
return ret;
}
else if (rightSize==0)
{
memcpy(ret,left,leftSize*sizeof(Interval));
*retSize=leftSize;
return ret;
}
int leftIndex=0;
int rightIndex=0;
int retIndex=0;
//Setup the first entry
if (left[leftIndex].lower<right[rightIndex].lower)
{
ret[retIndex].lower=left[leftIndex].lower;
ret[retIndex].upper=left[leftIndex].upper;
leftIndex++;
}
else
{
ret[retIndex].lower=right[rightIndex].lower;
ret[retIndex].upper=right[rightIndex].upper;
rightIndex++;
}
//merge the rest, earliest first
while(leftIndex<leftSize || rightIndex<rightSize)
{
//print_intervals(ret,retIndex+1);
if((leftIndex<leftSize && left[leftIndex].lower<right[rightIndex].lower)
|| rightIndex>=rightSize)
{
//printf("left\n");
//print_intervals(&left[rightIndex],1);
if(mergeSingleInterval(&ret[retIndex],&left[leftIndex]))
{
retIndex++;
}
leftIndex++;
}
else
{
//printf("right:");
//print_intervals(&right[rightIndex],1);
if(mergeSingleInterval(&ret[retIndex],&right[rightIndex]))
{
retIndex++;
}
rightIndex++;
}
}
*retSize=retIndex+1;
return (Interval*)realloc(ret, sizeof(Interval)*(*retSize));
}
int main(void)
{
Interval left[5] = { {1,2}, {3,4}, {5,6}, {7,8}, {9,10} };
Interval right[3] = { {4,7}, {9,12}, {13,14} };
Interval left2[2] = { {0,1}, {111,222} };
Interval right2[3] = { {1,2}, {3,4}, {9,14} };
int size;
Interval *merged = merge_intervals(left,5,right,3,&size);
print_intervals(merged,size);
free(merged);
merged = merge_intervals(right,3,left,5,&size);
print_intervals(merged,size);
free(merged);
merged = merge_intervals(left2,2,right,3,&size);
print_intervals(merged,size);
free(merged);
merged = merge_intervals(left2,2,right2,3,&size);
print_intervals(merged,size);
free(merged);
}
Well don't post it in the interview questions section then!
- SBD March 17, 2014