int testMAC()
{
prnlog("[+] Testing MAC calculation...");
//From the "dismantling.IClass" paper:
uint8_t cc_nr[] = {0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0,0,0,0};
//From the paper
uint8_t div_key[8] = {0xE0,0x33,0xCA,0x41,0x9A,0xEE,0x43,0xF9};
uint8_t correct_MAC[4] = {0x1d,0x49,0xC9,0xDA};
uint8_t calculated_mac[4] = {0};
doMAC(cc_nr,div_key, calculated_mac);
if(memcmp(calculated_mac, correct_MAC,4) == 0)
{
prnlog("[+] MAC calculation OK!");
}else
{
prnlog("[+] FAILED: MAC calculation failed:");
printarr(" Calculated_MAC", calculated_mac, 4);
printarr(" Correct_MAC ", correct_MAC, 4);
return 1;
}
return 0;
}
int main () {
int arr1[] = {1, 4, 6, 8, 10, 14};
int arr2[] = {5, 7, 9, 0, 0, 0, 0, 0, 0};
printarr (arr1, 6);
printarr (arr2, 3);
merge (arr1, arr2, 6, 3);
printarr (arr2, 9);
return 0;
}
int main(int argc, char **argv)
{
if(argc!=3)
die("Usage: ./sort <items> <processes>\n");
//initialize properties
ARRLEN=atoi(argv[1]);
CHILDCOUNT=atoi(argv[2]);
ARRSIZE = ARRLEN*sizeof(int);
INTERVAL = ARRLEN/CHILDCOUNT;
// if ARRLEN%CHILDCOUNT=0 then INTERVAL is accurate
// else last child will take care of the remainders
// if ARRLEN<CHILDCOUNT then Last child to sort'em all
//randomize, prepare shared array of elements
srand((unsigned)time(NULL));
int* numbers = preparememory();
//array for PID of all child processes (unnecessary right now)
int pids[CHILDCOUNT];
//print array (if small), fork() for glory and sort intervals like a boss
printarr(numbers, 0, ARRLEN);
for(int i=0; i<CHILDCOUNT; i++)
{
int forkresult=fork();
if(forkresult==0) //child
{
bubblesort(numbers, i);
exit(0);
}
else //parent
{
pids[i]=forkresult;
}
}
//kill all the zombies
int status=0;
for(int i=0;i<CHILDCOUNT; i++)
wait(&status);
//waitpid(-1, &status, 0); //like wait()
//waitpid(pids[i], &status, 0); //wait for specific PID
//merge semi-sorted intervals
mergeparts(numbers);
//print array (if small)
printarr(numbers, 0, ARRLEN);
//destroy shared array
unleashmemory(numbers);
return 0;
}
int main () {
int arr[] = {12, 11, 13, 5, 6, 7};
int n = sizeof(arr)/sizeof(arr[0]);
printf("before:\t");
printarr(arr, n);
heapsort(arr, n);
printf("after:\t");
printarr(arr, n);
return 0;
}
int main (void) {
int arr[SIZE][SIZE];
srand (time(NULL));
int i, j;
i = 0;
while (i < SIZE) {
j = 0;
while (j < SIZE) {
arr[i][j] = rand() % 25;
j++;
}
i++;
}
printarr (arr);
// Start DP magic?
// i have no idea what i'm doing but it works
printf ("Maximal sum is %d\n", DP (arr, 0, SIZE-1));
printdir (dir);
return EXIT_SUCCESS;
}
int main(void)
{
int v[] = {0,9,8,7,6,5,4,3,2,1,10};
shellsort(v, NELEMS(v));
printarr(v, NELEMS(v));
return 0;
}
void main() {
int i;
__m128i v1, v2;
char a1[16], a2[16];
// packing data
v1 = _mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
v2 = _mm_set_epi32(0x0f0e0d0c, 0x0b0a0908, 0x07060504, 0x03020100);
// load data
_mm_storeu_si128((__m128i*)a1, v1);
_mm_storeu_si128((__m128i*)a2, v2);
printarr(a1, "a1");
printarr(a2, "a2");
}
main()
{ //clrscr();
int i,s;
printf("\nEnter the number of numbers to be entered : ");
scanf("%d",&s);
for(i=0;i<s;i++)
{
printf("\nEnter the number : " );
scanf("%d",&A[i]);
}
printf("\nArray before sorting : \n");
printarr(s);
quicksort(A,0,s-1);
printf("\nArray after sorting : \n");
printarr(s);
getch();
}
int main() {
int i = 0;
for (i=0; i<10; i++) {
int arr[10] = {5,4,3, 2,1,8, 9,7,6,0};
mergesort(arr,i+1);
printarr(arr,i+1);
}
}
int main()
{
int a[100], n = 10, i = 0, j, tmp;
readarr(a, n);
printarr(a, n);
for (i = 0; i < n; i++)
{
for (j = 0; j < (n - i - 1); j++)
{ if (a[j] > a[j + 1])
{ tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
}
}
printarr(a, n);
}
int main(int argc, char* argv[]){
int* ints = (int*) malloc((argc-1)*sizeof(int));
if(ints==NULL){
return 1; //no memory
}
int capacity=argc-1;
int n=0;
int i;
for(i=1; i<argc-1; ++i){
int ok=1;
int complete=0;
FILE* file=fopen(argv[i],"r");
if(file==NULL){
ok=0;
continue;
}
complete++;
int number=0;
int x;
while(fscanf(file,"%d", &x)!=0 && feof(file)==0){
if(n+1 <= capacity){
capacity=capacity<<1;
ints=(int*)realloc(ints, capacity*sizeof(int));
}
if(ints!=NULL){
insert(ints, n, x);
n++;
}
number++;
}
if(feof(file)==0){
ok=0;
n-=number;
}
if(complete){
fclose(file);
}
}
int ok=1;
FILE* file=fopen(argv[argc-1],"w");
if(file==NULL){
return 2;
}
if(printarr(file, ints, n)==1){
ok=0;
}
fclose(file);
free(ints);
if(ok){
return 0; //ok
}
else{
return 2; //can't print
}
}
int main()
{
int a[100][100],b[100][100],m, n, i = 0, j;
printf("Enter the rows and columns of array\n");
scanf("%d %d", &m, &n);
printf("Enter the array A \n");
readarr(a, m, n);
printarr(a, m, n);
printf("transposed array is\n");
transarr(a, m, n);
}
int main(int argc,char *argv[])
{
if(argc==1){printf("双引号\n");return 0;}
char *ps=argv[1];
int n=0;
while(ps[n]!='\0')n++;
removua(ps,n);
// n=0;
// while(ps[n]!='\0')n++;
removre(ps,n+1);
printarr(ps,n+1);
return 0;
}
void quicksort(int arr[],int start,int end)
{
if(start<end)
{
int p=partition(arr,start,end);
// quicksort(arr,start,p-1);
// printarr(arr,end);
quicksort(arr,p+1,end);
printarr(arr,end);
}
}
int main() {
int a[5][5] =
{
{1,0,0,0,1},
{0,0,1,0,0},
{0,1,0,1,0},
{0,0,1,0,0},
{1,0,0,0,1}
};
paint_bucket_fill(5,5,(int *) a, 1, 2, 2);
printarr(5,5, (int *) a);
return 0;
}
/*glut keyboard function*/
void keyboard(unsigned char key, int x, int y)
{
switch (key)
{
case 0x1B:
case'q':
case 'Q':
exit(0);
break;
case 'n':
case 'N':
create_vertex();
break;
case 'h':
case 'H':
printarr();
break;
case 'c':
case 'C':
quick_hull();
break;
case 't':
case 'T':
quickHull_Top(allPoints[findMin()],allPoints[findMax()]);
break;
case 'b':
case 'B':
quickHull_Bottom(allPoints[findMin()],allPoints[findMax()]);
break;
case 'p':
case 'P':
quick_hull_peel();
break;
case 'k':
case 'K':
display_hull();
break;
case 'r':
case 'R':
reset();
break;
}
}//keyboard
void shellsort(int* arr, int len){
int h = 1,i=0,j=0,tmp=0;
while(h<len/3) {h=3*h+1;}
while(h>=1){
printf("h:%d\n",h);
for(i = h;i<len;i++){
for(j=i;j>=h&&(arr[j]<arr[j-h]);j-=h){
// printf("arr[%d]:%d arr[%d]:%d\n",j,arr[j],j-h,arr[j-h]);
tmp=arr[j];
arr[j]=arr[j-h];
arr[j-h]=tmp;
}
printarr(arr,len);
}
h=h/3;
}
}
void mergeparts(int *numbers)
//array now contains sorted intervals, like [[6789], [1239], [2478]], merge them!
{
int pointerinc[CHILDCOUNT]={0}; //how many times has each childcount pointer moved
int counter=0; //number of elements already sorted
int sorted[ARRLEN]={0}; //new array of sorted elements
if(ARRLEN<=100)
printf("Merging array:\n");
printarr(numbers, 0, ARRLEN);
//finally merge them...
while(1)//or while(counter<=ARRLEN)
{
//find pointer with lowest value
int plowest=-1;
for(int i=0; i<CHILDCOUNT; i++)
{
if((i<CHILDCOUNT-1 && pointerinc[i]>=INTERVAL) || pointerinc[i]>=ARRLEN-(CHILDCOUNT-1)*INTERVAL)
//this interval already exhausted
continue;
if(plowest==-1 || numbers[i*INTERVAL+pointerinc[i]]<numbers[plowest*INTERVAL+pointerinc[plowest]])
//first interval in iteration? pointer to lower value than detected so far?
plowest=i;
}
if(plowest==-1) //everything in place
break;
//add the lowest element into sorted array
sorted[counter]=numbers[plowest*INTERVAL+pointerinc[plowest]];
if(sorted[counter]==0)
{
printf("ZERO! counter=%d, plowest=%d, interval=%d, pointerinc[plowest]=%d\n", counter, plowest, INTERVAL, pointerinc[plowest]);
printf("numbers[plowest*INTERVAL+pointerinc[plowest]]=%d\n", numbers[plowest*INTERVAL+pointerinc[plowest]]);
}
pointerinc[plowest]++;
counter++;
}
memcpy(numbers, sorted, ARRSIZE); //replace partially sorted array with the fully sorted one
}
void queen(int A[8][8],int row)
{
int i;
if(row==8)
{
solution++;
printf("Solution No: %d\n",solution);
printarr(A);
printf("______________\n");
return;
}
for(i=0;i<8;i++)
{
if(A[row][i]==0)
{
modify(A,row,i,1);
queen(A,row+1);
modify(A,row,i,-1);
}
}
}
void bubblesort(int* numbers, int id)
//bubblesort defined range of numbers[] (different for each child process)
{
int start=INTERVAL*id;
int end=(id==CHILDCOUNT-1)?ARRLEN:INTERVAL*(id+1);
if(start>end)
{
printf("Process %d has an incorrect interval (%d - %d) defined!\n", id, start, end);
exit(1);
}
printf("Process %d will sort items %d through %d\n", id, start+1, end);
for(int i=start; i<end-1; i++) //for every number try find maximum value and move to the top
{
for(int j=start; j<end+start-i-1; j++) //for every yet unsorted number
{
if(numbers[j+1]<numbers[j])
swap(numbers+j+1, numbers+j);
}
}
if(ARRLEN<=100) printf("\nresult %d: ", id);
printarr(numbers, start, end);
}
void qsort(int v[], int left, int right)
{
int i, last;
void swap(int v[], int i, int j);
void printarr(int v[]);
if(left >= right)
return; /* do nothing if array contains fewer than two elements. */
swap(v, left, (left + right) / 2); /* move partition elem to v[0] */
last = left;
for(i = left + 1; i <= right; i++)
{
if(v[i] < v[left])
{
swap(v, ++last, i);
}
printarr(v);
}
swap(v, left, last); /* restore partition elelm */
qsort(v, left, last - 1);
qsort(v, last + 1, right);
}
void checkroot(entry* alpha)
{ if (!isroot(alpha))
{ printarr(alpha,Ssrank(grp)); error (" is not a root.\n"); }
}
void Euler(int *arr, int n, int m) {
int W[m];
int L[n*n];
int i, c, root, length = 0, cur, first, trail = 0;
int* arrplus = (int*) malloc (sizeof(int) * n+1);
int* arrminus = (int*) malloc (sizeof(int) * n+1);
arrplus = arrpow(arr, n, true, 1);
arrminus = arrpow(arr, n, true, 2);
first = 0;
for(i=0;i<n;i++) {
if((arrplus[i]+arrminus[i])%2 != 0) {
trail++;
}
}
if(trail != 0 && trail != 2) {
printf("Nothing was found!\n");
return;
}
for(i=first;i<n;i++) {
if((arrplus[i]+arrminus[i])%2 != 0) {
first = i;
trail = 1;
//printf("%d %d\n",first, trail);
//scanf("%d", &c);
break;
}
}
if(trail)
printf("Euler trail \n");
else
printf("Euler circle \n");
bool step = 0;
for(i=0;i<m;i++) {
W[i] = 0;
}
for(i=0;i<n;i++) {
for(c=0;c<n;c++) {
L[i*n+c] = 0;
}
}
for(i=0;i<n;i++) {
for(c=0;c<n;c++) {
if(arr[i*n+c]) {
L[i*n+c] = 1;
L[c*n+i] = 1;
}
}
}
//first = 4;
cur = first;
length = 0;
W[length] = cur+1;
while(true) {
/*if(i == first && length == m-1) {
printarr(W, 1, m);
break;
} else {*/
step = 0;
for(i=0;i<n;i++) {
if(L[cur*n+i]) {
length++;
if(/*i == first &&*/ length >= m) {
printarr(W, 1, m);
return;
}
L[cur*n+i] = 0;
L[i*n+cur] = 0;
cur = i;
W[length] = cur+1;
step = 1;
//printf("%d %d %d\n", cur, length, i);
//scanf("%d", &c);
break;
}
}
if(!step) {
for(i=0;i<n;i++) {
if(arr[cur*n+i]) {
L[cur*n+i] = 1;
L[i*n+cur] = 1;
}
}
W[length] = 0;
if(length == 0 || length+1 >= m) {
if(first < n) {
for(i=0;i<m;i++) {
W[i] = 0;
}
for(i=0;i<n;i++) {
for(c=0;c<n;c++) {
L[i*n+c] = 0;
}
}
for(i=0;i<n;i++) {
for(c=0;c<n;c++) {
if(arr[i*n+c]) {
L[i*n+c] = 1;
L[c*n+i] = 1;
}
}
}
if(!trail) {
first++;
} else {
for(i=first;i<n;i++) {
if((arrplus[i]+arrminus[i])%2 != 0) {
first = i;
break;
}
}
if(i == n) {
printf("Eulerian trail not found\n");
return;
}
}
cur = first;
length = 0;
W[length] = cur+1;
}
else {
printf("Eulerian circle not found\n");
return;
}
cur = first;
} else {
length--;
cur = W[length]-1;
//}
}
}
}
}
int main()
{
char lines[108][200];
FILE *fp;
fp=fopen("problem21.input", "r");
int l;
for (l=0; l<108; l++)
{
fgets(lines[l], 200, fp);
}
fclose(fp);
for (l=0; l<108; l++)
{
printf(lines[l]);
if (lines[l][6]=='=') {
printf(">short\n");
} else {
printf(">long\n");
}
printf(">\n");
}
printf(">\n");
int i=0;
int j=0;
int size=3;
for (i=0;i<size;i++){
for(j=0;j<size;j++){
arr[i][j]=a[i][j];
}
};
//printarr(3, three);
//looking for match
/*
int l1;
int l2;
for (l2=0; l2<108; l2++)
{
for (l1=0; l1<108; l1++)
{
if (lines[l1][6]!='=' && lines[l2][6]!='=') {
parse3(lines[l1],a3, a4);
parse3(lines[l2],b3, b4);
if (match(3, a3, b3)==1 && l1>l2) {
printf("bad \n");
}
}
}
}
exit(0);
*/
int iter;
for(iter=0; iter<5;iter++){
printf("iteration: %d\n",iter+1);
printf("current size : %d\n",size);
iterate(size, arr, arr2, lines);
copy(20, arr2, arr);
if (size % 2 == 0) {
size = (size/2)*3;
}
else if (size % 3 == 0) {
size = (size/3)*4;
}
printf("new size : %d\n",size);
printf("\n");
int answer=0;
//size=3;
for (i=0;i<size;i++){
for(j=0;j<size;j++){
if(arr[i][j]=='#') {
answer=answer+1;
}
}
};
printf("current answer: %d\n\n", answer);
printarr(20,arr);
//exit(0);
};
int answer=0;
//size=3;
for (i=0;i<size;i++){
for(j=0;j<size;j++){
if(arr[i][j]=='#') {
answer=answer+1;
}
}
};
printf("arr\n");
printarr(20, arr);
printf("arr2\n");
printarr(20, arr2);
printf("answer: %d", answer);
return 0;
}
void iterate(int size, char arr[20][20], char arr2[20][20], char lines[108][200]) {
printf("size is %d \n", size);
if (size % 2 == 0) {
printf("2->3 transform \n");
int x;
int y;
for (x=0;x<size/2;x++){
for(y=0;y<size/2;y++){
printf("x, y = %d, %d\n", x,y);
//grab a 2x2 square into "two"
copyfrom(20, 2, arr, x*2, y*2, a2);
//looking for match
int l;
for (l=0; l<108; l++)
{
if (lines[l][6]=='=') {
parse2(lines[l],b2, b3);
if (match(2, a2, b2)==1) {
printf("match found \n");
copyto(3,20, b3, arr2,x*3,y*3);
break;
}
}
}
}
}
size = (size/2)*3;
}
else if (size % 3 == 0) {
printf("3->4 transform \n");
int x;
int y;
for (x=0;x<size/3;x++){
for(y=0;y<size/3;y++){
printf("x, y = %d, %d\n", x,y);
//grab a 3x3 square into "three"
copyfrom(20, 3, arr, x*3, y*3, a3);
printf("three:\n");
printarr(3, a3);
//looking for match
int l;
for (l=0; l<108; l++)
{
if (lines[l][6]!='=') {
parse3(lines[l],b3, b4);
if (match(3, a3, b3)==1) {
/*
printf("line > ");
printf(lines[l]);
printf("three2:\n");
printarr(3, b3);
printf("four2:\n");
printarr(4, b4);
printf("----\n\n");
*/
printf("match!\n");
copyto(4,20, b4, arr2,x*4,y*4);
break;
}
}
}
}
}
size = (size/3)*4;
}
return;
}
int main(){
int arr[13]={9,2,6,8,5,10,4,7,3,13,12,11,1};
printarr(arr,13);
printf("\n");
shellsort(arr,13);
}
int main()
{
char lines[108][200];
FILE *fp;
fp=fopen("problem21.input", "r");
int l;
for (l=0; l<108; l++)
{
fgets(lines[l], 200, fp);
}
fclose(fp);
for (l=0; l<108; l++)
{
printf(lines[l]);
if (lines[l][6]=='=') {
printf(">short\n");
} else {
printf(">long\n");
}
printf(">\n");
}
printf(">\n");
int i=0;
int j=0;
int size=3;
for (i=0;i<size;i++){
for(j=0;j<size;j++){
arr[i][j]=a[i][j];
}
};
printarr(3, three);
//exit(0);
int iter;
/*
for(iter=0; iter<18;iter++){
if (size % 2 == 0) {
size = (size/2)*3;
}
else if (size % 3 == 0) {
size = (size/3)*4;
}
}
printf("%d",size);
exit(0);
*/
for(iter=0; iter<18;iter++){
printf("iteration: %d\n",iter+1);
printf("current size : %d\n",size);
iterate(size, arr, arr2, lines);
copy(3000, arr2, arr);
if (size % 2 == 0) {
size = (size/2)*3;
}
else if (size % 3 == 0) {
size = (size/3)*4;
}
printf("new size : %d\n",size);
printf("\n");
int answer=0;
//size=3;
for (i=0;i<size;i++){
for(j=0;j<size;j++){
if(arr[i][j]=='#') {
answer=answer+1;
}
}
};
printf("current answer: %d\n\n", answer);
//printarr(3000,arr);
//exit(0);
};
int answer=0;
//size=3;
for (i=0;i<size;i++){
for(j=0;j<size;j++){
if(arr[i][j]=='#') {
answer=answer+1;
}
}
};
//printf("arr\n");
//printarr(3000, arr);
//printf("arr2\n");
//printarr(3000, arr2);
printf("answer: %d", answer);
return 0;
}
