Programiranje u C-u - od svega pomalo

#include <stdio.h>
Skužio!

Zadatak glasi ovako:

Potrebno je učitati pozitivan broj X s tipkovnice i izračunati mu zbroj znamenki. Ako je zbroj znamenki prost broj onda treba ispisati sve proste brojeve manje od zbroja znamenki,a ako nije od korisnika treba traziti unos broja Y u intervalu [11, 15] i ispisati sve neparne brojeve djeljive sa Y u intervalu [1, X].

Ja evo pokušavam to nekako riješiti, ali gubim se u ovim if-ovima, for petljama jer na kraju ne znam gdje ubaciti ovaj zadnji ELSE na dnu koda, znam da mora biti nakon if-a, ali nesto ne stima. Pa ako moze mala pomoc ili ako ima netko nekakav savjet oko koda, na cemu bi trebao poraditi prilikom pisanja ovakvog koda, sto krivo radim etc.

Dolje sam stavio sliku kako bi trebao izgledati ulaz i izlaz na konzoli.

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

int main(void){

int x,z;
scanf("%d", &x);

while( x <= 0){
  printf("Nepravilni unos!\n");
  scanf("%d", &x);
}
/*Brojevi od 0 do 99*/
if ( x < 100){
  z = x%10;
  z = z + (x/10);
}
/*Brojevi od 100 do 999*/
if (x > 99 && x<1000){
  z = x%10;
  z = z + ((x%100)/10);
  z = z + (x/100);
}
/*Brojevi od 1000 do 9999*/
if (x>999 && x<10000){
  z = x%10;
  z = z + (x%100)/10;
  z = z + (x%1000)/100;
  z = z + (x/1000);
}

int i;
int br= 0;
int n;
int temp= 0;
int y;

for(i=1;i<=z;i++){
  if(z%i==0 && br==1){
    br++;
    printf(" %d", i);
  }

  for(n=2;n<z;n++){
    temp=0;

    for(i=1;i<z;i++){

      if(n%i==0){
      temp++;
      }
    }
    if (temp==2){
    printf(" %d", n);
  }

}
}
else
scanf("%d", &y);
if ( y < 11 && y >15){
   printf("Nepravilni unos!\n");
   scanf("%d\n", &y);
}
if(y>=11 && y<=15){
   for(i=1; i<=x;i++){
     if(i%2!=0 && i%y==0)
     printf("%d", i);
   }
}
return 0;
}

Ne da mi se rješavati zadatak, izgleda da ga je kolega Mr.ddevil rješio, ali budući da si pitao za savjete oko koda, evo jedan.

Koristi TOP-DOWN pristup. Što to znači? Znači da krećeš od viših arhitekturalnih/apstraktnih koncepata i onda postupno ideš prema nižim i na kraju samoj implementaciji.

Tvoj problem je što si se izgubio u kodu i ne znaš gdje ide zadnji else, ali da si čitav zadatak razlomio na manje dijelove i rješavao ih postupno, znao bi gdje treba zadnji else, a možda ti ne bi ni trebao.

E sad, da ti ovo sve objasnim na konkretnom primjeru, koristit ću tvoj zadatak.

Potrebno je učitati pozitivan broj X s tipkovnice i izračunati mu zbroj znamenki. Ako je zbroj znamenki prost broj onda treba ispisati sve proste brojeve manje od zbroja znamenki,a ako nije od korisnika treba traziti unos broja Y u intervalu [11, 15] i ispisati sve neparne brojeve djeljive sa Y u intervalu [1, X].

int main(void)

{

   /// Prvo se u zadatku traži ucitavanje pozitivnog broja

   /// s tipkovnice. Ova funkcija mora vratit pozitivan broj.

   int ucitani_broj_x = ucitaj_pozitivan_broj();

   /// Nakon ucitavanja, mora se izracunati njegov zbroj znamenki.

   int zbroj_znamenki = izracunaj_zbroj_znamenki(ucitani_broj);

   /// Ova funkcija provjerava je li predani broj prost. Ako je

   /// prost, vraca 1, ako nije, vraca 0. Kao argument funkcije

   /// predajemo zbroj znamenki, jer se tako traži u zadatku.

   int broj_prost = provjeri_prost_broj(zbroj_znamenki);

   /// Ako je prost, ispisi sve brojeve manje od zbroj_znamenki.

   /// Ako nije, ispisi sve brojeve do 

   if (broj_prost)

   {

     ispisi_proste_brojeve_do(zbroj_znamenki);

   }

   else

   {

     int ucitani_broj_y = ucitaj_broj_iz_intervala(11, 15);

     /// Ova funkcija ce ispisati sve neparne brojeve koji su

     /// djeljivi s prvim argumentom, a nalaze se u intervalu

     /// koji je definiran prvim i drugim argumentom.

     ispisi_sve_neparne_brojeve(ucitani_broj_y, 1, ucitani_broj_x);

   }

   return 0;

}

