Site Tools


museum

C

Получаем чистую линию

#include <stdio.h>

char Gline[1000]; // Global line


int GetLine(char s[]){
/*
IN = массив с котороым будем работать. (s[])
OUT = 1 - если строчка заканчивается \n; 0 - если строчка заканчивается EOF; Так же, в массив переданный в аргементе передается строка.

=========
1) Получаем символе в цикле до получения \n или EOF. Все символы сразу передаем в масив полученый в аргументе.
2) Если \n то возвращаем 1
3) Если EOF то возвращаем 0
*/


int c; // Переменная для текущего символа
int i = 0; // Маркер для текущего места в линии

// Очищаем полученный массив
while (s[i]){
	s[i] = '\0';
	++i;
}

i = 0;
while (1){ // ( c = getchar() ) != "EOF" || c != '\n' ){
	c = getchar();
	if (c == EOF){
		return 0; // Если EOF то выходим из функции и возвращаем 0
	}
	if (c == '\n'){
		s[i] = c; // Если \n то выходим из функции записывая последний \n символ и возвращаем 1
		return 1;
	}
	s[i] = c;
	++i;
}
}

int main(){
	while (GetLine(Gline)){
		printf("%s",Gline);
	}
	return 0;
}

Смотрим HEX введенных символов

#include <stdio.h>

main()
{
	int i;
	int s;
	for (i = 0; i < 100; ++i)
	{
		s = getchar();
		printf("-> %d -> %c\n",s,s);
	}
}

Limits - Получаем лимиты на локальной машине

#include <stdio.h>
#include <limits.h>
#include <float.h>
#define BELL '\007' //Звук

int test_min_and_max(){
	char Char = 0;
	int TmpChar = -1;
	while (TmpChar < Char){
		TmpChar = Char;
		++Char;
	}
	printf("Signed char -> %d to %d\n", Char, TmpChar);

        unsigned char UChar = 0;
        unsigned char TmpUChar = -1; 
        while (TmpUChar < UChar){
                TmpUChar = UChar;
                ++UChar;
        }   
        printf("Unsigned char -> %d to %d\n", UChar, TmpUChar);


        short int SInt = 0;
	int TmpSInt = -1; 
        while (TmpSInt < SInt){
		TmpSInt = SInt;
                ++SInt;
        }   
        printf("Signed short int -> %d to %d\n", SInt, TmpSInt);

        unsigned short int USInt = 0;
        unsigned short int TmpUSInt = -1; 
        while (TmpUSInt < USInt){
                TmpUSInt = USInt;
                ++USInt;
        }   
        printf("Unsigned short int -> %d to %d\n", USInt, TmpUSInt);


	int Int = 0;
	int TmpInt = -1;
	while (TmpInt < Int){
		TmpInt = Int;
		++Int;
	}
	printf("Signed int -> %d to %d\n", Int, TmpInt);

        unsigned int UInt = 0;
        unsigned int TmpUInt = -1; 
        while (TmpUInt < UInt){
                TmpUInt = UInt;
                ++UInt;
        }   
        printf("Unsigned int -> %u to %u\n", UInt, TmpUInt);


        long int LInt = 0;
        long int TmpLInt = -1; 
        while (TmpLInt < LInt){
                TmpLInt = LInt;
                ++LInt;
        }   
        printf("Signed long int -> %ld to %ld\n", LInt, TmpLInt);

        unsigned long int ULInt = 0;
        unsigned long int TmpULInt = -1; 
        while (TmpULInt < ULInt){
                TmpULInt = ULInt;
                ++ULInt;
        }   
        printf("Unsigned long int -> %lu to %lu\n", ULInt, TmpULInt);

}

// char, short , int , long * signed and unsigned
main(){
printf("========= In limits.h\a\n");
printf("Signed char -> %d to %d\n", SCHAR_MIN, SCHAR_MAX);
printf("Unsigned char -> 0 to %d\n", UCHAR_MAX);

printf("Signed short int -> %d to %d\n", SHRT_MIN, SHRT_MAX);
printf("Unsigned short int -> 0 to %d\n", USHRT_MAX);

printf("Signed int -> %d to %d\n", INT_MIN, INT_MAX);
printf("Unsigned int -> 0 to %u\n", UINT_MAX);

printf("Signed long int -> %ld to %ld\n", LONG_MIN, LONG_MAX);
printf("Unsigned long int -> 0 to %lu\n", ULONG_MAX);

printf("==========Real \n");
test_min_and_max();
}

