Ansi C

São nomes diferentes para um argumento. O argumento nesse exemplo é o endereço, na memória, do primeiro elementos da variável indexável (vetor) 'y'.
 
int y[] = {0, 2, 3, 4}; test(int testt[]) --> int testt [] ^--------> é só outro nome para int *testt | +--------> test(y): test (int *tesst= y) ^-------------------= &(y[0]) +-------+-------+-------+-------+ y | 0 | 2 | 3 | 4 | ^ +-------+-------+-------+-------+ | ^ | | +-----+---> 0x100407000 | +------> &(y[0])= 0x100407000 | +------> &(y[1])= 0x100407004 | +------> &(y[2])= 0x100407008 | +------> &(y[3])= 0x10040700c  

🥺
 
O meu nobre, você está no caminho certo, desde começo com 95% da resposta certa. 
Apenas precisa dá um dos valores inicialmente para  variável menor, um ponta pé inicial para que as decisões de lógica (if) fiquem corretas.
 
Acompanhe-me ... essa é uma cópia de sua programação, certinho ....
#include <stdio.h> int main() { float menor,v1,v2,v3; printf("\n Valor 1: "); scanf("%f",&v1); printf("\n Valor 2: "); scanf("%f",&v2); printf("\n Valor 3: "); scanf("%f",&v3); if (v1 < menor) menor = v1; if (v2 < menor) menor = v2; if (v3 < menor) menor = v3; printf ("\n Menor valor : %.2f ",menor); printf("\n peco: [%.2f], [%.2f]", v1, v2); return 0; }  
Bem ali, no topo está a checagem (v1 < menor) ... Daí eu te pergunto, quanto vale menor para ser já comparado com v1, qual o seu valor? Em algum momento deu um valor para  menor ? Isso meu querido... Se não dê inicialmente um valor para menor o computador não saberá as decisões restantes, mas assim mesmo ele faz e erradamente.
 
Então qual é valor inicial para menor que ajuda o computador a toma as decisões certas? 
Qualquer um dos três valores pode ser inicialmente passado para menor e ajudar o computador nas decisões certas, então vamos escolher o primeiro (v1).
"
 
Diga que menor, no topo das decisões, é igual a v1 e o computador decide o resto.
#include <stdio.h> int main() { float menor,v1,v2,v3; printf("\n Valor 1: "); scanf("%f",&v1); printf("\n Valor 2: "); scanf("%f",&v2); printf("\n Valor 3: "); scanf("%f",&v3); menor = v1; // <--- menor agora tem o valor de v1 if (v2 < menor) menor = v2; if (v3 < menor) menor = v3; printf("\n Menor valor : %.2f ",menor); printf("\n peco: [%.2f], [%.2f]",v1,v2); return 0; }  
Entendeu ??
"

é, quem busca excelência encontra mais facilmente nas bibliotecas apropriadas.
 
No exemplo citei Windows.h então quando importa ela esqueça stdio.h e todo o resto.

@Lucca Rodrigues Isso mesmo, se a palavra ultrapassar os 39  o excedente vai para buffer
 

Relativamente fácil!
 
Eu não escrevi, só de cabeça já tenho uma solução simples para problema do professor João Messias.
Precisei de uma matriz [20][10] respectivamente com 20 clientes x 10 notas por cliente, essa matriz é de uma estrutura para organizar os dados das notas.
Cliente: Nota Valor [10], Cliente: Nome Cliente.  
Quesito 1:
Bastante aninhar as instruções de loop, preferencialmente FOR, percorrer a matriz linha x coluna para ler os dois dados do cadastro, simplesmente linear.
 
Quesito 2:
Escrevo um algoritmo\função que realize esse processo por cliente, cujo parâmetro é um vetor [10] com retorno da soma dos elementos do vetor. Agora é suficiente aninha a chamada dessa função a um loop de 0 à 9 para calcular o total de todos os clientes
 
Quesito 3:
Uso o a função do quesito 2.
 
Quesito 4:
Coloco tudo em um vetor de funções ou switch-case, aninho o menu em  um vetor de cstrings e chamo dentro da main.
 
 
 
 

