Moze pitanje prvo prije nego postam zadatak za koji mi treba pomoć? 

Kako postati kod u tom nekakvom plavom okviru  pa da mi kod ostane pregledan, jer ako copy paste-am nema tabova ?

#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;
}

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

int main(){
    int x,sum = 0,t, remainder;
    scanf("%d",&x);
    while(x <= 0){          // PS. probaj unijet string od nekoliko znakova xD
        printf("Nepravilan unos!\n");
        scanf("%d",&x);
    }
    t = x;
    while(t != 0){
        remainder = t % 10;
        sum += remainder;
        t /= 10;
    }
    int prost = 0;
    for(int i=2;i<sum;i++){
        if (sum % i == 0){
            prost++;
        }
    }
    if (prost == 0){
        for(int i=2;i<sum;i++){
            int provjera = 0;
            for(int j=1;j<i;j++){
                if(i%j==0){
                    provjera++;
                }
            }
            if(provjera == 1){
                printf("%d ",i);
            }
        }
        return 0;
    }
    int y;
    scanf("%d", &y);
    while(y < 11 || y > 15){
        scanf("%d", &y);
    }
    for (int i=1;i<=x;i++){
        if (i%2 != 0){
            if(i % y ==0){
                printf("%d ", i);
            }
        }
    }
    return 0;
}

Evo ga, i mene je malo zbunilo haha, napisao sam ti komentar, ovaj ponovni unos sa while petljom mi je malo glup ali što je tu je , sretno ;)

EDIT: Pokušaj rastaviti kod na više funkcija, npr. ova za zbroj znamenaka i ova za provjeru je li prost (boolean, True ako je prost, False ako nije)

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?

Dobro objašnjeno, i baš mi smeta što danas, djecu u školi ne uče da kod razbiju na funkcije , ponekad klase i objekte, jer ih mogu kasnije xy puta koristiti, ja eto nisam to napravio jer iskostvo kaze ne treba  ( lazem, lijen sam )

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;
}

Kao element struct main liste staviti i pokazivač na prvi element child liste.

Ovisno o tome ponavlja li se element ili ne taj element staviti u main ili child listu.

Kod ispisa main liste za svaki njezin element provjeriti koliko ima takvih elemenata u child listi.

 #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* head_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;
   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* head_main_list, int number)
{
   child_list* last_node = head_main_list->head_child_list;
   if (last_node == NULL)
   {
      last_node = create_child_node(number);
      head_main_list->head_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->head_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;
   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;
            traverse_node = traverse_node->next;
         }
         if (duplicate == 0)
            insert_main_list(&*head_main_list, number);
         else
            insert_child_list(*head_main_list, number);
      }
      duplicate = 0;
   }
}
void print_list(main_list* head_main_list)
{
   main_list* traverse_node_main = head_main_list;
   child_list* traverse_node_child = head_main_list->head_child_list;
   int number = 0;
   while (traverse_node_main != NULL)
   {
      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_child = head_main_list->head_child_list;
      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->head_child_list;
   main_list* next_main_node;
   child_list* next_child_node;
   while (traverse_child_node != NULL)
   {
      next_child_node = traverse_child_node->next;
      free(traverse_child_node);
      traverse_child_node = next_child_node;
   }
   (*head_main_list)->head_child_list = NULL;
   while (traverse_main_node != NULL)
   {
      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);
}

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;
}

#include <stdio.h>
int main()
{
    int n1, n2;
    n1 = 1;
    n2 = 1;
    printf ("Na prvu n1 je %d, na drugu n2 je %d",n1,n2);

    n2=n1++;
    printf ("After n2=n1++, n1 je %d, n2 je %d\n", n1, n2);

    n2=n1-;
    printf ("After n2=n1-, n1 je %d, n2 je %d\n", n1, n2);

    return 0;

}

Zasto mi ovo ne zeli ucitati, problem je kod printf kolko sam shvatio

 Podebljano

 Kako da smanjim to onda?

The postfix increment and decrement expressions have the form

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

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

Tvoj primjer: n1--

Evo mene opet, dakle moram zbrojiti 1+1, -1+(-1) i 1.1 + 2.2. Sad ne znam kako da funkciju float ubacim u ovo sve?

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

int main()
{
    int a,b, zbroj;

    printf("Ucitaj dva broja:");
    scanf("%d %d", &a,&b);

    zbroj = a + b;

    printf("Njihov rezultat je: %d\n", zbroj);
    return 0;
}

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;
}

Problem je kad 1+1 zbrojim trebalo bi ispasti 2, a ne npr 2.0000 itd.

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

@Equi

Dobar stari C...dragi prijatelj...

Ključ rješenja je u ispisu: "%.1f".

Primjer testiranja:

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

int main()
{

float a, b, zbroj;

printf("Ucitaj dva broja:");
scanf_s("%f %f", &a, &b);

zbroj = a + b;

printf("Njihov rezultat je: %.1f\n", zbroj);

system("pause");

return 0;
}

 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

Ovakvo što nažalost nije baš trivijalan problem, potreban je ipak ponešto moćniji alat of scanf-a. To ili neki custom hakeraj koji će raditi samo za aritmetičke izraze...

Uglavnom, rekao bih da je potrebno nekako parsirati i evaluirati izraz. Ne znam, možda je scanf familija funkcija sposobna nekim načinom probaviti primjere koje si opisao no nisam baš siguran.

 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.

@Equi

ajde ti napiši točno kako glasi zadatak. stvarno ne kužim u čemu je problem jer i moj i kod od kolege Pzkftw rade skroz dobro...

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

@Equi

Što se tiče ovog što posljednje pitaš.

2. To smo već riješili.

1. Preko petlje koje vrtiš deset puta uzastopce.

Ovo što pišeš za učitavanje brojeva. To ne kužim što je krivo ili što bi ti htio.

Iako to ne znam na svoju žalost, volimo bi da me netko nauči.

Ovak sam ga ja postavio

Mutne su. Ugl ovako ti ide unos 10 brojeva

Pokušaj ovako. Iako bi trebalo i na onaj način radit kako treba...

 zašto castaš float sa float?

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

To mi je jedino palo na pamet. Bez toga (float) kod bi trebao raditi kako treba. Jedino može probati s double.

#include <stdio.h>

int main()
{
 int brojevi[10];

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