десятичное число в двоичное

#include <stdio.h>
void MyDec(int NumToDec)
{
int b = NumToDec;
//scanf("%d", &b);
int i;
    for (i = 31; i >= 0; i--) {
        if (b & (1 << i))
             printf("1");
        else
             printf("0");
    }
printf("\n");
}

void main()
{
int TMPTestVar;
scanf("%d", &TMPTestVar);
int TestVar = TMPTestVar;
printf("Test Var = %d int bit = ", TestVar);
MyDec(TestVar);

TestVar = TestVar & 0177;
printf("TestVar & 0177 = %d ; in bit = ", TestVar);
MyDec(TestVar);

TestVar = TMPTestVar;
TestVar = TestVar & ~0177;
printf("TestVar & ~0177 = %d ; in bit = ", TestVar);
MyDec(TestVar);

}

Аргументы командной строки

//http://bitbybit.ru/tutorial/cpp/lesson/204
#include <stdlib.h> /// для exit status
#include <unistd.h> /// для getopt
#include <stdio.h>
 
int main (int argc, char **argv)
{
  int oc; /// символ опции
  char *b_opt_arg;
  char *optstring = "ab:"; /// строка описывающая параметры,
    /// принимаюемые программой. о том что программа принимает опции a и
    /// b, двоеточие указывает на наличии аргумента у опции b так как
    /// следует за буквой b
  while ((oc = getopt (argc, argv, optstring)) != -1)
    {
      switch (oc)
        {
        case 'a' :
          printf ("установлена опция 'a'\n");
          break;
        case 'b':
          printf ("установлена опция 'b'\n");
          b_opt_arg = optarg;
          printf ("опция 'b' имеет аргумент %s\n", b_opt_arg);
          break;
        case ':':
          printf ("ошибка, получено ':'\n");
          break;
        case '?':
          printf ("ошибка, получено '?'\n");
          break;
        default :
          printf ("другая ошибка\n");
          break;
        }
    }
  return EXIT_SUCCESS;
};

Получение колличества букв и вертикальная гистограмма

#include <stdio.h>

main(){
	int c_hor = 1;
	int c_vert = 35;
	int mc_buf[c_vert];

	int chr = 0;
	int c_wSize = 0;


	// обнуляем масив
	int c_for = 0;
	for(; c_for <= c_vert; ++c_for){
		//printf("%d > %d",c_for,mc_buf[c_for]);
		mc_buf[c_for] = 0;
		//printf(" > %d\n", mc_buf[c_for]);
	}

	//получаем mc_buf = колличество слов с колличеством букв

	while((chr = getchar()) != EOF ){
		if(chr == ' ' || chr == '\n' || chr == '\t'){
			if(c_wSize > 0){
				++mc_buf[c_wSize];
			}
			c_wSize = 0;
		}else{
			++c_wSize;
		}

	}
	

/*
	mc_buf[1] = 4;
	mc_buf[5] = 8;
	mc_buf[3] = 3;
	mc_buf[10] = 15;
*/

	//Получаем с_hor(колличество горизонтальных линий)
	for(c_for = 0; c_for < c_vert; ++c_for){
		if(mc_buf[c_for] > c_hor){
			c_hor = mc_buf[c_for];
		}
	}




	int c_for2;
        printf("chars>");
        for(c_for2 = 0; c_for2 < c_vert ; ++c_for2){
                printf("%3d", c_for2);
        }
        printf("\n");
//Рисуем гистограмму
	//горизонтальные линии
	for(c_for = c_hor; c_for > 0 ; --c_for ){
		//вертикальные
		printf("%3d > ", c_for);
		for(c_for2 = 0; c_for2 < c_vert ; ++c_for2){
			if(mc_buf[c_for2] >= c_for){
				printf("  *");
			}else{
				printf("   ");
			}
		}
		printf("\n");
	}
	printf("chars>");
	for(c_for2 = 0; c_for2 < c_vert ; ++c_for2){
		printf("%3d", c_for2);
	}
	printf("\n");
}