Precisou também de mudanças interna da função.
#include <stdio.h> //Protótipo da funcção ReajSalNovo float ReajSalNovo(float salario); int main (void) { int k, i; float SalAntigo, SalNovo = 0; do{ printf("Digite um numero maior que 0 e menor que 11: "); scanf("%d", &k); } while ((k < 0) || (11 < k)); for(i=0; i < k; i++){ printf("Digite o valor do salario: "); scanf("%f", &SalAntigo); SalNovo = ReajSalNovo(SalAntigo); printf("Sal_antigo: %.2f\tSal_novo: %.2f\n",SalAntigo, SalNovo); } } float ReajSalNovo(float salario) { float sal_novo; //Condicionais que calculam o salário antigo com o reajuste para o sal_novo. if(salario < 800) { sal_novo = salario + salario * 0.15; }else if((salario >= 800) && (salario <= 1000)) { sal_novo = salario + salario * 0.10; }else { sal_novo = salario + salario * 0.05; } return (sal_novo); } Então funcionou ?

(.) e não (,) para separar as frações

@Lobarinhas Boa Dia !!
Seu engano é fazer a Leitura dos pontos aos pares de coordenadas, pois no plano (esquema) A leitura Certa x y, x y e não x x, y y como você programa.

Está certo? Isso é relativo por exemplo do ponto de vista do problema está certo. O que pode fazer é otimizar.
 
Caso queira otimizar deixa saber que é possível enxugar seu programa atual para duas linhas de maneira que o return é completamente desnecessário.
adicionado 2 minutos depois Pensem nisso.
adicionado 4 minutos depois É uma maneira certa.

Remova as instruções for. Esta instrução vaga++ está em local errado, deixo pra você, encontre seu local lógico no programa.

@emanuelrichard Bom dia.
 
 

Se uma rotina é muito complexa então pense nas rotinas menores. 
 
O rotina (em 4 etapas) da maneira como proponho fica complexa mesmo, fica mais complexa ainda quando tenta-se de uma só vez implementa-la. Para ter sucesso nesse caso é necessário dividir tudo em 3 partes e trabalhar com suas etapas individualmente. Não funcionou pra você.
 
Vamos tentar do seu jeito! Entada+Processamento+Saída tudo de uma só vez. Então...
 
 
1# A entrada do receber o Rn, a entrada não determinada de bits, o que sabemos é que a entradas param com -1. Seria que tamanho esse vetor? Como armazenar essas informações de bits sem largura fixa em C++?
 
Exemplo.
#include <iostream> #include <string> int main(void) { std::string bits (""); std::string plusbits (""); for (;;) { std::cin >>(bits); if (bits == "-1") break; plusbits = plusbits + bits; } std::cout <<(plusbits)<< std::endl; return 0; } Experimente entrar: 101 101 101 101 -1
 
 
 
 

@LinsmarVital Boa Noite!
 
 
Esse não é o maior número do mundo, mas é grande o bastante para não caber em um tipo primitivo. Acredito que ele (o professor) esteja sem razões para solicitar sua implementação. Fique tranquilo.
 
 
Como disse, esse não é o maior inteiro já calculado. Para determina-lo seria necessário algumas implementações especificas e talvez outro membro apareça mais tarde para essa discussão.
 
 
Qualquer x > 2147483647 cabe em tipos primitivos. Já quando se fala de qualquer x >>> 2147483647 (nas proximidades de 2277.232.917 – 1) então não é tão simples como fazer um bolo.
 

Nós não queremos lhe dar a resposta, as vezes alguns membros mesmo assim dão na forma de algoritmo narrativo, descritivo ou pseudocódigo. Como eu estou sem tempo então não posso lhe ajudar com muita coisa.
 
Percebo que o nome e o sobrenome são impressos separadamente no final, é o caso de lê na mesma técnica, ou seja, um de cada vez separadamente. Isso resume a leitura em 1 linha de código o que é muita coisa comparada a se fazer um "cabaré" por tão pouco.
 
char nome[42]; // para salvar o primeiro nome char sobrenome[150]; // para salvar o segundo nome scanf (" %s%149[^\n]", nome, sobrenome); // ler nome printf ("%s, %s", nome, sobrenome); // exibir nome  
Com relação a segunda parte, planeja a solução de como faria para resolver você mesmo e não com programação, nesse caso é você papel e caneta: como seu cérebro resolve isso. Depois aplique a linguagem e faça perguntas mais objetivas.

Letra d) Crie uma estrutura FOR que vai 1 até 6, dentro dessa estrutura crie outra igual. Na primeiro você coloca vetor de apostas, na segunda você coloca o gabarito, compare cada elemento do gabarito com um elemento do vetor de apostas. Notará que para cada aposta no vetor de apostas percorrera completamente o vetor com gabarito.
 
Esse ciclo se realizará para cada vetor de aposta, ou seja, 6 vezes também. Pode usar os vetores separados de apostas ou a matriz de aposta já que são iguais em conteúdo e valor.
 
 
Dica: Usar funções para separar os problemas e as soluções, uma estrutura também permite , além de melhorias de design, reaproveitamento de código que futuramente será cobrado.