Također, možeš primjetiti da funkcije učitavanja broja su prilično slične, iako možda na prvu ne izgleda tako. Učitavanje pozitivnog broja je ustvari učitavanje broja iz intervala od 0 (uključujući) do maksimalne veličine integer podatka u C-u (koja je otkrij sam). Definiraš maksimalnu vrijednost, te pozoveš funkciju kao ucitaj_broj_iz_intervala(0, MAX_INT_VALUE);. To znači da umjesto dvije slične funkcije imaš jednu:

int ucitaj_broj_iz_intervala(int pocetak_intervala, int kraj_intervala);

i time si zadovoljio i DRY princip.

Kao što vidiš, ovako rastavljen zadatak na manje cjeline je puno lakši za shvatiti. Kod je jednostavan i pregledan, sve funkcije su striktno definirane i točno se zna što koja prima, a što vraća, imaju samo jedan mali zadatak i samo njega obavljaju. Primjer loše funkcije bi bila funkcija ucitaj_pozitivan_broj_i_izracunaj_zbroj_znamenki(). Takva funkcija obavlja dva zadatka koji nisu povezani, a zbrajanje znamenki je nešto što bi se moglo ponovno koristiti. Zato je dobar kandidat za izdvajanje te mogućnosti u posebnu funkciju. Funkciju provjeri_prost_broj(int broj); možeš pozivati ponovno u funkciji ispisi_proste_brojeve_do(int broj);.

Ono što u main funkciji trebaš napisati je točno ono što se traži u zadatku, ali ne i kako to napraviti. Za samu implementaciju (kako) se brinu pojedine funkcije.

Eto, nadam se da sam malo pomogao i da će ti odsad biti lakše shvaćati zadatke.

EDIT: Kako formatirati kod bez ovih crta između?

Pozdrav ekipa,

naravno imam pitanje, radim upravo vezane liste u C-u i dobro bi mi došla pomoc, trebam udruzit dvije vezane liste. Naime, generiram slucajnih 20 brojeva koje spremam u jednu listu i ispisujem listu bez ponavljanja istih brojeva, to sam napisala i radi. drugi dio zadatka je izmijeniti prvi dio na nacin da se koristi vezana lista koja uz pokazivac na next ima i pokazivac na child vezanu listu. u child vezanu listu treba spremati sve duple vrijednostii na kraju ispisati osnovnu vezanu listu te koliko child elemenenata ima svaki elemennt. saljem vam svoj kod pa ako mi mozete objasnit di grijesim 

hvala puno!

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#include<malloc.h>
#include<time.h>
typedef struct child *pos;
typedef struct child {
int duplikat;
pos next;

}child;
typedef struct lista *position;
typedef struct lista {
int broj;
position next;
pos child;
}lista;
void insert1(int, position );
void insert(int, position);
void print1(pos);
void generiranje(position p) {
int i;
int x = 0;
for (i = 0; i < 20; i++) {
x = (rand() % 11);
insert(x, p);
insert1(x, p);
}

}
void print(position p) {
while (p != NULL) {
printf(" %d", p->broj);

p = p->next;
}
printf("\n");
}
void insert(int x, position p) {
position q;
q = (position)malloc(sizeof(lista));
while (p->next != NULL)

p = p->next;

q->broj = x;
q->next = p->next;
p->next = q;

}
void insert1(int br, pos p) {
position x ;

x = (position)malloc(sizeof(lista));
x->broj = br;
x->next = p->child;
p->child = x;

print1(x);
}
void print1(pos p) {
while (p != NULL) {
printf(" %d ", p->duplikat);
p = p->next;
}
}
void Delete(position p) {
position q, temp;
q = p;

while (p != NULL) {
while (q->next != NULL) {
if (p->broj == q->next->broj) {
temp = q->next;
q->next = q->next->next;


}
else
q = q->next;
}
p = p->next;

q = p;

}

}
int main() {
lista head;
head.next = NULL;
child head1;
head1.next = NULL;

srand((unsigned)time(NULL));
generiranje(&head);
print(head.next);
printf("\ndelete\n");
Delete(head.next);
print(head.next);
printf("\n strasno\n");

return 0;
}

Naravno, ovaj  gornji koncept gdje imam dvije paralelne liste, main i child listu i preko main liste imam link na početak child liste mi se baš ne sviđa jer kod ispisa broja duplikata imam kvadratnu složenost.

Koncept u kojem na svaki pojedini element main liste imam link na duplikate tog elementa, odnosno za svaki element main liste imam child listu tog elementa mi je prihvatljiviji jer nigdje ne prelazi linearnu složenost, ni kod brojenja duplikata a isto tako ni kod ispisa svih child elemenata kojih uvežem preko pojedinih elemenata main liste.

#include <iostream>
#include<time.h>

using namespace std;

