wczytywanie danych do tablicy

0

Witam, mam problem, wczytuje dane do tablicy o max. poj. 100, liczba -1 oznacza koniec wprowadzania danych, dziala, jednak musze przerobic program, poniewaz powinien przyjmowac takie lancuchy jak np. 0 1 -1 0 -1 i dopiero ostatnia liczbe traktowac jako koniec wprowadzania danych. Moze ktos pomoc?

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


int read_vector(int* tab, int size, int stop_value)
{
    if(tab == NULL || size <= 0 ) return -1;
    int sizeD = 0;

    for(int i=0; i<size; ++i)
    {
        if(scanf("%d", &(*(tab+i))) == 1)
        {   
            if(*(tab+0) == stop_value)
        	{
            	return 0;
        	}
        	sizeD++;

        	if(*(tab+i) == stop_value)
        	{
        		
            	sizeD--;
        		break;
        	}
        }else return -1;     
    }
    return sizeD;
}

void display_vector(const int* tab, int size)
{
    int i;
    for(i=0; i<size; ++i)
    {
        printf("%d ", *(tab+i));
    }
}

wywolanie w mainie :

int main()
{
    int T[100];
    int *tab = T;
    int size = 0;

    printf("Podaj liczby:\n");
    size = read_vector(tab, 100, -1);
.......
0

lub odwrotnie if( *(tab+i-1)== -1 && *(tab+i)==NULL)

0
bezil napisał(a):

lub odwrotnie if( *(tab+i-1)== -1 && *(tab+i)==NULL)

nie dziala

0

Chodzi ci o drugie wystąpienie -1 czy też -1 coś innego -1? bo to 2 różne rzeczy są. Ew można zrobić tak że będzie wczytywać dopóki nie nastąpi "koniec pliku" w przypadku wpisywania z palca symulujesz go przez ctrl + z pod Windows ew ctrl + d pod Linuksem.

0
sig napisał(a):

Chodzi ci o drugie wystąpienie -1 czy też -1 coś innego -1? bo to 2 różne rzeczy są. Ew można zrobić tak że będzie wczytywać dopóki nie nastąpi "koniec pliku" w przypadku wpisywania z palca symulujesz go przez ctrl + z pod Windows ew ctrl + d pod Linuksem.

Po prostu zeby bralo wszystkie liczby oprocz ostatniej liczby stop_value ktora wynosi -1 czyli np.
Input -> 1 2 3 -1 0 5 -1
Output -> -1 0 1 2 3 5
sortowanie juz mam

0

nie mozesz tego zrobic po prostu pomijając ostatni element tablicy, ktorym bedzie -1?

3
int read_vector(int* tab, int size, int stop_value)
{
    if(tab == NULL || size <= 0 ) return -1;
    int sizeD = 0;

    while (sizeD < size)
    {
        int read = scanf("%d", tab + sizeD);
        if (read < 0) return -1;
        if (read != 1 || tab[sizeD] == stop_value) break;
        ++sizeD;
    }
    return sizeD;
}

i dopiero ostatnia liczbe traktowac jako koniec wprowadzania danych.

Może rozwiniesz na jakiej podstawie ostatnie -1 ma być ważniejsze od pierwszego -1? To jest sprzeczne z sensem stop_value.
Najwyraźniej masz inne kryterium końca wczytywania danych, którego nie potrafiłeś nam wyjaśnić.

Jeśli to jest zadanie z serwisu typu SPOJ main.edu.pl hackerrank itp, to lepiej podaj link do zadania.

0

dziekuje wszystkim, jestem nad morzem na wakacjach i jak znajde chwilke to zupdatuje posta co i jak.

0

Woda zimna, ale o to wlasnie chodzi ze da sie schlodzic :D, dzisiaj bede cisnal

0

Dziala, dzieki.
Pojawil sie nowy problem, chodzi o przepelnienie tablicy, jesli dam wiecej argumentow niz rozmiar tablicy, rozwalaja mi program bo przy pobieraniu kolejnych danych program wyswietla 3 liniki kodu, zamiast po kazdej czekac na wpisany argument. Probowalem fflush(stdin) po scanf ale nie dziala, wie ktos jak temu zaradzic?

int read_vector(int *array, int array_size, int stop_value)
{
    if(array == NULL || array_size <= 0 ) return -1;
    int sizeD = 0;

    while (sizeD < array_size)
    {
        int read = scanf("%d", &(*(array + sizeD)));
        if ((read <= 0) ) return -1;
        if (read != 1 || *(array+sizeD) == stop_value) break;
        ++sizeD;
    }
    return sizeD;
}
printf("Podaj wektor: \n");
    array_size = read_vector(array, 150, 0);

    fflush(stdin);
    if(array_size <= 0)
    {
        printf("Not enough data available");
        exit(3);
    }
    else
    {
        printf("Podaj przesuniecie: \n");
        read = scanf("%d", &positions_to_shift);

        if (read <= 0)
        {
            printf("Incorrect input");
            exit(1);
        }
        else
        {
            printf("Podaj kierunek przesuniecia: \n");
            int read2 = scanf("%d", &kierunek);
            fflush(stdin);
            if(read2 <= 0 || (kierunek != 1 && kierunek != 2))
            {
                printf("Incorrect data input");
                exit(2);
            }
        }
    }
Podaj wektor: ⏎
55 19 60 64 55 16 59 14 14 19 62 34 11 45 78 6 96 64 43 40 ( ... wiecej niz 150...) 0⏎
Podaj przesuniecie: 
Podaj kierunek przesuniecia: 
Incorrect data input 8⏎
0

pomocy

0
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include "vector_utils.h"


int main()
{
    int array_size = 0, positions_to_shift = 0, kierunek = 0, T[150];
    int *array = T;
    int read = 0;

    printf("Podaj wektor: \n");
    array_size = read_vector(array, 150, 0);

    fflush(stdin);
    fflush(stdout);

    if(array_size == 0)
    {
        printf("Not enough data available");
        exit(3);
    }
    if(array_size == -1)
    {
        printf("Incorrect input");
        exit(1);
    }
    else
    {
        printf("Podaj przesuniecie: \n");
        read = scanf("%d", &positions_to_shift);

        if (read <= 0)
        {
            printf("Incorrect input");
            exit(1);
        }
        else
        {
            fflush(stdin);
            fflush(stdout);

            printf("Podaj kierunek przesuniecia: \n");
            int read2 = scanf("%d", &kierunek);
            fflush(stdin);
            if(read2 <= 0 || (kierunek != 1 && kierunek != 2))
            {
                printf("Incorrect data input");
                exit(2);
            }
        }
    }


    if(kierunek == 1)
    {
        read = shift(array, array_size, positions_to_shift, ROTATE_RIGHT);
    }
    else if(kierunek == 2)
    {
        read = shift(array, array_size, positions_to_shift, ROTATE_LEFT);
    }

    if (array_size == 0)
    {
        printf("Not enough data available");
        exit(3);
    }

    display_vector(array, array_size);

    system("pause");
    return 0;
}


int shift(int *array, int array_size, int positions_to_shift, enum direction dir)
{
    if( array == NULL || array_size <= 0 || (dir != 1 && dir != 2)) return 1;

    int indeks = 0, arrays[array_size];
    int *pointer = arrays;

    if(dir == 1)
    {
        positions_to_shift = (positions_to_shift + array_size) % array_size;

        do
        {
            int poz = (indeks + positions_to_shift + array_size) % array_size;
            *(arrays + poz) = *(array + indeks);
            indeks++;

        }while (indeks < array_size);
    }

    else if(dir == 2)
    {
        positions_to_shift = (positions_to_shift + array_size) % array_size;

        do
        {
            int poz = (indeks - positions_to_shift + array_size) % array_size;
            *(arrays + poz) = *(array + indeks);
            indeks++;

        }while (indeks < array_size);
    }

    for (int i = 0; i < array_size; i++)
    {
        *(array + i) = *(pointer + i);
    }

    return 0;
}

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


int read_vector(int *array, int array_size, int stop_value)
{
    if(array == NULL || array_size <= 0 ) return -1;
    int sizeD = 0;
    int array2[150];
    int *array2wsk = array2;

    while (sizeD < array_size)
    {
        int read = scanf("%150d", &(*(array2wsk + sizeD)));

        if(sizeD >= 150) break;
        if((read <= 0) ) return -1;
        if(read != 1 || *(array2wsk+sizeD) == stop_value) break;

        *(array + sizeD) = *(array2wsk + sizeD);
        ++sizeD;
    }
    return sizeD;
}

void display_vector(const int* tab, int size)
{
    int i;
    for(i=0; i<size; i++)
    {
        printf("%d ", *(tab+i));
    }
}
#ifndef vector_utils_h
#define vector_utils_h

enum direction {ROTATE_RIGHT = 1, ROTATE_LEFT = 2};
int read_vector(int* tab, int size, int stop_value);
int shift(int *array, int array_size, int positions_to_shift, enum direction dir);
void display_vector(const int* tab, int size);


#endif

0

Dziala, jakos dalem rade, do zamkniecia

int read_vector(int *array, int array_size, int stop_value)
{
    if(array == NULL || array_size <= 0 ) return -1;
    int sizeD = 0;

    while (sizeD < array_size)
    {
        int temp;
        int read = scanf("%d", &temp);

        if((read <= 0) ) return -1;
        if(read != 1 || temp == stop_value) break;

        *(array + sizeD) = temp;
        if(sizeD <= 149) ++sizeD;
    }
    return sizeD;
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1