#include <stdio.h> #include <stdlib.h> struct marketing{ int codigo_m; char tipo[10]; char codigo_prod[10]; } mar[2]; struct produto{ int codigo_prod; char descricao[10]; } produto[10]; void lerdados(){ int i=0,j=0; for(i=0; i<2; i++){ //cadastro do marketing printf("codigo marketing: "); scanf("%d",&mar[i].codigo_m); printf("tipo, lancamento ou promocao: "); scanf("%s",mar[i].tipo); printf(">>preenchendo o produto:\n"); //preenchendo produto for(j=0; j<10; j++){ printf("codigo produto"); scanf("%d",&produto[j].codigo_prod); printf(" descricao:\n"); scanf("%s",produto[j].descricao); } } } void gravar (){ int i,j; FILE *arq; arq=fopen("produtos.txt","w"); for(i=0;i<2;i++){ fprintf(arq,"tipo:%s||codigo_m:%d\n",mar[i].tipo,mar[i].codigo_m); fprintf(arq,"marketing\n"); for(j=0;j<10;j++){ fprintf(arq,"descricao: %s||codigo_prod: %s\n", produto[j].descricao, mar[j].codigo_prod); } fprintf(arq,"========="); } fclose(arq); } int main(){ int op; do{ printf(">>Menu:\n"); printf("1.Ler dados\n"); printf("2.Gravar dados\n"); printf("3.Sair\n"); scanf("%d",&op); switch(op){ case 1: lerdados(); break; case 2: //Gravar(); break; default: break; } }while(op!=3); return 0; } Compilou, mas ainda não sei ao certo porque ele faz o que faz da maneira que faz.

decimal notas= 0, mediaA= 0, mediaT= 0; int n= 0; do { for (int i = 0; i < 3; i++) { Console.WriteLine("Digite a sua nota " + i); notas += Decimal.Parse(Console.ReadLine()); } mediaA= notas / 3; Console.WriteLine("A média do aluno foi: " + mediaA); Console.WriteLine(); notas= 0; mediaT += mediaA; n++; } while (n < 10); Console.WriteLine("A média da turma foi: " + mediaT / n); Console.WriteLine(); Console.ReadKey();  
adicionado 0 minutos depois Editado: nota= 0;

Sim. Vou só rescrever o enunciado com minha interpretação.
 
Seja M uma matriz de ordem N= 12, e todos os elementos em A que pertence a diagonal principal são os Elementos de V. Mostre a soma de todos os elementos em V e o próprio V. 
Code
/* Protótipos Externos */ #include <stdio.h> #include <stdlib.h> /* Minhas Constantes */ enum matriz {ordem= 2}; /* Minha Função Principal */ int main(void) { /* Meu Programa C: Soma da Diagonal Principal */ /* 0) Variáveis Internas */ float M[ordem][ordem]; /* < Cria uma matriz de ordem 12 */ float vp[ordem]; /* < Cria um Vetor para receber a diagonal Pricipal */ float sp= 0; /* < Cria um variável para Soma da diagonal Principal */ /* 1) Preencher Matriz 12x12 */ for( int i= 0; i < ordem; ++i) { for(int j= 0; j < ordem; ++j) { printf("a%d%d= ", i, j); scanf("%f", (&M[i][j])); } } /* 2) Preencher o Vetor com a diagonal */ for(int o= 0; o < ordem; ++o) { vp[o]= M[o][o]; } /* 3) Exibir Vetor com a diagonal e realizar a adição dos seus elementos */ for(int o= 0; o < ordem; ++o) { printf("%.1f + ", vp[o]); sp= vp[o] + sp; } /* 4) Exibir soma dos seus elementos */ printf("\b\b= %.1f\n", sp); return EXIT_SUCCESS; }  

Olá, 
Existem incontatáveis maneiras de se fazer isso; eu por exemplo organizaria as entradas no vetor, ou seja, se o valor digitado for par então a índice par será incrementado e gravado no início do vetor, se o valor é ímpar, o índice impar é incrementado e o valor gravado no fim do vetor. 
 
A lógica é muito básica, ambos índices incrementam, porém apenas o índice que vem da "rabo" do vetor, ou seja, do seu tamanho subtrai, obviamente.
 
