Please note, this is a STATIC archive of website www.tutorialspoint.com from 11 May 2019, cach3.com does not collect or store any user information, there is no "phishing" involved.
Tutorialspoint
Home
Q/A
Tools
Coding Ground
Current Affairs
UPSC Notes
Online Tutors
Code Examples
Whiteboard
Net Meeting
Articles
Library
Videos
eBooks

Compile and Execute C Online

c 

#include <stdio.h>
int main(void)
{
	int a,b,c,d,e;
	int j = 0;
	int index = 0;
	//int array[10] = {1,3,5,7,8,9,2,4,6};
	int array[10];
	FILE *fp;
	fp = fopen("before_sort.txt","r");
	if(fp == NULL){
    printf( "ファイルオープンエラー\n");
    return 0;
	}
	while((a = fscanf(fp,"%d",&b)) != EOF) {
		//printf("%d",b);
		array[index] = b;
		printf("%d",array[index]);
		index++;
	}
	//printf("\n");
		for(c = 0;c < 9;c++){
		printf("\n");
	    for(d = 0;d < 9;d++){
	        if(array[c] < array[d]){
	            e = array[c];
	            //printf("%d\n",e);
	            array[c] = array[d];
	            //printf("%d\n",a[j]);
	            array[d] = e;
	        }
	        printf("%d",array[index]);
	    }
	}
	fclose(fp);
	return 0;
}
//C言語　ログの並び替え　文字列で検索

Bubble Sort

c 

