Submit Assignment For Help

MIT 6.S096 Assignment 1, Problem 4

info@programmingassignments.com
Go To Code Directly

Problem 4: Transposition Cipher (loop)

A very simple transposition cipher encrypt(S ) can be described by the following rules:
1. If the length of S is 1 or 2, then encrypt(S ) is S .
2. If S is a string of N characters s1 s2 s3 . . . sN and k = IN /2j, then

enc(S ) = encrypt(sk sk−1 . . . s2 s1 ) + encrypt(sN sN −1 . . . sk+1 )

where + indicates string concatenation.

For example, encrypt("Ok") = "Ok" and encrypt("12345678") = "34127856".

Write a program to implement this cipher, given an arbitrary text file input up to 16 MB in size. Start
with the template program found at provided in the file loop.data.zip as a basis for your program.
In this program, you will see a mostly complete function to read a file into a dynamically allocated
string as required for this problem.
size t getstr( char **str, FILE *input ) {
size t chars to read = BLOCK SIZE;
size t length = 0;
II ...snipped... see template file
size t chars = 0;
while( ( chars = fread( *str + length, 1, chars to read, input ) ) ) {
II you fill this out
}
II ...snipped... see template file
return length;
}

Read through the code carefully, make sure you understand it, and complete the inner part of the while
loop. Look up realloc and the <string.h> header. If you have any questions about the provided code
or don’t know why something is structured the way it is, please ask about it on Piazza.

You will also see an empty function “encrypt”, which you should fill out.
void encrypt( char *string, size t length ) {
II you fill this out
}

Resource Limits
For this problem you are allotted 3 seconds of runtime and up to 32 MB of RAM.

Input Format
Lines 1. . . : The whole file (can be any number of lines) should be read in as a string.

https://www.programmingassignments.com/ 1

MIT 6.S096 Assignment 1, Problem 4

Sample Input (file loop.in)

Test
early
and often!

Output Format
Line 1: One integer: the total number of characters in the string
Lines 2. . . : The enciphered string.

21
aeyrleT
sttf!enn
aod

Output Explanation
Here’s each character in the string as we are supposed to read it in, separated with ‘.’ so we can see the
newlines and spaces:
.T.e.s.t.\n.e.a.r.l.y.\n.a.n.d. .o.f.t.e.n.!.

The string is first split in half and then each half reversed, and the function called recursively; you can
see the recursion going on here:
.y.l.r.a.e.\n.t.s.e.T. .!.n.e.t..f.o. .d.n.a.\n.
.e.a.r.l.y. .T.e.s.t.\n. .f.t.e.n.!. .\n.a.n.d. .o.
.a.e. .y.l.r .e.T. .\n.t.s. .t.f. .!.n.e .n.a.\n. .o. .d.
I \ I \ I \ \
.y. .r.l. .\n. .s.t. .!. .e.n. \
I \ I \
.n. .\n.a. .o. .d. .

This diagram makes it look a bit more complicated than it actually is. You can see that the sample is
correct by reading off the leaves of the tree from left to right–it’s the enciphered string we want.
.a.e.y.r.l.e.T.\n.s.t.t.f.!.e.n.n.\n.a.o.d. .

/*

PROG: matrix2

LANG: C

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef struct Matrix_s {

size_t R, C;

int *index;

} Matrix;

Matrix* allocate_matrix( size_t R, size_t C ) {

Matrix *matrix = malloc( sizeof( Matrix ) );

matrix->R = R;

matrix->C = C;

matrix->index = malloc( R * C * sizeof( int ) );

return matrix;

void destroy_matrix( Matrix *matrix ) {

free( matrix->index );

free( matrix );

3
}

typedef enum {

REGULAR = 0,

TRANSPOSE = 1

} Transpose;

// Allowing reading a matrix in as either regular or transposed

Matrix* read_matrix( FILE *input, Transpose orient ) {

size_t R, C;

fscanf( input, "%zu %zu", &R, &C );

Matrix *matrix = NULL;

if( orient == REGULAR ) {

matrix = allocate_matrix( R, C );

for( size_t r = 0; r < matrix->R; ++r ) {

for( size_t c = 0; c < matrix->C; ++c ) {

fscanf( input, "%d", &matrix->index[c + r * C] );

} else if( orient == TRANSPOSE ) {

matrix = allocate_matrix( C, R );

4
 for( size_t r = 0; r < matrix->C; ++r ) {

for( size_t c = 0; c < matrix->R; ++c ) {

fscanf( input, "%d", &matrix->index[r + c * R] );

} else {

fprintf( stderr, "Error: unknown orientation %d.\n", orient

);

exit( EXIT_FAILURE );

return matrix;

void print_matrix( FILE *output, Matrix *matrix ) {

fprintf( output, "%zu %zu\n", matrix->R, matrix->C );

for( size_t r = 0; r < matrix->R; ++r ) {

for( size_t c = 0; c < matrix->C - 1; ++c ) {

fprintf( output, "%d ", matrix->index[c + r * matrix->C]

);

fprintf( output, "%d\n", matrix->index[matrix->C - 1 + r *

matrix->C] );

5
Matrix* product_matrix( Matrix *a, Matrix *b ) {

if( a->C != b->C ) {

printf( "Error: tried to multiply (%zux%zu)x(%zux%zu)\n", a-

>R, a->C, b->C, b->R );

exit( EXIT_FAILURE );

Matrix *prod = allocate_matrix( a->R, b->R );

size_t nRows = prod->R, nCols = prod->C, nInner = a->C;

for( size_t r = 0; r < nRows; ++r ) {

for( size_t c = 0; c < nCols; ++c ) {

prod->index[c + r * nCols] = 0;

for( size_t i = 0; i < nInner; ++i ) {

prod->index[c + r * nCols] += a->index[i + r * nInner] *

b->index[i + c * nInner];

return prod;

int main(void) {
6
FILE *fin = fopen( "matrix2.in", "r" );

if( fin == NULL ) {

printf( "Error: could not open matrix2.in\n" );

exit( EXIT_FAILURE );

Matrix *a = read_matrix( fin, REGULAR );

Matrix *b = read_matrix( fin, TRANSPOSE );

fclose( fin );

Matrix *c = product_matrix( a, b );

FILE *output = fopen( "matrix2.out", "w" );

if( output == NULL ) {

printf( "Error: could not open matrix2.out\n" );

exit( EXIT_FAILURE );

print_matrix( output, c );

fclose( output );

7
 destroy_matrix( a );

destroy_matrix( b );

destroy_matrix( c );

return 0;

Below is the output using the test data:

matrix2:
1: OK [0.006 seconds]
2: OK [0.007 seconds]
3: OK [0.007 seconds]
4: OK [0.019 seconds]
5: OK [0.017 seconds]
6: OK [0.109 seconds]
7: OK [0.178 seconds]
8: OK [0.480 seconds]
9: OK [0.791 seconds]
10: OK [1.236 seconds]
11: OK [2.088 seconds]

10