/* Exemplo básico do que estou falando, só para ilustração */ enum Constantes {TAM= 10,}; /*: Constante do programa */ int valor_int= 0; /*: alocar uma variável do tipo inteiro */ int pares= 0; /*: índece para pares */ int impares= 0; /*: índice para ímpares */ int valores_int[TAM]= {0}; /*: alocar base para os valores */ scanf( "%i", (& valor_int) ); /*: Da entrada padrão pegar um dado inteiro */ if( valor_int & 1 ) { /*: Se ímpar então salvar e incrementar os ímpares */ valores_int[(TAM - 1) - impares++]= valor_int; } else { /*: Se não então salvar e incrementar os pares */ valores_int[pares++]= valor_int; } Daqui, eu acredito que você já ver as quantidades de pares e ímpares, saberá também que todos os valores ímpares estão no fim do vetor, a partir da última célula, bem como todos os valores pares estão no começo do vetor, a partir da primeira célula. 
 
Valeu!

Pera lá! Como disse antes fscanf lé até encontrar um ENTER, basta modificar o flag para virgula, assim ôh: "%[^,]" 

@SamuraiOcidental Boa noite!
Então ... Vamos lá
 
#include <stdio.h> int main( void ) { struct Banda { char nome[ 30 ]; char tipo[ 30 ]; int integrantes; } Banda bandas[ 5 ]= { 0 }; int index= 0; int maior= 0; for( index= 0; index < 5; ++index ) { printf( "%d Nome da Banda: ", index + 1 ); scanf( " %29[^\n]", bandas[ index ].nome ); setbuf( stdin, NULL ); printf( "Estilo de Musica: " ); scanf( " %29[^\n]", bandas[ index ].Tipo ); setbuf( stdin, NULL ); printf( "Entre com a quantidade de integrantes: " ); scanf( " %d", (& bandas[ index ].integrantes) ); setbuf( stdin, NULL ); } printf( "Nome das Bandas \n\n" ); for( index= 0; index < 5; ++index ) { printf( "%d Banda\n", index + 1 ); printf( "Nome..........: %s\n", bandas[ index ].nome ); printf( "Estilo musical: %s\n", bandas[ index ].Tipo ); printf( "Membros.......: %d\n", bandas[ index ].integrantes ); } for( index = 0; index < 5; ++index ) { if ( bandas[ index ].integrantes > bandas[ maior ].integrantes ) { maior= index; /* banda de mais integrantes */ } } printf( "A banda com mais integrandes e: %s \n\n", bandas[ maior ].nome ); return 0; }  

Então não há o que explicar;
Sua lógica está correta;
Só a função que tem  de ser outras
: recomendo a função putchar( int ch ); com ela vai imprimir direto na saída padrão; igual fez com printf( "%c",  nome [ letra ] );
 
Outra coisa só não use gets para leitura de string em outros projetos daqui em diante, essa função foi de  introdução do C,  e cai  em desus a partir da versão 2011 da linguagem, consulte gets_s. As razões para o _s no final é que essa é de uma implementação mais segura da versão ANSI C.
 

Você somente precisa iniciar a variável x, atribuindo 1 pra ela.
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApp1 { class Program { class Coisa { int x= 1; int Fibo( int a ) { if( a > 1 ) { x= a * Fibo( a - 1 ); } Console.WriteLine( a + " " + x ); return x; } static void Main() { string c; int a; Console.WriteLine( "Insira um número para ver sua fatoração" ); c= Console.ReadLine(); a= Convert.ToInt32( c ); Coisa coisa = new Coisa(); coisa.Fibo( a ); Console.WriteLine( "A Fatorial de " + a + " é " + coisa.x ); Console.ReadLine(); }}} }  

@Arthur Vandellay O que é uma string em C, qual a diferença entre um vetor de caracteres e uma strings na linguagem C? Essa não é uma pergunta difícil, longe disso, não é nenhuma novidade é coisa velha d+, e vai te auto-educar com relação a seu problema. 
 
Muito fácil.

Sim a função solicita libertação do segmento e atualiza o apontador, se tudo de certo um apontador diferente de 0 e retornado pela função.

@rafael bartz Você não precisa simultaneamente contar computar quantos estão e quantos não no intervalo. Basta escolher um ou o outro porque são mutualmente excludentes.
 
Seu maior erro é com relação a expressão de controle que seleciona quem está ou não no intervalo fechado. Ao que me parece você fez uma tentativa inspirada na matematicidade da notação de intervalos (assim como viu em um livro de matemática usou em C). Quando o correto é:
/* ∀ n | 10 ≤ n ≤ 20 é verdade ⇔ n ∈ {10, 11 ... 20} */ (10 <= n && n <= 20)