#include <stdio.h>
int main() {
    int a[100],i,j,n;
    scanf("%d",&n);
    for (i = 0; i < n; i++){
        scanf("%d",&a[i]);
    }
    for (i = 0; i < n-1; i++){
        for (j = 0; j < n - 1 - i; j++){
            if (a[j]>a[j+1]){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
    for (i = 0; i < n; i++){
        printf("%d ",a[i]);
    }
    return 0;
}

Bitwise Boolean Operators

c 

#include <stdio.h>

int main()
{
    unsigned char a=0b01010101;
    unsigned char b=0b10101010;
    unsigned char c;
    
    c=a&b;
    
    printf("a&b=%x\n\r",c);

    c=a|b;
    
    printf("a|b=%x\n\r",c);

    c=b^a;
    
    printf("b^a=%x\n\r",c);
    return 0;
}

Compile and Execute C Online

c 

#include <stdio.h>
#include <stdlib.h>
#define max 100
struct pilha 
{
    int FL;
    int dados[max];
};
typedef struct pilha Pilha;

Pilha *Cria_pilha(void)
{
    Pilha *pt = (Pilha *) malloc(sizeof(Pilha));
    if (pt != NULL)
        pt->FL = 0;
    return pt;
}
Pilha *Libera_pilha(Pilha *Ptl)
{
    free(Ptl);
    //Debug
    printf("Liberando pilha da memoria\n");
    return NULL;
}
Pilha*Insere_elem(Pilha *Ptl, int elem)
{

    if (Ptl == NULL || Ptl->FL == max){
        printf("Nao foi possivel inserir elemento, Pilha cheia !!!!\n");
        return Ptl;
    }
        
    // insere elemento no final da lista
    Ptl->dados[Ptl->FL] = elem;
    Ptl->FL++;
    return Ptl;
}
int Tamanho_pilha(Pilha *Ptl)
{
    if (Ptl == NULL)
        return -1;
    else
        return Ptl->FL;
}

Pilha *Remove_elem_mov(Pilha *Ptl, int elem)
{
    int i, k;
    if (Ptl == NULL || Ptl->FL == 0)
        return Ptl;
    // procura elemento na lista

    i = 0;
    while (i < Ptl->FL && Ptl->dados[i] != elem)
        i++;

    if (i == Ptl->FL) // elemento nao encontrado
        return Ptl;

    //elemento encontrado na posiçao i. Remover elemento
    // com movimentaçao de dados

    for (k = i; k < Ptl->FL - 1; k++)
        Ptl->dados[k] = Ptl->dados[k + 1];

    // atualiza fim de lista
    Ptl->FL--;
    return Ptl;
}

int Consulta_nodo(Pilha *Ptl, int pos, int *info)
{

    if (pos <= 0 || pos > Ptl->FL)
        return 0;

    *info = Ptl->dados[pos - 1];
    return 1;
}

int E_cheia(Pilha *Ptl)
{
    if (Ptl->FL == max)
        return 1;
    else
        return 0;
}

int E_vazia(Pilha *Ptl)
{
    if (Ptl->FL == 0){
        //Codigo para debub
        printf("Lista Vazia\n");
        return 1;
    }
    else{
        //Codigo para debug
        printf("Lista contem elementos\n");
        return 0;
    }
        
}
int Imprime_pilha(Pilha *Ptl){
    int elemento;
    int tamanho = Tamanho_pilha(Ptl);
    printf("\n*** IMPRIMINDO ELEMENTOS DA PILHA ***\n");
    
    for(int i=1; i<=tamanho;i++){
    Consulta_nodo(Ptl, i, &elemento);
    printf("%d - %d\n", i, elemento);    
 }
}


int main()

{
    int k;
Pilha* minhapilha;
minhapilha = Cria_pilha();
 //Libera_lista(minhaLista);
 
int vazia = E_vazia(minhapilha);
 
for(k=0;k<=10;k++){
     Insere_elem(minhapilha, k);
 }
 printf("inserção de elementos \n");
 
 }

 int vazia2 = E_vazia(minhapilha);
 
 //int tamanho = Tamanho_pilha(minhapilha);
//printf("Tamanho da pilha = %d\n", tamanho);
// int elemento;
/* for(int i=1; i<=tamanho;i++){
    Consulta_nodo(minhapilha, i, &elemento);
    printf("elemento da pilha = %d\n", elemento);    
 }
  
//Imprime_pilha(minhapilha);
for(int v=0; v<=50;v++) {
  Remove_elem_mov(minhapilha, v);
}
for(int i=1; i<=tamanho;i++){
    Consulta_nodo(minhapilha, i, &elemento);
    printf("elemento da pilha = %d\n", elemento);    
 }  
 

printf("Tamanho da pilha = %d\n", tamanho);
*/
    return 0;
}

Compile and Execute C Online

c 

#include <stdio.h>

int main()
{
    printf("Hello, World!\n");

    return 0;
}

PILHA 04.04.2019 ALUNOS DIEGO, GABRIEL E THALES

c 




#include <stdio.h>
#include <stdlib.h>
#define MAX 100

typedef struct pilha {
    int topo;
    int dados[MAX];
} Pilha;

Pilha *criarPilha(void) {
    Pilha *p = (Pilha *) malloc(sizeof(Pilha));
    if (p != NULL) {
        p->topo = 0;
    }
    return p;
}

int eVazia(Pilha *p) {
    if (p->topo == 0){
        return 1;
    } else {
        return 0;
    }
}

Pilha *empilhar(Pilha *p, int valor) {
    if (p == NULL || p->topo == MAX) {
        return p;
    }
    p->dados[p->topo] = valor;
    p->topo++;
    return p;
}

Pilha *desempilhar(Pilha *p) {
    if (p == NULL || p->topo == 0) {
        return p;
    }
    p->topo--;
    return p;
}

int topo(Pilha *p) {
    return p->dados[p->topo - 1];
}

int main()
{
    printf( "Diego Mendelson RA 14171   Gabriel Brito RA 14147  Thales Henrique RA 14494")    ;
    // criando pilha
    Pilha* minhaPilha;
    minhaPilha = criarPilha();

    // INSERE 100 ELEMENTOS
    int i = 1;
    for (i=1; i<=100; i++) {
        empilhar(minhaPilha, i);
        printf("  %d \n", topo(minhaPilha));
    }
    
    // REMOVE 50 ELEMENTOS
    for (i=0; i<50; i++) {
        printf("  %d \n", topo(minhaPilha));
        desempilhar(minhaPilha);
    }
    
    // TOPO DA LISTA
    printf("TOPO = %d \n", topo(minhaPilha));
    
    return 0;
}

Lista Linear

c 

#include<stdio.h>
#include<stdlib.h>
#define MAX 9
struct lista
{
    int FL;
    int dados[MAX];
};

typedef struct lista Lista;

Lista *Cria_lista(void)
{
    Lista *pt = (Lista *) malloc(sizeof(Lista));
    if (pt != NULL)
        pt->FL = 0;
    return pt;
}

Lista *Libera_lista(Lista *Ptl)
{
    free(Ptl);
    //Debug
    printf("Liberando lista da memoria\n");
    return NULL;
}

Lista *Insere_elem(Lista *Ptl, int elem)
{

    if (Ptl == NULL || Ptl->FL == MAX){
        printf("Nao foi possivel inserir elemento, LISTA CHEIA!!!!\n");
        return Ptl;
    }
        
    // insere elemento no final da lista
    Ptl->dados[Ptl->FL] = elem;
    Ptl->FL++;
    return Ptl;
}

Lista *Remove_elem_mov(Lista *Ptl, int elem)
{
    int i, k;
    if (Ptl == NULL || Ptl->FL == 0)
        return Ptl;
    // procura elemento na lista

    i = 0;
    while (i < Ptl->FL && Ptl->dados[i] != elem)
        i++;

    if (i == Ptl->FL) // elemento nao encontrado
        return Ptl;

    //elemento encontrado na posiçao i. Remover elemento
    // com movimentaçao de dados

    for (k = i; k < Ptl->FL - 1; k++)
        Ptl->dados[k] = Ptl->dados[k + 1];

    // atualiza fim de lista
    Ptl->FL--;
    return Ptl;
}

int Consulta_nodo(Lista *Ptl, int pos, int *info)
{

    if (pos <= 0 || pos > Ptl->FL)
        return 0;

    *info = Ptl->dados[pos - 1];
    return 1;
}

int E_cheia(Lista *Ptl)
{
    if (Ptl->FL == MAX)
        return 1;
    else
        return 0;
}

int E_vazia(Lista *Ptl)
{
    if (Ptl->FL == 0){
        //Codigo para debub
        printf("Lista Vazia\n");
        return 1;
    }
    else{
        //Codigo para debug
        printf("Lista contem elementos\n");
        return 0;
    }
        
}

int Tamanho_lista(Lista *Ptl)
{
    if (Ptl == NULL)
        return -1;
    else
        return Ptl->FL;
}

int Imprime_lista(Lista *Ptl){
    int elemento;
    int tamanho = Tamanho_lista(Ptl);
    printf("\n*** IMPRIMINDO ELEMENTOS DA LISTA ***\n");
    
    for(int i=1; i<=tamanho;i++){
    Consulta_nodo(Ptl, i, &elemento);
    printf("%d - %d\n", i, elemento);    
 }
}

int main() {
 Lista* minhaLista;
 minhaLista = Cria_lista();
 //Libera_lista(minhaLista);
 
 int tamanho = Tamanho_lista(minhaLista);
 printf("Tamanho da lista = %d\n", tamanho);
 
 
 Insere_elem(minhaLista,10);
 Insere_elem(minhaLista,20);
 Insere_elem(minhaLista,30);
 Insere_elem(minhaLista,40);
 Insere_elem(minhaLista,50);
 Insere_elem(minhaLista,60);
 
 int vazia = E_vazia(minhaLista);
 tamanho = Tamanho_lista(minhaLista);
 printf("Tamanho da lista = %d\n", tamanho);
 
 
 
 //Imprime todos elementos da lista na unha
 int elemento;
 for(int i=1; i<=tamanho;i++){
    Consulta_nodo(minhaLista, i, &elemento);
    printf("elemento da lista = %d\n", elemento);    
 }
 
 //Libera_lista(minhaLista);
 
 Imprime pela operacao
 Imprime_lista(minhaLista);
 
 
}

Lista Linear

c 

#include<stdio.h>
#include<stdlib.h>
#define MAX 11

struct lista
{
    int FL;
    int dados[MAX];
};

typedef struct lista Lista;

Lista *Cria_lista(void)
{
    Lista *pt = (Lista *) malloc(sizeof(Lista));
    if (pt != NULL)
        pt->FL = 0;
    return pt;
}

Lista *Libera_lista(Lista *Ptl)
{
    free(Ptl);
    //Debug
    printf("Liberando lista da memoria\n");
    return NULL;
}

Lista *Insere_elem(Lista *Ptl, int elem)
{

    if (Ptl == NULL || Ptl->FL == MAX){
        printf("Nao foi possivel inserir elemento, LISTA CHEIA!!!!\n");
        return Ptl;
    }
        
    // insere elemento no final da lista
    Ptl->dados[Ptl->FL] = elem;
    Ptl->FL++;
    return Ptl;
}

Lista *Remove_elem_mov(Lista *Ptl, int elem)
{
    int i, k;
    if (Ptl == NULL || Ptl->FL == 0)
        return Ptl;
    // procura elemento na lista

    i = 0;
    while (i < Ptl->FL && Ptl->dados[i] != elem)
        i++;

    if (i == Ptl->FL) // elemento nao encontrado
        return Ptl;

    //elemento encontrado na posiçao i. Remover elemento
    // com movimentaçao de dados

    for (k = i; k < Ptl->FL - 1; k++)
        Ptl->dados[k] = Ptl->dados[k + 1];

    // atualiza fim de lista
    Ptl->FL--;
    return Ptl;
}

int Consulta_nodo(Lista *Ptl, int pos, int *info)
{

    if (pos <= 0 || pos > Ptl->FL)
        return 0;

    *info = Ptl->dados[pos - 1];
    return 1;
}

int E_cheia(Lista *Ptl)
{
    if (Ptl->FL == MAX)
        return 1;
    else
        return 0;
}

int E_vazia(Lista *Ptl)
{
    if (Ptl->FL == 0){
        //Codigo para debub
        printf("Lista Vazia\n");
        return 1;
    }
    else{
        //Codigo para debug
        printf("Lista contem elementos\n");
        return 0;
    }
        
}

int Tamanho_lista(Lista *Ptl)
{
    if (Ptl == NULL)
        return -1;
    else
        return Ptl->FL;
}

int Imprime_lista(Lista *Ptl){
    int elemento;
    int tamanho = Tamanho_lista(Ptl);
    printf("\n*** IMPRIMINDO ELEMENTOS DA LISTA ***\n");
    
    for(int i=1; i<=tamanho;i++){
    Consulta_nodo(Ptl, i, &elemento);
    printf("%d - %d\n", i, elemento);    
 }
}

int main() {
 Lista* minhaLista;
 minhaLista = Cria_lista();
 //Libera_lista(minhaLista);
 
 int tamanho = Tamanho_lista(minhaLista);
 printf("Tamanho da lista = %d\n", tamanho);
 
 Insere_elem(minhaLista,10);
 Insere_elem(minhaLista,20);
 Insere_elem(minhaLista,30);
 Insere_elem(minhaLista,40);
 Insere_elem(minhaLista,50);
 Insere_elem(minhaLista,60);
 Insere_elem(minhaLista,60);

 
 int vazia = E_vazia(minhaLista);
 tamanho = Tamanho_lista(minhaLista);
 printf("Tamanho da lista = %d\n", tamanho);
 
 
 
 //Imprime todos elementos da lista na unha
 int elemento;
 for(int i=1; i<=tamanho;i++){
    Consulta_nodo(minhaLista, i, &elemento);
    printf("elemento da lista = %d\n", elemento);    
 }
 
 //Libera_lista(minhaLista);
 
 //Imprime pela operacao
 Imprime_lista(minhaLista);
 
 
}

Compile and Execute C Online

c 

#include <stdio.h>

#define BYTE_TO_BINARY_PATTERN(n) \
    (n == 10)?"%010d \r\n": \
    (n == 9)?"%09d \r\n": \
    (n == 8)?"%08d \r\n": \
    (n == 7)?"%07d \r\n": \
    (n == 6)?"%06d \r\n": \
    (n == 5)?"%05d \r\n": \
    (n == 4)?"%04d \r\n": \
    (n == 3)?"%03d \r\n": \
    (n == 2)?"%02d \r\n": \
    (n == 1)?"%01d \r\n":"" 
    
#define BYTE_TO_BINARY(byte, n)  \
    0 + \
    (((byte % 2) & 0x1)    * 1) + \
    (((byte / 2) & 0x1)    * 10) + \
    (((byte / 4) & 0x1)    * 100) + \
    (((byte / 8) & 0x1)    * 1000) + \
    (((byte / 16) & 0x1)   * 10000) + \
    (((byte / 32) & 0x1)   * 100000) + \
    (((byte / 64) & 0x1)   * 1000000) + \
    (((byte / 128) & 0x1)  * 10000000) + \
    (((byte / 256) & 0x1)  * 100000000) + \
    (((byte / 512) & 0x1)  * 1000000000) + \
    (((byte / 1024) & 0x1) * 10000000000)

#define POWER_OF_TWO(x) (1 << (x))
#define NUMBER 10

int N = NUMBER;
int Tab[POWER_OF_TWO(NUMBER)];

void GenerateGreyCode(int N, int* pTab)
{
    int max = 1 << N, i = 0;
    for(i = 0; i < max; ++i)
    {
        pTab[i] = i ^ (i >> 1);
    }
}

int main()
{
    int i = 0;

    GenerateGreyCode(N, Tab);

    for(i = 0; i < POWER_OF_TWO(NUMBER); ++i)
    {
        printf(BYTE_TO_BINARY_PATTERN(N), BYTE_TO_BINARY(Tab[i], N));
    }

    return 0;
}

esercizio2

c 

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

int altamenteComposto(int n, int *d);
int contaDivisori(int n);

int main()
{
    int k, d;
    
    scanf("%d", &k);
    if(altamenteComposto(k, &d) == 0) {
        printf("\nIl numero %d è altamente composto, avendo %d divisori\n", k, d);
    } else {
        printf("\nIl numero %d NON è altamente composto pur avendo %d divisori\n", k, d);
    }
    
    return 0;
}

int altamenteComposto(int n, int *d) {
    int flag = 1;
    *d = contaDivisori(n);
    
    for(int i = n; i >= 1; i--) {
        if(contaDivisori(n) >= contaDivisori(i)) {
            flag = 0;
        } else { break; }
    }
    
    return flag;
}

// Funzione che conta il numero di divisori di un intero N
int contaDivisori(int n) {
    int counter = 0;
    for(int i = 1; i <= n; i++) {
        if(n%i == 0)
            counter++;
    }
    return counter;
}

Previous 1 ... 4 5 6 7 8 9 10 ... 950 Next
Advertisements
Loading...
img img img img img img

Follow

© Copyright 2019. All Rights Reserved.

Newsletter

We use cookies to provide and improve our services. By using our site, you consent to our Cookies Policy.