Άσκηση σε c

[CSF]

Ευχαριστώ για τις απαντήσεις σας.Θα καθίσω να τις επεξεργαστώ και αν προκύψει κάτι καινούριο θα ξαναρωτήσω.

 

>#include<stdio.h>
#define N 16
main()
{
int i,sum,c,bin[N],l;
printf("dwse to duadiko arithmo\n");
for(i=0;i<N;i++)
{
	scanf("%d",&bin[i]);
}
i=N-1;
sum=0;
while(i>0)
{
	c=bin[i]*2*2+bin[i-1]*2+bin[i-2];
	i-=3;
	sum+=c;
}
printf("o oktadikos arithmos einai o : %d\n",sum);
sum2=0;
while(i>0)
{
	l=bin[i]*2*2*2+bin[i-1]*2*2+bin[i-2]*2+bin[i-3];
	i-=4;
	sum2+=l;
}
}

 

έφτιαξα και κάτι για το οκταδικό.Να σας θυμίσω οτι είμαι στα πολύ βασικά ακόμα.Φαίνεται άλλωστε και απο τις λύσεις μου!:)

 

Πίσω στο δεκαεξαδικό θέλω καμία ιδέα για το πως θα γραψω τον αριθμό σε δεκαεξαδική μορφή δλδ απο 0-9 και Α-F.

[migf1]

Αν αποφασίσεις να το υλοποιήσεις με c-strings, ο παρακάτω κώδικας διαβάζει μέχρι 16 δυαδικά ψηφία, κι αν είναι λιγότερα τα κάνει pad με leading zeros...

 

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

#define MAX_BINDIGITS	16+1

int main( void )
{
char bin[ MAX_BINDIGITS ] = {'\0'};		/* c-string to hold the binary digits */
int c, bindigit;			/* c is char, bindigit is boolean 	*/
size_t i=0, len;

/* keep asking until all digits are valid binary digits */
do {
	bindigit = 1;
	printf("binary: ");
	for (i=0; bindigit && i < MAX_BINDIGITS && (c=bin[i]=getchar()) != '\n'; i++)
		bindigit = (bin[i] == '0' || bin[i] == '1');

	/* flush stdin (if needed) */
	while ( c != '\n')
		c = getchar();

} while ( bin[0] == '\n' || !bindigit );

/* nil-terminate the bin c-string */
len = i == MAX_BINDIGITS ? --i : i;
bin[ len ] = '\0';

/* pad with leading zeros */
memmove( &bin[MAX_BINDIGITS-1-len], &bin[0], len+1 );
memset( bin, '0', MAX_BINDIGITS-len-1 );

printf( "%s\n", bin );

return 0;
}

 

Φαντάζει πολύπλοκος, ίσως και να είναι, γιατί κάνω τα πάντα manually (ακόμα και το flushing της stdin). Απορρίπτει όμως οποιοδήποτε invalid input (ή τουλάχιστον το ελπίζω).

 

Για να μετατρέψεις το τελικό binary c-string σε hex, το σπας σε 4άδες και στην κάθε μια αντιστοιχείς το 16αδικό 2ψήφιο c-string που της αντιστοιχεί, σύμφωνα με αυτόν τον πίνακα: http://en.wikipedia....em#Hexadecimal. Για octal, σπας το bin σε 3άδες και στην κάθε μια αντιστοιχείς το 8αδικό μονοψήφιο που της αντιστοιχείς.

 

Για τις αντιστοιχίες ή θα χρησιμοποιήσεις πίνακες αντιστοίχισης (arrays ή array maps) ή θα το κάνεις με if-else (ή με switch).

[migf1]

...

Πίσω στο δεκαεξαδικό θέλω καμία ιδέα για το πως θα γραψω τον αριθμό σε δεκαεξαδική μορφή δλδ απο 0-9 και Α-F.

Για αυτό βολεύουν τα c-strings σε αυτή την περίπτωση, γιατί έτσι κι αλλιώς οι 16αδικοί περιέχουν χαρακτήρες μέσα τους, οπότε η χρήση των c-strings εξυπηρετεί (όχι πως δεν γίνεται και με απλούς χαρακτήρες).

 

Λοιπόν, σου έφτιαξα ολόκληρο τον κώδικα που διαβάζει 16 2αδικά ψηφία και τα μετατρέπει σε 4 16αδικά. Η όλη ιστορία όπως σου έγραψα και χτες είναι να σπάσεις τα 16 2αδικά ψηφία σε 4άδες και για την κάθε μια τους να αντιστοιχήσεις το κατάλληλο 16αδικό ψηφίο, βάση του πίνακα.

 

Στον παρακάτω κώδικα, την κάθε 4άδα 2αδικών ψηφίων την αποθηκεύω σε έναν απλό πίνακα χαρακτήρων που τον ονομάζω: quart (από το quartet) καθώς διατρέχω τα 2αδικά ψηφία. Μέσα στο loop αυτό, μετατρέπω το quart σε δεκαδικό αριθμό (int) τον οποίον τον χρησιμοποιώ για να κάνω indexing τον πίνακα αντιστοίχισης των 16αδικών ψηφίων. Τον πίνακα αντιστοίχισης τον ονομάζω HEXTAB και τον υλοποιώ ως c-string literal με τη βοήθεια του preprocessor.

 

