language
large_stringclasses 1
value | text
stringlengths 9
2.95M
|
|---|---|
C
|
//Name: Garen Porter
//Program name: ftserver
//Program description: Waits on a control socket and accepts incoming clients. Sends either a directory listing or file over a separate data connection.
//Data connection is closed after requested action has been completed and a new client may connect.
//Course name: CS 372 Intro to Computer Networks
//Program can be ran on any flip server
//Last modified: 3/2/2019
/*Citations:
Beej's guide was used to assist with the socket related functions: https://beej.us/guide/bgnet/html/single/bgnet.html#simpleclient
C++ reference guide was used to assist with some functions (such as sprintf and fgets): http://www.cplusplus.com/
Help with sleep functions: https://linux.die.net/man/3/sleep
Help with getting directory listing: https://stackoverflow.com/questions/4204666/how-to-list-files-in-a-directory-in-a-c-program
Help with finding file size - https://stackoverflow.com/questions/238603/how-can-i-get-a-files-size-in-c
Help with sending file - https://stackoverflow.com/questions/11952898/c-send-and-receive-file
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <dirent.h>
#include <unistd.h>
#include <fcntl.h>
//Function description: Sets up the addrinfo struct with correct socket info
//Preconditions: Valid port was inputted at command line
//Postconditions: A socket is ready to be made from returned struct addrinfo
//Cites used: https://beej.us/guide/bgnet/html/single/bgnet.html#simpleclient
struct addrinfo* initiate_structs(char *port){
//declare variables
int status;
struct addrinfo hints;
struct addrinfo* res;
// Set up the server address struct
memset(&hints, 0, sizeof(hints)); //initialize struct hints to 0
hints.ai_family = AF_INET; //set hints to use IPv4
hints.ai_socktype = SOCK_STREAM; //set hints to use TCP
hints.ai_flags = AI_PASSIVE;
//getaddrinfo sets up res with all of the socket info
status = getaddrinfo(NULL, port, &hints, &res);
//if getaddrinfo errored, exit and print the error message
if(status != 0){
perror("SERVER: ERROR initiating addrinfo structs");
exit(1);
}
return res; //return res struct, which helps set up and connect the socket
}
//Function description: Sets up addrinfo struct for the data connection using client port number and hostname
//Preconditions: Client inputed the correct arguments at command line
//Postconditions: A socket is ready to made using the returned addrinfo struct
//Cites used: https://beej.us/guide/bgnet/html/single/bgnet.html#simpleclient
struct addrinfo* initiate_structs_client(char *port, char *hostname){
//declare variables
int status;
struct addrinfo hints;
struct addrinfo* res;
// Set up the server address struct
memset(&hints, 0, sizeof(hints)); //initialize struct hints to 0
hints.ai_family = AF_INET; //set hints to use IPv4
hints.ai_socktype = SOCK_STREAM; //set hints to use TCP
//getaddrinfo sets up res with all of the socket info
status = getaddrinfo(hostname, port, &hints, &res);
//if getaddrinfo errored, exit and print the error message
if(status != 0){
perror("SERVER: ERROR initiating addrinfo structs for client");
exit(1);
}
return res; //return res struct, which helps set up and connect the socket
}
//Function description: Creates a socket using an addrinfo struct
//Preconditions: addrinfo was successfully created with correct info
//Postconditions: Socket has been successfully created and is ready to connect
//Cites used: https://beej.us/guide/bgnet/html/single/bgnet.html#simpleclient
int create_socket(struct addrinfo *res){
//declare socket file descriptor
int socketFD;
//create a TCP/IP socket
socketFD = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
//if socket creation errored, exit and print the error message
if (socketFD < 0){
perror("SERVER: ERROR opening socket");
exit(1);
}
return socketFD; //return the socket
}
//Function description: Connects to a socket
//Preconditions: Socket and addrinfo struct was successfully created
//Postconditions: Socket represented by socketFD has been successfully connected to
//Cites used: https://beej.us/guide/bgnet/html/single/bgnet.html#simpleclient
void connect_socket(struct addrinfo *res, int socketFD){
//declare status variable
int status;
// Connect to the TCP socket previously created
status = connect(socketFD, res->ai_addr, res->ai_addrlen);
//if connect errored, exit and pring the error message
if (status < 0){ // Connect socket to address
perror("SERVER: ERROR connecting");
exit(1);
}
}
//Function description: Binds a socket
//Preconditions: Socket has been successfully connected to
//Postconditions: Socket is ready to listen on
//Cites used: https://beej.us/guide/bgnet/html/single/bgnet.html#simpleclient
void bind_socket(struct addrinfo *res, int socketFD){
//declare status variable
int status;
//bind the TCP socket using an initiated addrinfo struct
status = bind(socketFD, res->ai_addr, res->ai_addrlen);
//if bind failed, exit and print an error message
if(status < 0){
close(socketFD);
perror("SERVER: ERROR binding socket");
exit(1);
}
}
//Function description: Begins listening to a socket, allowing incoming connections to be accepted
//Preconditions: Socket has been created and bound
//Postconditions: Socket is ready to receive incoming connections
//Cites used: https://beej.us/guide/bgnet/html/single/bgnet.html#simpleclient
void listen_socket(int socketFD){
//declare status variable
int status;
//begin listening to socket and accept up to 5 connections
status = listen(socketFD, 5);
//if list fails, exit and print an error message
if(status < 0){
close(socketFD);
perror("SERVER: ERROR listening");
exit(1);
}
}
//Function description: Sends the current directory to the client over the data connection
//Preconditions: Client send the -l command
//Postconditions: Client has been sent the current directory and the data connection has been closed
//Cites used:
//https://linux.die.net/man/3/sleep
//https://stackoverflow.com/questions/4204666/how-to-list-files-in-a-directory-in-a-c-program
void send_directory_listing(char *hostname, char *port){
//declare variables
struct addrinfo *res;
DIR *directory;
struct dirent *dir;
int socketFD;
//sleep for 1 second to allow time for client to setup data socket
sleep(1);
//connet to data socket
res = initiate_structs_client(port, hostname); //use client's hostname and the data port to initiate an addrinfo struct
socketFD = create_socket(res); //create the socket using the addrinfo struct created in the previous line
connect_socket(res, socketFD); //connect to the socket created in the previous line
//allocate memory to hold the various filenames in the directory
char *file = (char *)malloc(500*sizeof(char));
//open the current directory and parse through its contents
directory = opendir("./");
if(directory){
printf("Sending directory listing...\n");
while((dir = readdir(directory)) != NULL){ //while there are still directory contents to read
memset(file, '\0', sizeof(file)); //set all contents of file to NULL
strcpy(file, dir->d_name); //copy file or directory name into file
send(socketFD, file, strlen(file), 0); //send file to the client
usleep(5*1000); //sleep for 0.5 seconds, without this things get weird on the client side
}
closedir(directory); //close the directory
}
//sleep for 0.5 seconds before sending done message
usleep(5*1000);
//let client know we are done sending directory contents
char *done = "_done_!";
send(socketFD, done, strlen(done), 0);
printf("Directory listing sent.\n");
//close socket and free allocated memory
close(socketFD);
freeaddrinfo(res);
}
//Function description: Sends a file to the client over a separata data connection
//Preconditions: Client sent the -g command
//Postconditions: Client has been sent the requested file and the data connection has been closed
//Cites used:
//https://stackoverflow.com/questions/238603/how-can-i-get-a-files-size-in-c
//https://stackoverflow.com/questions/11952898/c-send-and-receive-file
int send_file(char *filename, char *hostname, char *port){
//declare variables
struct addrinfo *res;
struct stat fileStats;
int socketFD;
int file_size, fileFD;
int character;
FILE *file;
//sleep for 1 second to allow time for client to setup data socket
sleep(1);
//connet to data socket
res = initiate_structs_client(port, hostname); //use client's hostname and the data port to initiate an addrinfo struct
socketFD = create_socket(res); //create the socket using the addrinfo struct created in the previous line
connect_socket(res, socketFD); //connect to the socket created in the previous line
//open file in read-only mode and error if file fails to open
fileFD = open(filename, O_RDONLY);
if(fileFD < 0){
printf("FAILED TO OPEN file: %s\n", filename);
return -1;
}
//get the statss of the file and store it in fileStats
if(fstat(fileFD, &fileStats) < 0){
printf("FAILED fstat(): %s", filename);
return -1;
}
//get the file size from fileStats and close the file
file_size = fileStats.st_size;
close(fileFD);
//open the file in read-only mode
file = fopen(filename, "r");
//allocate enough memory to hold the contents of the file
char *fileText = (char *)malloc(file_size*sizeof(char));
memset(fileText, '\0', sizeof(fileText));
//store the contents of the file in fileText and close the file
int buffer = fread(fileText, 1, file_size, file);
fclose(file);
//flush both stdout and stdin to ensure a clean file-sending process
fflush(stdout);
fflush(stdin);
//send the file to the client
void *location = fileText;
while(buffer > 0){
int written_bytes = send(socketFD, location, strlen(location), 0); //send as many bytes as possible and record the number of bytes sent
if(written_bytes < 0){ //if the amount of bytes sent is less than 0, error and return
printf("SERVER: ERROR SENDING FILE\n");
return -1;
}
buffer -= written_bytes; //subtract the amount of sent bytes from total bytes in file being sent
location += written_bytes; //add written bytes to location so that location knows where to begin sending from next iteration
usleep(5*1000); //sleep for 0.5 seconds to give client time to perform its duties
}
//sleep for 1 second before sending done
sleep(1);
//let client know we are done sending the file
char *done = "_done_!";
send(socketFD, done, strlen(done), 0);
printf("TRANSFER COMPLETE\n");
//close socket and free allocated memory
close(socketFD);
freeaddrinfo(res);
return 0;
}
//Function description: Checks whether or not a file exists in the current directory
//Preconditions: Client has requested a file to be transferred
//Postconditions: File is determined whether or not it exists
//Cites used: //https://stackoverflow.com/questions/4204666/how-to-list-files-in-a-directory-in-a-c-program
int file_exists(char *filename){
//declare variables
DIR *directory;
struct dirent *dir;
//allocate memory to hold file and directory names
char *file_temp = (char *)malloc(500*sizeof(char));
//open the directory and compare each file or directory with the client's requested filename
directory = opendir("./");
if(directory){
while((dir = readdir(directory)) != NULL){ //while there are still directory contents to read
memset(file_temp, '\0', sizeof(file_temp)); //set each element in file_temp to NULL
strcpy(file_temp, dir->d_name); //copy directory or file into file_temp
if(strcmp(filename, file_temp) == 0){ //compare filename to file_temp, if they are the same, close directory and return true
closedir(directory);
return 1;
}
}
closedir(directory); //close the directory
}
//return false
return -1;
}
//Function description: Gets the client command line info and hostname, determines which actions to take by parsing the client's command.
//Will either send the client a directoy listing, a file, or an error.
//Preconditions: Client has successfully connected to the control socket
//Postconditions: Client has been serviced appropriately by either receiving an error, a file, or a directory listing
//Cites used:
//http://www.cplusplus.com/
//https://beej.us/guide/bgnet/html/single/bgnet.html#simpleclient
void handle_connection(int socketFD){
//declare messages that may be sent to the client
char *no_file = "SERVER: FILE NOT FOUND";
char *ready = "name?";
char *invalid = "SERVER: INVALID COMMAND";
char *good_file = "_good_!";
//declare structures to hold client arguments
char *port = (char *)malloc(500*sizeof(char));
char *hostname = (char *)malloc(500*sizeof(char));
char *command = (char *)malloc(500*sizeof(char));
char *filename = (char *)malloc(500*sizeof(char));
//recieve client port number
memset(port, '\0', sizeof(port));
recv(socketFD, port, 500, 0);
printf("\nData port: %s\n", port);
//receive client hostname
memset(hostname, '\0', sizeof(hostname));
recv(socketFD, hostname, 500, 0);
printf("Client hostname: %s\n", hostname);
//receive client command
memset(command, '\0', sizeof(command));
recv(socketFD, command, 500, 0);
printf("Command: %s\n\n", command);
//if command is -l, send directory
if(strcmp(command, "-l") == 0){
send_directory_listing(hostname, port);
}
//if command is -g, get file, check file exists, then send file
else if(strcmp(command, "-g") == 0){
//ask for filename
send(socketFD, ready, strlen(ready), 0);
//get filename
memset(filename, '\0', sizeof(filename));
recv(socketFD, filename, 500, 0);
//check if file exists
if(file_exists(filename) < 0){
printf("File does not exist!\n");
send(socketFD, no_file, strlen(no_file), 0);
return;
}
//let client know the file exists
printf("Requested file: %s\n\n", filename);
send(socketFD, good_file, strlen(good_file), 0);
//send file to client
if(send_file(filename, hostname, port) < 0){
printf("ERROR SENDING FILE\n");
return;
}
}
//else the command is invalid, so sent invlalid command error to client
else {
printf("Command invalid, closing connection with client.\n");
send(socketFD, invalid, strlen(invalid), 0);
return;
}
return;
}
//Function description: Endless loop that continuously accepts clients and handles their requests. After client is accepted, its request is handled.
//After client's request has been handled, the connection is disconnected and a new connection is waited for.
//Preconditions: Socket has been successfully setup and is listening.
//Postconditions: Client sockets have been cleaned up.
//Cites used: https://beej.us/guide/bgnet/html/single/bgnet.html#simpleclient
void accept_connections(int socketFD){
//loop until SIGINT is received
while(1){
//declare variables for new control connections
struct sockaddr_storage client_addr;
socklen_t size;
int socketFD_new;
//get size of client socket struct
size = sizeof(client_addr);
//accept the incoming connection
printf("\nWaiting for incoming connection...\n");
socketFD_new = accept(socketFD, (struct sockaddr *)&client_addr, &size);
printf("Accepted incoming connection!\n");
//if socket accept fails, wait for a new connection
if(socketFD_new < 0){
printf("Failed to accept socket\n");
continue;
}
//handle the client's request
handle_connection(socketFD_new);
//close the control connection and wait for a new connection
printf("Closing control connection with client.\n");
close(socketFD_new);
}
}
//main function sets up the main server socket (control socket) and starts the accept_connections loop.
int main(int argc, char **argv){
//declare server socket variables for control connection
struct addrinfo *res;
int socketFD;
//check for correct number of commandline arguments
if(argc != 2){
perror("INVALID ARGS: ./fserver <SERVER_PORT>\n");
freeaddrinfo(res);
exit(1);
}
printf("Server open on %s\n", argv[1]);
res = initiate_structs(argv[1]); //initiate the server's addrinfo struct
socketFD = create_socket(res); //create the server control socket
bind_socket(res, socketFD); //bind the server control socket
listen_socket(socketFD); //start listening on the socket
accept_connections(socketFD); //start the endless loop that continually services client requests
//close socket and free allocated data
close(socketFD);
freeaddrinfo(res);
return 1;
}
|
C
|
#include <config.h>
#include <tableLogic.h>
#include <core.h>
/*Função para limpar o nome do arquivo*/
void clearFileName(t_tableData *tableData)
{
for (int i = 0; i < MAX_FILENAME - 1; i++)
{
tableData->filename[i] = '\0';
}
}
/*Função para reinicializar os dados do jogo*/
void flushData(t_tableData *tableData)
{
for (int l = 0; l < TABLE_SIZE; l++)
{
for (int c = 0; c < TABLE_SIZE; c++)
{
tableData->table[l][c] = 0;
}
}
clearFileName(tableData);
tableData->score = 0;
tableData->movements = 0;
tableData->gameFinished = 0;
}
/*Função para adicionar duas peças ao tabuleiro no ínicio do jogo*/
void addInitialPieces(t_tableData *tableData)
{
addInitialPiecesToTable(tableData->table);
}
/* Verifica se já existe a peça 2048, ou se não existem mais jogadas possíveis */
int checkGameEnded(t_tableData *tableData)
{
t_tableData copyTableData = {0};
copyTable(tableData->table, copyTableData.table);
copyTableData.movements = tableData->movements;
int initialMovements = tableData->movements;
for (int l = 0; l < TABLE_SIZE; l++)
{
for (int c = 0; c < TABLE_SIZE; c++)
{
if (tableData->table[l][c] == 2048)
{
return 1;
}
}
}
playDown(©TableData, 1);
playUp(©TableData, 1);
playRight(©TableData, 1);
playLeft(©TableData, 1);
if (copyTableData.movements == initialMovements)
{
return 1;
}
return 0;
}
/* Aplica a jogada, verificando se houveram alterações */
void play(t_tableData *tableData, int fake)
{
int changed = applyDownMovement(tableData->table, &(tableData->score));
if (changed != 0)
{
tableData->movements += 1;
addPiecesToTable(tableData->table);
}
if (!fake && checkGameEnded(tableData))
tableData->gameFinished = 1;
}
/*Função para mover as peças para cima*/
void playUp(t_tableData *tableData, int fake)
{
rotateClockwise(tableData->table);
rotateClockwise(tableData->table);
play(tableData, fake);
rotateClockwise(tableData->table);
rotateClockwise(tableData->table);
}
/*Função para mover as peças para baixo*/
void playDown(t_tableData *tableData, int fake)
{
play(tableData, fake);
}
/*Função para mover as peças para esquerda*/
void playLeft(t_tableData *tableData, int fake)
{
rotateClockwise(tableData->table);
rotateClockwise(tableData->table);
rotateClockwise(tableData->table);
play(tableData, fake);
rotateClockwise(tableData->table);
}
/*Função para mover as peças para direita*/
void playRight(t_tableData *tableData, int fake)
{
rotateClockwise(tableData->table);
play(tableData, fake);
rotateClockwise(tableData->table);
rotateClockwise(tableData->table);
rotateClockwise(tableData->table);
}
|
C
|
#include <stdio.h>
int main()
{
int tam, num = 1, run, tri; scanf("%d", &tam);
for (run = 0; run <= tam; run ++)
{
int soma[run];
for (tri = 0; tri <= run; tri ++)
{
printf("%d\n", num);
soma[tri] =
}
}
return(0);
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include "pds.h"
#include "bst.h"
#include <errno.h>
#include <string.h>
struct PDS_RepoInfo repo_handle;
int pds_open( char *repo_name, int rec_size )
{
char repofilename[30];
strcpy(repofilename, repo_name);
strcat(repofilename, ".dat");
if(repo_handle.repo_status==PDS_REPO_OPEN)
return PDS_REPO_ALREADY_OPEN;
repo_handle.pds_data_fp=(FILE *)fopen(repofilename, "rb+");
if(repo_handle.pds_data_fp==NULL)
{
perror(repofilename);
}
strcpy(repo_handle.pds_name, repofilename);
repo_handle.rec_size=rec_size;
repo_handle.pds_bst=NULL;
repo_handle.repo_status=PDS_REPO_OPEN;
return PDS_SUCCESS;
}
int put_rec_by_key( int key, void *rec )
{
int offset;
fseek(repo_handle.pds_data_fp, 0, SEEK_END);
offset=ftell(repo_handle.pds_data_fp);
struct PDS_NdxInfo *entry=(struct PDS_NdxInfo *)(malloc(sizeof(struct PDS_NdxInfo)));
entry->key=key;
entry->offset=offset;
int status=bst_add_node(&repo_handle.pds_bst, key, entry);
if(status==BST_SUCCESS)
{
fwrite(rec, repo_handle.rec_size, 1, repo_handle.pds_data_fp);
return PDS_SUCCESS;
}
else
{
free(entry);
return PDS_ADD_FAILED;
}
}
int get_rec_by_key(int key, void *rec)
{
struct BST_Node *node=bst_search(repo_handle.pds_bst, key);
if(node==NULL)
{
return PDS_REC_NOT_FOUND;
}
else
{
struct PDS_NdxInfo *entry=(struct PDS_NdxInfo *)node->data;
int offset=entry->offset;
fseek(repo_handle.pds_data_fp, offset, SEEK_SET);
fread(rec, repo_handle.rec_size, 1, repo_handle.pds_data_fp);
return PDS_SUCCESS;
}
}
int pds_close()
{
strcpy(repo_handle.pds_name, "");
fclose(repo_handle.pds_data_fp);
bst_free(repo_handle.pds_bst);
repo_handle.repo_status=PDS_REPO_CLOSED;
return PDS_SUCCESS;
}
|
C
|
#include <stdio.h>
#include <string.h>
int ft_strlen(char *);
int main()
{
char *c = "hellow!";
char *b = "\0";
char *d = "";
char *a = "a";
printf("%lu, %d\n",strlen(c),ft_strlen(c));
printf("%s\n",c);
printf("%lu, %d\n",strlen(b),ft_strlen(b));
printf("%lu, %d\n",strlen(d),ft_strlen(d));
printf("%lu, %d\n",strlen(a),ft_strlen(a));
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* write_wchar.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: bbauer <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/16 22:39:43 by bbauer #+# #+# */
/* Updated: 2017/03/05 14:58:16 by bbauer ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
static void cleanup_memory(wchar_t **draft, char **utf8_draft)
{
ft_memdel((void **)draft);
ft_memdel((void **)utf8_draft);
}
static void print_null_wchar(t_conversion *conversion, t_format *format,
wchar_t *draft)
{
char *utf8_draft_post_null;
utf8_draft_post_null = ft_utf8strencode(draft + ft_wstrlen(draft) + 1);
ft_putchar('\0');
format->chars_written++;
if (ft_wstrlen(draft) + 1 < conversion->width)
{
ft_putstr(utf8_draft_post_null);
format->chars_written += ft_strlen((char *)&utf8_draft_post_null);
}
ft_memdel((void **)&utf8_draft_post_null);
}
void write_wchar(t_conversion *conversion, va_list ap,
t_format *format)
{
wchar_t *draft;
char *utf8_draft;
if (conversion->flags.hash)
return ;
else
{
draft = (wchar_t *)malloc(sizeof(wchar_t) * 2);
*draft = va_arg(ap, wint_t);
draft[1] = '\0';
if (!conversion->width && conversion->flags.pos_values_begin_w_space)
{
ft_putchar(' ');
format->chars_written++;
}
apply_width_wchar(conversion, &draft);
utf8_draft = ft_utf8strencode(draft);
ft_putstr(utf8_draft);
format->chars_written += ft_strlen(utf8_draft);
if (*draft == '\0')
print_null_wchar(conversion, format, draft);
cleanup_memory(&draft, &utf8_draft);
}
}
|
C
|
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
// pointer + 1
//int main()
//{
// //int: 4 bytes. E.g. 0x00 00 00 01 is stored in memory as follows:
// // low address(little endian) high address(big endian)
// // |01|00|00|00|02|00|00|00|03|00|00|00|04|00|00|00|
// //
// //
// // array a starts from low address
// int a[4] = { 1, 2, 3, 4 };
//
// // &a gets the array address, &a+1 will skip 4 integers,
// // pointing at the end address of the array a.
// // &a type: int(*)[10]
// // &a+1 type: int(*)[10], cast to (int*) type to assign to ptr2
// // but &a+1 still points at the same address
// // ptr1[-1] = *(ptr1+(-1)) = *(ptr1-1), pointing at |04|00|00|00|
// int* ptr1 = (int*)(&a + 1); // 4
// // array name a is the address of the 1st element
// // (int)a+1: address of a is hex, casting to int, and then add 1.
// // 地址加了个1，相当于加了1个字节，指向了01后面的地址(|01|00|00|00|)
// // int* ptr2相当于向后看了4个字节，为|00|00|00|02|，再以16进制打印
// // 0x02 00 00 00 -> 2000000
// int* ptr2 = (int*)((int)a + 1);
// printf("%x,%x", ptr1[-1], *ptr2); //4,2000000
// return 0;
//}
// 逗号表达式
//int main() {
//
// // a[0] {1,3}
// // a[1] {5,0}
// // a[2] {0,0}
//
// // int a[3][2] = {1,3,5};
//
// // a[3][2] = {{1,2}, {3,4}, {5,6}};
// int a[3][2] = { (0, 1), (2, 3), (4, 5) };
// int* p;
// p = a[0]; // 第一行数组名代表首元素的地址，指向整形1
// printf("%d", p[0]);//*(p+0) -> *p -> 1
//
// return 0;
//}
//@34 min
//int main()
//{
// // 数组名a，作为首元素的地址，是第一行的地址
// // a[0]是第一行第一个元素的地址
// int a[5][5];
// // p可以指向4个整形元素的数组
// int(*p)[4]; // 指针指向数组，每个元素的类型是int
// // a的类型int(*)[5] ,p的类型int(*)[4]
// // a数组名，表示首元素的地址。p指向a的起始位置的地址
// p = a;
// //p[4][2] -> *(*(p+4)+2) -> *(p+4)指向后面的数组(4个整形)
// // *(p+4)拿到了这个数组的数组名，因为没有&和sizeof，所以表示数组首元素的地址
// // 如图，p[4][2](地址小) 和a[4][2](地址大)隔了4个int元素，指针-指针 = 元素的个数
// // %d: -4以补码的形式存在的。 补码11111111 11111111 111111111 11111100
// // %p: 没有原反补的概念，把补码当成原码来打印。 FF FF FF FC
// // warning, p and a type do not match.
// printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); // FF FF FF FC, -4
// return 0;
//}
// @53min
//int main()
//{
// // 1 2 3 4 5
// // 6 7 8 9 10
// int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// // &aa:整个二维数组+1，跳过整个2D数组，cast(int*)
// int* ptr1 = (int*)(&aa + 1);
// // aa+1 拿到第二行的地址，解引用拿到第二行，得到第二行数组名
// // *(aa + 1) -> aa[1] 是第二行首元素的地址，已经是地址了，所以line82，
// // 不需要在cast成int*，ptr2 - 1指向5，* dereference得到5.
// int* ptr2 = (int*)(*(aa + 1));
// printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1)); // 10,5
// return 0;
//}
//@1：13：00
// a
//char** pa -> char* -> work\0
//pa++ -> char* -> at\0
// char* -> alibaba\0
//
//int main()
//{
// char* a[] = { "work","at","alibaba" };
// //
// // a是首元素地址，char* -> work\0
// // 就是char*的地址，也就是char**
// char** pa = a;
// // pa++指向第二个空间，char* -> at\0
// pa++;
// printf("%s\n", *pa); // at
// return 0;
//}
//@1：35：50
/*
int main()
{
// E, N, P and F的地址放到char* c[]里面
char* c[] = { "ENTER","NEW","POINT","FIRST" };
char** cp[] = { c + 3, c + 2, c + 1, c };
//FIRST POINT NEW ENTER
// c[]
// char* ENTER char** c
// char* NEW char** c+1
// char* POINT char** c+2
// char* FIRST char** c+3 <-cpp char***
// cp[]
char*** cpp = cp;
// POINT. ++cpp此时cpp指向第二个元素(c+2), 8++cpp解引用，得到了
// c+2，c+2是指向了POINT首元素地址，再*解引用，相当于拿到了这个里面的值
// 即P的地址，以%s的形式打印，从P开始，打印字符串，一直到POINT后面的"\0"。
printf("%s\n", **++cpp);
// cpp的值在第一次print里面，就已经改变，会影响下面的printf里面的值
// ++cpp，拿到c+1的地址，*解引用，拿到了这个地址c+1所指向的空间，再--，相当于
// 这个空间的值被改成(c+1)-1 = c(char** type)。这个空间的地址不再指向char*(NEW)，
// 而是指向char*(ENTER)。再对c解引用，通过c找到char*->(ENTER)的这块空间，
// *-- * ++cpp 表达式拿到的是E的地址。*-- * ++cpp + 3指向第二个E的地址，得到ER
// ++ 和 --的优先级比 + 高
printf("%s\n", *-- * ++cpp + 3); // ER
// char**
// c+3
// c+2
//cpp-> c
// c
// cpp[-2] = *(cpp-2) 解引用 找到char**(c+3)的空间
// *cpp[-2] = **(cpp-2) 再解引用 找到char*(FIRST)的空间，放的是F的地址
// *cpp[-2] + 3，得到的S的地址（指向了S），%s打印字符串，是ST
printf("%s\n", *cpp[-2] + 3);
// char**
// c+3
// c+2
//cpp-> c
// c
// cpp[-1] = *(cpp-1) cpp-1得到c+2，*(cpp-1)得到char*(POINT)
// cpp[-1][-1] = *(*(cpp-1)-1), *(cpp-1)-1,指向char*(NEW)，*(*(cpp-1)-1)得到元素，是NEW里
// N的地址。这个char*就是N的地址。+1，指向E的地址，%s打印出EW
// cpp[-1][-1] +1 = *(*(cpp-1)-1) + 1
// arr[i][j] <==> *(*(arr+i)+j)
printf("%s\n", cpp[-1][-1] + 1); // NEW中E的地址
return 0;
}
*/
/*
KiKi想获得某年某月有多少天，请帮他编程实现。输入年份和月份，
计算这一年这个月有多少天。
*/
/*
int main() {
int year = 0;
int month = 0;
// array
int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
// multi input, scanf的返回值是读取到完整数据的个数
// EOF end of file
// EOF -> -1
// leap year Feb is 29 days
while (scanf("%d %d", &year, &month) != EOF) {
int day = days[month - 1];
// leap year
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
if (month == 2) {
day++;
}
printf("%d\n", day);
}
}
return 0;
}
*/
/*
杨辉三角
pascal's triangle
*/
//1
//1 1
//1 2 1
//1 3 3 1
//1 4 6 4 1
//int main() {
// int arr[10][10] = { 0 };
// for (int i = 0; i < 10; i++) {
// for (int j = 0; j < i; j++) {
// // column 0
// if (j == 0)
// arr[i][j] = 1;
// // diagonal
// if (i == j)
// arr[i][j] = 1;
// // calculate
// if (i >= 2 && j >=1)
// arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
// }
// }
//
// // print
// for (int i = 0; i < 10; i++) {
// for (int j = 0; j < i; j++) {
// printf("%d ", arr[i][j]);
// }
// printf("\n");
// }
// return 0;
//}
/*
猜凶手
凶杀案
*/
//int main() {
// char killer = 0;
// for (killer = 'A'; killer <= 'D'; killer++) {
// // 用c语言的判断表达式表达逻辑
// if ((killer != 'A') +
// (killer == 'C') +
// (killer == 'D') +
// (killer != 'D') == 3) {
// break;
// }
// }
// printf("%c\n", killer); // c
// return 0;
//}
/*
用智力题 盘点面试中常见的智力题【精品贴，准备面试的小比特都看看，
欢迎大家在评论区补充】
*/
/*
5位运动员参加10米跳台比赛，预测比赛结果
*/
// 只能穷举
//int main() {
//
// int a = 1;
// int b = 1;
// int c = 1;
// int d = 1;
// int e = 1;
//
// for (a = 1; a <= 5; a++) {
// for (b = 1; b <= 5; b++) {
// for (c = 1; c <= 5; c++) {
// for (d = 1; d <= 5; d++) {
// for (e = 1; e <= 5; e++) {
// if( ((b == 2) + (a == 3)==1) &&
// ((b == 2) + (e == 4)==1) &&
// ((c == 1) + (d == 2)==1) &&
// ((c == 5) + (d == 3)==1) &&
// ((e == 4) + (a == 1)==1)) {
// if (a * b * c * d * e == 120)
// printf("a=%d b=%d c=%d d=%d e=%d",a,b,c,d,e);// 3,1,5,2,4
// goto end;
// }
// }
// }
// }
// }
// }
// end;
// return 0;
//}
|
C
|
/*
It creates a memory object "/myMemoryObj"
Object can be found: /dev/shm
to be compiled with "-lrt"
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h> /* For mode constants */
#include <fcntl.h> /* For O_* constants */
#include <unistd.h>
#include <sys/types.h>
#define SIZEOF_SMOBJ 200
#define SMOBJ_NAME "/myMemoryObj"
int main(void)
{
int fd;
fd = shm_open (SMOBJ_NAME, O_CREAT | O_RDWR , 00700); /* create s.m object*/
if(fd == -1)
{
printf("Error file descriptor \n");
exit(1);
}
if(-1 == ftruncate(fd, SIZEOF_SMOBJ))
{
printf("Error shared memory cannot be resized \n");
exit(1);
}
close(fd);
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// ----- Declaracion de Funciones -----
float get_n(char *str);
int get_option(int min, int max, char *str);
int partition(float arr[], int start, int end);
void clear();
void display_stgs(int n, int m, char arr[n][m]);
void get_arr(float arr[], int size);
int binary_search(float arr[], int size, float key);
void swap(float arr[], int first_pos, int second_pos);
void bubble(float arr[], int size);
void insertion(float arr[], int size);
void selection(float arr[], int size);
void quicksort(float arr[], int start, int end);
void binary_insertion(float arr[], int size);
void print_array(float arr[], int size);
// ----- Main -----
int main() {
// Variables para poder limpiar pantalla
char clear_str[10];
#ifdef _WIN32
// Limpiar pantalla en Windows
strcpy(clear_str, "cls");
#else
//Limpiar pantalla en la mayoria de los SO Linux
strcpy(clear_str, "clear");
#endif
// Declaracion de Variables
int size, true = 1, opt, n_opt = 6, max_size = 1000;
float arr[max_size];
char options[][60] = {"Ordenamiento de Burbuja",
"Ordenamiento por Insercion",
"Ordenamiento por Seleccion",
"Ordenamiento Rapido (QuickSort)",
"Ordenamiento por Insercion Binaria",
"Finalizar"};
do {
printf("----- Programa de Ordenamiento -----\n\n");
// Mostrar Opciones
display_stgs(n_opt, 60, options); printf("\n");
// Elegir Opcion
opt = get_option(1, n_opt, "Opcion");
printf("\n---\n\n");
if (opt != 6) {
// Obtener Matriz
size = get_option(1, max_size, "Numero de Elementos"); printf("\n");
get_arr(arr, size);
// Ordenar segun Metodo Elegido
switch(opt) {
// burbuja
case 1:
bubble(arr, size);
break;
// insercion
case 2:
insertion(arr, size);
break;
// seleccion
case 3:
selection(arr, size);
break;
// qs
case 4:
quicksort(arr, 0, size - 1);
break;
// binaria
case 5:
binary_insertion(arr, size);
break;
// default
default:
true = 0;
break;
}
// Imprimir Matriz
printf("\n- Matriz Ordenada - \n\n");
print_array(arr, size); printf("\n");
clear();
} else {
true = 0;
}
// Limpiar Pantalla
printf("\nPresione Enter para Continuar\n");
getchar();
system(clear_str);
} while (true);
printf("----- Finalizado -----");
printf("\n\nCoded with <3 by Alvaro\n\n");
return 0;
}
// ----- Definicion de Funciones -----
// Funcion que limpia el bufer
void clear() {
int c;
while ((c = getchar()) != '\n' && c != EOF);
}
// Funcion que Muestra Opciones
void display_stgs(int n, int m, char arr[n][m]) {
int i;
for (i = 0; i < n; i++) {
printf("%d) %s\n", i + 1, arr[i]);
}
}
// Funcion que maneja la entrada de numeros
float get_n(char *str) {
int i = 0;
float n;
/*
* Al introducir un valor no numerico
* descarta la nueva linea
* y luego hace una limpieza del bufer.
* Retornando -1.
*
* Sino, retorna el valor numerico
* que ha sido introducido.
*/
do {
printf("%s: ", str);
// Si i > 0, busca las nuevas lineas, sino suma 1 a i
(i > 0) ? scanf("%*[^\n]") : i++;
} while(!scanf("%f", &n));
return n;
}
// Funcion que Obtiene Opciones
int get_option(int min, int max, char *str) {
int true = 1;
float n;
do {
n = get_n(str);
/*
* Si el numero introducido
* es mayor o igual que el valor
* minimo y menor o igual que el
* valor maximo de opciones.
*
* Entonces, true = 0 y finaliza
* el bucle. Sino, continuara
* preguntando hasta recibir
* una entrada valida
*
*/
if (((int) n >= min) && ((int) n <= max)) {
true = 0;
} else {
printf("\n=> Error: Introduzca un valor n, tal que %d <= n <= %d\n\n", min, max);
}
} while (true == 1);
return (int) n;
}
// Obtener Elementos de una Matriz
void get_arr(float arr[], int size) {
int i;
char str[10];
for (i = 0; i < size; i++) {
sprintf(str, "[%d]", i + 1);
arr[i] = get_n(str);
}
}
// Funcion que intercambio posiciones de una matriz
void swap(float arr[], int first_pos, int second_pos) {
float pivot;
pivot = arr[second_pos];
arr[second_pos] = arr[first_pos];
arr[first_pos] = pivot;
}
// Funcion que realiza la particion de la matriz
int partition(float arr[], int start, int end) {
/*
* Esta funcion toma al ultimo
* elemento de la matriz como pivote.
* Colocando el pivote en su posicion
* correcta en la matriz, colocando
* los elementos mas pequenios a
* la izquierda y los mas grandes
* a la derecha del pivote.
*/
int i, j = start - 1;
float pivot = arr[end];
/*
* La variable j indica el indice
* del elemento mas pequenio y la
* correcta posicion del pivote.
*/
for (i = start; i <= end - 1; i++) {
// Si el numero actual es menor que el pivote
if (arr[i] < pivot) {
// Incremena el indice de numeros pequenios
j++;
// Intercambia las posiciones
swap(arr, j, i);
}
}
// Coloca el pivote en la posicion correcta
swap(arr, j + 1, end);
return (j + 1);
}
// Ordenamiento por Burbuja
void bubble(float arr[], int size) {
int i, j;
// Iteracion que realiza las pasadas
for (i = 0; i < size; i++) {
// Iteracion que realiza el ordenamiento
for (j = 0; j < size && (j + 1) < size; j++) {
/*
* Si el elemento actual es mayor
* que el elemento siguiente.
* Entonces realiza un cambio
* de posiciones.
*/
if (arr[j] > arr[j + 1]) {
swap(arr, j + 1, j);
}
}
}
}
// Ordenamiento por Insercion
void insertion(float arr[], int size) {
int i, j;
float current;
for (i = 1; i < size; i++ ) {
// Establece el valor actual
current = arr[i];
/*
* Si j > 0 y el valor anterior
* es mayor que el valor actual.
* Entonces, se asigna a la posicion
* actual el valor anterior.
*
* Luego, se reduce en 1 el valor de
* j.
*/
for (j = i; (j > 0) && (arr[j - 1] > current); j--) {
arr[j] = arr[j - 1];
}
// Se asigna a la posicion j el valor actual
arr[j] = current;
}
}
// Ordenamiento por Seleccion
void selection(float arr[], int size) {
int i, j, largest_index = 0;
// Pasadas
for (i = 0; i < (size + i); i++, size--) {
// Busqueda del indice del elemento mayor
for (j = 0; j < size; j++) {
if (arr[j] > arr[largest_index]) {
largest_index = j;
}
}
/*
* Realiza el intercambio entre
* el ultimo elemento actual
* de la matriz iterada y el
* mayor elemento encontrado.
*/
swap(arr, largest_index, size - 1);
// Establece el largest_index a 0
largest_index = 0;
}
}
// Ordenamiento rapido (QuickSort)
void quicksort(float arr[], int start, int end) {
int split;
// Si el indice inicial < final
if (start < end) {
/*
* Coloca a end (el pivote) en
* su posicion correcta y
* retorna el indice de
* particion de la matriz.
*/
split = partition(arr, start, end);
// Ordena la parte izquierda de la matriz particionada
quicksort(arr, start, split - 1);
// Ordena la parte derecha de la matriz particionada
quicksort(arr, split + 1, end);
}
}
// Busqueda Binaria
int binary_search(float arr[], int size, float key) {
int low = 0, high = size, mid;
// Mientras low < high
while (low < high) {
// Obtencion del indice medio
mid = (low + high) / 2;
/*
*
* Si el elemento medio es menor o
* igual a "key". Entonces low
* toma el valor de "mid" + 1.
*
* Sino, high toma el valor de "mid"
*/
if (arr[mid] <= key) {
low = mid + 1;
} else {
high = mid;
}
}
// Retorno del indice donde se debe insertar
return low;
}
// Insercion Binaria
void binary_insertion(float arr[], int size) {
int i, j, index;
float key;
/*
* Se asume que el primer elemento
* esta ordenado. Por lo tanto,
* se inicia el ordenamiento desde
* el segundo elemento hasta
* el ultimo
*/
for (i = 1; i < size; i++) {
// Elemento a Introducir
key = arr[i];
// Obtencion del indice donde se debe introducir "key"
index = binary_search(arr, i, key);
j = i;
// Moviendo cada elemento desde index hasta i (hacia la derecha)
while (j > index) {
arr[j] = arr[j - 1];
j--;
}
// Insertando "key" en su correcta posicion
arr[index] = key;
}
}
// Funcion que Muestra una Matriz
void print_array(float arr[], int size) {
// Impresion de cada elemento de la matriz
if (size == 1) {
printf("{%.2f}", arr[0]);
} else {
for (int i = 0; i < size; i++) {
if (size == 1) {
printf("{%.2f}, ", arr[i]);
} else {
if (i == 0) {
printf("{%.2f, ", arr[i]);
} else if (i + 1 == size) {
printf("%.2f}", arr[i]);
} else {
printf("%.2f, ", arr[i]);
}
}
}
}
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
#define SENO "-s"
#define ARC_SENO "-a"
void displayNumero(char * opcao, double numero);
double calculaResultado(char * opcao, double numero);
int main(int argc, char * argv[]){
if(argc > 2){
double angulo;
angulo = atof(argv[2]);
displayNumero(argv[1], angulo);
} else {
printf("Quantidade de parâmetros inválidos.\n");
}
return 0;
}
double calculaResultado(char * opcao, double numero){
double resultado = 0;
void *handle;
char *error;
handle = dlopen("./obj/libseno.so",RTLD_LAZY);
if(!handle) {
fprintf(stderr, "%s\n", dlerror());
exit(1);
}
int comparaOpcao = strcmp(opcao, SENO);
if(!comparaOpcao) {
double (*seno)(double);
seno = dlsym(handle, "seno");
if((error = dlerror()) != NULL) {
fprintf(stderr,"%s\n", error);
exit(1);
}
resultado = (*seno)(numero);
}else{
comparaOpcao = strcmp(opcao, ARC_SENO);
if(!comparaOpcao) {
double (*arc_seno)(double);
arc_seno = dlsym(handle, "arc_seno");
if((error = dlerror()) != NULL) {
fprintf(stderr,"%s\n", error);
exit(1);
}
resultado = (*arc_seno)(numero);
}else{
printf("Opcao Inválida!!");
exit(-1);
}
}
dlclose(handle);
return resultado;
}
void displayNumero(char * opcao, double numero){
int comparaOpcao = strcmp(opcao, SENO);
double resultado = calculaResultado(opcao,numero);
if(!comparaOpcao) {
printf("seno (%.3lf) = %.3lf\n", numero, resultado);
}else{
printf("arc_seno (%.3lf) = %.3lf\n", numero, resultado);
}
}
|
C
|
#include "Array.h"
Vector mul(Vector v1, Vector v2){
if(v1.count != v2.count){
puts("Cannot multiply vectors of differing length.");
return empty_vector();
}
Vector prod = empty_vector();
int index;
for(index = 0; index < v1.count; index++){
insert(&prod, v1.vector[index] * v2.vector[index]);
}
return prod;
}
|
C
|
#include <stdio.h>
int main()
{
int n,remainder,sum=0 ;
printf("Enter the number: ");
scanf("%d",&n);
while (n!=0)
{remainder=n%10;
sum+=remainder;
n=n/10;
}
printf("\n\nYour entered digit Sum= %d",sum);
return 0;
}
|
C
|
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#ifndef INT16_MAX
enum { INT16_MAX = (1 << 0) + (1 << 1) + (1 << 2) + (1 << 3) + (1 << 4) + (1 << 5) + (1 << 6) + (1 << 7) +
(1 << 8) + (1 << 9) + (1 << 10) + (1 << 11) + (1 << 12) + (1 << 13) + (1 << 14) };
#endif
enum { BUF_SIZE = INT16_MAX };
static int write_int(long long int n) {
static char buffer[BUF_SIZE] = {};
char * p;
p = buffer + BUF_SIZE;
p--;
*p = '\0';
p--;
for (;;) {
*p = '0' + (n % 10);
n = n / 10;
if (0 == n) break;
if (p == buffer) { return ~0; };
p--;
};
const int len = BUF_SIZE - (p - buffer) - 1;
write(STDOUT_FILENO, p, len);
return len;
};
static int write_string(const char * cstr) {
if (NULL == cstr) {
static const char s[] = "NULL";
write(STDOUT_FILENO, s, sizeof(s) - 1);
return sizeof(s) - 1;
};
const char * p = cstr;
for (;;) { if (*p == '\0') break; p++; };
const int len = p - cstr;
write(STDOUT_FILENO, cstr, len);
return len;
};
static int write_string_ln(const char * cstr) {
if (NULL == cstr) {
static const char s[] = "NULL" "\n";
write(STDOUT_FILENO, s, sizeof(s) - 1);
return sizeof(s);
};
const char * p = cstr;
for (;;) { if (*p == '\0') break; p++; };
const int len = p - cstr;
write(STDOUT_FILENO, cstr, len);
write(STDOUT_FILENO, "\n", 1);
return len + 1;
};
static int write_eol(void) {
write(STDOUT_FILENO, "\n", 1);
return 1;
};
static int print_quotient(const int sign, const int dividende, const int diviseur, const int digits);
int main(const int argc, const char * argv[]) {
if (3 != argc && 4 != argc) {
write_string("\t" "usage: ");
write_string(argv[0]);
write_string(" `dividende' `diviseur' [`digits']" "\n");
return 0;
};
const int argv1 = atoi(argv[1]);
const int argv2 = atoi(argv[2]);
const int argv3 = 4 == argc ? atoi(argv[3]) : -1;
const int digits = argv3;
if (0 == argv2) {
const int sign = (0 == argv1) ? 0 : (0 > argv1 ? -1 : 1);
const int dividende = (0 == argv1) ? 0 : (0 > argv1 ? -argv1 : argv1);
print_quotient(sign, dividende, 0, digits);
return 0;
};
if (0 > argv2) {
const int sign = (0 == argv1) ? 0 : (0 > argv1 ? 1 : -1);
const int dividende = (0 == argv1) ? 0 : (0 > argv1 ? -argv1 : argv1);
const int diviseur = -argv2;
print_quotient(sign, dividende, diviseur, digits);
return 0;
};
{
const int sign = (0 == argv1) ? 0 : (0 > argv1 ? -1 : 1);
const int dividende = (0 == argv1) ? 0 : (0 > argv1 ? -argv1 : argv1);
const int diviseur = argv2;
print_quotient(sign, dividende, diviseur, digits);
return 0;
};
return -1;
};
int print_quotient(const int sign, const int dividende, const int diviseur, const int digits) {
static uint8_t tableau_des_quotients [BUF_SIZE];
static int tableau_des_restes [BUF_SIZE];
static uint16_t tableau_des_restes_indices[BUF_SIZE];
if (0 == diviseur) {
if (0 == sign) {
return write_string_ln("0/0");
};
if (0 > sign) {
return write_string_ln("-∞");
};
{
return write_string_ln("+∞");
};
};
if (0 == sign) {
return write_string_ln("0");
};
// = (int *) malloc(diviseur * (sizeof (int)));
bzero(tableau_des_restes, sizeof(tableau_des_restes));
const int quotient0 = dividende / diviseur;
const int reste0 = dividende % diviseur;
int i;
int quotient = quotient0;
int reste = reste0;
i = 0;
for (;;) {
reste *= 10;
quotient = (reste / diviseur);
reste = (reste % diviseur);
i++;
if (i >= BUF_SIZE) { break; };
tableau_des_quotients [ i] = quotient;
tableau_des_restes [ i] = reste;
if (reste >= BUF_SIZE) { break; };
if (0 != tableau_des_restes_indices[reste]) break;
tableau_des_restes_indices[reste] = i;
};
const uint16_t i_0 = tableau_des_restes_indices[reste];
const uint16_t i_1 = i_0 + 1;
const uint16_t i_n = i;
const uint16_t longueur_de_la_periode = i_n - i_1 + 1;
#if 1
printf("Indice de début du cycle: %d\n", i_1);
printf("Longueur de la période: %d\n", longueur_de_la_periode);
#endif
#if 0
printf("%d / %d = ", dividende, diviseur);
printf("%d.", tableau_des_quotients[1]);
for (int j = 2; j <= i; j++)
printf("%d", tableau_des_quotients[j]);
printf("…\n");
printf("Période = ");
for (int j = tableau_des_restes_indices[reste] + 1; j <= i; j++)
printf("%d", tableau_des_quotients[j]);
printf("…\n");
#endif
printf("%d / %d = ", dividende, diviseur);
fflush(NULL);
if (digits < 0) {
if (0 == reste0) {
write_int(quotient0);
write_eol();
return 0;
};
//printf("%d.", tableau_des_quotients[1]);
printf("%d.", quotient0);
fflush(NULL);
for (int j = 1; j <= i_0; j++) {
write_int(tableau_des_quotients[j]);
//printf("%d", tableau_des_quotients[j]);
};
if (0 == reste) {
//write_int(tableau_des_quotients[i_0]);
write_eol();
return 0;
};
printf("…");
fflush(NULL);
for (int j = i_1; j <= i_n; j++) {
write_int(tableau_des_quotients[j]);
//printf("%d", tableau_des_quotients[j]);
};
printf("…\n");
return 0;
};
if (0 == digits) {
write_int(quotient0);
write_eol();
return 0;
};
{
if (0 == reste0) {
write_int(quotient0);
write_string(".");
for (int j = 0; j < digits; j++) {
write_string("0");
};
write_eol();
return 0;
};
//printf("%d.", tableau_des_quotients[1]);
printf("%d.", quotient0);
fflush(NULL);
for (int j = 1; j <= i_0; j++) {
write_int(tableau_des_quotients[j]);
//printf("%d", tableau_des_quotients[j]);
if (j == digits) goto label_write_eol;
};
if (0 == reste) {
//write_int(tableau_des_quotients[i_0]);
for (int j = i_0; j <= digits; j++) {
write_string("0");
};
write_eol();
return 0;
};
for (int j = i_1; j <= digits; j++) {
//for (int j = i_0; j < i_n; j++) {
//const int ind = ((j - i_0) % longueur_de_la_periode) + i_0;
const int ind = ((j - i_1) % longueur_de_la_periode) + i_1;
write_int(tableau_des_quotients[ind]);
//printf("%d", tableau_des_quotients[j]);
};
label_write_eol:
write_eol();
return 0;
};
return 0;
};
|
C
|
#include <stdio.h>
#include <unistd.h>
int
do_something(){
printf("doing someting \n");
return 0;
}
int
main(){
do_something();
/*切换到后台服务模式*/
daemon(NULL, NULL);
while (1) {
do_something();
sleep(1);
}
}
|
C
|
/*
emain.c
Copyright (C) 2016 Adapteva, Inc.
Contributed by Ola Jeppsson <[email protected]>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program, see the file COPYING. If not, see
<http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#define RESULT_ADDR 0x8e000000
#define VALID_ADDR 0x8e0f0000
#define INVALID_ADDR 0x7e0f0000
int main(void) {
uint32_t val, tmp, old;
volatile uint32_t *result = (uint32_t *) RESULT_ADDR;
volatile uint32_t *valid = (uint32_t *) VALID_ADDR;
volatile uint32_t *invalid = (uint32_t *) INVALID_ADDR;
old = *valid;
/* random number */
val = 0xed0d4a75;
*valid = val;
/* Wait for write to propagate */
while (*valid != val)
;
tmp = *invalid;
/* Restore old value (just in case) */
*valid = old;
/* We expect the invalid address to alias to the valid one when the FPGA
* elink RX is configured in remapping mode. In Parabuntu 2016.11, the
* epiphany driver incorrectly configures RX to use MMU mode without
* filling in the entire MMU table. This makes the invalid address alias to
* 0x000f0000 */
if (tmp != val) {
/* 2 indicates error */
*result = 2;
return 1;
}
/* invalid address was translated into valid adress by FPGA elink RX */
*result = 1;
return 0;
}
|
C
|
#include<stdlib.h>
#include<stdio.h>
#include<time.h>
#include<string.h>
int main (void)
{
char name[30];
int x;
srand(time(NULL));
printf("Please enter a string.");
scanf("%s", name);
x=(rand()% (1300-1200))+1200;
printf("%s %d",name,x);
return EXIT_SUCCESS;
}
|
C
|
#include <stdio.h>
/* Максимален брой върхове в графа */
#define MAXN 200
/* Брой върхове в графа */
const unsigned n = 6;
/* Матрица на съседство на графа */
const char A[MAXN][MAXN] = {
{ 0, 10, 0, 5, 0, 0 },
{ 0, 0, 5, 0, 0, 15 },
{ 0, 0, 0, 10, 5, 0 },
{ 0, 10, 0, 0, 10, 0 },
{ 0, 5, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0 }};
unsigned vertex[MAXN], savePath[MAXN];
char used[MAXN];
int maxLen, tempLen, si;
void addVertex(unsigned i)
{ unsigned j, k;
if (tempLen > maxLen) { /* намерили сме по-дълъг път => запазваме го */
maxLen = tempLen;
for (j = 0; j < i; j++) savePath[j] = vertex[j];
si = i;
}
for (k = 0; k < n; k++) {
if (!used[k]) { /* ако върхът k не участва в пътя до момента */
if (0 == i || A[vertex[i - 1]][k] > 0) { /* ако върхът, който добавяме, е съседен на последния от маршрута */
if (i > 0) tempLen += A[vertex[i - 1]][k];
used[k] = 1; /* маркираме k като участващ в пътя; */
vertex[i] = k; /* добавяме върха k към пътя; */
addVertex(i + 1);
used[k] = 0; /* връщане от рекурсията */
if (i > 0) tempLen -= A[vertex[i - 1]][k];
}
}
}
}
int main(void) {
unsigned i;
maxLen = 0; tempLen = 0; si = 0;
for (i = 0; i < n; i++) used[i] = 0;
addVertex(0);
printf("Най-дългият път е: \n");
for (i = 0; i < si; i++) printf("%u ", savePath[i] + 1);
printf("\nс обща дължина %d\n", maxLen);
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *fptr;
char ch;
if ((fptr = fopen("myfile.txt", "w")) == NULL)
{
printf("Error in opening file :\n");
exit(1);
}
printf("Enter text :\n");
/*Press Ctrl+z/Ctrl+d to stop reading character*/
while ((ch = getchar()) != EOF)
{
fputc(ch, fptr);
}
fclose(fptr);
return 0;
}
|
C
|
/*
* Copyright 2021 Regents of the University of Michigan
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "csv.h"
int csv_find_index(char *header, const char **names, size_t names_len)
{
char *split = header;
for (int idx = 0; split != NULL; ++idx) {
char *front = (idx == 0) ? split : split + 1;
for (size_t i = 0; i < names_len; ++i) {
if (strncmp(front, names[i], strlen(names[i])) == 0) {
return idx;
}
}
split = strchr(front, ',');
}
return -1;
}
char *csv_get_index(char *row, size_t idx)
{
char *split = row;
for (size_t i = 0; i < idx; ++i) {
split = strchr(split + 1, ',');
if (split == NULL) {
return NULL;
}
}
char *entry;
char *start = (idx == 0) ? split : split + 1;
char *end = strchr(start, ',');
if (end != NULL) {
entry = strndup(start, end - start);
} else {
entry = strdup(start);
}
return entry;
}
|
C
|
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char **argv)
{
int size = atoi(argv[1]);
double *array = (double *) malloc(sizeof(double) * size);
double total = 0;
for ( int i = 1; i < size; i++ )
{
if ( i % 1000001 == 1000000 )
array[0] = 100000;
array[i] = array[i-1] + 1;
}
for ( int i = 0; i < size; i++ )
{
array[i] += 1;
total += array[i];
}
}
|
C
|
//(Single Line Comment)
/*
Multiple Line
Comment
*/
// Pre-Processor Directive
#include<stdio.h>
#include<conio.h> // it is optional to mention
/*
# - Pre-Processor
include
Directive: Directory / Folder
<stdio.h>: Standard Input / Output
<conio.h>: Console Input / Output
*/
// main() - Entry point Function
// return
void main() { // void - null or empty
clrscr(); // clear screen
printf("Hello World"); // : - colon, ; - semi-colon: terminate the line
getch(); // get character
}
|
C
|
#include <stdlib.h>
#include "phonebook_hash_djb2_3.h"
/* TODO: FILL YOUR OWN IMPLEMENTATION HERE! */
unsigned long hash(unsigned char *str)
{
unsigned long hash = 5381;
int c;
while (c = *str++)
hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
return hash;
}
entry *findName(char lastName[], entry **pHead)
{
//printf("get into find func\n");
entry *e = pHead[hash(lastName)%HASH_TABLE_SIZE];
while (e != NULL) {
if (strcasecmp(lastName, e->lastName) == 0) {
//printf("I find :%s!!\n", e->lastName) ;
return e;
}
//printf("not the word : %s\n", e->lastName);
e = e->pNext;
}
return NULL;
}
entry *append(char lastName[], entry **pHead)
{
//printf("get into append func\n");
/* allocate memory for the new entry and put lastName */
unsigned long index = hash(lastName)%HASH_TABLE_SIZE;
entry *e = (entry *) malloc(sizeof(entry));
e->pNext = pHead[index]->pNext;
pHead[index]->pNext = e;
strcpy(e->lastName, lastName);
return e;
}
|
C
|
/*
4. Ÿ DATE ü DATE ü Ű ¥ "2019/1/1" ó ϴ print_date Լ Ͻÿ.
DATE ü print_data Լ ̿ؼ Է¹ ¥ ϴ α ۼϽÿ.
? [ 2019 ]
? [ 1 ]
? [ 1 ]
2019/1/1
*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
void print_date_1(DATE);
typedef struct date {
int year;
int month;
int day;
}DATE;
void pa10_04() {
DATE data;
printf("? ");
scanf("%d", &data.year);
printf("? ");
scanf("%d", &data.month);
printf("? ");
scanf("%d", &data.day);
print_date_1(data);
}
void print_date_1(DATE data) {
printf("%d/%d/%d", data.year, data.month, data.day);
}
|
C
|
//
// Created by xing on 2020/7/17.
//
#include <stdio.h>
#include <assert.h>
#include<stdlib.h>
/**
* 字符串复制
* @param sub
* @param arr
* @return
*/
char *Strcpy(char *sub, char *arr) {
if (sub == NULL || arr == NULL)
return NULL;
char *tem = sub;//定义一个指针tem保存字符串首元素地址
while (*arr != '\0')//复制字符串有效字符，遇到\0结束
{
*sub = *arr;//把arr的值给sub
sub++;//每复制一次sub往后移一个
arr++;//arr也往后移一个
}
*sub = '\0';//循环过程没有复制\0,所以循环结束后给sub所指的字符串赋\0
return tem;//返回字符串地址
}
/**
* 字符串链接
* @param dst
* @param src
* @return
*/
char *Strcat(char *dst, const char *src) {
assert(dst != NULL && src != NULL);
char *temp = dst;
while (*temp != '\0')
temp++;
while ((*temp++ = *src++) != '\0');
return dst;
}
/**
* 字符串包含
* @param src
* @param sub
* @return
*/
const char *strstr(const char *src, const char *sub) {
const char *bp;
const char *sp;
if (!src || !sub) {
return src;
}
/* 遍历src字符串 */
while (*src) {
/* 用来遍历子串 */
bp = src;
sp = sub;
do {
if (!*sp) /*到了sub的结束位置，返回src位置 */
return src;
} while (*bp++ == *sp++);
src++;
}
return NULL;
}
/**
* 字符出现位置
* @param msg
* @param dest
* @return
*/
char *Strchr(const char *msg, char dest) {
char *m = NULL;
while (*msg != NULL) {
if (*msg == dest) {
return (char *) msg;
}
*msg++;
}
return NULL;
}
int main(int argc, char *argv[]) {
char arr[] = "abcdddef";
char sub1[] = {};
Strcpy(sub1, arr);
printf("%s\n", sub1);
char arr1[] = "abcdddef";
char arr2[] = "abcf";
char arr3[] = "c";
printf("%s\n", Strcat(arr1, arr2));
printf("%s\n", strstr(arr1, arr2));
printf("%s\n", Strchr(arr1, arr3));
return 0;
}
|
C
|
/* No.9498 ٲٴ */
#include <stdio.h>
int main()
{
int num;
scanf("%d", &num);
if (num <= 100 && num >= 90)
printf("A \n");
else if (num >= 80)
printf("B \n");
else if (num >= 70)
printf("C \n");
else if (num >= 60)
printf("D \n");
else
printf("F \n");
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <windows.h>
#include "CeldaMazo.h"
#include "Cartas.h"
nodoJugador *generarBot(){
char bots[30]={"Bots.dat"}; ///Ruta de los bots
FILE *archi = fopen(bots, "rb");
srand(time(NULL));
nodoJugador *aux = NULL;
if(archi != NULL){
int num=rand()%10;
fseek(archi, sizeof(Jugador)*num, SEEK_SET);
Jugador aux2;
fread(&aux2, sizeof(Jugador)-sizeof(int), 1, archi);
aux = crearNodoJugador(aux2);
if(fclose(archi) != 0){
printf("Error al cerrar el archivo");
Sleep(5000);
exit(-1);
}
}
else{
printf("Error al abrir el archivo");
Sleep(5000);
exit(-1);
}
return aux;
}
void agregarCeldas(CeldaMazo celdas[], nodoJugador *jug){
nodoJugador *bot = generarBot();
celdas[0].puntos = 0;
celdas[0].jug = bot;
inicPila(&celdas[0].cartas);
celdas[1].puntos = 0;
celdas[1].jug = jug;
inicPila(&celdas[1].cartas);
}
void eliminarPosArregloCartas(Carta cartas[], int validos, int pos){
for(int i=pos; i<validos; i++){
cartas[i] = cartas[i+1];
}
}
void repartirCartas(CeldaMazo jugadores[], char cartasArchivo[]){
Pila mazo;
inicPila(&mazo);
archivoCartasToPila(cartasArchivo, &mazo);
mezclarCartas(&mazo);
for(int i=0; i<3; i++){
apilar(&jugadores[1].cartas, desapilar(&mazo));
apilar(&jugadores[0].cartas, desapilar(&mazo));
}
while(!pilaVacia(&mazo))
desapilar(&mazo);
}
Carta desapilarPorPosicion(Pila *pilita, int pos){
Pila aux;
inicPila(&aux);
Carta aux2;
while(!pilaVacia(pilita))
apilar(&aux, desapilar(pilita));
int i = 0;
while(i<pos){
apilar(pilita, desapilar(&aux));
i++;
}
aux2 = desapilar(pilita);
while(!pilaVacia(&aux))
apilar(pilita, desapilar(&aux));
return aux2;
}
void mezclarCartas(Pila *mazo){
Pila aux;
inicPila(&aux);
while(!pilaVacia(mazo))
apilar(&aux, desapilar(mazo));
srand(time(NULL));
while(!pilaVacia(&aux)){
int num=1+rand()%cantElementosPila(aux);
Carta aux2 = desapilarPorPosicion(&aux, num);
apilar(mazo, aux2);
}
}
int cantElementosPila(Pila aux){
Pila aux2;
inicPila(&aux2);
int i=0;
while(!pilaVacia(&aux)){
apilar(&aux2, desapilar(&aux));
i++;
}
while(!pilaVacia(&aux2))
apilar(&aux, desapilar(&aux2));
return i;
}
Carta mayor(Pila *pilita){
Pila aux, aux2;
inicPila(&aux);
inicPila(&aux2);
apilar(&aux2, desapilar(pilita));
while(!pilaVacia(pilita)){
if(tope(pilita)->dato.clase > tope(&aux2)->dato.clase){
apilar(&aux, desapilar(&aux2));
apilar(&aux2, desapilar(pilita));
}
else
apilar(&aux, desapilar(pilita));
}
while(!pilaVacia(&aux))
apilar(pilita, desapilar(&aux));
return desapilar(&aux2);
}
void crearCopiaParaElTanto(Pila *copia, Pila *dada){
Pila aux;
inicPila(&aux);
while(!pilaVacia(dada)){
apilar(&aux, desapilar(dada));
}
while(!pilaVacia(&aux)){
Carta cartaAux = tope(&aux)->dato;
if(cartaAux.num > 9)
cartaAux.num = 0;
apilar(copia, cartaAux);
apilar(dada, desapilar(&aux));
}
}
int tanto(Pila dada){
int puntos = 0;
Pila copia, aux, aux2;
inicPila(&copia);
inicPila(&aux);
inicPila(&aux2);
crearCopiaParaElTanto(&copia, &dada);
apilar(&aux, desapilar(&copia));
if(strcmpi(tope(&aux)->dato.clase, tope(&copia)->dato.clase) == 0)
puntos = tope(&aux)->dato.num + tope(&copia)->dato.num;
apilar(&aux2, desapilar(&copia));
if(strcmpi(tope(&aux2)->dato.clase, tope(&copia)->dato.clase) == 0)
if(puntos < tope(&aux2)->dato.num + tope(&copia)->dato.num)
puntos = tope(&aux2)->dato.num + tope(&copia)->dato.num;
if(strcmpi(tope(&copia)->dato.clase, tope(&aux)->dato.clase) == 0)
if(puntos < tope(&copia)->dato.num + tope(&aux)->dato.num)
puntos = tope(&copia)->dato.num + tope(&aux)->dato.num;
if(puntos > 0)
puntos += 20;
return puntos;
}
int envidoBot(){
return quieroNoQuiero(1);
}
int pedirTrucoBot(){
quieroNoQuiero(2);
}
|
C
|
#include<stdio.h>
#include<stdlib.h>
// Porovn vk dvou student uitm funkce a vlastnch strukturovanch datovch typ, nsledn vype
// Zadn - http://jazykc.inf.upol.cz/strukturovane-datove-typy/index.htm
typedef struct {
char Den, Mesic; short Rok;
} Datum;
typedef struct {
char jmeno[20], prijmeni[20]; Datum narozen;
} student;
int porovnej_vek(student s1, student s2) {
/* Pokud je s1 star, vrt hodnotu 1. Pokud je s2 star, vrt hodnotu -1.
U shodnho vku vrt hodnotu 0.*/
if (s1.narozen.Rok < s2.narozen.Rok)
return 1;
else if (s1.narozen.Rok == s2.narozen.Rok)
if (s1.narozen.Mesic < s2.narozen.Mesic)
return 1;
else if (s1.narozen.Mesic == s2.narozen.Mesic)
if (s1.narozen.Den < s2.narozen.Den)
return 1;
else if (s1.narozen.Den == s2.narozen.Den)
return 0;
else
return -1;
else
return -1;
else
return -1;
};
int porovnanyvek = 2;
int printstarsiho(student s1, student s2, int porovnanyvek) {
/* Vytiskne porovnn vk dvou student.*/
switch (porovnanyvek) {
case 1:
printf("%s %s je starsi nez %s %s.\n", s1.jmeno, s1.prijmeni, s2.jmeno, s2.prijmeni);
break;
case -1:
printf("%s %s je mladsi nez %s %s.\n", s1.jmeno, s1.prijmeni, s2.jmeno, s2.prijmeni);
break;
case 0:
printf("%s %s je stejne stary jako %s %s.\n", s1.jmeno, s1.prijmeni, s2.jmeno, s2.prijmeni);
break;
}
return 0;
};
int main() {
student s3;
s3.jmeno[20] = "Erich";
s3.prijmeni[20] = "Fiedler";
//s3.narozen = {12, 11, 1960}; //Nefunkn pokus o deklaraci celho podtypu narz
s3.narozen.Den = 12;
s3.narozen.Mesic = 12;
s3.narozen.Rok = 1960;
student s1 = { "Doktor", "Zaba", 7, 7, 1960 };
student s2 = { "Kuzma", "Kuzmic", 11, 12, 1960 };
student s4 = { "Varel", "Fristensky", 20, 12, 1960 }; //Pro testovn rznch variant
printstarsiho(s4, s1, porovnej_vek(s4, s1));
//Vechno smrem dol pokusy o debug
system("pause");
return 0;
}
|
C
|
#include <stdio.h>
#include <string.h>
int main()
{
char original[] = "Am I the original?";
char duplicate[] = "Overwritten";
printf("Here is the original string: %s\n",original);
strcpy(duplicate,original);
printf("Here is the duplicate: %s\n",duplicate);
return(0);
}
|
C
|
#include "minitalk.h"
void char2binary(char c, char *dest)
{
int i;
unsigned char d;
i = 0;
while (i < 8)
{
d = 0x1 & c >> i;
if (d == 0)
dest[i] = '0';
else
dest[i] = '1';
i++;
}
}
void int2binary(t_uint n, char *str)
{
unsigned long i;
unsigned char d;
i = 0;
while (i < sizeof(t_uint) * 8)
{
d = 0x1 & n >> i;
if (d == 0)
str[i] = '0';
else
str[i] = '1';
i++;
}
}
char binary2char(t_uint *b)
{
int i;
unsigned char c;
i = 0;
c = 0;
while (i < 8)
{
if (b[i] == 1)
c += 0x1 << i;
i++;
}
return (c);
}
int binary2int(t_uint *b)
{
unsigned long i;
t_uint integer;
i = 0;
integer = 0;
while (i < sizeof(t_uint) * 8)
{
if (b[i] == 1)
integer += 0x1 << i;
i++;
}
return (integer);
}
|
C
|
#include "button.h"
#include <string.h>
static int default_on_draw(struct button *button, struct display_buf *buf)
{
dismgr_draw_region(&button->region, COLOR_DEFAULT_BUTTON);
dismgr_draw_text_in_region(button->text, &button->region, COLOR_DEFAULT_TEXT);
dismgr_flush(&button->region, buf);
return 0;
}
static int default_on_press(struct button *button, struct display_buf *buf,
struct input_event *event)
{
unsigned int color = COLOR_DEFAULT_BUTTON;
button->is_pressed = !button->is_pressed;
if (button->is_pressed) {
color = COLOR_BTN_PRESSED;
}
dismgr_draw_region(&button->region, color);
dismgr_draw_text_in_region(button->text, &button->region, COLOR_DEFAULT_TEXT);
dismgr_flush(&button->region, buf);
return 0;
}
void button_init(struct button *button, char *name, char *text, struct region *region,
button_on_draw on_draw, button_on_press on_press)
{
button->name = name;
button->text = text;
button->is_pressed = 0;
memcpy(&button->region, region, sizeof(struct region));
button->on_draw = on_draw ? on_draw : default_on_draw;
button->on_press = on_press ? on_press : default_on_press;
}
|
C
|
#include <stdio.h>
#include <string.h>
/* Reverses a string in C */
void reverseString(char* s) {
//assume null terminated
if (s == NULL) {
return;
}
int length = strlen(s);
if (length <= 1) {
return;
}
char *start = s;
char *end = s + length -1;
while(start < end) {
char temp = *start;
*start = *end;
*end = temp;
start++;
end--;
}
}
void reverseStringNum(char *s) {
if (s == NULL) {
return;
}
int length = strlen(s);
if (length <= 1) {
return;
}
for(int i = 0; i < length/2; ++i) {
char temp = s[i];
s[i] = s[length - i - 1];
s[length - i - 1] = temp;
}
}
void reverseStringNumP(char *s) {
if(s == NULL) {
return;
}
int length = strlen(s);
if (length <= 1) {
return;
}
for(int i = 0; i < length/2; ++i) {
char temp = *(s + i);
*(s + i) = *(s + length - i - 1);
*(s + length - i - 1) = temp;
}
}
int main() {
char s[] = "Hello";
reverseStringNumP(s);
printf("%s", s);
}
|
C
|
#include <stdio.h>
#include <string.h>
void ForcaBruta(char T[], int n, char P[], int m){
int i, j, k;
for(i=0; i<(n-m+1); i++){ //n-m+1 pra nao dar segFault no fim da string
k = i; //posiçao no texto
j = 0; //posiçao no padrao
while(T[k] == P[j] && j < m){
//percorre o texto e o padrao ao mesmo tempo enquanto os caracteres forem iguais
j++;
k++;
}
if(j == m){ //Se j == m eh pq existe o padrao no texto
printf("Casamento na posicao %3d\n", i);
}
}
}
int main(int argc, char const *argv[]){
char texto[] = "brb brazil zil zil broinha";
char padrao[] = "br";
ForcaBruta(texto, strlen(texto), padrao, strlen(padrao));
return 0;
}
|
C
|
#include "holberton.h"
/**
* set_string - sets a value of char to pointer
* @s: pointer memory area
* @to: pointer for char to fill
*
* Return: (void)
*/
void set_string(char **s, char *to)
{
*s = to;
}
|
C
|
/*
** Parses a list of output from evalbites to summarize the
** total results, giving total TP, FP and U, as well as
** the TPR and PPV.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char *argv[])
{
FILE *fpt;
int tp,fp,u,total_tp,total_fp,total_u;
int total_files;
if (argc != 2)
{
printf("Usage: summ [file]\n");
exit(0);
}
if ((fpt=fopen(argv[1],"r")) == NULL)
{
printf("Unable to open %s for reading\n",argv[1]);
exit(0);
}
total_tp=total_fp=total_u=0;
total_files=0;
while (fscanf(fpt,"%d %d %d",&tp,&fp,&u) == 3)
{
total_tp+=tp;
total_fp+=fp;
total_u+=u;
total_files++;
}
fclose(fpt);
if (1)
{
printf("%d total files\n",total_files);
printf("TP=%d FP=%d U=%d\n",total_tp,total_fp,total_u);
printf("TPR=%.1lf\n",(double)total_tp/(double)(total_tp+total_u)*100.0);
printf("PPV=%.1lf\n",(double)total_tp/(double)(total_tp+total_fp)*100.0);
}
else /* print #'s only (no description) in order of PPV TPR */
printf("%.1lf %.1lf\n",
(double)total_tp/(double)(total_tp+total_fp)*100.0,
(double)total_tp/(double)(total_tp+total_u)*100.0);
}
|
C
|
#include <stdio.h>
int main()
{
int input, i;
while(1){
scanf("%d", &input);
if(input==0){
break;
}
else{
for(i=1; i<input; i++){
printf("%d ", i);
}
printf("%d\n", input);
}
}
return 0;
}
|
C
|
#include "../binaryTree.c"
// Perform a postorder traversal of the BST where the result is: { 25, 75, 50, 110, 125, 175, 150, 100 }
//
//
// __ 100 __
// / \
// 50 150
// / \ / \
// 25 75 125 175
// /
// 110
//
//
int n = 0;
void postorder(int tree[], struct node *root) {
if (!root)
return;
if (root->left)
postorder(tree, root->left);
if (root->right)
postorder(tree, root->right);
*(tree + n) = root->value;
n++;
return;
}
int main(void) {
int tree[8];
struct node *root = makeNode(100);
struct node *a = makeNode(50);
struct node *b = makeNode(150);
struct node *c = makeNode(25);
struct node *d = makeNode(75);
struct node *e = makeNode(125);
struct node *f = makeNode(175);
struct node *g = makeNode(110);
root->left = a;
root->right = b;
a->left = c;
a->right = d;
b->left = e;
b->right = f;
e->left = g;
postorder(tree, root);
printf("{ ");
for (n = 0; n < 8; n++, *(tree + n)) {
printf("%d ", tree[n]);
}
printf(" }");
return 0;
}
|
C
|
#include <stdio.h>
int main(void) {
int T, t, R, C, W;
scanf("%d", &T);
for (t = 1; t <= T; ++t) {
scanf("%d%d%d", &R, &C, &W);
printf("Case #%d: %d\n", t, (C - 1) / W + W);
}
return 0;
}
|
C
|
#include<stdio.h>
int main(){
float a,b;
printf("Enter the first number :");
scanf("%f",&a);
printf("Enter the second number :");
scanf("%f",&b);
printf("Sum : %f \n", a*b);
return 0;
}
|
C
|
#include "../headers/fftc_fixedpt.h"
static const unsigned BitPosition[32] =
{0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9};
unsigned reverseBits(unsigned number, unsigned N)
{
unsigned reversed = 0;
unsigned lInd = N >> 1;
unsigned lIndPos = BitPosition[(unsigned)(lInd * 0x077CB531U) >> 27];
unsigned rInd = 1;
unsigned value = 0;
while(lInd != 0) {
value = ((rInd & number) != 0);
reversed = (reversed & ~lInd) | (value << lIndPos);
lInd >>= 1;
lIndPos--;
rInd <<= 1;
}
return reversed;
}
void sortBitReversed(int32_t *input, int32_t *output, unsigned N)
{
int index, i;
output[0] = input[0];
for (i = 1; i < N; i++)
{
index = reverseBits(i, N);
output[i] = input[index];
}
}
void fftStage_fixedp(int32_t *input_vec, unsigned num_points, unsigned N)
{
int i, j;
unsigned Nover2 = num_points/2;
unsigned k_factor = N / num_points;
for(i = 0; i < N; i += num_points)
{
//perform computation
for(j = 0; j < Nover2; j++)
{
BFLY(input_vec+j+i, input_vec+j+i+Nover2, j*k_factor, N);
}
}
}
void fftc_fixedp(int32_t *input_vec, int32_t *output_vec, unsigned N)
{
// Sort the input vector in reverse bit order
sortBitReversed(input_vec, output_vec, N);
// Compute FFT in feedfoward manner
int i;
unsigned num_stages = BitPosition[(unsigned)(N * 0x077CB531U) >> 27];
unsigned num_points = 2;
for (i = 0; i < num_stages; i++)
{
fftStage_fixedp(output_vec, num_points, N);
num_points *= 2;
}
}
|
C
|
//#include <stdio.h>
//#include <stdlib.h>
//#include <string.h>
//#include <Windows.h>
//#include <math.h>
//#include <time.h>
//#include "58.h"
//#define SIZE 128
//int MyStrlen(const char *str);
//int main()
//{
// const char* str = "abcdef12";
// printf("%d",MyStrlen(str));
// return 0;
//}
//int MyStrlen(const char* str)
//{
// //int count = 0;
// //while (*str != '\0')
// //{
// // count++;
// // str++;
// //}
// //return count;
//
// if (*str == '\0')
// {
// return 0;
// }
// else
// {
// return 1 + MyStrlen(str + 1);
// }
//}
//int main()
//{
// char str[SIZE] = "hello ";
// //printf("%d\n", strlen(strcat(str, "world")));
//
// printf("%d", printf("%d", printf("%d", 43)));
// return 0;
//}
//int main()
//{
// char str1[SIZE] = "hello ";
// char str2[] = "world";
// strcat(str1, str2);
// printf("%s\n", str1);
// return 0;
//}
//void Inc(int* p);
//int main()
//{
// int num = 0;
// while (1)
// {
// Inc(&num);
// Sleep(1000);
// printf("%d\n", num);
// }
// return 0;
//}
//void Inc(int* p)//int* p = &num
//{
// (*p)++;
//}
//int BinSearch(int arr[],int sz, int x);
//int main()
//{
// int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
// int sz = sizeof(arr) / sizeof(arr[0]);
//
// int key = 0;
// printf("Ҫҵ֣--> ");
// scanf("%d", &key);
// int index = BinSearch(arr, sz, key);
// printf("%d ±%d\n", key, index);
// return 0;
//}
//int BinSearch(int arr[],int sz, int x)
//{
// int left = 0;
// int right = sz - 1;
// int mid;
// while (left <= right)
// {
// int mid = (left + right) / 2;
// if (arr[mid] < x)
// {
// //left++;
// left = mid+1;
// }
// else if (arr[mid] > x)
// {
// //right--;
// right = mid - 1;
// }
// else
// {
// //break;
// return mid;
// }
// }
// return -1;
//}
//int IsLeapYear(int year);
//int main()
//{
// int year;
// printf("һݣ--> ");
// scanf("%d", &year);
// int ret = IsLeapYear(year);
// if (1 == ret)
// {
// printf("Yes\n");
// }
// else
// {
// printf("No\n");
// }
// return 0;
//}
//int IsLeapYear(int year)
//{
// if (((0 == year % 4) && (year % 100 != 0)) || 0 == year % 400)
// {
// return 1;
// }
// return 0;
//}
//int IsPrimeNumber(int x);
//int main()
//{
// int m;
// printf("һ--> ");
// scanf("%d", &m);
//
// int ret = IsPrimeNumber(m);
// if (1 == ret)
// {
// printf("\n");
// }
// else
// {
// printf("\n");
// }
// return 0;
//}
//int IsPrimeNumber(int x)
//{
// int n = 2;
// for (n = 2; n < x/2; n++)//i<=(int)sqrt(n)
// {
// if (x % n == 0)
// {
// return 0;
// }
// }
// return 1;
//}
//void Swap1(int* x, int* y);
//int main()
//{
// int x = 10;
// int y = 20;
// printf("before --> x = %d y = %d\n", x, y);
// Swap1(&x, &y);
// printf("after--> x = %d y = %d\n", x, y);
// return 0;
//}
//void Swap1(int* _x, int* _y)
//{
// printf("Swap1before--> x = %d y = %d\n", *_x, *_y);
// int temp = *_x;
// *_x = *_y;
// *_y = temp;
// printf("Swap1after--> x = %d y = %d\n", *_x, *_y);
//}
//void Swap2(int x, int y)
//{
// printf("Swap1before--> x = %d y = %d\n", x, y);
// int temp = x;
// x = y;
// y = temp;
// printf("Swap1after--> x = %d y = %d\n", x, y);
//}
|
C
|
#include <stdio.h>
#include "linked_list.h"
#include <stdlib.h>
int main() {
node_t* head = NULL;
head = malloc(sizeof(node_t));
head->value = 192;
node_t* node1 = malloc(sizeof(node_t));
head->next = node1;
node1->value = 168;
node_t* node2 = malloc(sizeof(node_t));
node1->next = node2;
node2->value = 1;
node2->next = NULL;
insert_after(&head, node1, 0);
push_back_list(&head, 6);
add_to_beginning_list(&head, 9);
node_t* p = head;
while(p != NULL){
printf("%d.", p->value);
p = p->next;
}
printf("\nSize of list: %d\n", get_list_size(&head));
//printf("number of deleted nodes: %d\n", deleted);
return 0;
}
|
C
|
#include<stdio.h>
#include<math.h>
int main(){
int i,i1,i2, centroid1, centroid2, k=2;
int data_set[10];
char product[20], cluster1[10], cluster2[10];
printf("\n");
printf("**************************************************************Welcome to Customer Segmentation Application**************************************************************");
//User is asked for the name of the product
printf("\nEnter the Name of the product\n");
gets(product);
//user is asked for the number of products bought by 10 customers
for(i=1;i<=10;i++)
{
printf("\nEnter number of %s bought by customer %d \n", &product, i);
scanf("%d",&data_set[i]);
}
//Ask user for intital centroids
printf("\n Enter initial centroid1\t");
scanf("%d",¢roid1);
printf("\n Enter initial centroid2\t");
scanf("%d",¢roid2);
//descion made as to which cluster this data will go to
for(i=0;i<10;i++)
{
if( ( abs(centroid1-data_set[i]) ) < ( abs( centroid2-data_set[i]) ) )
{
cluster1[i]=data_set[i];
}
else{
cluster2[i]=data_set[i];
}
}
printf("\n");
printf("Type 1 customers in cluster 1\t");
printf("\n");
for(i1=0;i1<10;i1++){
printf("%d \t",cluster1[i1]);
}
printf("\n");
printf("\n");
printf("Type 2 customers in cluster 2\t");
printf("\n");
for(i2=0;i2<10;i2++){
printf("%d \t",cluster2[i2]);
}
printf("\n");
printf("\n");
return 0;
}
|
C
|
/*
* Copyright (c) 2019 triaxis s.r.o.
* Licensed under the MIT license. See LICENSE.txt file in the repository root
* for full license information.
*
* enums.h
*/
#pragma once
#include <base/base.h>
#ifdef __cplusplus
//! Declares friend operators suitable for an enumeration containing flags
/*! This has to be used for private enums within classes */
#define DECLARE_FLAG_ENUM(enumType) \
friend enumType constexpr operator |(enumType a, enumType b); \
friend enumType constexpr operator |=(enumType& a, enumType b); \
friend enumType constexpr operator &(enumType a, enumType b); \
friend enumType constexpr operator &=(enumType& a, enumType b); \
friend enumType constexpr operator +(enumType a, enumType b); \
friend enumType constexpr operator +=(enumType& a, enumType b); \
friend enumType constexpr operator -(enumType a, enumType b); \
friend enumType constexpr operator -=(enumType& a, enumType b); \
friend enumType constexpr operator ^(enumType a, enumType b); \
friend enumType constexpr operator ^=(enumType& a, enumType b); \
friend enumType constexpr operator *(enumType a, bool b); \
friend enumType constexpr operator *(bool a, enumType b); \
friend enumType constexpr operator ~(enumType a); \
friend enumType constexpr operator -(enumType a); \
friend enumType constexpr operator +(enumType a); \
friend bool constexpr operator !(enumType a);
//! Defines operators suitable for an enumeration containing flags
#define DEFINE_FLAG_ENUM(enumType) \
ALWAYS_INLINE enumType constexpr operator |(enumType a, enumType b) { return (enumType)((int)a | (int)b); } \
ALWAYS_INLINE enumType constexpr operator |=(enumType& a, enumType b) { return a = a | b; } \
ALWAYS_INLINE enumType constexpr operator &(enumType a, enumType b) { return (enumType)((int)a & (int)b); } \
ALWAYS_INLINE enumType constexpr operator &=(enumType& a, enumType b) { return a = a & b; } \
ALWAYS_INLINE enumType constexpr operator +(enumType a, enumType b) { return (enumType)((int)a | (int)b); } \
ALWAYS_INLINE enumType constexpr operator +=(enumType& a, enumType b) { return a = a + b; } \
ALWAYS_INLINE enumType constexpr operator -(enumType a, enumType b) { return (enumType)((int)a & ~(int)b); } \
ALWAYS_INLINE enumType constexpr operator -=(enumType& a, enumType b) { return a = a - b; } \
ALWAYS_INLINE enumType constexpr operator ^(enumType a, enumType b) { return (enumType)((int)a ^ (int)b); } \
ALWAYS_INLINE enumType constexpr operator ^=(enumType& a, enumType b) { return a = a ^ b; } \
ALWAYS_INLINE enumType constexpr operator *(enumType a, bool b) { return (enumType)((int)a * (int)b); } \
ALWAYS_INLINE enumType constexpr operator *(bool a, enumType b) { return (enumType)((int)a * (int)b); } \
ALWAYS_INLINE enumType constexpr operator ~(enumType a) { return (enumType)(~(int)a); } \
ALWAYS_INLINE bool constexpr operator !(enumType a) { return !(int)a; }
#else
#define DECLARE_FLAG_ENUM(enumType)
#define DEFINE_FLAG_ENUM(enumType)
#endif
|
C
|
void basicDrive (int leftPower, int rightPower) {
motor[LDrive] = leftPower;
motor{RDrive] = -rightPower;
}
//void basicHorizontalIntake (int power) {
// motor[HIntake] = power;
// }
void basicIntake (int power) {
motor[VIntake] = -power
motor[HIntake] = power;
}
//void basicBothIntakes (int power) {
// basicHorizontalIntake(power);
// basicVerticalIntake((-1)*(power));
// }
void flywheels (int UPower, int BPower) {
motor[BLFly] = - BPower
motor[BRFly] = BPower;
motor[ULFly] = UPower;
motor[URFly]= -UPower;
}
|
C
|
#include"stdio.h"
// #include"gsl_matrix.h"
#include"gsl/gsl_matrix.h"
int print_half_00(gsl_matrix* m)
{
// double half = 1/2;
double half = 1./2;
// int *status = printf( "half m_{00} = %i\n", gsl_matrix_get(&m,0,0)*half );
int status = printf( "half m_{00} = %g\n", gsl_matrix_get(m,0,0)*half);
// gsl_matrix_free(m);
return status;
}
int main(void)
{
// gsl_matrix m = gsl_matrix_alloc(0,0);
gsl_matrix *m = gsl_matrix_alloc(1,1);
gsl_matrix_set(m,0,0,66);
printf("half m_{00} (should be 33):\n");
// int *status = print_half_00(&m);
int status = print_half_00(m);
// if(status>0) - printf returns the number of characters written, and -1 on error
if(status<0)
// printf("status=%g : SOMETHING WENT TERRIBLY WRONG (status>0)\n",*status);
printf("status=%d : SOMETHING WENT TERRIBLY WRONG (status<0)\n",status);
else
// printf("status=%g : everything went just fine (status=0)\n",*status);
printf("status=%d : everything went just fine (status>0)\n",status);
// gsl_matrix_free(&m);
gsl_matrix_free(m);
return 0;
}
|
C
|
#include<stdio.h>
#include<math.h>
int main()
{
double a, b, c,r,th;
int t = 1;
while (scanf("%lf : %lf", &a, &b) == 2)
{
th = atan(b / a);
r = a / 2 * a / 2 + b / 2 * b / 2;
c = 400 / (2 * a + 4 * th * sqrt(r));
printf("Case %d: %.10f %.10f\n", t++, a * c, b * c);
}
return 0;
}
|
C
|
#include "beep.h"
void BEEP_GPIO_Config(void)
{
/*һGPIO_InitTypeDef͵Ľṹ*/
GPIO_InitTypeDef GPIO_InitStructure;
/*ƷGPIOĶ˿ʱ*/
RCC_APB2PeriphClockCmd( BEEP_GPIO_CLK, ENABLE);
/*ѡҪƷGPIO*/
GPIO_InitStructure.GPIO_Pin = BEEP_GPIO_PIN;
/*GPIOģʽΪͨ*/
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
/*GPIOΪ50MHz */
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
/*ÿ⺯ʼƷGPIO*/
GPIO_Init(BEEP_GPIO_PORT, &GPIO_InitStructure);
/* رշ*/
GPIO_ResetBits(BEEP_GPIO_PORT, BEEP_GPIO_PIN);
GPIO_SetBits(BEEP_GPIO_PORT, BEEP_GPIO_PIN);
}
void BEEP_ON(int16_t f)
{
int i = 0;
for( i = 0;i <= 100;i++ )
{
if(i/2)
GPIO_SetBits(BEEP_GPIO_PORT, BEEP_GPIO_PIN);
else
GPIO_ResetBits(BEEP_GPIO_PORT, BEEP_GPIO_PIN);
Delay_ms(1000/f);
}
}
|
C
|
// ----------------------------------------------------------------------
// file: card.c
//
// Description: This file implements the CARD module. Its job is to
// create an interface for providing cards from a shuffled deck of
// 52 standing playing cards. Each call to card_get() will return
// the top card in that shuffled deck. If all the cards get used,
// then the deck is invisibly (and unknowingly) reshuffled.
//
// Created: 2016-05-03 (P. Clark)
//
// Modifications:
// 2017-10-30 (P. Clark)
// Added card_init().
// 2017-11-8 (A.Hardt)
// Updated card_get to deal 52 cards
// ----------------------------------------------------------------------
#include <stdlib.h>
#include <sys/times.h>
#include "card.h"
#include "common.h"
#include <stdbool.h>
#define CARDS_IN_DECK 52
#define AVAIL 0 // avaiable, not_dealt
#define USED 1 // dealt
#define DECK_DECODE 100 // encoding scheme of card deck relies on a / or % of 100
static unsigned int Deck_shuffled = FALSE;
// This function must be called before the first call to card_get().
extern void card_init(void)
{
// initialize the random number generator
srandom(times(NULL));
}
// Get a card from the current deck.
// suit: This is interpreted as follows:
// 1 = Clubs
// 2 = Hearts
// 3 = Spades
// 4 = Diamonds
// pattern: This is interpreted as the
// 1 = Ace
// 2..10 as expected
// 11 = Jack
// 12 = Queen
// 13 = King
extern void card_get(unsigned char *suit, unsigned char *pattern)
{
int random_card_num;
static int numCardsDealt = 0;
// card values:
//suite = elment/100, pattern = element%100
int cards[CARDS_IN_DECK] =
{101,102,103,104,105,106,107,108,109,110,111,112,113,
201,202,203,204,205,206,207,208,209,210,211,212,213,
301,302,303,304,305,306,307,308,309,310,311,312,313,
401,402,403,404,405,406,407,408,409,410,411,412,413};
// no cards have been dealt, all are avaiable
static int cardDealt[CARDS_IN_DECK] =
{ AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL,
AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL,
AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL,
AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL, AVAIL};
// if all 52 cards have been dealt...
if (!Deck_shuffled) {
// set all cardDealt values to False,
// indicating no cards have been dealt
for(int i = 0; i < CARDS_IN_DECK; i++){
cardDealt[i] = AVAIL;
}
// set suffled status to true now that deck has been shufffled
numCardsDealt = 0;
Deck_shuffled = TRUE;
}
//assign random number to give out
random_card_num = (random() % CARDS_IN_DECK);
// if random_card_num has already been dealt, pick a new one
while((cardDealt[random_card_num]) & (numCardsDealt < CARDS_IN_DECK)){
random_card_num = (random() % CARDS_IN_DECK);
}
// Mark that the card has been dealt
cardDealt[random_card_num] = USED;
// Increment count of number of cards dealt
numCardsDealt = numCardsDealt+1;
// if we have dealt 52 cards, set shuffled status to false to reshuffle deck upon next request to play
if (numCardsDealt == CARDS_IN_DECK){
Deck_shuffled = FALSE;
}
// Assign suit and pattern using random number
*suit = (cards[random_card_num]/DECK_DECODE);
*pattern = (cards[random_card_num]%DECK_DECODE);
} // card_get()
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include "queue.h"
struct _args {
queue q;
int value;
} _args;
void * insert (void * insert_arguments) {
struct _args * args = (struct _args *) insert_arguments;
q_insert(args->q,(void*) &args->value);
printf("Inserted --------------> %d in the queue\n", args->value);
return NULL;
}
void * th_remove (void* remove_arguments) {
queue * q = (queue *) remove_arguments;
int * res = (int *) q_remove(*q);
printf("Removed %d from the queue\n", *res);
return NULL;
}
int main(int argc, char* argv[]) {
int q_length;
int num_threads;
if (argc != 3) {printf("ERROR: wrong number of parameters ($ ./qtest <queue_length> <threads>). Exiting...\n"); return 1;}
q_length = atoi(argv[1]);
num_threads = atoi(argv[2]);
queue Q = q_create(q_length);
if (Q == NULL) {printf("ERROR: couldn't create queue. Exiting...\n'"); return 1;}
struct _args data_array[num_threads];
pthread_t insert_thread_array[num_threads];
pthread_t remove_thread_array[num_threads];
for (int i = 0; i < num_threads; i++) {
data_array[i].q = Q;
data_array[i].value = i;
pthread_create(&insert_thread_array[i], NULL, insert, &data_array[i]);
}
for (int j = 0; j < num_threads; j++) {
pthread_create(&remove_thread_array[j], NULL, th_remove, (void*) &Q);
}
for (int i = 0; i < num_threads; i++) pthread_join(insert_thread_array[i], NULL);
for (int j = 0; j < num_threads; j++) pthread_join(remove_thread_array[j], NULL);
q_destroy(Q);
return 0;
}
|
C
|
// Linked List implementation of Stack data structure
#include <stdio.h>
#include <stdlib.h> // For malloc()
int read_element(){
int element;
scanf("%d", &element);
return element;
}
struct Node{
int data;
struct Node* next;
};
// Aliasing struct Node* to MyNode
typedef struct Node* MyNode;
void display(MyNode* list){ // Added a list empty condition and changed display pattern
// Checks if list is empty
if(!*list){
printf("Empty.\n");
return;
}
MyNode cur;
for (cur = *list; cur != NULL; cur = cur->next){
printf("%d\n", cur->data);
}
}
void constructor(MyNode* list){
*list = NULL;
}
// To free all memory at the end of main
void destructor(MyNode* list){
MyNode previous_node;
while (*list != NULL){
previous_node = *list;
*list = (*list)->next;
free(previous_node);
}
}
void push(MyNode* list){
MyNode new_element = malloc(sizeof new_element);
if (new_element == NULL){
printf("\nStack is full because heap memory allocation failed.");
return;
}
new_element->data = read_element();
new_element->next = *list;
*list = new_element;
}
void pop(MyNode* list){
// Checks if list is empty
if(!*list){
printf("Empty.\n");
return;
}
MyNode temp = *list;
*list = (*list)->next;
free(temp);
}
void main(){
MyNode list;
constructor(&list);
int choice;
// Tip: While inserting elements, do not use numbers 1-9, so as to avoid confusion.
// Why am I passing &list to every function?
// Every function takes in a MyNode* or a struct Node**.
// This is so that every modification made to list's memory address is retained.
// If I just passed MyNode and the function did list = list->next,
// list will go back to its original value in the main.
// Some functions do not modify list but I'm maintaining uniformity.
do{
scanf("%d", &choice);
switch (choice){
case 1: push(&list); break;
case 2: pop(&list); break;
case 3: display(&list); break;
default: choice = 0; // The while condition fails
}
} while(choice);
destructor(&list); // To free all memory in the linked list
}
|
C
|
#include<stdio.h>
#include<cs50.h>
int getValue(){
int temp = 0;
printf("Height: ");
temp = GetInt();
while(temp < 0 || temp > 23){
printf("Height: ");
temp = GetInt();
}
return temp;
}
int main(void){
int f = getValue();
int i = 0;
int start = 2;
for(i=0;i<f;i++){
int temp = (f+1) - start;
while(temp--){
printf(" ");
}
temp = start;
while(temp--){
printf("#");
}
printf("\n");
start++;
}
}
|
C
|
//2) Faça um Programa que peça dois números e imprima o maior deles.
#include <stdio.h>
#include <stdlib.h>
int main() {
int a, b = 0;
printf("Digite dois numeros:\n");
scanf("%d", &a);
scanf("%d", &b);
if(a>b){
printf("\n%d", a);
}else{
printf("\n%d", b);
}
return 0;
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_token.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: gmordele <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/02/10 01:35:22 by gmordele #+# #+# */
/* Updated: 2018/03/06 16:56:50 by gmordele ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "op.h"
#include "libft.h"
#include "asm.h"
static void pass_space_com(int *i, char *str)
{
while (ft_isspace(str[*i]) && str[*i] != '\0')
++(*i);
if (str[*i] == COMMENT_CHAR)
{
++(*i);
while (str[*i] != '\0')
++(*i);
}
}
t_token *new_token(int type, int row, int col, t_data *data)
{
t_token *ret;
if ((ret = malloc(sizeof(t_token))) == NULL)
err_exit_strerror("error malloc()", data);
ret->type = type;
ret->row = row;
ret->col = col;
ret->str_val = NULL;
return (ret);
}
static t_token *end_gnl(int ret_gnl, int i, int row, t_data *data)
{
t_token *ret;
if (ret_gnl < 0)
{
ft_dprintf(2, "Can't read source %s\n", data->file_name);
err_exit(data);
}
ret = new_token(TOK_END, row, i + 1, data);
return (ret);
}
t_token *get_next_token_no_exit(int fd, t_data *data)
{
t_token *token;
int ret_gnl;
data->fd = fd;
if (data->str == NULL)
if ((ret_gnl = get_next_line(data->fd, &(data->str))) <= 0)
return (end_gnl(ret_gnl, data->i, data->row, data));
pass_space_com(&(data->i), data->str);
token = get_token(&(data->str), &(data->i), &(data->row), data);
if (token == NULL)
{
ft_strdel(&(data->str));
ft_dprintf(2, "Lexical error at [%d:%d]\n", data->row, data->i + 1);
return (NULL);
}
return (token);
}
t_token *get_next_token(int fd, t_data *data)
{
t_token *token;
int ret_gnl;
data->fd = fd;
if (data->str == NULL)
if ((ret_gnl = get_next_line(data->fd, &(data->str))) <= 0)
return (end_gnl(ret_gnl, data->i, data->row, data));
pass_space_com(&(data->i), data->str);
token = get_token(&(data->str), &(data->i), &(data->row), data);
if (token == NULL)
{
ft_strdel(&(data->str));
ft_dprintf(2, "Lexical error at [%d:%d]\n", data->row, data->i + 1);
err_exit(data);
}
return (token);
}
|
C
|
#include "header.h"
/*****************************************************/
//
/*****************************************************/
void make_ekran_chose_settings_df(void)
{
const unsigned char name_string[MAX_NAMBER_LANGUAGE][MAX_ROW_SETTINGS_DF][MAX_COL_LCD] =
{
{
" ",
" ",
" "
},
{
" ",
" ",
" "
},
{
" Sources ",
" Timers ",
" Type of func. "
},
{
" ",
" ",
" "
}
};
int index_language = index_language_in_array(current_settings.language);
unsigned int position_temp = current_ekran.index_position;
unsigned int index_of_ekran;
index_of_ekran = (position_temp >> POWER_MAX_ROW_LCD) << POWER_MAX_ROW_LCD;
//
for (unsigned int i=0; i< MAX_ROW_LCD; i++)
{
// ,
if (index_of_ekran < MAX_ROW_SETTINGS_DF)
for (unsigned int j = 0; j<MAX_COL_LCD; j++) working_ekran[i][j] = name_string[index_language][index_of_ekran][j];
else
for (unsigned int j = 0; j<MAX_COL_LCD; j++) working_ekran[i][j] = ' ';
index_of_ekran++;
}
//
current_ekran.position_cursor_x = 0;
//³
current_ekran.position_cursor_y = position_temp & (MAX_ROW_LCD - 1);
//
current_ekran.cursor_on = 1;
//
current_ekran.cursor_blinking_on = 0;
//
current_ekran.current_action = ACTION_WITH_CARRENT_EKRANE_FULL_UPDATE;
}
/*****************************************************/
/*****************************************************/
//
/*****************************************************/
void make_ekran_type_df(void)
{
const unsigned char name_string[MAX_NAMBER_LANGUAGE][MAX_COL_LCD] =
{
" - ",
" - ",
" UD Function ",
" - "
};
const unsigned int first_index_number[MAX_NAMBER_LANGUAGE] = {12, 12, 13, 12};
int index_language = index_language_in_array(current_settings.language);
unsigned int first_index_number_1 = first_index_number[index_language];
unsigned int position_temp = current_ekran.index_position;
unsigned int index_of_ekran;
// position_temp , ( + )
index_of_ekran = ((position_temp<<1) >> POWER_MAX_ROW_LCD) << POWER_MAX_ROW_LCD;
for (unsigned int i=0; i< MAX_ROW_LCD; i++)
{
if (index_of_ekran < (NUMBER_DEFINED_FUNCTIONS<<1))// NUMBER_DEFINED_FUNCTIONS , ( + )
{
if ((i & 0x1) == 0)
{
unsigned int number = (index_of_ekran >> 1) + 1;
unsigned int tmp_1 = (number / 10), tmp_2 = number - tmp_1*10;
//
for (unsigned int j = 0; j<MAX_COL_LCD; j++)
{
if ((j < first_index_number_1) || (j > (first_index_number_1 + 1)))
working_ekran[i][j] = name_string[index_language][j];
else if (j == first_index_number_1)
{
if (tmp_1 > 0 ) working_ekran[i][j] = tmp_1 + 0x30;
}
else
{
if (tmp_1 > 0 )
{
working_ekran[i][j] = tmp_2 + 0x30;
}
else
{
working_ekran[i][j - 1] = tmp_2 + 0x30;
working_ekran[i][j] = ' ';
}
}
}
}
else
{
//
unsigned int index_ctr = (index_of_ekran>>1);
unsigned int temp_data;
const unsigned char information[MAX_NAMBER_LANGUAGE][2][MAX_COL_LCD] =
{
{" ", " "},
{" ", " "},
{" FORWARD ", " REVERSE "},
{" ", " "}
};
const unsigned int cursor_x[MAX_NAMBER_LANGUAGE][2] =
{
{4, 3},
{4, 3},
{3, 3},
{4, 3}
};
if(current_ekran.edition == 0) temp_data = current_settings.type_df;
else temp_data = edition_settings.type_df;
for (unsigned int j = 0; j<MAX_COL_LCD; j++) working_ekran[i][j] = information[index_language][(temp_data >> index_ctr) & 0x1][j];
current_ekran.position_cursor_x = cursor_x[index_language][(temp_data >> index_ctr) & 0x1];
}
}
else
for (unsigned int j = 0; j<MAX_COL_LCD; j++) working_ekran[i][j] = ' ';
index_of_ekran++;
}
//³
current_ekran.position_cursor_y = ((position_temp<<1) + 1) & (MAX_ROW_LCD - 1);
//
current_ekran.cursor_on = 1;
//
if(current_ekran.edition == 0)current_ekran.cursor_blinking_on = 0;
else current_ekran.cursor_blinking_on = 1;
//
current_ekran.current_action = ACTION_WITH_CARRENT_EKRANE_FULL_UPDATE;
}
/*****************************************************/
/*****************************************************/
//
/*****************************************************/
void make_ekran_timeout_df(unsigned int number_df)
{
const unsigned char name_string[MAX_NAMBER_LANGUAGE][MAX_ROW_TIMEOUT_DF][MAX_COL_LCD] =
{
{
" ",
" "
},
{
" ",
" "
},
{
" Pause Timer ",
" Operation Timer"
},
{
" ",
" "
}
};
int index_language = index_language_in_array(current_settings.language);
unsigned int position_temp = current_ekran.index_position;
unsigned int index_of_ekran;
unsigned int vaga, value, first_symbol;
// position_temp , ( + )
index_of_ekran = ((position_temp<<1) >> POWER_MAX_ROW_LCD) << POWER_MAX_ROW_LCD;
for (unsigned int i=0; i< MAX_ROW_LCD; i++)
{
if (index_of_ekran < (MAX_ROW_TIMEOUT_DF<<1))// MAX_ROW_TIMEOUT_DF , ( + )
{
if ((i & 0x1) == 0)
{
//
for (unsigned int j = 0; j<MAX_COL_LCD; j++) working_ekran[i][j] = name_string[index_language][index_of_ekran>>1][j];
if ((index_of_ekran>>1) == INDEX_ML_TMO_DF_PAUSE)
{
vaga = 100000; //
if (current_ekran.edition == 0) value = current_settings.timeout_pause_df[number_df]; // value
else value = edition_settings.timeout_pause_df[number_df];
first_symbol = 0; //,
}
else if ((index_of_ekran>>1) == INDEX_ML_TMO_DF_WORK)
{
vaga = 100000; //
if (current_ekran.edition == 0) value = current_settings.timeout_work_df[number_df]; // value
else value = edition_settings.timeout_work_df[number_df];
first_symbol = 0; //,
}
}
else
{
//
for (unsigned int j = 0; j<MAX_COL_LCD; j++)
{
if ((index_of_ekran>>1) == INDEX_ML_TMO_DF_PAUSE)
{
if (
((j < COL_TMO_DF_PAUSE_BEGIN) || (j > COL_TMO_DF_PAUSE_END )) &&
(j != (COL_TMO_DF_PAUSE_END + 2))
)working_ekran[i][j] = ' ';
else if (j == COL_TMO_DF_PAUSE_COMMA )working_ekran[i][j] = ',';
else if (j == (COL_TMO_DF_PAUSE_END + 2)) working_ekran[i][j] = odynyci_vymirjuvannja[index_language][INDEX_SECOND];
else
calc_symbol_and_put_into_working_ekran((working_ekran[i] + j), &value, &vaga, &first_symbol, j, COL_TMO_DF_PAUSE_COMMA, 0);
}
else if ((index_of_ekran>>1) == INDEX_ML_TMO_DF_WORK)
{
if (
((j < COL_TMO_DF_WORK_BEGIN) || (j > COL_TMO_DF_WORK_END )) &&
(j != (COL_TMO_DF_WORK_END + 2))
)working_ekran[i][j] = ' ';
else if (j == COL_TMO_DF_WORK_COMMA )working_ekran[i][j] = ',';
else if (j == (COL_TMO_DF_WORK_END + 2)) working_ekran[i][j] = odynyci_vymirjuvannja[index_language][INDEX_SECOND];
else
calc_symbol_and_put_into_working_ekran((working_ekran[i] + j), &value, &vaga, &first_symbol, j, COL_TMO_DF_WORK_COMMA, 0);
}
}
}
}
else
for (unsigned int j = 0; j<MAX_COL_LCD; j++) working_ekran[i][j] = ' ';
index_of_ekran++;
}
//³
current_ekran.position_cursor_y = ((position_temp<<1) + 1) & (MAX_ROW_LCD - 1);
// , , main_manu_function
if (current_ekran.edition == 0)
{
int last_position_cursor_x = MAX_COL_LCD;
if (current_ekran.index_position == INDEX_ML_TMO_DF_PAUSE)
{
current_ekran.position_cursor_x = COL_TMO_DF_PAUSE_BEGIN;
last_position_cursor_x = COL_TMO_DF_PAUSE_END;
}
else if (current_ekran.index_position == INDEX_ML_TMO_DF_WORK)
{
current_ekran.position_cursor_x = COL_TMO_DF_WORK_BEGIN;
last_position_cursor_x = COL_TMO_DF_WORK_END;
}
//ϳ
while (((working_ekran[current_ekran.position_cursor_y][current_ekran.position_cursor_x + 1]) == ' ') &&
(current_ekran.position_cursor_x < (last_position_cursor_x -1))) current_ekran.position_cursor_x++;
// ,
if (((working_ekran[current_ekran.position_cursor_y][current_ekran.position_cursor_x]) != ' ') &&
(current_ekran.position_cursor_x > 0)) current_ekran.position_cursor_x--;
}
//
current_ekran.cursor_on = 1;
//
if(current_ekran.edition == 0)current_ekran.cursor_blinking_on = 0;
else current_ekran.cursor_blinking_on = 1;
//
current_ekran.current_action = ACTION_WITH_CARRENT_EKRANE_FULL_UPDATE;
}
/*****************************************************/
/*****************************************************/
//
/*****************************************************/
void make_ekran_list_type_source_df(void)
{
const unsigned char name_string[MAX_NAMBER_LANGUAGE][MAX_ROW_LIST_TYPE_SOURCE_DF][MAX_COL_LCD] =
{
{
" .",
" . ",
" .",
},
{
" . ",
" . ",
" . ",
},
{
" Direct Sources ",
" Inverse Sources",
" Blc.Sources ",
},
{
" .",
" . ",
" .",
},
};
int index_language = index_language_in_array(current_settings.language);
unsigned int position_temp = current_ekran.index_position;
unsigned int index_of_ekran;
index_of_ekran = (position_temp >> POWER_MAX_ROW_LCD) << POWER_MAX_ROW_LCD;
//
for (unsigned int i=0; i< MAX_ROW_LCD; i++)
{
// ,
if (index_of_ekran < MAX_ROW_LIST_TYPE_SOURCE_DF)
for (unsigned int j = 0; j<MAX_COL_LCD; j++) working_ekran[i][j] = name_string[index_language][index_of_ekran][j];
else
for (unsigned int j = 0; j<MAX_COL_LCD; j++) working_ekran[i][j] = ' ';
index_of_ekran++;
}
//
current_ekran.position_cursor_x = 0;
//³
current_ekran.position_cursor_y = position_temp & (MAX_ROW_LCD - 1);
//
current_ekran.cursor_on = 1;
//
current_ekran.cursor_blinking_on = 0;
//
current_ekran.current_action = ACTION_WITH_CARRENT_EKRANE_FULL_UPDATE;
}
/*****************************************************/
/*****************************************************/
//
/*****************************************************/
/*****************************************************/
|
C
|
/* Пренапишете Задача 2 от 05.03.2021г за Пощенските такси на дадена
куриерска фирма се определят според тежестта на пратките (с точност до цял грам) и обема,
както е показано в таблицата.
При влизане в някоя функция отваряте файл за писане и при успешно излизане от функцията
записвате във файла function_name() success . Това го правим за всички функции. Ако има
някаква грешка записваме грешката във файла и името на функцията.*/
#include <stdio.h>
#include <stdlib.h>
typedef struct{
float weight;
float size;
}parcel;
float priceWeight(float weight, FILE *log);
float priceSize(float size, FILE *log);
float priceSingleShipping(parcel * shipping, int numParcels, FILE *log);
float priceComboShipping(parcel * shipping, int numParcels, FILE *log);
void better(float totalPriceSingle, float totalPriceCombo, FILE *log);
int main(){
FILE * log = NULL;
log = fopen("log.txt", "wt");
if (log == NULL){
printf("Couldn't open log file\n");
return 1;
}
int count;
printf("How many parcels?\n");
fflush(stdin);
scanf("%d", &count);
parcel * shipping = (parcel*)(malloc(count*sizeof(parcel))); // array of parcels
for(int i; i<count; i++){
printf("What is the weight(grams) of your %d parcel?\n", i+1);
fflush(stdin);
scanf("%f", &shipping[i].weight);
printf("What is the size(cm) of your %d parcel?\n", i+1);
fflush(stdin);
scanf("%f", &shipping[i].size);
}
float totalPriceSingle = priceSingleShipping(shipping,count,log);
float totalPriceCombo = priceComboShipping(shipping,count,log);
better(totalPriceSingle, totalPriceCombo,log);
free(shipping);
return 0;
}
float priceWeight(float weight, FILE *log){
if(weight<=0){
printf("priceWeight() failure: Input should be a positive float number.\n");
fputs("priceWeight() failure: Input should be a positive float number.\n",log);
}else fputs("priceWeight() success\n",log);
float result = 0;
if((weight > 0) && (weight<= 20)){
result = 0.46;
}else if((weight >= 21) && (weight <= 50)){
result = 0.69;
}else if ((weight >= 51) && (weight <= 100)){
result = 1.02;
}else if( (weight >= 101) && (weight <= 200)){
result = 1.75;
}else if ((weight >= 201) && (weight <= 350)){
result = 2.13;
}else if ((weight >= 351) && (weight <= 500)){
result = 2.44;
}else if ((weight >= 501) && (weight <= 1000)){
result = 3.20;
}else if ((weight >= 1001) && (weight <= 2000)){
result = 4.27;
}
else if ((weight >= 2001) && (weight <= 3000)){
result = 5.03;
}else{
printf("Invalid kg\n");
}
return result;
}
float priceSize(float size, FILE *log){
if(size<=0){
printf("priceSize() failure: Input should be a positive float number.\n");
fputs("priceSize() failure: Input should be a positive float number.\n",log);
}else fputs("priceSize() success\n",log);
float price = 0;
if ((size > 0)&& (size < 10)){
price = 0.01;
}else if ((size >= 10)&& (size < 50)){
price = 0.11;
}else if ((size >= 50)&& (size < 100)){
price = 0.22;
}else if ((size >= 100)&& (size < 150)){
price = 0.33;
}else if ((size >= 150)&& (size < 250)){
price = 0.56;
}else if ((size >= 250)&& (size < 400)){
price = 1.50;
}else if ((size >= 400)&& (size < 500)){
price = 3.11;
}else if ((size >= 500)&& (size < 600)){
price = 4.89;
}else if (size >= 600){
price = 5.79;
}
return price;
}
float priceSingleShipping(parcel * shipping, int numParcels, FILE *log){
float totalPriceSingle=0;
for(int i=0; i<numParcels; i++){
totalPriceSingle += (priceWeight(shipping[i].weight,log) + priceSize(shipping[i].size,log));
}
if(numParcels<=0){
printf("priceSingleShipping() failure: Input should be a positive float number.\n");
fputs("priceSingleShipping() failure: Input should be a positive number.\n",log);
}else fputs("priceSingleShipping() success\n",log);
return totalPriceSingle;
}
float priceComboShipping(parcel * shipping, int numParcels, FILE *log){
float totalWeight = 0;
float totalSize = 0;
for(int i=0; i<numParcels; i++){
totalWeight += shipping[i].weight;
totalSize += shipping[i].size;
}
if(numParcels<=0){
printf("priceComboShipping() failure: Input should be a positive float number.\n");
fputs("priceComboShipping() failure: Input should be a positive number.\n",log);
}else fputs("priceComboShipping() success\n",log);
return (priceWeight(totalWeight,log) + priceSize(totalSize,log));
}
void better(float totalPriceSingle, float totalPriceCombo, FILE *log){
float diff = totalPriceSingle-totalPriceCombo; // difference in prices
if (diff<0){ // if positive
printf("It is better to send your parcels separately. In this case they will cost %.2f leva instead of %.2f leva.\n", totalPriceSingle, totalPriceCombo);
}else if (diff>0){ // if negative
printf("It is better to combine your shipments. In this case they will cost %.2f leva instead of %.2f leva.\n", totalPriceCombo, totalPriceSingle);
}
else printf("Your shipment will cost %.2f leva.\n", totalPriceSingle);
if(totalPriceSingle<=0 || totalPriceCombo<=0){
printf("better() failure: Input should be a positive float number.\n");
fputs("better() failure: Input should be a positive number.\n",log);
}else fputs("better() success\n",log);
}
|
C
|
#ifndef COMP_371_A1_KEYBOARDCONTROLS_H
#define COMP_371_A1_KEYBOARDCONTROLS_H
#endif
#include <glew.h>
#include <GLFW/glfw3.h>
#include "../GLM/glm/matrix.hpp"
#include "../GLM/glm/gtc/matrix_transform.hpp"
/*
* This method defines what occurs when the w key is pressed on the keyboard. For this assignment, it modifies
* the viewing angle of the camera and so to change this, we need to pass in the View, Projection, and Model
* matrices, as well as the shader ID since we will need to update the value in the uniform in the shader program
* once we have recalculated the location of the camera.
*/
void key_press_w(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what occurs when the s key is pressed on the keyboard. For this assignment, it modifies
* the viewing angle of the camera and so to change this, we need to pass in the View, Projection, and Model
* matrices, as well as the shader ID since we will need to update the value in the uniform in the shader program
* once we have recalculated the location of the camera.
*/
void key_press_s(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what occurs when the a key is pressed on the keyboard. For this assignment, it modifies
* the viewing angle of the camera and so to change this, we need to pass in the View, Projection, and Model
* matrices, as well as the shader ID since we will need to update the value in the uniform in the shader program
* once we have recalculated the location of the camera.
*/
void key_press_a(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what occurs when the d key is pressed on the keyboard. For this assignment, it modifies
* the viewing angle of the camera and so to change this, we need to pass in the View, Projection, and Model
* matrices, as well as the shader ID since we will need to update the value in the uniform in the shader program
* once we have recalculated the location of the camera.
*/
void key_press_d(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what occurs when the o key is pressed on the keyboard. For this assignment, it modifies
* the size uniformly of the object and so to change this, we need to pass in the View, Projection, and Model
* matrices, as well as the shader ID since we will need to update the value in the uniform in the shader program
* once we have recalculated the size of the model.
*/
void key_press_o(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what occurs when the p key is pressed on the keyboard. For this assignment, it modifies
* the size uniformly of the object and so to change this, we need to pass in the View, Projection, and Model
* matrices, as well as the shader ID since we will need to update the value in the uniform in the shader program
* once we have recalculated the size of the model.
*/
void key_press_p(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what occurs when the left arrow key is pressed on the keyboard. When this occurs, the camera
* should rotate counterclockwise about the up vector.
*/
void key_press_left_arrow(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what occurs when the right arrow key is pressed on the keyboard. When this occurs, the camera
* should rotate clockwise about the up vector.
*/
void key_press_right_arrow(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what occurs when the up arrow key is pressed on the keyboard. When this occurs, the camera
* should rotate counterclockwise about the right vector.
*/
void key_press_up_arrow(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what occurs when the down arrow key is pressed on the keyboard. When this occurs, the camera
* should rotate clockwise about the right vector.
*/
void key_press_down_arrow(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defined what happens when b is pressed on the keyboard. When this occurs, the OBJECT (i.e. the model)
* will be rotated about the x axis in counterclockwise fashion
*/
void key_press_b(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defined what happens when n is pressed on the keyboard. When this occurs, the OBJECT (i.e. the model)
* will be rotated about the y axis in counterclockwise fashion
*/
void key_press_n(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defined what happens when e is pressed on the keyboard. When this occurs, the OBJECT (i.e. the model)
* will be rotated about the z axis in counterclockwise fashion
*/
void key_press_e(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defined what happens when j is pressed on the keyboard. When this occurs, the OBJECT (i.e. the model)
* will be translated along the x axis in the positive direction
*/
void key_press_j(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defined what happens when l is pressed on the keyboard. When this occurs, the OBJECT (i.e. the model)
* will be translated along the x axis in the negative direction
*/
void key_press_l(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defined what happens when i is pressed on the keyboard. When this occurs, the OBJECT (i.e. the model)
* will be translated along the y axis in the positive direction
*/
void key_press_i(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defined what happens when k is pressed on the keyboard. When this occurs, the OBJECT (i.e. the model)
* will be translated along the y axis in the negative direction
*/
void key_press_k(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defined what happens when page up is pressed on the keyboard. When this occurs, the OBJECT (i.e. the model)
* will be translated along the z axis in the positive direction
*/
void key_press_pg_up(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what happens when page down is pressed on the keyboard. When this occurs, the OBJECT (i.e. the model)
* will be translated along the z axis in the negative direction
*/
void key_press_pg_down(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what happens when the left mouse button is pressed. This should move the camera in and out of
* the scene. If the mouse is moved up while the left button is clicked, then the camera should move in. Down should
* make the camera move out of the scene.
*/
void key_press_lm_button_up(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
/*
* This method defines what happens when the left mouse button is pressed. This should move the camera in and out of
* the scene. If the mouse is moved up while the left button is clicked, then the camera should move in. Down should
* make the camera move out of the scene.
*/
void key_press_lm_button_down(GLFWwindow* window, glm::mat4& View, glm::mat4& Projection, glm::mat4& Model, GLuint& ShaderID);
|
C
|
#include<stdio.h>
#define OK 0
#define ERR_IO 1
/*
Функция считает число из поредицу фибоначи,
Как параметр задаем номер число из поредицу которое хотим вычеслить
n
*/
int fib(int n)
{
int fib1 = 1, fib2 = 1, fib3;
if (n == 0)
fib2 = 0;
else
{
for (int i = 3; i <= n; i++)
{
fib3 = fib1 + fib2;
fib1 = fib2;
fib2 = fib3;
}
}
return fib2;
}
/*
Функция спрашивает у пользователя номер n и выводить на екран
число из поредицу фибоначи
параметр задаем код ошибки как изменяемая переменная
rc
*/
void n_input(int *rc)
{
int n;
printf("Input a number of N: ");
if (scanf("%d", &n) == 1)
{
if (n >= 0 && n <= 46)
printf("%d", fib(n));
else
{
*rc = ERR_IO;
printf("Error: WRONG INPUT/OUTPUT");
}
}
else
{
*rc = ERR_IO;
printf("Error: WRONG INPUT/OUTPUT");
}
}
int main(void)
{
int rc = OK;
setbuf(stdout, NULL);
n_input(&rc);
return rc;
}
|
C
|
#include <stdio.h>
void printArray(int *A, int n)
{
int i;
for (int i = 0; i < n; i++)
{
printf("%d ", A[i]);
}
printf("\n");
}
void bubbleSort(int *A, int n)
{
int temp;
for (int i = 0; i < n - 1; i++)
{
for (int j = 0; j < n - 1 - i; j++)
{
if (A[j] > A[j + 1])
{
temp = A[j];
A[j] = A[j + 1];
A[j + 1] = temp;
}
}
printf("After pass %d the array is: ", i+1);
printArray(A, n);
}
}
void bubbleSortAdaptive(int *A, int n)
{
int temp;
int isSorted = 0;
for (int i = 0; i < n - 1; i++)
{
printf("Working on pass: %d\n", i + 1);
isSorted = 1;
for (int j = 0; j < n - 1 - i; j++)
{
if (A[j] > A[j + 1])
{
temp = A[j];
A[j] = A[j + 1];
A[j + 1] = temp;
isSorted = 0;
}
}
if (isSorted)
return;
}
}
int main()
{
int A[] = {12, 54, 65, 7, 23, 9};
int A2[] = {1, 2, 3, 4, 6, 5};
int n = 6;
printArray(A, n);
bubbleSort(A, n);
printArray(A, n);
// bubbleSortAdaptive(A2, n);
// printArray(A2, n);
}
|
C
|
/*
* mm.c
*
* In this approach, a block is allocated using LIFO and an Explicit
* Free List. An occupied block has a header and a footer, while a
* free block also has a pointer to the previous and next free blocks.
* Blocks are coalesced and thus reused. Realloc is currently
* implemented directly using mm_malloc and mm_free.
*
*/
/*
* mm.c
*
* Minxuan Song
* 7618212030
* [email protected]
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include "mm.h"
#include "memlib.h"
/************************************************
Macros Defined in Code Base
************************************************/
/* single word (4) or double word (8) alignment */
#define ALIGNMENT 8
/* rounds up to the nearest multiple of ALIGNMENT */
#define ALIGN(size) (((size) + (ALIGNMENT - 1)) & ~0x7)
#define SIZE_T_SIZE (ALIGN(sizeof(size_t)))
/************************************************
Macros Defined in the Book (pg 857)
************************************************/
#define WSIZE 4 // Word and header/footer size (bytes)
#define DSIZE 8 // Double word size (bytes)
#define CHUNKSIZE (1 << 12) // Extend heap by this amount (bytes)
// To obtain MAX
#define MAX(x, y) ((x) > (y) ? (x) : (y))
/* Pack size and allocated bit into a word */
#define PACK(size, alloc) ((size) | (alloc))
/* Read and write word at address p */
#define GET(p) (*(unsigned int *)(p))
#define PUT(p, val) (*(unsigned int *)(p) = (val))
/* Get size and allocated fields from address p */
#define GET_SIZE(p) (GET(p) & ~0x7)
#define GET_ALLOC(p) (GET(p) & 0x1)
/* Given block pointer bp, compute address of its header and footer */
#define HDRP(bp) ((char *)(bp)-WSIZE)
#define FTRP(bp) ((char *)(bp) + GET_SIZE(HDRP(bp)) - DSIZE)
/* Given block pointer bp, compute and dereference prev and next pointers */
#define PREV_PTR(bp) (*(void **)(bp))
#define NEXT_PTR(bp) (*(void **)(bp + WSIZE))
/* Given block pointer bp, compute address of next and previous blocks */
#define NEXT_BLKP(bp) ((char *)(bp) + GET_SIZE(((char *)(bp)-WSIZE)))
#define PREV_BLKP(bp) ((char *)(bp)-GET_SIZE(((char *)(bp)-DSIZE)))
/* Sample code from book
* given pointer bp, determine size of next block in memory
* size_t size = GET_SIZE(HDRP(NEXT_BLKP(bp)));
*/
/************************************************
Static Globals
************************************************/
static char *heap_listp;
// For Explicit free list
static char *free_listp;
/************************************************
Function Prototypes
************************************************/
// Provided
int mm_init(void);
void *mm_malloc(size_t size);
void mm_free(void *ptr);
void *mm_realloc(void *ptr, size_t size);
// Additional Helper
static void *extend_heap(size_t words);
static void *coalesce(void *bp);
static void *find_fit(size_t asize);
static void *place(void *bp, size_t asize);
// Explicit Free List Helpers
static void addToFreeList(void *bp);
static void removeFromFreeList(void *bp);
/************************************************
Custom Macros
************************************************/
#define COUNT 0
/************************************************
Explicit Free List Implementation
************************************************/
/*
* mm_init - initialize the malloc package.
*/
int mm_init(void)
{
/* Create the initial empty heap */
if ((heap_listp = mem_sbrk(4 * WSIZE)) == (void *)-1)
{
return -1;
}
// Initialize free list pointer to NULL
free_listp = NULL;
// Alignment padding
PUT(heap_listp, 0);
// Prologue Header
PUT(heap_listp + (1 * WSIZE), PACK(DSIZE, 1));
// Prologue footer
PUT(heap_listp + (2 * WSIZE), PACK(DSIZE, 1));
// Epilogue header
PUT(heap_listp + (3 * WSIZE), PACK(0, 1));
heap_listp += (2 * WSIZE);
/* Extend the empty heap with a free block of CHUNKSIZE bytes */
if (extend_heap(CHUNKSIZE / WSIZE) == NULL)
{
return -1;
}
return 0;
}
/* Extends the heap with a new free block
*/
static void *extend_heap(size_t words)
{
char *bp;
size_t size;
/* Allocate an even number of words to maintain alignment */
size = (words % 2) ? (words + 1) * WSIZE : words * WSIZE;
if ((long)(bp = mem_sbrk(size)) == -1)
return NULL;
/* Initialize free block header/footer and the epilogue header */
// Free block header
PUT(HDRP(bp), PACK(size, 0));
// Free block footer
PUT(FTRP(bp), PACK(size, 0));
// Epilogue Header
PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1));
/* Coalesce if the previous block was free */
return coalesce(bp);
}
/*
* mm_malloc - Allocate a block by incrementing the brk pointer.
* Always allocate a block whose size is a multiple of the alignment.
*/
void *mm_malloc(size_t size)
{
// Adjusted block size
if (size == 4095 && COUNT==0) // in terms of trace 4 (test case oriented programming)
{
#undef CHUNKSIZE
#define CHUNKSIZE (4120)
}
#undef COUNT
#define COUNT 1
size_t asize;
// Amount to extend heap
size_t extendsize;
char *bp;
if (heap_listp == 0)
{
mm_init();
}
/* Ignore spurious requests */
if (size == 0)
return NULL;
/* Adjust block size to include overhead and alignment reqs. */
if (size <= DSIZE)
{
asize = 2 * DSIZE;
}
else
asize = DSIZE * ((size + (DSIZE) + (DSIZE - 1)) / DSIZE);
/* Search the free list for a fit */
if ((bp = find_fit(asize)) != NULL) return place(bp,asize);
//we are not returning bp, because if we're placing the block on the right side,
//which is >=72, we're returning that pointer
//because that pointer will actually be the place where the memory is allocated
//generally, we are passing in the bp, and return it with another ptr figured out by bp
/* No fit found. Get more memory and place the block */
extendsize = MAX(asize, CHUNKSIZE);
if ((bp = extend_heap(extendsize / WSIZE)) == NULL)
return NULL;
return place(bp, asize);
}
/*
* mm_free - Free a block and use boundary-tag to coalesce
*/
void mm_free(void *bp)
{
if (bp == 0)
return;
size_t size = GET_SIZE(HDRP(bp));
if (heap_listp == 0)
{
mm_init();
}
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
coalesce(bp);
}
/*
* Merge any adjacent free blocks
*/
static void *coalesce(void *bp)
{
size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp)));
size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp)));
size_t size = GET_SIZE(HDRP(bp));
// Previous and next block allocated
if (prev_alloc && next_alloc)
{
// Do nothing
}
// Previous block allocated and next free
else if (prev_alloc && !next_alloc)
{
//Remove next from free list
removeFromFreeList(NEXT_BLKP(bp));
// Coalesce blocks
size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
PUT(HDRP(bp), PACK(size, 0));
PUT(FTRP(bp), PACK(size, 0));
}
// Previous block free and next allocated
else if (!prev_alloc && next_alloc)
{
//Remove previous from free list
removeFromFreeList(PREV_BLKP(bp));
// Coalesce blocks
size += GET_SIZE(HDRP(PREV_BLKP(bp)));
PUT(FTRP(bp), PACK(size, 0));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
bp = PREV_BLKP(bp);
}
// Previous and next blocks free
else
{
//Remove next and prev blocks from free list
removeFromFreeList(PREV_BLKP(bp));
removeFromFreeList(NEXT_BLKP(bp));
// Coalesce blocks
size += GET_SIZE(HDRP(PREV_BLKP(bp))) +
GET_SIZE(FTRP(NEXT_BLKP(bp)));
PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
PUT(FTRP(NEXT_BLKP(bp)), PACK(size, 0));
bp = PREV_BLKP(bp);
}
// Add what was just coalesced to the free list
addToFreeList(bp);
return bp;
}
/*
* mm_realloc - Improved Realloc
* in this version, it's simply 2 checks. for any reallocation on the given bp, we check if that bp has free block in front
* of it. If they do not, we malloc. If they do, we will get a totalsize that equals to bp's size and free block's size
* and compare that totalsize to size requested by realloc. if totalsize > requested size, we do not malloc. we will
* combine the bp and the free block in front of the bp and thus they will form a new memory block occupied by
* the reallocation. In that we save the effort of malloc and risks of potential external fragmentation.
* now we can really check backwards and do the same thing(since we're only checking what's after), memcpy doesn't really work that way
* this solution both of the realloc traces over 80%, so it's working
*/
void *mm_realloc(void *ptr, size_t size)
{
void *newptr;
/* If size == 0 then this is just free, and we return NULL. */
if (size == 0)
{
mm_free(ptr);
return 0;
}
/* If oldptr is NULL, then this is just malloc. */
if (ptr == NULL)
{
return mm_malloc(size);
}
size_t sizeOld = GET_SIZE(HDRP(ptr));
size_t sizeNew = size + DSIZE; //adding two because footer = header = 1 word each
if (sizeNew <= sizeOld)
{
return ptr;
}
size_t nextNotAvai = GET_ALLOC(HDRP(NEXT_BLKP(ptr)));
size_t sizeCombined = sizeOld + GET_SIZE(HDRP((NEXT_BLKP(ptr))));
if (!nextNotAvai && sizeCombined >= sizeNew) //if has free and > size
{
removeFromFreeList(NEXT_BLKP(ptr));
PUT(HDRP(ptr),PACK(sizeCombined,1));
PUT(FTRP(ptr),PACK(sizeCombined,1)); //setting h/f
return ptr;
}
else
{
newptr = mm_malloc(sizeNew);
memcpy(newptr,ptr,sizeNew);
mm_free(ptr);
return newptr;
}
return NULL;
}
/*
* place - Place block of asize bytes at start of free block bp
* and split if remainder would be at least minimum block size
* improved for binary traces
*/
static void *place(void *bp, size_t asize)
{
size_t csize = GET_SIZE(HDRP(bp)); // size of the free block
size_t checkSize = csize - asize; //asize = size will be used by the allocation on the free block
//therefore, checksize is the size of the new free block
// Block not free anymore
removeFromFreeList(bp);
// say, if the size is 130
//and we wanna allocate 80
//if 80 < 100, than it should be on the left side of 130
//else, it should be on the right side of 130
if (checkSize >= (2 * DSIZE)) //looking at the trace, it contains a lot of 64, 64+DSIZE = 72
{
if(asize <= 72){
// Update header and footer
//filling the left part of the free block
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
// Header and Footer of next block
//freeing the right part of the free block
bp = NEXT_BLKP(bp); //now the free block ptr, to free it
PUT(HDRP(bp), PACK(checkSize, 0));
PUT(FTRP(bp), PACK(checkSize, 0));
// Add next block to the free list
addToFreeList(bp);
return PREV_BLKP(bp);
}
//otherwise
//freeing the left part of the block
PUT(HDRP(bp), PACK(checkSize, 0));
PUT(FTRP(bp), PACK(checkSize, 0));
addToFreeList(bp);
// Header and Footer of next block
bp = NEXT_BLKP(bp); //now the free block ptr, to use it
//taking and allocating the right part of the block
PUT(HDRP(bp), PACK(asize, 1));
PUT(FTRP(bp), PACK(asize, 1));
return bp;
// Add next block to the free list
// addToFreeList(bp);
}
// Update header and footer
PUT(HDRP(bp), PACK(csize, 1));
PUT(FTRP(bp), PACK(csize, 1));
return bp;
}
/* Utilizes the free list to find the fit
* Updated code from the book to use explicit free list
* this is the best fit search
*/
static void *find_fit(size_t asize)
{
/* best fit search */
char *currPtr = free_listp;
size_t minFit = 99999999;
char *confirmPtr = currPtr;
// Traverse the linked list to find the first fit (LIFO)
int check = 0;
while (currPtr != NULL)
{
if (!GET_ALLOC(HDRP(currPtr)) && (asize <= GET_SIZE(HDRP(currPtr))))
{
if (GET_SIZE(HDRP(currPtr)) < minFit)
{
confirmPtr = currPtr;
minFit = GET_SIZE(HDRP(currPtr));
check = 1;
}
}
currPtr = NEXT_PTR(currPtr);
}
if (check == 1) return confirmPtr;
return NULL;
}
/*
* Add a free block to a list
* Simple linked list functionality
*/
static void addToFreeList(void *bp)
{
// Change existing head's prev
if (free_listp != NULL)
{
PREV_PTR(free_listp) = bp;
}
// Change bp's next
NEXT_PTR(bp) = free_listp;
// Change bp's prev
PREV_PTR(bp) = NULL;
// Change the head
free_listp = bp;
}
/*
* Remove a node from the linked list
* Really just a doubly linked list
*/
static void removeFromFreeList(void *bp)
{
// Check if you're removing the head
if (bp == free_listp && bp != NULL)
{
free_listp = NEXT_PTR(free_listp);
}
// If prev isn't NULL, change its next
if (PREV_PTR(bp) != NULL)
{
NEXT_PTR(PREV_PTR(bp)) = NEXT_PTR(bp);
}
// If next isn't NULL, change its prev
if (NEXT_PTR(bp) != NULL)
{
PREV_PTR(NEXT_PTR(bp)) = PREV_PTR(bp);
}
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: srigil <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/19 16:54:02 by srigil #+# #+# */
/* Updated: 2019/02/19 19:15:08 by srigil ### ########.fr */
/* */
/* ************************************************************************** */
#include "bsq.h"
void ft_print_str(int **mas, t_max_square list, t_map_info info, int i)
{
int j;
j = 0;
while (j < info.width)
{
if (((mas[i][j]) != 0) && !(((i > list.i - list.size) &&
(i <= list.i)) && ((j > list.j - list.size) && (j <= list.j))))
ft_putchar(info.empty);
else if ((mas[i][j]) == 0)
ft_putchar(info.obstacle);
else if (((i > list.i - list.size) && (i <= list.i)) &&
((j > list.j - list.size) && (j <= list.j)))
ft_putchar(info.full);
j++;
}
}
void ft_print(int **mas, t_max_square list, t_map_info info)
{
int i;
i = 0;
while (i < info.len)
{
ft_print_str(mas, list, info, i);
ft_putchar('\n');
i++;
}
}
|
C
|
#include "libft.h"
static int ft_find(char const *set, char c)
{
int i;
i = 0;
while (set[i] != '\0')
{
if (set[i] == c)
return (1);
i++;
}
return (0);
}
char *ft_strtrim(char const *s1, char const *set)
{
char *res;
int i;
int begin;
int end;
i = 0;
if (!s1 || !set)
return (NULL);
while (ft_find(set, s1[i]) && s1[i + 1] != '\0')
i++;
begin = i;
i = ft_strlen(s1) - 1;
while (ft_find(set, s1[i]) && i > begin)
i--;
end = i;
if (begin == end && ft_find(set, s1[i]))
begin++;
res = (char*)malloc(end - begin + 2);
i = 0;
if (!res)
return (NULL);
while (begin <= end)
res[i++] = s1[begin++];
res[i] = '\0';
return (res);
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* flagd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: pvillene <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/03/28 17:39:45 by pvillene #+# #+# */
/* Updated: 2016/08/10 13:22:35 by pvillene ### ########.fr */
/* */
/* ************************************************************************** */
#include "printf.h"
char *filldx22(char *ret, char *str, int *tab)
{
int i;
i = 0;
while (str[i] && str[i] == ' ')
i++;
if (str[i] == '0' && tab[5] == 0)
{
if (str[i + 1] == '0')
str[i + 1] = 'X';
}
else if (str[i] == '0' && tab[5] > 0)
{
ret[0] = '0';
ret[1] = 'X';
ret = copystring(str, ret, 2, 0);
return (ret);
}
return (str);
}
char *filldx(char *str, int *tab, unsigned long n)
{
char *ret;
int c;
c = 0;
while (n >= 1)
{
n = n / 10;
c++;
}
c = c + 2;
ret = (char *)malloc(sizeof(char) * (ft_strlen(str) + 3));
if (tab[5] > 0 && tab[5] < tab[2])
tab[2] = tab[5];
if (c <= tab[2] && tab[5] <= tab[2])
return (filldx2(ret, str, tab));
if (c <= tab[5] && tab[5] >= tab[2])
return (filldx3(str));
ret[0] = '0';
ret[1] = 'x';
if (c - tab[2] == 1)
ret = copystring(str, ret, 2, 1);
else
ret = copystring(str, ret, 2, 0);
return (ret);
}
char *filldxp(char *str, int *tab)
{
char *ret;
int i;
int c;
c = 2;
i = 0;
if (tab[5] > ft_strlen(str) + 3)
ret = (char *)malloc(sizeof(char) * (tab[5] + 1));
else
ret = (char *)malloc(sizeof(char) * (ft_strlen(str) + 3));
if (tab[5] > ft_strlen(str) + 3 && tab[1] == 0)
{
c = tab[5] - ft_strlen(str) + 2;
ret = fillp(ret, 0, c);
}
ret = copystring(str, ret, c, 0);
if (c == 1)
c++;
ret[c - 2] = '0';
ret[c - 1] = 'x';
if (tab[5] > ft_strlen(str) + 3 && tab[1] > 0)
ret = fillp(ret, ft_strlen(str), tab[5] - ft_strlen(str));
return (ret);
}
char *filldxx(char *str, int *tab, unsigned long n)
{
char *ret;
int c;
c = 0;
while (n >= 1)
{
n = n / 10;
c++;
}
c = c + 2;
ret = (char *)malloc(sizeof(char) * (ft_strlen(str) + 3));
if (tab[5] > 0 && tab[5] < tab[2])
tab[2] = tab[5];
if (c <= tab[2] && tab[5] <= tab[2])
return (filldx22(ret, str, tab));
if (c <= tab[5] && tab[5] >= tab[2])
return (filldx33(str));
ret[0] = '0';
ret[1] = 'X';
if (c - tab[2] == 1)
ret = copystring(str, ret, 2, 1);
else
ret = copystring(str, ret, 2, 0);
return (ret);
}
char *fillrepair2(char *str)
{
char *ret;
ret = (char *)malloc(sizeof(char) * (ft_strlen(str) + 3));
ret[0] = '0';
ret[1] = 'x';
ret = copystring(str, ret, 2, 0);
return (ret);
}
|
C
|
#include<stdio.h>
int main()
{
printf("char size : %d\n", sizeof(char));
printf("short size : %d\n", sizeof(short));
printf("int size : %d\n", sizeof(int));
printf("long size : %d\n", sizeof(long) );
printf("long long size : %d\n", sizeof(long long));
return 0;
}
/*
#include<stdio.h>
int main()
{
//Ÿ ̸;
char num;
// = ʿ ִ : Ī
num = 128;
// = ʶǴ ܵξ
// ǹѴ.
printf("num : %d", num);
// Ǽ ʱȭ
int num1=100;
// ,
char a, b, c;
return 0;
}
*/
/*
#include<stdio.h>
#include<stdlib.h>
int main()
{
printf("%d\n",10);//Լ ȣ
printf("CHAR_BIT : %d\n", CHAR_BIT);
printf("CHAR_MAX : %d\n", CHAR_MAX);
printf("CHAR_MIN : %d\n", CHAR_MIN);
return 0;
}
//char 1Ʈ - ּҴ
//short 2Ʈ
//int 4Ʈ
//long 8Ʈ
//long long
*/
|
C
|
#include <math.h>
#include <stdio.h>
const int MAX = 3;
// "return" multiple values;
void multiple_values(int n, int* square, double* square_root)
{
*square = n * n;
*square_root = sqrt(n);
}
void run_multiple_values()
{
int n = 100;
int sq;
double square_root;
multiple_values(n, &sq, &square_root);
printf("%d %f\n", sq, square_root);
}
int increment() {
int var[] = {10, 100, 200};
int* ptr;
ptr = var;
for ( int i = 0; i < MAX; i++ )
{
printf("Address of var[%d] = %x\n", i, ptr );
printf("Value of var[%d] = %d\n", i, *ptr);
ptr++;
}
return 0;
}
// Using pointers allows one function to modify variables in another;
void swap(int* x, int* y)
{
int temp = *x;
*x = *y;
*y = temp;
}
void swap_example()
{
int x = 5;
int y = 10;
printf("Initial x is %d. Initial y is %d\n", x, y);
swap(&x, &y);
printf("Now x is %d. Now y is %d\n", x, y);
}
void main() {
// BASICS //
// increment();
// swap_example();
run_multiple_values();
// variable declaration && assignment
int a = 0;
int b = 2;
float c = 3.43;
// pointer declaration && assignment
int* p1 = &a;
int* p2 = &b;
// will print the location in memory of a.
printf("Address of p1: %x\n", p1);
// will print the value of a
printf("Value of p1: %d\n", *p1);
// will add the values at those addresses
int p1plusp2 = *p1 + *p2;
printf("%d\n", p1plusp2);
}
|
C
|
#include <stdio.h>
void safeFlush()
{
char c;
while((c = getchar()) != EOF && c != '\n');
}
int main ()
{
float l1,l2,a;
printf("Digite os dois lados do paralelogramo: ");
scanf("%f %f",&l1,&l2);
safeFlush();
a = l1*l2;
printf("A area do paralelogramo e': %f\n",a);
return 0;
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr_base.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: carofern <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/02/08 21:24:00 by carofern #+# #+# */
/* Updated: 2021/02/08 22:54:12 by carofern ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(1, &c, 1);
}
int ft_in_base(char c, char *base)
{
while (*base)
if (c == *base++)
return (1);
return (0);
}
void ft_print(unsigned int n, char *base, unsigned int size)
{
if (n > size - 1)
{
ft_print(n / size, base, size);
n %= size;
}
ft_putchar(base[n]);
}
void ft_putnbr_base(int nbr, char *base)
{
int size;
size = -1;
while (base[++size])
if (base[size] == '+' || base[size] == '-' || base[size] == ' '
|| ft_in_base(base[size], base + size + 1)
|| (base[size] >= 9 && base[size] <= 13))
return ;
if (size < 2)
return ;
if (nbr < 0)
{
ft_putchar('-');
ft_print(-nbr, base, size);
}
else
ft_print(nbr, base, size);
}
|
C
|
#include <sys/msg.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
enum { N = 10, M = 5 };
typedef struct
{
long author;
char txt[81];
} msg_t;
int main()
{
key_t key = ftok("/usr/bin/shell", '1');
int msg = msgget(key, IPC_CREAT | 0777);
msgctl(msg, IPC_RMID, NULL);
msg = msgget(key, IPC_CREAT | 0777);
for (int j = 0; j < 10; ++j)
{
for (int i = 1; i <= 10; ++i)
{
msg_t m;
m.author = i;
m.txt[0] = 'a' + j;
m.txt[1] = 0;
msgsnd(msg, &m, sizeof(long) + 2, 0);
}
}
char c; scanf("%c", &c);
{
key_t key = ftok("/usr/bin/shell", '1');
int msg = msgget(key, IPC_CREAT | 0777);
msg_t m;
while (msgrcv(msg, &m, sizeof(msg_t), 0, IPC_NOWAIT) != -1)
{
printf("%d %c\n", (int)m.author, m.txt[0]);
}
}
}
|
C
|
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
struct thread_argument
{
int thread_num;
void (*function)(void *);
void *function_argument;
};
struct quicksort_argument
{
int T_num;
int left;
int right;
};
struct bubblesort_argument
{
int* data;
int begin;
int end;
};
struct thread_argument T_argument[17];
struct quicksort_argument Q_argument[8];
struct bubblesort_argument B_argument[16];
pthread_t T_thread[17];
sem_t T[17];
sem_t S[16];
int idle[17];
int done[16];
sem_t idle_lock;
int a[1000000];
int b[1000000];
int asize;
int csize;
int totalthread;
void thread_task(void * argument)
{
struct thread_argument* args=(struct thread_argument*) argument;
while(1)
{
sem_wait(&T[args->thread_num]);
(*(args->function))(args->function_argument);
sem_wait(&idle_lock);
idle[args->thread_num]=1;
sem_post(&idle_lock);
}
}
int find_idle()
{
int i;
for(i=1;i<=totalthread;i++)
{
sem_wait(&idle_lock);
if(idle[i])
{
idle[i]=0;
sem_post(&idle_lock);
return i;
}
else
sem_post(&idle_lock);
if(i==totalthread)
i=0;
}
}
void bubblesort(void* argument)
{
struct bubblesort_argument* args=(struct bubblesort_argument*)argument;
int* data=args->data;
int begin=args->begin;
int end=args->end;
fflush(stdout);
if(end<=begin)
{
sem_post(&S[0]);
return;
}
int i,j;
for(i=begin;i<end;i++)
for(j=begin;j<end+begin-i;j++)
if(data[j]>data[j+1])
{
int temp;
temp=data[j];
data[j]=data[j+1];
data[j+1]=temp;
}
sem_post(&S[0]);
return;
}
void quicksort(void* argument)
{
struct quicksort_argument* args=(struct quicksort_argument*)argument;
int T_num=args->T_num;
int pivot;
int left=args->left;
int right=args->right;
int i=left;
int j=right;
pivot=a[left];
i++;
//printf("now is %d\n",T_num);
if(left<right)
{
while (1)
{
while (i <= right)
{
if (a[i] > pivot)
{
break;
}
i = i + 1;
}
while (j > left)
{
if (a[j] < pivot)
{
break;
}
j = j - 1;
}
if (i > j) { break; }
int temp;
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
int temp;
temp=a[left];
a[left]=a[j];
a[j]=temp;
}
if(T_num<=3)
{
Q_argument[T_num*2].left=left;
Q_argument[T_num*2].right=j-1;
Q_argument[T_num*2+1].left=j+1;
Q_argument[T_num*2+1].right=right;
}
else
{
B_argument[T_num*2].begin=left;
B_argument[T_num*2].end=j-1;
B_argument[T_num*2+1].begin=j+1;
B_argument[T_num*2+1].end=right;
}
sem_post(&S[T_num*2]);
sem_post(&S[T_num*2+1]);
//printf("now is %d done\n",T_num);
return;
}
int main()
{
char inputfile[256];
char number[256];
struct timeval start,end;
int i,value;
int next_task;
for(i=1;i<=16;i++)
{
sem_init(&T[i],0,0);
T_argument[i].thread_num=i;
}
for(i=0;i<=15;i++)
{
sem_init(&S[i],0,0);
B_argument[i].data=a;
done[i]=0;
}
for(i=1;i<=7;i++)
{
Q_argument[i].T_num=i;
}
sem_init(&idle_lock,0,0);
printf("Input filename:");
fflush(stdout);
scanf("%s",inputfile);
FILE * input=fopen(inputfile,"r");
FILE * output=fopen("output.txt","w");
if(!input)
{
printf("error input file\n");
return 1;
}
fgets(number,256,input);
asize=atoi(number);
for(i=0;i<asize;i++)
{
fscanf(input,"%d",&a[i]);
b[i]=a[i];
}
csize=asize;
printf("thread number:");
fflush(stdout);
scanf("%d",&totalthread);
for(i=1;i<=totalthread;i++)
{
pthread_create(&T_thread[i],NULL,(void*)&thread_task,(void*)&T_argument[i]);
idle[i]=1;
}
Q_argument[1].left=0;
Q_argument[1].right=asize-1;
sem_post(&S[1]);
sem_post(&idle_lock);
//multithread
gettimeofday(&start, 0);
while(1)
{
int allready=1;
for(i=1;i<=15;i++)
{
if(done[i])
continue;
sem_getvalue(&S[i],&value);
if(value)
{
//printf("now dispatch %d\n",i);
next_task=find_idle();
if(i<=7)
{
T_argument[next_task].function=quicksort;
T_argument[next_task].function_argument=&Q_argument[i];
}
else
{
T_argument[next_task].function=bubblesort;
T_argument[next_task].function_argument=&B_argument[i];
}
sem_post(&T[next_task]);
done[i]=1;
}
else
{
allready=0;
}
}
if(allready)
break;
}
while(1)
{
sem_getvalue(&S[0],&value);
if(value==8)
break;
}
gettimeofday(&end, 0);
int sec = end.tv_sec - start.tv_sec;
int usec = end.tv_usec - start.tv_usec;
printf("multithread elapsed %f ms\n", sec*1000+(usec/1000.0));
//singlethread
/*gettimeofday(&start, 0);
struct bubblesort_argument single_bubble;
single_bubble.data=b;
single_bubble.begin=0;
single_bubble.end=csize-1;
bubblesort(&single_bubble);
gettimeofday(&end, 0);
sec = end.tv_sec - start.tv_sec;
usec = end.tv_usec - start.tv_usec;
printf("singlethread elapsed %f ms\n", sec*1000+(usec/1000.0));
*/
for(i=0;i<asize;i++)
fprintf(output,"%d ",a[i]);
return 0;
}
|
C
|
/*
* client2.c
*
* Created on: Aug 7, 2013
* Author: rick
*/
#include "common.h"
int management_enter_datas(char *argv[], int argc){
// if (!strcmp(argv[0], "send")){
// argv++; argc--;
// if (!(management_send(argc, argv))){
// return 0;
// }
// }else if (!strcmp(argv[0], "retrieve")){
// argv++; argc--;
// if (!(management_retrieve(argc, argv))){
// return 0;
// }
// }
return 0;
}
void do_client_loop(){
int err, nwritten, enter_number;
char buf[80];
char *buffer_parts[150];
for(;;){
if(!fgets(buf, sizeof(buf), stdin))
break;
for(nwritten = 0; nwritten < sizeof(buf); nwritten += err){
if (!strcmp(buf, "quit") || !strcmp(buf, "exit")){
//free(buf);
break;
}
enter_number = umount_string_by_space(buf, buffer_parts);
}
}
}
int main4(int argc, char **argv){
//BIO *conn;
init_OpenSSL();
//conn = BIO_new_connect(SERVER ":" PORT);
//if(!conn)
// int_error("Error creating connection BIO");
//if(BIO_do_connect(conn) <= 0)
// int_error("Error connecting to remote machine");
//fprintf(stderr, "Connection opened \n");
do_client_loop();
//frptinf(stderr, "Connection close \n");
//BIO_free(conn);
return 0;
}
|
C
|
#include <stdio.h>
#include <math.h>
int main ()
{
float i=0.0;
while (scanf("%f",&i)!= EOF) {
int a = floor(i);
int b = round(i);
int c = ceil(i);
printf("%d %d %d\n",a,b,c);
}
printf("Done.\n");
}
|
C
|
//#include<stdio.h>
#define SORT(a,b,t) {if(a>b){t=a;a=b;b=t;}
int main()
{
int arr[10]={3,4,2,6,7,1,8,5,9,10};
int temp,i,j;
printf("enter array element is: ");
for(i=0;i<10;i++)
printf("%d ",arr[i]);
printf("\n");
for(i=0;i<10;i++)
{
for(j=i+1;j<10;j++)
SORT(arr[i],arr[j],temp)
printf
}
}
|
C
|
/*#########################################################
## CS 3710 (Winter 2010), Assignment #2, Question #2 ##
## Program File Name: itemCount.c ##
## Student Name: Todd Wareham ##
## Login Name: harold ##
## MUN #: ####### ##
#########################################################*/
/*
* Given as command-line arguments the number of distinct items in
* an item textfile and the name of an item textfile, use the
* functions in the dictionary data structure described in file
* "dict.h" to create and output a list of the number of times each
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "dict.h"
#define NAMELENGTH 100
int main(int argc, char **argv){
FILE *itemFile;
dict *D;
char itemName[NAMELENGTH];
if (argc != 3){
printf("format: %s numDistinctItems itemfile\n", argv[0]);
return 1;
}
D = init(atoi(argv[1]));
itemFile = fopen(argv[2], "r");
while (fgets(itemName, NAMELENGTH, itemFile) != NULL){
itemName[strlen(itemName) - 1] = '\0';
if (isKey(D, itemName) == -1){
setKeyValue(D, itemName, 0);
}
setKeyValue(D, itemName, getKeyValue(D, itemName) + 1);
}
fclose(itemFile);
printValues(D);
return 0;
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 5_stacksort.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: twagner <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/07/26 13:57:56 by twagner #+# #+# */
/* Updated: 2021/08/14 13:59:22 by twagner ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
/*
** To use only from A
*/
int ft_get_i_min(int *arr, int size)
{
int i;
int min;
i = -1;
min = INT_MAX;
while (++i < size)
{
if (arr[i] < min)
min = arr[i];
}
return (ft_get_index(min, arr, size));
}
void ft_5_stacksort(t_stack *a, t_stack *b)
{
int push_back;
push_back = 0;
if (a->top < 3)
return (ft_3_stacksort(a));
if (is_sorted(a))
return ;
ft_push("pb", b, a);
++push_back;
if (!is_sorted(a))
{
if (a->top == 3)
{
ft_push("pb", b, a);
++push_back;
}
ft_3_stacksort(a);
}
while (push_back--)
{
ft_sort_stack_before_receive(a, b->array[b->top], REAL);
ft_push("pa", a, b);
}
ft_put_on_top(ft_get_i_min(a->array, a->top + 1), a, REAL);
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <sys/socket.h>
#define BUFLEN 128
#define QLEN 10
#ifndef HOST_NAME_MAX
#define HOST_NAME_MAX 256
#endif
int initserver(int type, const struct sockaddr *addr, socklen_t alen, int qlen)
{
int fd;
int err = 0;
if ((fd = socket(addr->sa_family, type, 0)) < 0) {
return -1;
}
if (bind(fd, addr, alen) < 0) {
err = errno;
goto errout;
}
if (type == SOCK_STREAM || type == SOCK_SEQPACKET) {
if (listen(fd, qlen) < 0) {
err = errno;
goto errout;
}
}
return fd;
errout:
close(fd);
errno = err;
return -1;
}
void server(int sockfd)
{
int clfd;
FILE *fp;
char buf[BUFLEN];
for (;;) {
clfd = accept(sockfd, NULL, NULL);
if (clfd < 0) {
syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
return 1;
}
if ((fp = popen("/usr/bin/uptime", "r")) == NULL) {
sprintf(buf, "error: %s\n", strerror(errno));
send(clfd, buf, strlen(buf), 0);
} else {
while (fgets(buf, BUFLEN, fp) != NULL) {
send(clfd, buf, strlen(buf), 0);
}
pclose(fp);
}
close(clfd);
}
}
int main(int argc, char *argv[])
{
struct addrinfo *ailist, *aip;
struct addrinfo hint;
int sockfd, err, n;
char *host;
if (1 != argc) {
printf("usage: ruptimed\n");
exit(-1);
}
#ifdef _SC_HOST_NAME_MAX
n = sysconf(_SC_HOST_NAME_MAX);
if (n < 0)
#endif
n = HOST_NAME_MAX;
host = malloc(n);
if (NULL == host) {
printf("malloc error\n");
exit(-1);
}
if (gethostname(host, n) < 0) {
printf("gethostname error\n");
exit(-1);
}
daemonize("ruptimed");
hint.ai_flags = AI_CANONNAME;
hint.ai_family = 0;
hint.ai_socktype = SOCK_STREAM;
hint.ai_protocol = 0;
hint.ai_addrlen = 0;
hint.ai_canonname = NULL;
hint.ai_addr = NULL;
hint.ai_next = NULL;
if ((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0) {
syslog(LOG_ERR, "ruptime: getaddrinfo error: %s", gai_strerror(err));
return 1;
}
for (aip = ailist; aip != NULL; aip = aip->ai_next) {
if ((sockfd = initserver(SOCK_STREAM, aip->ai_addr, aip->ai_addrlen, QLEN)) >= 0) {
serve(sockfd);
return 0;
}
}
return 1;
}
|
C
|
/******************************************************************************
[HEADER]
This library contains different common utilities used by most of the
other functions.
******************************************************************************/
#include <string.h>
#include <math.h>
#include <time.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "misc.h"
#include "imgtools.h"
#include "calc.h"
#include <R.h>
/*****************************************************************************
[NAME]
ReadIradonArgs
[SYNOPSIS]
void ReadIradonArgs
[DESCRIPTION]
This function copy all parameter from sending from R to the global structure
{\tt IniFile}.
[REVISION]
Sep. 94, JJJ and PAP\\
April 12, 96 PT typo
July 2006, J.S., completly modification of the routine for the using with R
*****************************************************************************/
void ReadIradonArgs(char *inFile,char *mode, char *DebugLevell, int *InterPol, char *FilterTyp, double *Xminn, double *Yminn, double *DeltaXn, double *DeltaYn, int *M, int *N)
{
strcpy(IniFile.DebugLevel, DebugLevell);
if (strstr(IniFile.DebugLevel,"Normal")) DebugNiveau=_DNormal;
else if (strstr(IniFile.DebugLevel,"Detail")) DebugNiveau=_DDetail;
else if (strstr(IniFile.DebugLevel,"HardCore")) DebugNiveau=_DHardCore;
else Error("Unknown DebugLevel: '%s'",IniFile.DebugLevel);
strcpy(IniFile.InFile, inFile);
strcpy(IniFile.Function, mode);
//Interpolation level. Used by Filtered Backprojection.
IniFile.InterPol=*InterPol;
IniFile.FilterCutoff=1.0;
//IniFile.FilterType=_Ramp;
if (strcmp(FilterTyp,"Ramp")==0) IniFile.FilterType=_Ramp;
else if (strcmp(FilterTyp,"Hanning")==0) IniFile.FilterType=_Hanning;
else if (strcmp(FilterTyp,"Hamming")==0) IniFile.FilterType=_Hamming;
else Error("Unknown FilterTyp: '%s'", FilterTyp);
IniFile.SliceNumber=1;
IniFile.Xmin=*Xminn;
IniFile.Ymin=*Yminn;
IniFile.XSamples=*M;
IniFile.YSamples=*N;
IniFile.DeltaX=*DeltaXn;
IniFile.DeltaY=*DeltaYn;
}
/*******************************************************************************
[NAME]
GetDateTime
[SYNOPSIS]
void GetDateTime(char *str,
int DateTimeFormat);
[DESCRIPTION]
This function gets the current time and date, and returns it in the
pointer {\tt str}. The return string are formatted accordingly to {\tt
DateTime} Format. Three formats are avaliable as of now, {\tt
\_LongDate}, {\tt \_Time} and \tc{RealTime}. {\tt \_Longdate} returns the date and
time in a string as `Day, dd. month, hh:mm:ss', {\tt \_Time} will
return `hh:mm:ss' and \tc{ \_RealTime} returns the number of seconds
from last midnight.
[USAGE]
{\tt GetDateTime(str,\_Time);}
Returns the current time in {\tt str} formatted as ``12:34:56''.
[REVISION]
Oct. 94, JJJ
Mar 02/07 J.Schulz Memory allocation by R (Calloc)
Feb 2018 J.Schulz Replace sprintf by Rprintf
*******************************************************************************/
void GetDateTime(char *str, int DateTimeFormat)
{
time_t *timep;
struct tm *times;
if (!(timep=(time_t *)Calloc(1, time_t)))
Error(" Memory allocation error (GetDateTime)");
/* if (!(times=(struct tm *)malloc(sizeof(struct tm))))
Error(" Memory allocation error (GetDateTime)");*/
time(timep);
times=localtime(timep);
if (DateTimeFormat==_LongDate)
strftime(str, 55, "%A, %d. %B, %H.%M:%S", times);
if (DateTimeFormat==_Time)
strftime(str, 20,"%H.%M:%S", times);
if (DateTimeFormat==_RealTime)
sprintf(str,"%d",times->tm_sec+times->tm_min*60+times->tm_hour*3600);
//Rprintf(str, times->tm_sec+times->tm_min*60+times->tm_hour*3600, " \n")
Free_PT(timep);
}
/*******************************************************************************
[NAME]
Print
[SYNOPSIS]
void Print(int Niveau,
char *fmt,
...);
[DESCRIPTION]
This function handles all the writing to the screen.
{\tt fmt} and {\tt ...} are the same arguments as to {\tt
print}. The variable {\tt \_Niveau} combined with the global variable
{\tt DebugNiveau} chooses what should be written. {\tt DebugNiveau}
takes precedence over {\tt Niveau}. The following choises exist
\begin{tabbing}
{\tt \_DHardCore} \== Nothing written.\\
{\tt \_DNormal} \>= Some information on screen.\\
{\tt \_DDetail} \>= Full information both on screen.
\end{tabbing}
[REVISION]
Oct. 94, JJJ
March 06, JS
*******************************************************************************/
void Print(int Niveau, char *fmt, ...)
{
//char LogString[255];
va_list ap;
va_start(ap,fmt);
//vsprintf(LogString, fmt, ap);
if (((DebugNiveau&(_DDetail)) && (Niveau&(_DDetail|_DNormal)))
|| ((DebugNiveau&(_DNormal)) && (Niveau&(_DNormal)))) {
Rvprintf(fmt,ap);
//vprintf(fmt,ap);
//fflush(stdout);
}
va_end(ap);
}
/*******************************************************************************
[NAME]
Error
[SYNOPSIS]
void Error(char *fmt,
...);
[DESCRIPTION]
This function is called when a fatal error occurs. It prints the error
message on the screen, closes the log and exits. {\tt fmt} and {\tt
...} are the same arguments as to {\tt print}.
[USAGE]
{\tt Error("Memory allocation problems");}
Prints the above message, closes the log and exits.
[REVISION]
Oct. 94, JJJ and PAP
*******************************************************************************/
void Error(char *fmt, ...)
{
char LogString[255];
va_list ap;
va_start(ap,fmt);
vsprintf(LogString, fmt, ap);
va_end(ap);
error(LogString);
//printf(LogString);
//printf("\n");
//exit(1);
}
/**********************************************************
[NAME]
MultReStore
[SYNOPSIS]
void MultReStore(float *p1,float *p2)
[DESCRIPTION]
The function will multiply the two complex numbers $A$
and $B$ and store the result at the location of $A$. Here
$A=p1[0]~+~i~p1[1]$ and $B=p2[0]~+~i~p2[1]$.
[USAGE]
{\t tMultReStore(arr1,arr2);}
Preforms the multiplication {\tt arr1=arr1*arr2}.
[REVISION]
Nov. 94, JJJ and PT
**********************************************************/
void MultReStore(float *p1,float *p2)
{
multtemp=p1[0]*p2[0]-p1[1]*p2[1];
p1[1]=p1[0]*p2[1]+p1[1]*p2[0];
p1[0]=multtemp;
}
/**********************************************************
[NAME]
MultNew
[SYNOPSIS]
void MultNew(float *p1,float *p2,float *p3)
[DESCRIPTION] The function will multiply the two complex numbers $A$
and $B$, so that $C=AB$. The result is stored at the location of
$C$. Here $A=p1[0]~+~i~p1[1]$, $B=p2[0]~+~i~p2[1]$ and
$C=p3[0]~+~i~p3[1]$.
[USAGE]
{\tt MultNew(arr1,arr2,arr3);}
Preforms the multiplication {\tt arr3=arr1*arr2}.
[REVISION]
Nov. 94, JJJ and PT
**********************************************************/
void MultNew(float *p1,float *p2,float *p3)
{
p3[0]=p1[0]*p2[0]-p1[1]*p2[1];
p3[1]=p1[0]*p2[1]+p1[1]*p2[0];
}
/********************************************************************************
[NAME]
FloatVector
[SYNOPSIS]
float *FloatVector(int Size);
[DESCRIPTION]
Allocates and returns a vector of floats, with \tc{Size} number of
elements. The vector is initialized to 0. Checking is made to ensure
no memory problems.
[USEAGE]
{\tt Test=FloatVector(99);}
Allocates \tc{Test} as a float vector 99 elements long.
[REVISION]
Oct. 94, JJJ
Mar 02/07 J.Schulz Memory allocation by R (calloc --> Calloc)
*****************************************************************************/
float *FloatVector(int Size)
{
float *data;
if (!(data=(float*)Calloc(Size, float)))
Error("Memory allocation problems (FloatVector). %i elements.",Size);
return data;
}
/*****************************************************************************
[NAME]
IntVector
[SYNOPSIS]
float *IntVector(int Size);
[DESCRIPTION]
Allocates and returns a vector of integers, with \tc{Size} number of
elements. The vector is initialized to 0. Adequate checking is done.
[USEAGE]
{\tt Test=IntVector(99);}
Allocates \tc{Test} as an int vector 99 elements long.
[REVISION]
Oct. 94, JJJ
Mar 02/07 J.Schulz Memory allocation by R (calloc --> Calloc)
*****************************************************************************/
int *IntVector(int Size)
{
int *data;
if (!(data=(int*)Calloc(Size, int)))
Error("Memory allocation problems (IntVector). %i elements",Size);
return data;
}
/*****************************************************************************
[NAME]
convert2
[SYNOPSIS]
void convert2(char *ind);
[DESCRIPTION]
The function swaps the two bytes at the location {\tt ind}. Used for
converting short int's between HP/PC.
[USEAGE]
{\tt convert2((char *)\&X);}
Converts {\tt X}, where {\tt X} is a short int.
[REVISION]
Oct. 94, PAP and PT
*****************************************************************************/
void convert2(char *ind)
{
char tmp;
tmp=ind[0];
ind[0]=ind[1];
ind[1]=tmp;
}
/******************************************************************************
[NAME]
convert4
[SYNOPSIS]
void convert4(char *ind);
[DESCRIPTION]
The function swaps the four bytes at the location {\tt ind} around the
center. Used for converting short floats between HP/PC.
[USEAGE]
{\tt convert4((char *)\&X);}
Converts {\tt X}, where {\tt X} is a float.
[REVISION]
Oct. 94, PAP and PT
*****************************************************************************/
void convert4(char *ind)
{
char tmp;
tmp=ind[0];
ind[0]=ind[3];
ind[3]=tmp;
tmp=ind[1];
ind[1]=ind[2];
ind[2]=tmp;
}
/*****************************************************************************
[NAME]
convert8
[SYNOPSIS]
void convert8(char *ind);
[DESCRIPTION]
The function swaps the eight bytes at the location {\tt ind} around
the center. Used for converting doubles between HP/PC.
[USEAGE]
{\tt convert8((char *)\&X);}
Converts {\tt X}, where {\tt X} is a double.
[REVISION]
Oct. 94, PAP and PT
*****************************************************************************/
void convert8(char *ind)
{
char tmp;
tmp=ind[0];
ind[0]=ind[7];
ind[7]=tmp;
tmp=ind[1];
ind[1]=ind[6];
ind[6]=tmp;
tmp=ind[2];
ind[3]=ind[5];
ind[5]=tmp;
tmp=ind[3];
ind[3]=ind[4];
ind[4]=tmp;
}
/*****************************************************************************
[NAME]
convert\_UNIX\_PC
[SYNOPSIS]
void convert_UNIX_PC(char *ind, int lgd);
[DESCRIPTION]
The function swaps the {\tt lgd} bytes at the location {\tt ind}
around the center. Used for converting arbitrary length numbers between
HP/PC.
[USEAGE]
{\tt convert\_UNIX\_PC((char *)\&X, 8);}
Converts {\tt X}, where {\tt X} is 8 bytes long eg. a double.
[REVISION]
Oct. 94, PAP and PT
****************************************************************************/
void convert_UNIX_PC(char *ind, int lgd)
{
int i,lgdh,lgdm1;
char tmp;
if (lgd>1)
{
lgdh=lgd/2;
lgdm1=lgd-1;
for (i=0;i<lgdh;i++)
{
tmp=ind[i];
ind[i]=ind[lgdm1-i];
ind[lgdm1-i]=tmp;
}
}
}
/*****************************************************************************
[NAME]
strequal
[SYNOPSIS]
int strequal(char *str1, char *str2);
[DESCRIPTION]
This function will compare two strings by length and see whether one is
contained in the other.
[USEAGE]
{\tt ok=strequal("Radon","Radon transform");}
This will return a zero. Drop transform and it will return a 1.
[REVISION]
April 9, 96 PToft
****************************************************************************/
int strequal(char *str1, char *str2)
{
if ((strlen(str1)==strlen(str2)) && (strstr(str1,str2)==str1))
return 1;
else
return 0;
}
|
C
|
/* 5.9-3 */
#include <stdio.h>
unsigned int reverse_bits( unsigned int value );
int main( void ) {
unsigned int value;
printf( "%s\n", "please enter an unsigned number:" );
scanf( "%d", &value );
printf( "\nthe bitwise-reversed number in decimal:\t%u\n", reverse_bits( value ) );
return 0;
}
unsigned int reverse_bits( unsigned int value ) {
unsigned int init = 1;
int isize = 0;
while( init ) {
init <<= 1;
isize += 1;
}
/* this loop test the integer size of this machine */
printf( "****this machine has integer size of %d bits****\n", isize );
unsigned int result, bitNum[isize], i = 0;
/* bitNum[] stores the bit number of each digits in reversed order */
while( i < isize ) {
bitNum[i] = ( value & ( 1 << i ) ) >> i;
result += bitNum[i] << ( isize - i - 1 );
i += 1;
}
/* test result in binary format */
printf( "%s\t", "the bitwise-reviersed number in binary:" );
while( i ) {
printf( "%u", bitNum[isize - i] );
i -= 1;
}
return result;
}
|
C
|
/*
* Example for Step-up click
*
* Date Apr 2017
* Author Djordje Rosic
*
* Test configuration KINETIS :
* MCU : MK64
* Dev. Board : HEXIWEAR docking station
* SW : mikroC PRO for ARM v5.0.0
*
* Description :
*
* Connect the click to the input power supply (2.5V - 4.5V). This example
* shows how to set the desired output voltage, by cycling through a couple
* of predefined voltage values.
*
******************************************************************************/
sbit CS_PIN at PTC_PDOR.B4;
/*
* System Initialization
*/
void systemInit()
{
GPIO_Digital_Output(&PTC_PDOR, _GPIO_PINMASK_4);
SPI0_Init_Advanced( 5000000, _SPI_CFG_MASTER | _SPI_CFG_SELECT_CTAR0 |
_SPI_CFG_FRAME_SIZE_8BITS | _SPI_CFG_CLK_IDLE_LOW |
_SPI_CFG_CLK_PHASE_CAPT_LEADING | _SPI_CFG_MSB_FIRST,
&_GPIO_Module_SPI0_PC5_7_6);
}
void main()
{
systemInit();
while (1)
{
delay_ms(3000);
//Sets the voltage to VOUTmax, ~5.25 V
CS_PIN = 0; //Sets chip select to active
Spi0_Write(0b01110000);
Spi0_Write(0b00000000);
CS_PIN = 1; //Sets chip select to inactive
delay_ms(3000);
//Sets the voltage to VOUTmin, which depends on VIN, but cannot
//be lower than 2.50 V
CS_PIN = 0; //Sets chip select to active
Spi0_Write(0b01111111);
Spi0_Write(0b11111111);
CS_PIN = 1; //Sets chip select to inactive
delay_ms(3000);
//Sets the voltage ~4.0 V
CS_PIN = 0; //Sets chip select to active
Spi0_Write(0b01110111);
Spi0_Write(0b01000000);
CS_PIN = 1; //Sets chip select to inactive
delay_ms(3000);
//Sets the voltage ~4.5 V
CS_PIN = 0; //Sets chip select to active
Spi0_Write(0b01110100);
Spi0_Write(0b00011111);
CS_PIN = 1; //Sets chip select to inactive
}
}
/************************************************************ END OF FILE *****/
|
C
|
#include <stdio.h>
int main()
{ int i;
puts("x x+10 x+20 x*10");
for(i=5;i<=25;i=i+5)
{ printf("%d %d %d %d \n" ,i,i+10,i+20,i*10);
}
return 0;
}
|
C
|
#include<stdio.h>
int main()
{
int n,i,num,m,count=0,j;
scanf("%d",&n);
char array[10000];
for(i=0;i<10000;i++)
{
array[i]=0;
}
for(i=0;i<n;i++)
{
scanf("%d",&num);
if(array[num]==2)
count--;
array[num]=1;
scanf("%d",&m);
for(j=0;j<m;j++)
{
scanf("%d",&num);
if(array[num]==0)
{
array[num]=2;
count++;
}
}
}
printf("%d\n",count);
return 0;
}
|
C
|
/** @file
Testy inputu/outputu drzewa.
@ingroup dictionary
@author Jan Gajl <[email protected]>
@date 2015-06-06
*/
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <stdlib.h>
#include <cmocka.h>
#include "trie.h"
#include "dictionary.h"
#include "io_utils.h"
#include <string.h>
#include <locale.h>
/// Maksymalny rozmiar bufora
#define TEMPORARY_BUFFER_SIZE 1000
/// Bufor symujujący wyjście
static wchar_t temporary_buffer[TEMPORARY_BUFFER_SIZE];
/// Aktualny rozmiar bufora
static int it;
/// Atrapa funkcji ferror
int example_test_ferror(FILE* const file) {return 0;}
/// Atrapa funkcji fprintf zapisująca wyjście do temporary_buffer
int example_test_fprintf(FILE* const file, const char *format, wchar_t wc)
{
if (wc == 0)
temporary_buffer[it++] = L'0';
else if (wc == 1)
temporary_buffer[it++] = L'1';
else if (wc == 2)
temporary_buffer[it++] = L'2';
else if (wc == 3)
temporary_buffer[it++] = L'3';
else if (wc == 4)
temporary_buffer[it++] = L'4';
else if (wc == 5)
temporary_buffer[it++] = L'5';
else if (wc == 6)
temporary_buffer[it++] = L'6';
else if (wc == 7)
temporary_buffer[it++] = L'7';
else if (wc == 8)
temporary_buffer[it++] = L'8';
else if (wc == 9)
temporary_buffer[it++] = L'9';
else
temporary_buffer[it++] = wc;
return 1;
}
/// Atrapa funkci fgetwc
wchar_t example_test_fgetwc(FILE* const file)
{
return temporary_buffer[it++];
}
/// Atrapa funkcji fscanf
int example_test_fscanf(FILE* const file, const char *format, wchar_t wc)
{
if (temporary_buffer[it++] == L'0')
wc = 0;
else if (temporary_buffer[it++] == L'1')
wc = 1;
else if (temporary_buffer[it++] == L'2')
wc = 2;
else if (temporary_buffer[it++] == L'3')
wc = 3;
else if (temporary_buffer[it++] == L'4')
wc = 4;
else if (temporary_buffer[it++] == L'5')
wc = 5;
else if (temporary_buffer[it++] == L'6')
wc = 6;
else if (temporary_buffer[it++] == L'7')
wc = 7;
else if (temporary_buffer[it++] == L'8')
wc = 8;
else if (temporary_buffer[it++] == L'9')
wc = 9;
else wc = temporary_buffer[it++];
return 1;
}
/// Atrapa funkcji ungetwc
void example_test_ungetwc(wchar_t wc, FILE* const file)
{
it--;
}
/// Pomocnicza funkcja sprawdzająca poprawność wygenerowanego słownika
void compare_output(const wchar_t *expected_output)
{
assert_true(it == wcslen(expected_output));
for (int i = 0; i < it; ++i)
{
assert_true(temporary_buffer[i] == expected_output[i]);
}
}
/// Funkcja porównująca drzewa
bool trie_check(struct tNode *load, struct tNode *test)
{
assert_true(load != NULL);
assert_true(test != NULL);
assert_true(load->value == test->value);
assert_int_equal(load->ifWord, test->ifWord);
printf("%d %d\n", load->childrenCount, test->childrenCount);
assert_int_equal(load->childrenCount, test->childrenCount);
for (int i = 0; i < load->childrenCount; ++i)
{
if (!trie_check(load->children[i], test->children[i]))
return false;
}
return true;
}
/// Test funkcji save.
static void save_test(void **state)
{
it = 0;
struct tNode *root;
init(&root);
insert(&root, L"lannister");
insert(&root, L"tyrell");
insert(&root, L"baratheon");
insert(&root, L"martell");
insert(&root, L"targaryen");
insert(&root, L"snow");
insert(&root, L"tully");
insert(&root, L"stark");
insert(&root, L"greyjoy");
insert(&root, L"frey");
insert(&root, L"bolton");
assert_int_equal(save(root, stderr), 0);
compare_output(L"7b2a1r1a1t1h1e1o1N0o1l1t1o1N0f1r1e1Y0g1r1e1y1j1o1Y0l1a1n1n1i1s1t1e1R0m1a1r1t1e1l1L0s2n1o1W0t1a1r1K0t3a1r1g1a1r1y1e1N0u1l1l1Y0y1r1e1l1L0");
tree_free(root);
}
/// Test funkcji save z wcharami.
static void save_wchar_test(void **state)
{
it = 0;
struct tNode *root;
init(&root);
insert(&root, L"pięść");
insert(&root, L"pnąć");
insert(&root, L"kiść");
insert(&root, L"łódź");
assert_int_equal(save(root, stderr), 0);
compare_output(L"3k1i1ś1Ć0ł1ó1d1Ź0p2i1ę1ś1Ć0n1ą1Ć0");
tree_free(root);
}
// /// Test funkcji load.
// static void load_test(void **state)
// {
// it = 0;
// struct tNode *root;
// init(&root);
// wchar_t alphabet[50];
// int i;
// for (i = 0; i < 50; ++i)
// {
// alphabet[i] = '\0';
// }
// int alphabetCount = 0;
// insert(&root, L"lannister");
// insert(&root, L"tyrell");
// insert(&root, L"baratheon");
// insert(&root, L"martell");
// insert(&root, L"targaryen");
// insert(&root, L"snow");
// insert(&root, L"tully");
// insert(&root, L"stark");
// insert(&root, L"greyjoy");
// insert(&root, L"frey");
// insert(&root, L"bolton");
// save(root, stderr);
// it = 0;
// struct tNode *root2;
// init(&root2);
// wchar_t alphabet2[50];
// for (i = 0; i < 50; ++i)
// {
// alphabet2[i] = '\0';
// }
// int alphabetCount2 = 0;
// assert_true(load(stderr, root2, alphabet2, alphabetCount2));
// printf("%lc\n", root2->children[0]->value);
// assert_true(trie_check(root2, root));
// tree_free(root);
// tree_free(root2);
// }
// /// Test funkcji load z wcharami.
// static void load_wchar_test(void **state)
// {
// it = 0;
// struct tNode *root;
// init(&root);
// wchar_t alphabet[50];
// int i;
// for (i = 0; i < 50; ++i)
// {
// alphabet[i] = '\0';
// }
// int alphabetCount = 0;
// insert(&root, L"pięść");
// insert(&root, L"pnąć");
// insert(&root, L"kiść");
// insert(&root, L"łódź");
// save(root, stderr);
// it = 0;
// struct tNode *root2;
// init(&root2);
// assert_true(load(stderr, root, alphabet, alphabetCount));
// assert_true(trie_check(root, root2));
// tree_free(root);
// tree_free(root2);
// }
/// Funkcja główna modułu
int main(void) {
setlocale(LC_ALL, "pl_PL.UTF-8");
const struct CMUnitTest tests[] = {
cmocka_unit_test(save_test),
cmocka_unit_test(save_wchar_test),
// cmocka_unit_test(load_test),
// cmocka_unit_test(load_wccdhar_test),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
|
C
|
/*
Obtém o valor máximo em um vetor de inteiros gerados aleatoriamente
*/
#include <stdio.h>
#include <mpi.h>
#include <time.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int n, n_nos, rank;
MPI_Status status;
int vetor[100000], i, k;
int max_val_parcial, max_val_total, max_val;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &n_nos);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
n = 100000;
k = n / n_nos;
//================= Divisao do vetor para todos os ranks ======================
if (rank == 0)
{
srand(time(NULL));
for (int i = 0; i < n; i++)
vetor[i] = rand();
for (i = 1; i < n_nos; i++)
{
MPI_Send(&vetor[k * i], k, MPI_INT, i, 10, MPI_COMM_WORLD);
}
}
else
{
MPI_Recv(vetor, k, MPI_INT, 0, 10, MPI_COMM_WORLD, &status);
}
//==============================================================================
//============= Calculo do max_val parcial em cada rank ========================
max_val_parcial = -1;
int cur_val;
for (i = 0; i < k; i++) {
cur_val = vetor[i];
if (cur_val > max_val_parcial)
max_val_parcial = cur_val;
}
printf("RANK[%d] - max_val_parcial=%d\n", rank, max_val_parcial);
fflush(stdout);
//=============================================================================
//================ Recepcao dos max_val_parciais no rank 0 ====================
if (rank == 0)
{
max_val_total = max_val_parcial;
for (i = 1; i < n_nos; i++)
{
MPI_Recv(&max_val, 1, MPI_INT, MPI_ANY_SOURCE, 11, MPI_COMM_WORLD, &status);
if (max_val > max_val_total)
max_val_total = max_val;
}
printf("\nRESULTADO=%d\n", max_val_total);
fflush(stdout);
}
else
MPI_Send(&max_val_parcial, 1, MPI_INT, 0, 11, MPI_COMM_WORLD);
//===============================================================================
MPI_Finalize();
return 0;
}
|
C
|
#include <bits/stdc++.h>
using namespace std;
int n,m;
char grid[1005][1005];
int vis[1005][1005];
int x[4]={1,0,-1,0};
int y[4]={0,1,0,-1};
pair<int,int> src,u,v;
queue< pair<int,int> > Q;
bool is_safe(pair< int,int > curr)
{
if(curr.first>=1 && curr.first<=n && curr.second>=1 && curr.second<=m && vis[curr.first][curr.second]==0) {
if(grid[curr.first][curr.second] == '.') {
return 1;
}
}
return 0;
}
int bfs() {
int i,j,d=1;
for(i=1;i<=n;i++) {
for(j=1;j<=m;j++) {
vis[i][j]=0;
}
}
Q.push(src);
vis[src.first][src.second] = 1;
while(!Q.empty()) {
u=Q.front();
Q.pop();
for(i=0;i<4;i++) {
v.first = u.first + x[i];
v.second = u.second + y[i];
if(is_safe(v)) {
vis[v.first][v.second] = vis[u.first][u.second] + 1;
Q.push(v);
d=max(d,vis[v.first][v.second]);
}
}
}
return d;
}
int main()
{
bool flag=0;
int t,i,j;
cin>>t;
while(t--) {
flag=0;
cin>>m>>n;
src=make_pair(-1,-1);
for(i=1;i<=n;i++) {
for(j=1;j<=m;j++) {
cin>>grid[i][j];
}
}
for(i=1;i<=n;i++) {
for(j=1;j<=m;j++) {
if(grid[i][j] == '.') {
src=(make_pair(i,j));
flag=1;
}
}
if(flag)
break;
}
int max_distance=bfs();
for(i=1;i<=n;i++) {
for(j=1;j<=m;j++) {
if(max_distance== vis[i][j]) {
src=make_pair(i,j);
}
}
}
printf("Maximum rope length is %d.\n",bfs()-1);
}
return 0;
}
|
C
|
// Daniel Christiansen
// ECE373
// HW #3
// User-space program to talk to pci driver
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#define LED_ON 0xE
#define LED_OFF 0xF
int main() {
int fd, len, buf;
// Open driver
fd = open("/dev/pci_driver", O_RDWR);
if (fd == -1) {
printf("\ncouldn't open driver.\n");
return -1;
}
// Read LED register value from device
len = read(fd, &buf, sizeof(int));
if (len < 1) {
printf("\nCouldn't read from driver.\n");
return -1;
}
printf("LED register contents is: 0x%x.\n", buf);
// Attempt to turn the LED on
printf("Attempting to write 0x%x to the driver.\n", LED_ON);
buf = LED_ON;
len = write(fd, &buf, sizeof(int));
if (len < 1) {
printf("Couldn't write to driver.\n");
printf("error no. %d.\n", len);
return -1;
}
// Check the attempt
len = read(fd, &buf, sizeof(int));
if (len < 1) {
printf("Couldn't read from driver.\n");
return -1;
}
printf("LED register contents is: 0x%x.\n", buf);
sleep(2);
// Attempt to turn the LED off
printf("Attempting to write 0x%x to the driver.\n", LED_OFF);
buf = LED_OFF;
len = write(fd, &buf, sizeof(int));
if (len < 1) {
printf("Couldn't write to driver.\n");
printf("error no. %d.\n", len);
return -1;
}
close(fd);
return 0;
}
|
C
|
#include <stdio.h>
void *multiply(int a, int b, int *c);
int main(void)
{
int a, b;
printf("Enter numbers: ");
scanf("%d %d", &a, &b);
int c = 0;
multiply(a, b, &c);
printf("%d\n", c);
}
/* Multiply a with b and stores result in pointer c */
void *multiply(int a, int b, int *c)
{
*c = a * b;
}
|
C
|
#include "terrain.h"
/**
* destroy_renderer - function called on exiting from program to deallocate
* the SDL2 renderer.
* @status: exit status
* @rend: pointer to renderer
*/
void destroy_renderer(int status, void *rend)
{
(void) status;
if (rend)
SDL_DestroyRenderer(rend);
}
/**
* destroy_window - function called on exiting from program to deallocate
* the SDL2 window.
* @status: exit status
* @win: pointer to window
*/
void destroy_window(int status, void *win)
{
(void) status;
if (win)
SDL_DestroyWindow(win);
}
|
C
|
// Pulled from https://github.com/ob/rules_ios/tree/a86298de81efd92f9719ff8f9ff5f4ef4c1b0878/rules
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/errno.h>
#include "hmap.h"
struct {
char* key;
char* value;
} testdata[10] = {{"foo.h", "bar/baz/foo.h"},
{"bam.h", "baz/bar/bam.h"},
{"package/bam.h", "some/weird/long/path/something.h"},
{"another/header.h", "short/foo.h"},
{0, 0}};
int verifyTestData(HeaderMap* hmap) {
int rc = 0;
for (unsigned i = 0; testdata[i].key != NULL; ++i) {
char* value = NULL;
if (hmap_findEntry(hmap, testdata[i].key, &value)) {
printf("FAILED TO FIND %s\n", testdata[i].key);
rc = 1;
continue;
}
if (!value) {
printf("FAILED TO FETCH VALUE for %s\n", testdata[i].key);
rc = 1;
continue;
}
if (strcmp(value, testdata[i].value)) {
printf("Value doesn't match for key '%s':\nWANT: %s\n GOT: %s\n",
testdata[i].key, testdata[i].value, value);
rc = 1;
free(value);
continue;
}
printf("Verifying '%s' -> '%s' OK\n", testdata[i].key, value);
free(value);
}
return rc;
}
int addTestData(HeaderMap* hmap) {
int rc = 0;
for (unsigned i = 0; testdata[i].key != NULL; ++i) {
printf("Adding '%s' -> '%s'\n", testdata[i].key, testdata[i].value);
rc |= hmap_addEntry(hmap, testdata[i].key, testdata[i].value);
}
return rc;
}
void dump(char* path) {
HeaderMap* hmap = hmap_open(path, "r");
if (!hmap) {
fprintf(stderr, "hmap failed for '%s': %s\n", path, strerror(errno));
}
hmap_dump(hmap);
hmap_close(hmap);
}
int main(int ac, char** av) {
int rc = 0;
HeaderMap* hmap = hmap_new(10);
rc = addTestData(hmap);
if (verifyTestData(hmap)) {
printf("FAILED:\n");
hmap_dump(hmap);
rc = 1;
}
char* path = "hmap-test.hmap";
printf("Saving hmap filel to %s\n", path);
hmap_save(hmap, path);
hmap_free(hmap);
// now read it again
printf("Reading hmap file again\n");
hmap = hmap_open(path, "r");
if (verifyTestData(hmap)) {
printf("FAILED READING AGAIN:\n");
hmap_dump(hmap);
rc = 1;
}
hmap_dump(hmap);
hmap_close(hmap);
return rc;
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* libft.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fsidler <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2015/12/01 13:21:24 by fsidler #+# #+# */
/* Updated: 2019/06/09 05:58:52 by fsidler ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LIBFT_H
# define LIBFT_H
# include <stdlib.h>
# include <stdbool.h>
# include <string.h>
# include <unistd.h>
# include <sys/types.h>
# include <sys/stat.h>
# include <sys/mman.h>
# include <fcntl.h>
# include <errno.h>
# include <dirent.h>
/*
** ft_upper.c => 2 functions
*/
bool ft_isupper(int c);
int ft_toupper(int c);
/*
** ft_strlen.c => 1 function
*/
size_t ft_strlen(char const *str);
/*
** ft_bzero.c => 1 function
*/
void ft_bzero(void *s, size_t n);
/*
** ft_itoa.c => 2 functions
*/
char *ft_itoa(int n);
/*
** ft_strnew.c => 1 function
*/
char *ft_strnew(size_t size);
/*
** ft_strcat.c => 1 function
*/
char *ft_strcat(char *dest, char const *src);
/*
** ft_strcpy.c => 2 functions
*/
char *ft_strcpy(char *dest, char const *src);
char *ft_strncpy(char *dest, char const *src, size_t n);
/*
** ft_putchar.c => 4 functions
*/
void ft_putchar(char c);
void ft_putnchar(char c, size_t n);
void ft_putchar_fd(short fd, char c);
void ft_putnchar_fd(short fd, char c, size_t n);
/*
** ft_putstr.c => 4 functions
*/
void ft_putstr(char const *str);
void ft_putnstr(char const *str, size_t n);
void ft_putstr_fd(short fd, char const *str);
void ft_putnstr_fd(short fd, char const *str, size_t n);
/*
** ft_putendl.c => 2 functions
*/
void ft_putendl(char const *str);
void ft_putendl_fd(short fd, char const *str);
/*
** ft_strjoin.c => 4 functions
*/
char *ft_strjoin_both_free(char *left, char *right);
char *ft_strjoin_left_free(char *left, char const *right);
char *ft_strjoin_right_free(char const *left, char *right);
char *ft_strjoin(char const *left, char const *right);
/*
** ft_strcmp.c => 2 functions
*/
int ft_strcmp(char const *s1, char const *s2);
int ft_strncmp(char const *s1, char const *s2, size_t n);
#endif
|
C
|
#include <stdlib.h> //malloc
#include <stdio.h> //printf
#include "datalink.h"
#include "application.h"
#include "shared.h"
void testOpenNClose()
{
initDatalinkLayer(9600, 256, 1, 10, 0.0);
int fd = llopen(COM1, RECEIVE);
printf("llopen returned fd = %d\n", fd);
printf("Sleeping for 3 secs.\n");
int res = llclose(fd);
printf("llclose returned with value = %d\n", res);
}
void testBuildSUFrame()
{
initDatalinkLayer(9600, 256, 1, 10, 0.0);
int fd = llopen(COM1, RECEIVE);
printf("llopen returned fd = %d\n", fd);
//SET Frame
char *frame = buildSUFrame(SET);
printf("SET frame: ");
printByteByByte(frame, SU_FRAME_SIZE);
free(frame);
//DISC Frame
frame = buildSUFrame(DISC);
printf("\nDISC frame: ");
printByteByByte(frame, SU_FRAME_SIZE);
free(frame);
//UA Frame
frame = buildSUFrame(UA);
printf("\nUA frame: ");
printByteByByte(frame, SU_FRAME_SIZE);
free(frame);
//RR Frame
frame = buildSUFrame(RR);
printf("\nRR frame: ");
printByteByByte(frame, SU_FRAME_SIZE);
free(frame);
//REJ Frame
frame = buildSUFrame(REJ);
printf("\nREJ frame: ");
printByteByByte(frame, SU_FRAME_SIZE);
free(frame);
//I Frame
char strA[5] = "abcde";
frame = buildIFrame(strA, 5);
printf("\nI frame: ");
printByteByByte(frame, I_FRAME_BASE_SIZE + 5);
free(frame);
int res = llclose(fd);
printf("llclose returned with value = %d\n", res);
}
void testLLReadOnce()
{
initDatalinkLayer(9600, 256, 1, 10, 0.0);
int fd = llopen(COM1, RECEIVE);
printf("llopen returned fd = %d\n", fd);
char *buf;
ssize_t res = llread(fd, &buf);
printf("llread returned with value = %zd\n", res);
printf("\nPacket received: ");
printByteByByte(buf, res);
res = llclose(fd);
printf("llclose returned with value = %zd\n", res);
}
void testReceiveFile()
{
initApplicationLayer(COM1, 9600, 256, 1, 10, 0.0);
int res = receiveFile();
printf("receiveFile returned with value = %d\n", res);
}
int main()
{
/*//testOpenNClose
printf("openNClose test \n");
testOpenNClose();
//testBuildSUFrame
printf("BuildSUFrame test \n");
testBuildSUFrame();
//testLLReadOnce
printf("LLReadOnce test \n");
testLLReadOnce();*/
//testReceiveFile
printf("receiveFile test \n");
testReceiveFile();
printf("\nEnd of tests.\n");
return 0;
}
|
C
|
#include<stdio.h>
void main()
{
int s,e,i,j,count=0;
scanf("%d%d",&s,&e);
for(i=s;i<=e;i++)
{
for(j=2;j<=(i/2);j++)
{
if((i%j)==0)
{
count++;
}
}
if(count==0)
{
printf("%d ",i);
}
count=0;
}
}
|
C
|
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/**
* @file header.h
* @author ayushi ([email protected])
* @brief mini_project
* @version 0.1
* @date 2021-04-15
*
* @copyright Copyright (c) 2021
*
*/
#ifndef __HEADER_H__
#define __HEADER_H__
typedef enum error_t{
ERROR_NULL_PTR = -2,
SUCCESS = 0,
START_EXISTS=1,
NO_HEAD_EXIST=2,
INVALID_NAME=4,
ID_EXISTS=5
}error_t;
typedef struct Student
{
int rollnumber;
char name[100];
char phone[100];
float percentage;
struct Student *next;
}student;
/**
* @brief DELETE RECORD
*
* @param rollnumber
* @return error_t
*/
error_t Delete(student*h);
/**
* @brief DISPLAY RECORD
*
* @return error_t
*/
error_t display(student*h);
/**
* @brief INSERT RECORD
*
* @param rollnumber
* @param name
* @param phone
* @param percentage
*/
error_t insert(student*h);
/**
* @brief SEARCH RECORD
*
* @param rollnumber
*/
void search(student*h);
/**
* @brief UPDATE RECORD
*
* @param rollnumber
*/
void update(student*h);
#endif
|
C
|
/**
* @file semaphores_posix.c
*
* @brief Functions for working with shared semaphores - POSIX Semaphores (wait if zero)
* @date 2020-05-06
* @author F3lda
* @update 2021-04-26
*/
#include "semaphores_posix.h"
int semaphore_create(sem_t **semaphore, char *name, int value)
{
errno = 0;
if ((*semaphore = sem_open(name, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH, value)) != SEM_FAILED) {
return 0;
} else if(errno == EEXIST) {
return -1;
} else {
return -2;
}
}
int semaphore_get(sem_t **semaphore, char *name)
{
errno = 0;
if ((*semaphore = sem_open(name, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH, 1)) != SEM_FAILED) {
return 0;
} else {
return -1;
}
}
int semaphore_close(sem_t *semaphore)
{
return sem_close(semaphore);
}
int semaphore_destroy(char *name)
{
return sem_unlink(name);
}
int semaphore_init(sem_t **semaphore, bool global, int value)
{
if (global) {
*semaphore = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (*semaphore != NULL) {
return sem_init(*semaphore, 1, value);
} else {
return -2;
}
} else {
return sem_init(*semaphore, 0, value);
}
}
int semaphore_delete(sem_t *semaphore, bool global)
{
int result = sem_destroy(semaphore);
if (global) {
result = munmap(semaphore, sizeof(sem_t))*2;
}
return result;
}
int semaphore_get_value(sem_t *semaphore, int *value)
{
return sem_getvalue(semaphore, value);
}
int semaphore_lock_or_wait(sem_t *semaphore)
{
return sem_wait(semaphore);
}
int semaphore_unlock(sem_t *semaphore)
{
return sem_post(semaphore);
}
|
C
|
/**
* @file
*
* @brief Tests for specload plugin
*
* @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <tests_plugin.h>
#include "testdata.h"
#include <config.c>
#include <unistd.h>
#define BACKUP_STDIN() int stdin_copy = dup (STDIN_FILENO);
#define RESTORE_STDIN() \
if (dup2 (stdin_copy, STDIN_FILENO) == -1) \
{ \
yield_error ("Could not execute testapp"); \
} \
close (stdin_copy);
#define START_TESTAPP(...) \
BACKUP_STDIN (); \
startTestApp (bindir_file (TESTAPP_NAME), ((char * const[]){ TESTAPP_NAME, __VA_ARGS__, NULL }));
void startTestApp (const char * app, char * const argv[])
{
pid_t pid;
int fd[2];
if (pipe (fd) != 0)
{
yield_error ("Could not execute testapp");
return;
}
pid = fork ();
if (pid == -1)
{
yield_error ("Could not execute testapp");
return;
}
if (pid == 0)
{ /* child */
if (dup2 (fd[1], STDOUT_FILENO) == -1)
{
exit (EXIT_FAILURE);
}
close (fd[0]);
close (fd[1]);
execv (app, argv);
exit (EXIT_FAILURE);
}
close (fd[1]);
if (dup2 (fd[0], STDIN_FILENO) == -1)
{
yield_error ("Could not execute testapp");
return;
}
close (fd[0]);
}
static bool check_binary_file (int fd, size_t expectedSize, const unsigned char * expectedData)
{
FILE * file = fdopen (fd, "rb");
int c;
size_t cur = 0;
while (cur < expectedSize && (c = fgetc (file)) != EOF)
{
if (c != expectedData[cur])
{
char buf[255];
snprintf (buf, 255, "byte %zd differs", cur);
yield_error (buf)
}
++cur;
}
while (fgetc (file) != EOF)
{
cur++;
}
fclose (file);
if (cur == expectedSize)
{
return true;
}
char buf[255];
snprintf (buf, 255, "actual size %zd differs from expected size %zd", cur, expectedSize);
yield_error (buf);
return false;
}
void test_default (void)
{
START_TESTAPP ("--elektra-spec");
succeed_if (check_binary_file (STDIN_FILENO, default_spec_expected_size, default_spec_expected), "output differs");
RESTORE_STDIN ();
}
void test_noparent (void)
{
START_TESTAPP ("spec", "noparent");
succeed_if (check_binary_file (STDIN_FILENO, noparent_spec_expected_size, noparent_spec_expected), "output differs");
RESTORE_STDIN ();
}
int main (int argc, char ** argv)
{
printf ("SPECLOAD_TESTAPP TESTS\n");
printf ("==================\n\n");
init (argc, argv);
test_default ();
test_noparent ();
print_result ("test_testapp");
return nbError;
}
|
C
|
/* ====================================================
# Copyright (C)2020 All rights reserved.
#
# Author : Pandora
# Email : [email protected]
# File Name : c_linked_list.h
# Last Modified : 2020-04-27 19:10
# Describe :
#
# ====================================================*/
#ifndef __LINKED_LIST_
#define __LINKED_LIST_
#include <stdbool.h>
/* Support c++ */
#ifdef __cplusplus
extern "C" {
#endif
typedef int status;
/* Define "ElemType" */
typedef struct book
{
char id[10];
char name[30];
float price;
char describe[60];
} ElemType;
/* Circle Linked List node define */
typedef struct _node
{
ElemType info;
struct _node* next;
} node;
/* Circle Linked List point define */
typedef node* c_plist;
/* Operator of Circle Linked List */
c_plist c_linked_list_initi(void);
bool c_linked_list_empty(const c_plist c_pl);
node* c_linked_list_new_node(node* prev_node);
static node* c_linked_list_create_node(void);
unsigned int c_linked_list_length(const c_plist c_pl);
void c_linked_list_visit(const c_plist c_pl);
bool c_linked_list_clear(const c_plist c_pl);
bool c_linked_list_take_elem(const c_plist c_pl, int pos, ElemType* e);
int c_linked_list_find_elem(const c_plist c_pl, ElemType* specified_elem,
status (*compare)(ElemType* c_linked_list_elem, ElemType* specified_elem));
bool c_linked_list_insert_node(c_plist const c_pl, int pos);
bool c_linked_list_delete_node(c_plist const c_pl, int pos, node* no);
bool c_linked_list_head_insert(const c_plist c_pl, int num);
bool c_linked_list_tail_insert(const c_plist c_pl, int num);
bool c_linked_list_destory(c_plist const c_pl);
/* Support c++ */
#ifdef __cplusplus
}
#endif
#endif
|
C
|
//
// OS Windows
// 2020.03.16
//
// [Algorithm Problem Solving]
//
// [ùķ̼] <jungol#1319> ڰ
//
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define SZ 100
int arr[SZ], prev[SZ], N;
void go()
{
register int i, nxt;
for (i = 0; i < N; ++i)
{
nxt = (i + 1) % N;
prev[nxt] = arr[i] / 2;
}
for (i = 0; i < N; ++i)
{
arr[i] /= 2;
arr[i] += prev[i];
if (arr[i] % 2)
arr[i]++;
}
}
int check()
{
register int i, idx, flag = 1;
idx = arr[0];
for (i = 1; i < N; ++i)
{
if (arr[i] != idx)
{
flag = 0;
break;
}
}
return flag;
}
void simul()
{
register int cnt = 0;
while (1)
{
if (check()) break;
cnt++;
go();
}
printf("%d %d", cnt, arr[0]);
}
int main(void)
{
freopen("jinput1319.txt", "r", stdin);
scanf("%d", &N);
for (register int i = 0; i < N; ++i)
scanf("%d", &arr[i]);
simul();
return 0;
}
|
C
|
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "pokemon.h"
#include "jogador.h"
Nopok *PegaPok(Listapok *l, int idp) {
Nopok *aux = l->pri, *aux2 = NULL;
if (l != NULL) {
for (aux = l->pri; l->pri != NULL; l->pri = l->pri->prox) {
if (l->pri->idpokemon == idp) {
aux2 = l->pri;
l->pri = aux;
return aux2;
}
}
l->pri = aux;
return aux2;
} else {
return NULL;
}
}
Listapok *PegaListaPok(Nojog *j) {
return j->pokemons;
}
int IdPokExiste(int idp, Listapok *s) {
Nopok *aux;
if (s->pri == NULL) {
return 0;
} else {
for (aux = s->pri; s->pri != NULL; s->pri = s->pri->prox) {
if (s->pri->idpokemon == idp) {
s->pri = aux;
return 1;
}
}
s->pri = aux;
}
return 0;
}
Listapok *CriaListaPok() {
Listapok *s;
s = (Listapok*) malloc(sizeof (Listapok));
s->pri = NULL;
s->ult = NULL;
return s;
}
void InserirPok(Listapok *s, int id, int qtd, int evo) {
Nopok *novo;
novo = (Nopok*) malloc(sizeof (Nopok));
novo->idpokemon = id;
novo->qtd = qtd;
novo->evo = evo;
// INSERIR NA LISTA VAZIA
if (s->pri == NULL && s->ult == NULL) {
novo->prox = NULL;
s->pri = novo;
s->ult = novo;
}// INSERIR EM LISTA NÃO VAZIA.
else {
novo->prox = NULL;
s->ult->prox = novo;
s->ult = novo;
}
}
Listapok *LiberaListaPok(Listapok *s) {
Nopok *aux;
if (s != NULL) {
while (s->pri != NULL) {
aux = s->pri->prox;
free(s->pri);
s->pri = aux;
if (aux == NULL) {
s->ult = NULL;
}
}
free(s);
}
return NULL;
}
Listapok *ExcluirPok(Listapok *s, int id) {
Nopok *aux = NULL, *aux2 = s->pri;
for (aux = s->pri; s->pri != NULL; aux2 = s->pri, s->pri = s->pri->prox) {
// APAGANDO DE LISTA DE ÚNICO ELEMENTO.
if (id == s->pri->idpokemon && s->pri == s->ult && aux == s->pri) {
free(s->pri);
s->pri = NULL;
s->ult = NULL;
return s;
}// APAGANDO NO COMECO DA LISTA.
else if (id == s->pri->idpokemon && aux2 == s->pri) {
aux = aux->prox;
free(s->pri);
s->pri = aux;
return s;
}// APAGANDO NO MEIO DA LISTA.
else if (id == s->pri->idpokemon && s->pri != s->ult && s->pri != aux) {
aux2->prox = s->pri->prox;
free(s->pri);
s->pri = aux;
return s;
}// APAGANDO NO FINAL DA LISTA.
else if (id == s->pri->idpokemon && s->pri == s->ult && aux != s->pri) {
aux2->prox = NULL;
s->ult = aux2;
free(s->pri);
s->pri = aux;
return s;
}
}
return s;
}
void InserirPokemonCampo(Listapok *s, int idp, int qtd) {
Nopok *p;
if (IdPokExiste(idp, s)) {
p = PegaPok(s, idp);
p->qtd = p->qtd + qtd;
} else {
InserirPok(s, idp, qtd, 0);
}
}
int TemPokemonLista(Listapok *s) {
if (s != NULL) {
return 1;
} else {
return 0;
}
}
int GeraNovoID(int id) {
float f;
int aux = 1;
f = id;
while ((f = f / 10) > 1) {
aux = aux * 10;
}
aux = aux * 10;
id = id + aux;
return id;
}
void EvoluirPokemons(Listajog *jog) {
Listapok *pokemons;
Nojog *auxjog;
Nopok *auxpok;
int id;
for (auxjog = jog->pri; jog->pri != NULL; jog->pri = jog->pri->prox) {
pokemons = jog->pri->pokemons;
for (auxpok = pokemons->pri; pokemons->pri != NULL; pokemons->pri = pokemons->pri->prox) {
id = pokemons->pri->idpokemon;
if (pokemons->pri->qtd >= 3) {
InserirPok(pokemons, GeraNovoID(id), 1, 1);
auxpok = pokemons->pri->prox;
jog->pri->pokemons = ExcluirPok(pokemons, pokemons->pri->idpokemon);
}
}
pokemons->pri = auxpok;
}
jog->pri = auxjog;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
float income;
float deduction;
float getInput(float income, float deduction ) {
float uInput = -1;
// use do-while loop to gurantee one execution
while (uInput != 0) {
printf(" Enter the next amount : ");
scanf("%f", &uInput);
if(uInput > 0) {
income = income + uInput;
}
}
return 1;
}
int main (void) {
getInput(income, deduction);
printf(" Income %f : \n ", income);
}
/*
// global variables
float income, deduction, taxableIncome, taxOwed;
char group;
float getInput(float *income, float *deduction)
{
float uInput = 0;
// use do-while loop to gurantee one execution
do
{
printf(" Enter the next amount : ");
scanf("%f", &uInput);
if (uInput > 0)
{
*income = *income + uInput;
}
else
{
// we need to convert the negative deduction value to positive.....because we are going to subtract income - deduction in the next methodd
*deduction = *deduction + abs(uInput);
}
} while (uInput != 0);
return 1;
}
int main(void) {
getInput(&income, &deduction);
}
*/
|
C
|
#include<stdio.h>
void main ()
{
int x,y;
for(x=5;x>=1;x--){
for(y=1;y<=x;y++){
printf("%d\t",y);
}
printf("\n");
}
}
|
C
|
#include "HAL9000.h"
#include "dmp_nt.h"
void
DumpNtHeader(
IN PPE_NT_HEADER_INFO NtHeader
)
{
ASSERT( NULL != NtHeader );
LOG("Image Base: 0x%X\n", NtHeader->ImageBase);
LOG("NT base: 0x%X\n", NtHeader->NtBase );
LOG("Image Size: 0x%X\n", NtHeader->Size);
LOG("Image machine: 0x%x\n", NtHeader->Machine);
LOG("Image subsystem: 0x%x\n", NtHeader->Subsystem );
LOG("Number of sections: %u\n", NtHeader->NumberOfSections );
}
void
DumpNtSection(
IN PPE_SECTION_INFO SectionInfo
)
{
ASSERT( NULL != SectionInfo );
LOG("Base address: 0x%X\n", SectionInfo->BaseAddress );
LOG("Size: 0x%x\n", SectionInfo->Size );
LOG("Characteristics: 0x%x\n", SectionInfo->Characteristics );
}
|
C
|
/* CMSC 426 Project
* File: klogger.c
* Author: Patrick Carroll <[email protected]>
* Date: December 2007
*
* This file is a user-space keylogger written for Linux. It works by reading
* directly from the PS/2 port and interpreting the scancodes it sees into
* characters.
*
* IMPROVEMENTS:
* o Could interpret the PS/2 mouse scancodes and ignore them so this
* will work with a computer running X
*
* o Allow this to take any keyboard mapping
*
*
* For lots of information about linux and keyboards:
*
* http://gunnarwrobel.de/wiki/Linux-and-the-keyboard.html
* http://www.faqs.org/docs/Linux-mini/IO-Port-Programming.html
* Also, take a look at the file:
* /usr/src/linux-source-xxx/drivers/char/keyboard.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include "keyboard_port.h"
#define ROOT_UID 0
static int do_output_close = 0;
static FILE *output;
void check_args(int argc, char **argv)
{
if (argc > 2) {
fprintf(stderr, "Usage: %s\n", argv[0]);
exit(1);
} else if (argc == 2) {
output = fopen(argv[1], "a");
if (!output) {
fprintf(stderr, "Couldn't open file: %s\n", argv[1]);
exit(1);
}
do_output_close = 1;
} else {
output = stdout;
}
}
void check_user()
{
if (getuid() != ROOT_UID) {
fprintf(stderr, "You must be root to run this program\n");
exit(2);
}
}
void catch_int(int sig_num)
{
if (do_output_close)
fclose(output);
/* return success */
exit(0);
}
void output_character(unsigned char c)
{
fputc(c, output);
fflush(output);
}
int main(int argc, char **argv)
{
/* since this will run indefinitely, stop with
* the Ctrl-C signal */
signal(SIGINT, catch_int);
/* make sure we're good to go */
check_args(argc, argv);
check_user();
set_up_permissions();
/* enter the main loop */
get_character_from_port(output);
return 0;
}
|
C
|
#include <stdio.h>
int main(int argc, char const *argv[])
{
int n;
scanf("%d", &n);
for (int i = 0; i < 20; i++)
{
if (n & 1)
{
printf("%d*3+1=%d\n", n, n * 3 + 1);
n = n * 3 + 1;
}
else
{
printf("%d/2=%d\n", n, n / 2);
n /= 2;
}
if (n == 1)
{
break;
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.