typedef struct child_list
{
   int number;
   child_list* next;
};
typedef struct main_list
{
   int number;
   main_list* next;
   child_list* position_child_list;
};
main_list* create_main_node(int number)
{
   main_list* new_element = (main_list*)malloc(sizeof(main_list));
   new_element->number = number;
   new_element->next = NULL;
   new_element->position_child_list = NULL;
   return new_element;
}
child_list* create_child_node(int number)
{
   child_list* new_element = (child_list*)malloc(sizeof(child_list));
   new_element->number = number;
   new_element->next = NULL;
   return new_element;
}
void insert_child_list(main_list* position_node, int number)
{
   child_list* last_node = position_node->position_child_list;
   if (last_node == NULL)
   {
      last_node = create_child_node(number);
      position_node->position_child_list = last_node;
   }
   else
   {
      while (last_node->next != NULL)
         last_node = last_node->next;
      last_node->next = create_child_node(number);
   }
}
void insert_main_list(main_list** head_main_list, int number)
{
   main_list* last_node = *head_main_list;
   if (last_node == NULL)
   {
      last_node = create_main_node(number);
      last_node->position_child_list = NULL;
      *head_main_list = last_node;
   }
   else
   {
      while (last_node->next != NULL)
         last_node = last_node->next;
      last_node->next = create_main_node(number);
   }
}
void generate_numbers(main_list** head_main_list)
{
   int number, duplicate = 0;
   main_list* position_node = NULL;
   for (int i = 0; i < 20; i++)
   {
      number = rand() % 11;
      if (*head_main_list == NULL)
         insert_main_list(&*head_main_list, number);
      else
      {
         main_list* traverse_node = *head_main_list;
         while (traverse_node != NULL)
         {
            if (traverse_node->number == number)
            {
               duplicate = 1;
               position_node = traverse_node;
            }
            traverse_node = traverse_node->next;
         }
         if (duplicate == 0)
            insert_main_list(&*head_main_list, number);
         else
            insert_child_list(position_node, number);
      }
      duplicate = 0;
   }
}
void print_list(main_list* head_main_list)
{
   main_list* traverse_node_main = head_main_list;
   child_list* traverse_node_child = NULL;
   int number = 0;
   while (traverse_node_main != NULL)
   {
      traverse_node_child = traverse_node_main->position_child_list;
      while (traverse_node_child != NULL)
      {
         if(traverse_node_main->number == traverse_node_child->number)
            number++;
         traverse_node_child = traverse_node_child->next;
      }
      printf("%d - %d duplikata\n", traverse_node_main->number, number);
      number = 0;
      traverse_node_main = traverse_node_main->next;
   }
}
void delete_list(main_list** head_main_list)
{
   main_list* traverse_main_node = *head_main_list;
   child_list* traverse_child_node = traverse_main_node->position_child_list;
   main_list* next_main_node;
   child_list* next_child_node;
   while (traverse_main_node != NULL)
   {
      while (traverse_child_node != NULL)
      {
         next_child_node = traverse_child_node->next;
         free(traverse_child_node);
         traverse_child_node = next_child_node;
      }
      next_main_node = traverse_main_node->next;
      free(traverse_main_node);
      traverse_main_node = next_main_node;
   }
   *head_main_list = NULL;
}
int main()
{
   srand(time(NULL));
   main_list* head_main_list = NULL;
   generate_numbers(&head_main_list);
   print_list(head_main_list);
   delete_list(&head_main_list);
   return 0;
}

 Podebljano

The postfix increment and decrement expressions have the form

1) expr ++ (postfix increment (post-increment))

2) expr --  (postfix decrement (post-decrement))

Tvoj primjer: n1--

float nije funkcija, float je tip podatka.

#include<stdio.h>

int main()
{
   float a = 0;
   float b = 0;
   float zbroj = 0;

   printf("unesi 2 broja: ");
   scanf(" %f\n%f", &a, &b);

   zbroj = a + b;

   printf("%f + %f = %f\n", a, b, zbroj);

   return 0;
}

 kad zbrojim 1.1 i 2.2 trebalo bi biti 3.3, a ne 3

 Nije mi dobro jer učitava 1.0000 i 2.000, iako je rez. točan

Imam dakle 3 slučaja:

1.) 1+1 = 2

2.) -1 + (-1) = -2

3.) 1.1 + 2.2= 3.3

 Ovo je probni zadatak na tvz-u, dakle trebalo bi biti nešta jako jednostavno no nije (bar za mene) znam int i float, al kako ih spojiti to ne znam.

1. Pitanje, kako da limitiram unos od samo 10 brojeva (uvijek samo 10 brojeva). Dakle broj1, broj2 i tak do broj10, ako ide preko toga gotov program

2. Potrebno je učitati dva broja sa standardnog ulaza (a i b), i ispisati kao rezultat njihov zbroj.  Ovo je zadatak

Ovak sam ga ja postavio

Imam problem, trebam upisati 10 brojeva koje onda pretvaram u slova, jel to sa for petljom primjerice (broj =1; broj <=10; i kako sad) 

jos sam stavio uvjet s if

if ( broj == 1)

slovo = s +broj

Define s samo stavio 64. Ne znam kako da napisem uvjet da mogu unijeti SAMO 10 brojeva i kakk onda ubaciti funkciju da te brojeve pretvara u slova

#include <stdio.h>

int main()
{
 int brojevi[10];

 for(byte i = 0; i < sizeof(brojevi); i++)
 {
  sscanf("%d", &brojevi[i]);
 }
}