Οπότε, αν π.χ. η 4άδα 2αδικών quart είναι η: 1010 μετατρέπεται σε 10αδικό αριθμό, που είναι το 10. Χρησιμοποιώντας αυτό το 10 ως index του HEXTAB μας γυρίζει το A, διότι HEXTAB[10] == 'A'. Η μετατροπή από 2αδικά ψηφία σε 10αδικό αριθμό γίνεται με την κλασική πρόσθεση δυνάμεων του 2 για τα αναμμένα bits της 4άδας, ξεκινώντας από αριστερά προς τα δεξιά: bit*2^3 + bit*2^2 + bit*2^1 + bit*2^0 ( συνάρτηση: quart2dec() ).

 

>
#include <stdio.h>				/* for printf(), getchar()            	*/
#include <string.h>				/* for memmove(), memcpy()            	*/
#include <math.h>				/* for pow()                          	*/

#define HEXTAB		"0123456789ABCDEF"	/* hex digits table with decimal indexing */

/* function prototypes */
char	*prompt_bin16( char *prompt, char *bin16 );
char	*bin2hex( char *bin16, char *hex4 );
int	quart2dec( char *quart );

/* ---------------------------------------------------------------------
*
* ---------------------------------------------------------------------
*/
int main( void )
{
char bin16[ 16+1 ] 	= {'\0'};	/* c-string to hold 16 binary digits 	*/
char hex4[ 4+1 ]	= {'\0'};	/* c-string to hold 4 hexadecimal digits */

prompt_bin16( "Enter up to 16 binary digits: ", bin16 );
printf( "bin: %s\n", bin16 );
printf( "hex: %s\n", bin2hex( bin16, hex4) );

return 0;
}

/* ---------------------------------------------------------------------
*
* ---------------------------------------------------------------------
*/
char *prompt_bin16( char *prompt, char *bin16 )
{
int c, isbindigit;			/* c is char, isbindigit is boolean  	*/
size_t i=0, len;

if ( !bin16 )
	return NULL;

/* keep asking until all digits are valid binary digits */
do {
	isbindigit = 1;			/* true */
	printf("%s", !prompt ? "binary (up to 16 digits): " : prompt );
	for (i=0; isbindigit && i < (16+1) && (c=bin16[i]=getchar()) != '\n'; i++)
		isbindigit = (bin16[i] == '0' || bin16[i] == '1');

	/* flush stdin (if needed) */
	while ( c != '\n')
		c = getchar();

} while ( bin16[0] == '\n' || !isbindigit );

/* nil-terminate the binary c-string */
len = i == (16+1) ? --i : i;
bin16[ len ] = '\0';

/* pad with leading zeros */
memmove( &bin16[(16+1)-1-len], &bin16[0], len+1 );	/* put input to the right */
memset( bin16, '0', (16+1)-len-1 );			/* pad with leading zeros */

return bin16;
}

/* ---------------------------------------------------------------------
*
* ---------------------------------------------------------------------
*/
char *bin2hex( char *bin16, char *hex4 )
{
char quart[4] = {'0', '0', '0', '0'};		/* this is NOT a c-string      	*/
size_t i,j;					/* digit counters for bin16 & hex4 */

if ( !bin16 || !hex4 )				/* sanity checks   				*/
	return NULL;

memset( hex4, '\0', 4+1 );			/* make sure hex4 starts empty 	*/
for (i=0,j=0; *bin16 && i < 16; i += 4,j++)	/* for every 4 binary digits   	*/
{						/* ...             				*/
	memcpy( quart, &bin16[i], 4 );		/* ... make them a binary quartet  */
	hex4[j] = HEXTAB[ quart2dec(quart) ];	/* ... convert quartet to 1 hex dig*/
}						/* ... (using decimal indexed tab) */

return hex4;					/* the resulting hex c-string  	*/
}

/* ---------------------------------------------------------------------
*
* ---------------------------------------------------------------------
*/
int quart2dec( char *quart )		/* NOT a c-string, just a plain array of 4 chars */
{
int i, sum4 = 0;

if ( !quart )
	return 0;

for ( i=0; i < 4; i++ )
	sum4 += (quart[i] - '0') * pow(2, 3-i);

return sum4;
}

Για μετατροπή σε οκταδικό είναι παραπλήσια η διαδικασία, αλλά όχι ακριβώς. Πρέπει να σπάσεις τα 16 2αδικά ψηφία σε 3άδες (triples) αντί για 4άδες.

 

Στα 16 όμως ψηφία παίρνεις 5 3άδες και σου περισσεύει το most-significant bit. Υποθέτοντας πως δεν σας έχει πει να διαχειρίζεστε το most significant bit ως πρόσημο, έχεις 2 εναλλακτικές αντιμετώπισης: ή θα το αγνοήσεις τελείως το most significant bit, ή θα το χρησιμοποιήσεις ως μονάδα που θα την προσθέσεις στην αρχή της οκταδικής απεικόνισης.