/*
1буквк=4
5букв=8
3буквы=3

горизонтальная
вертикальная

10	1=4 X								
9
8					*				
7					*		
6					*	
5					*
4	*				*
3	*		*		*	
2	*		*		*
1	*		*		*
	1	2	3	4	5	6	7	8	9
*/

Faringate -> Celsius

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

int far_to_cels(int far);
int cels_to_far(int cels);

int main(int argc, char *argv[]){
    //Флаги
    int low = 0, uper = 100, step = 1;
    int f_far = 0, f_cels = 0, f_reverse = 0, f_debug = 0;
    int celsius, faringate;

    //Структура аргументов
    struct option longopts[] = {
        {"low", required_argument, NULL, 'l'},
        {"uper", required_argument, NULL, 'a'},
        {"step", required_argument, NULL, 's'},
        {"faringate", no_argument, NULL, 'F'},
        {"celsius", no_argument, NULL, 'C'},
        {"help", no_argument, NULL, 'h'},
        {"reverse", no_argument, NULL, 'r'},
        {"debug", no_argument, NULL, 'd'},
        {0,0,0,0}
    };

    //Получение аргументов
    char c;
    while ((c = getopt_long(argc, argv, "l:a:s:FrChd", longopts, NULL)) != -1){
        switch(c){
            case 'l':
                low = atoi(optarg);
                break;
            case 'a':
                uper = atoi(optarg);
                break;
            case 's':
                step = atoi(optarg);
            case 'F':
                if(f_far < f_cels){
                    f_far = 1;
                    f_cels = 2;
                }else{
                    f_far = 1;
                }
                break;
            case 'r':
                f_reverse = 1;
                break;
            case 'C':
                if(f_cels < f_far){
                    f_cels = 1;
                    f_far = 2;
                }else{
                    f_cels = 1;
                }
                break;
            case 'h':
                printf("\t-F or --faringate - Faringate\n\t-C or --celsius - Celsius\n\n\t-l or --low - low intager\n\t-a or --uper - uper intager\n\t-s or --step - step intager\n\t-r or --reverse - reverse\n\n\t-d or --debug - debug\n\t-h or --help - this help\n");
                return 1;
                break;
            case 'd':
                f_debug = 1;
                break;
            case ':':
                printf("case ':'\n");
                printf("=>%c\n", c);
                break;
            case '?':
                printf("case '?'\n");
                printf("=>%c\n", c);
                break;
        }
    
    }

    if(f_debug){
        printf("low = %d\nuper = %d\nstep = %d\nf_far = %d\nf_cels = %d\nf_reverse = %d\nf_debug = %d\n",low,uper,step,f_far,f_cels,f_reverse,f_debug);
    }



//l:a:s:FrChd   ->  celsius = 5 * (faringate-32) / 9   -> 



    if(f_far > f_cels){
        ( f_reverse ? (faringate = low) : (faringate = uper) );
        printf("%10s || %-10s\n","faringate","celsius");
        while(( f_reverse ? faringate <= uper : low <= faringate)){
            celsius = far_to_cels(faringate);
            printf("%10d || %-10d\n", faringate, celsius);
            ( f_reverse ? (faringate += step) : (faringate -= step));
        }
    
    }else{
        ( f_reverse ? (celsius = low) : (celsius = uper) );
        printf("%10s || %-10s\n","celsius","faringate");
        while(( f_reverse ? celsius <= uper : low <= celsius)){
            faringate = cels_to_far(celsius);
            printf("%10d || %-6d\n", celsius, faringate);
            ( f_reverse ? (celsius += step) : (celsius -= step));
        }
    }
}

int cels_to_far(int cels){
    int far = (9 * cels / 5) + 32;
    return far;
}

int far_to_cels(int far){
    int cels = 5 * (far-32) / 9;
    return cels;
}
You could leave a comment if you were logged in.
museum.txt · Last modified: 2011/12/29 19:11 (external edit)

Page Tools