c13--数组

//
//  main.c
//  进制查表法
//
//  Created by xiaomage on 15/6/10.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>
void printfBinary(int value);
void printfBinary2(int value);
void printOct(int value);
void printfHex(int value);

void printfHex2(int value);
void printfOct2(int value);
void printfBinary3(int value);

int main(int argc, const char * argv[]) {
    /*
         0000000000000000000000000000
     00000000000000000000000000000111
     */
    int num = 10;// 1010;
//    printfBinary2(num);
//    printOct(num);
//    printfHex2(num);
//    printfOct2(num);
    printfBinary3(num);
    return 0;
}

void printfBinary3(int value)
{
    // 1.定义一个数组, 用于保存二进制中所有的取值
    char charValues[] = {'0', '1'};
    // 2.定义一个数组, 用于保存查询后的结果
    char results[32] = {'0'};
    // 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
    int pos = 32;
    
    while (value != 0) {
        // 1.取出1位的值
        int res = value & 1;
        // 2.利用取出来得值到表中查询对应的结果
        char c = charValues[res];
        // 3.存储查询的结果
        results[--pos] = c;
        // 4.移除二进制被取过的1位
        value = value >> 1;
    }
    
    // 4.打印结果
    for (int i = pos; i < 32; i++) {
        printf("%c", results[i]);
    }
    printf("
");

    
}

void printfOct2(int value)
{
    // 1.定义一个数组, 用于保存八进制中所有的取值
    char charValues[] = {'0', '1', '2', '3', '4', '5', '6', '7'};
    // 2.定义一个数组, 用于保存查询后的结果
    char results[11] = {'0'};
    // 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
    int pos = 11;
    while (value != 0) {
        // 1.取出3位的值
        int res = value & 7;
        // 2.利用取出来得值到表中查询对应的结果
        char c = charValues[res];
        // 3.存储查询的结果
        results[--pos] = c;
        // 4.移除二进制被取过的三位
        value = value >> 3;
    }
    
    // 4.打印结果
    for (int i = pos; i < 11; i++) {
        printf("%c", results[i]);
    }
    printf("
");
    
}

void printfHex2(int value)
{
    // 1.定义一个数组, 用于保存十六进制中所有的取值
    // 规律: 取出的4个二进制位得到的值, 正好是数组中角标对应的值
    char charValues[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
//                    '', '', '', '', '', '', '', ''
    char results[8] = {'0'};
    int pos = 8;
    
    while (value != 0) {
        // 取出4位的值
        int res = value & 15;
        // 利用这个值作为索引去数组中查询对应的十六进制的值
        char c = charValues[res];
//        printf("%c", c);
        // 将取出来得值放到用于存储结果数组中
        results[--pos] = c;
        
        // 每取完一次就干掉它最低的4位
        value = value >> 4;
//        printf("pos = %i
", pos);
    }
    
    for (int i = pos; i < 8; i++) {
        printf("%c", results[i]);
    }
    printf("
");
}

void printfHex(int value)
{
    for (int i = 0; i <= 8; i++) {
        int res = value & 15; // 1111
        // 对十六进制进行特殊处理
        if (res > 9) {
            //  11 - 10 1 + a
            char c = res - 10 + 'a';
            printf("%c", c);
        }else
        {
            printf("%i", res);
        }
        value = value >> 4;
    }
}

void printOct(int value)
{
    for (int i = 0; i <= 11; i++) {
        int res = value & 7; // 111
        printf("%i", res);
        value = value >> 3;
    }
}

void printfBinary2(int value)
{
    for (int i = 0; i <= 32; i++) {
        int res = value & 1;
        printf("%i", res);
        value = value >> 1;
    }
    printf("
");
}

void printfBinary(int value)
{
//    int offset = sizeof(value) * 8 - 1;
    int offset = (sizeof(value) << 3) - 1;
    while (offset >= 0) {
        int res = (value >> offset) & 1;
        printf("%i", res);
        offset--;
    }
    printf("
");
}

//
//  main.c
//  进制查表法优化
//
//  Created by xiaomage on 15/6/10.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>
void total(int value, int base, int offset);
void ptintBinary(int num);
void printfOct(int num);
void printfHex(int num);

int main(int argc, const char * argv[]) {
    // insert code here...
//    ptintBinary(10);
//    printfOct(10);
    printfHex(10);
    return 0;
}

void printfHex(int num)
{
    total(num, 15, 4);
}

void printfOct(int num)
{
    total(num, 7, 3);
}

void ptintBinary(int num)
{
    total(num, 1, 1);
}

// 转换所有的进制
// value就是需要转换的数值
// base就是需要&上的数
// offset就是需要右移的位数
void total(int value, int base, int offset)
{
    // 1.定义一个数组, 用于保存十六进制中所有的取值
    char charValues[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    // 2.定义一个数组, 用于保存查询后的结果
    char results[32] = {'0'};
    // 3.定义一个变量, 用于记录当前需要存储到查询结果数组的索引
    int pos = sizeof(results)/ sizeof(results[0]);
    
    while (value != 0) {
        // 1.取出1位的值
        int res = value & base;// 1 7 15
        // 2.利用取出来得值到表中查询对应的结果
        char c = charValues[res];
        // 3.存储查询的结果
        results[--pos] = c;
        // 4.移除二进制被取过的1位
        value = value >> offset;// 1 3 4
    }
    
    // 4.打印结果
    for (int i = pos; i < 32; i++) {
        printf("%c", results[i]);
    }
    printf("
");
    
}

//
//  main.c
//  练习4
//
//  Created by xiaomage on 15/6/10.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {
    // 要求从键盘输入6个0~9的数字,排序后输出
    // 0~9999
    
    // 1.定义数组保存用户输入的数据
    int nums[10] = {0};
    // 2.接收用户的数据
    int value = -1;
    for (int i = 0; i < 6; i++) {
        printf("请输入第%i个数据
", i + 1);
        scanf("%i", &value); // 2, 2, 1, 2
        // 7, 3, 6, 1
//        nums[value] = 1;
        nums[value] = nums[value] + 1;
    }
    
    for (int i = 0; i < 10; i++) { // i == 7
//        printf("nums[%i] = %i
", i , nums[i]);
        /*
        if (nums[i] != 0) {
            printf("%i
", i); // 1, 2, 2, 2
        }
         */
        for (int j = 0; j < nums[i]; j++) { // j == 1
            printf("%i
", i); // 1, 1, 2, 3, 3, 6
        }
    }
    
    return 0;
}

//
//  main.c
//  数组的注意点
//
//  Created by xiaomage on 15/6/10.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {
    char nums[2] = {1, 5};
//    0 , 1 , 2
    char values[3] = {7, 8, 9};
    
    // 注意点: 在使用数组的时候, 一定不要访问不属于字节的存储空间, 这样会导致数据混乱
    // 有时候如果访问了不属于自己的存储空间, 程序会报错
//    values[3] = 44;
//    printf("values[3] = %i
", values[3]);
//    printf("nums[0] = %i
", nums[0]);
    
    nums[-1] = 88;
    printf("values[2] = %i
", values[2]);
    return 0;
}

//
//  main.c
//  day07
//
//  Created by xiaomage on 15/6/10.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {
    // 变量在内存中的存储
    // 由于变量的内存寻址是从大到小, 所以存储数据时会从高字节开始存储
    int num = 10; // 0000 0000 0000 0000 0000 0000 0000 1010
    
    // 注意: 数组的存储和变量有点不一样, 数组存储元素, 是从所占用的低字节开始存储
    char charValues[4] = {'l', 'u', 'c', 'k'};

    printf("charValues[0] = %p
", &charValues[0]);
    printf("charValues[1] = %p
", &charValues[1]);
    printf("charValues[2] = %p
", &charValues[2]);
    printf("charValues[3] = %p
", &charValues[3]);
     /*
     charValues[0] = 0x7fff5fbff7c8
     charValues[1] = 0x7fff5fbff7c9
     charValues[2] = 0x7fff5fbff7ca
     charValues[3] = 0x7fff5fbff7cb
     */
    
    // &charValues == &charValues[0] == charValues
    printf("&charValues = %p
", &charValues);
    // 数组名,保存的是数组的首地址,是第0个元素的地址，
    printf("charValues = %p
", charValues);
    
//    00000000 00000000 00000000 00000101
//    00000000 00000000 00000000 00000110
    int nums[2] = {5, 6};
    
    return 0;
}

//
//  main.c
//  数组练习1
//
//  Created by xiaomage on 15/6/10.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>

int main(int argc, const char * argv[]) {
    // 从键盘录入当天出售BTC的价格并计算出售的BTC的总价和平均价(比如说一天出售了3个比特币)
    
    // 1.接收数据
    
    printf("请输入第1个比特币的价格
");
    int value1 = -1;
    scanf("%i", &value1);
    
    printf("请输入第2个比特币的价格
");
    int value2 = -1;
    scanf("%i", &value2);

    printf("请输入第3个比特币的价格
");
    int value3 = -1;
    scanf("%i", &value3);
    
//    int value3 = -1;
    
    int sum = 0;
    int value = -1;
    for (int i = 0; i < 3; i++) {
        printf("请输入第3个比特币的价格
");
        scanf("%i", &value);
        sum += value;
    }
    
    
    // 1.1定义数组保存每个比特币的价格
    int values[4] = {-1};
    // 1.2动态计算数组的元素个数
    int length = sizeof(values) / sizeof(values[0]);
    // 1.3定义变量保存总和
    int sum = 0;
    for (int i = 0; i < length; i++) {
        printf("请输入第%i个比特币的价格
", i + 1);
        scanf("%i", &values[i]);
        
        sum += values[i];
    }
    
    
    // 2.计算总和
//    int sum = value1 + value2 + value3;
    int sum = 0;
    for (int i = 0; i < length; i++) {
        sum += values[i];
    }
    
    // 3.计算平局值
    int average = sum / length;
    // 4.输出结果
    printf("sum = %i, average = %i
", sum, average);
    
    return 0;
}

//
//  main.c
//  数组和函数
//
//  Created by xiaomage on 15/6/10.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>

// 基本数据类型作为函数的参数是值传递
// 如果形参是基本数据类型, 在函数中修改形参的值不会影响到实参的值
void change(int value)
{
    value = 55;
}

// 注意: 数组名作为函数的参数传递, 是传递的数组的地址
// 因为数组名就是数组的地址 &number = &number[0] == number
// 注意: 如果数组作为函数的形参, 元素的个数可以省略
// 如果形参是数组, 那么在函数中修改形参的值, 会影响到实参的值
//void change2(int values[2])
void change2(int values[])
{
    values[0] = 88;
    values[1] = 99;
}
int main(int argc, const char * argv[]) {
    /*
    int num = 10;
    change(num);
    printf("num = %i
", num);
     */
    
    int nums[2] = {1, 5};
    
    change2(nums); // 相当于传递了数组的地址
    printf("nums[1] = %i
", nums[1]);
    
    change(nums[0]);
    printf("nums[0] = %i
", nums[0]);
    return 0;
}

//
//  main.c
//  数组和函数2
//
//  Created by xiaomage on 15/6/10.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>
//void printArray(int values[5]);
void printArray(int values[5], int length);

int main(int argc, const char * argv[]) {
    // 要求定义一个函数, 实现遍历数组. (只要别人传递数组给函数, 就要求输出数组中所有元素的值)
    int nums[3] = {1 , 3 , 5};
    printf("size = %i
", sizeof(nums));
    
    int length = sizeof(nums) / sizeof(nums[0]);
    
    printArray(nums, length); // 数组名称保存的是数组的地址
    return 0;
}

// 如果传递的数组的名称, 其实传递的是地址
// 如果传递的是地址, 其实传递的是指针
// 指针在64位编译环境占8个字节

// 注意: 如果数组作为形参, 那么在函数中就不能通过数组的名称计算出数组元素的个数
// 因为系统会自动将数组形参转换为指针, 指针占用8个字节
void printArray(int values[5], int length)
{
    printf("size = %i
", sizeof(values));//8,指针类型
    
    // 1.动态计算数组的元素个数，sizeof(values)获取的是字节的大小，
    int length1 = sizeof(values) / sizeof(values[0]);//8/4=2
    // 永远只有2个
    for (int i = 0; i < length; i++) {
        printf("values[%i] = %i
", i,values[i]);
    }
}

//
//  main.c
//  数组练习2
//
//  Created by xiaomage on 15/6/10.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>

int arrayMax(int values[], int length);
int arrayMax2(int values[], int length);

int main(int argc, const char * argv[]) {
    //  设计一个函数int arrayMax(int a[], int count)找出数组元素的最大值
    int nums[5] = {-99, -188, -5, -100, -77};
    int length = sizeof(nums) / sizeof(nums[0]);
    int max1 =  arrayMax(nums, length);
    int max = arrayMax2(nums, length);
    printf("max = %i
", max);
    
    return 0;
}

int arrayMax2(int values[], int length)
{
    // 1.定义变量, 保存数组中最大值的角标(索引)
    int max = 0;
    // 2.遍历数组
    for (int i = 1; i < length; i++) {
        // 3.取出数组中对应角标的元素的值进行比较
        if (values[max] < values[i]) {
            // 如果当前遍历到的角标对应的元素的值大于max这个角标对应元素的值
            // 那么就将当前的角标最为最大值的角标
            max = i;
        }
    }
    return values[max];
}

int arrayMax(int nums[], int length)
{
    // 1.定义一个变量, 假设为最大值
//    int max = 0; // 注意: 不能假设一个不是数组中的值最为最大
    int max = nums[0];
    // 2.遍历数组
    for (int i = 1; i < length; i++) {
        // 3.依次取出数组中每一个元素的值, 和假设的最大值进行比较
        // 如果数组的元素大于假设的最大值, 就让当前元素的值作为最大值
        if (max < nums[i]) {
            max = nums[i];
        }
    }
    return max;
}