Using 3D arrays — can't make the output

Question

I have to make a program that read the input from the keyboard. It includes uppercase and lowercase letters, all signs and numbers and every one of these characters to be made from asterisks and to appear in one line. I am working only with two letters to see how is it working, but I get really confused.

My code doesn't work at all, I have no idea how to do it. Printing out the arrays seems very hard for me and also to be in one line. I need to use only while, for, return, break, continue, if, else, switch, case, default, and the very easy codes that are for beginners.

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

    char line[100]={'A','B'};
    int i;
    const int nGlyphs = 1;
    const int nRow = 7;
    const int nChar = 6;
    const char alphabet[nGlyphs][nRows][nChar]={ 
    alphabet[0]= {
    "  *  ",
    " * * ",
    "*   *",
    "*   *",
    "*****",
    "*   *",
    "*   *"
    },
    {
    "***  ",
    "*  * ",
    "*  * ",
    "* *  ",
    "*   *",
    "*   *",
    "**** "}
    };

   int main(int argc, char *argv[])
   {
   printf("Type a word or number, or both: ");
   scanf("%s",line[i]);
   for (i = 0; i < 100; i++);
   {
    for (nRows = 0; nRows < 7; nRows++);
    {

    printf("%s\n",alphabet[nGlyphs]);


     }
  }     

 return (0);
 }

You need to try a little harder. For example, the first error from the compiler says *"use of undeclared identifier 'nGlyphs'"*. You need to figure that out and fix it. Then move on to the next compiler error, until you find a compiler error that you can't fix on your own. — user3386109, Nov 03 '15 at 19:08
sorry about that, it was "nGlyphs", but started making changes and forgot to turn the original code — Trex00, Nov 03 '15 at 19:10
Ok, but the point was that you should post code that has 0 errors and 0 warnings. You've got a long way to go. — user3386109, Nov 03 '15 at 19:16
Yep, that's part of the learning process. Two techniques that are useful. 1) Only look at the **first** warning or error from the compiler. Fix it, and then run the compiler again. C compilers are notorious for going bonkers after the first error. 2) Compile early and often. For example, put a semicolon after `[nChar]` on line 9, and delete everything after that. Once you get that to compile, then add more. — user3386109, Nov 03 '15 at 19:48

Mykola · Accepted Answer · 2015-11-04T19:13:15.573

Here is your fixed code.

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

char line[100];

// C do not support 'const' keyword as array size specifier 
#define GLYPHS 2 // you use 2 glyphs instead 1
#define ROWS 7
#define CHARS 7 // extra char for whitespace

char alphabet[GLYPHS][ROWS][CHARS]={
    {
        "  *   ",
        " * *  ",
        "*   * ",
        "*   * ",
        "***** ",
        "*   * ",
        "*   * "
    },
    {
        "***   ",
        "*  *  ",
        "*  *  ",
        "* *   ",
        "*   * ",
        "*   * ",
        "****  "
    }
};

int main(int argc, char *argv[])
{
    int i = 0;
    int j = 0;

    printf("Type a word or number, or both: ");

    scanf("%s",line); // must be line instead line[0]

    for (i = 0; i < ROWS; i++) // ; must be removed otherwise loop has not body
    {
        for (j = 0; j < strlen(line); j++) // ; must be removed otherwise loop has not body
        {
                     // 'A' is the first array element
            printf("%s", alphabet[line[j] - 'A'][i]);
        }

        printf("\n");
    }
    return (0);
}

This code support only uppercase letters, but may be easly expanded to support other chars.

The example of implementation all printable chars by combination of bytes

#ifndef __FONT_H_INCL__
#define __FONT_H_INCL__

unsigned char font6_8[][6] =
{
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },   // sp
    { 0x00, 0x00, 0x00, 0x2f, 0x00, 0x00 },   // !
    { 0x00, 0x00, 0x07, 0x00, 0x07, 0x00 },   // "
    { 0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #
    { 0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $
    { 0x00, 0x62, 0x64, 0x08, 0x13, 0x23 },   // %
    { 0x00, 0x36, 0x49, 0x55, 0x22, 0x50 },   // &
    { 0x00, 0x00, 0x05, 0x03, 0x00, 0x00 },   // '
    { 0x00, 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (
    { 0x00, 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )
    { 0x00, 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *
    { 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +
    { 0x00, 0x00, 0x00, 0xA0, 0x60, 0x00 },   // ,
    { 0x00, 0x08, 0x08, 0x08, 0x08, 0x08 },   // -
    { 0x00, 0x00, 0x60, 0x60, 0x00, 0x00 },   // .
    { 0x00, 0x20, 0x10, 0x08, 0x04, 0x02 },   // /
    { 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0
    { 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1
    { 0x00, 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2
    { 0x00, 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3
    { 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4
    { 0x00, 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5
    { 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6
    { 0x00, 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7
    { 0x00, 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8
    { 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9
    { 0x00, 0x00, 0x36, 0x36, 0x00, 0x00 },   // :
    { 0x00, 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;
    { 0x00, 0x08, 0x14, 0x22, 0x41, 0x00 },   // <
    { 0x00, 0x14, 0x14, 0x14, 0x14, 0x14 },   // =
    { 0x00, 0x00, 0x41, 0x22, 0x14, 0x08 },   // >
    { 0x00, 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?
    { 0x00, 0x32, 0x49, 0x59, 0x51, 0x3E },   // @
    { 0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C },   // A
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C
    { 0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D
    { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F
    { 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G
    { 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H
    { 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I
    { 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J
    { 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K
    { 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L
    { 0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M
    { 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N
    { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O
    { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P
    { 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q
    { 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R
    { 0x00, 0x46, 0x49, 0x49, 0x49, 0x31 },   // S
    { 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T
    { 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U
    { 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V
    { 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W
    { 0x00, 0x63, 0x14, 0x08, 0x14, 0x63 },   // X
    { 0x00, 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y
    { 0x00, 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z
    { 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [
    { 0x00, 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // 55
    { 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]
    { 0x00, 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^
    { 0x00, 0x40, 0x40, 0x40, 0x40, 0x40 },   // _
    { 0x00, 0x00, 0x01, 0x02, 0x04, 0x00 },   // '
    { 0x00, 0x20, 0x54, 0x54, 0x54, 0x78 },   // a
    { 0x00, 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x20 },   // c
    { 0x00, 0x38, 0x44, 0x44, 0x48, 0x7F },   // d
    { 0x00, 0x38, 0x54, 0x54, 0x54, 0x18 },   // e
    { 0x00, 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f
    { 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C },   // g
    { 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h
    { 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i
    { 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00 },   // j
    { 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k
    { 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l
    { 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m
    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n
    { 0x00, 0x38, 0x44, 0x44, 0x44, 0x38 },   // o
    { 0x00, 0xFC, 0x24, 0x24, 0x24, 0x18 },   // p
    { 0x00, 0x18, 0x24, 0x24, 0x18, 0xFC },   // q
    { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r
    { 0x00, 0x48, 0x54, 0x54, 0x54, 0x20 },   // s
    { 0x00, 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t
    { 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u
    { 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v
    { 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w
    { 0x00, 0x44, 0x28, 0x10, 0x28, 0x44 },   // x
    { 0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C },   // y
    { 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44 },   // z
    { 0x00,0x00, 0x06, 0x09, 0x09, 0x06 }    // horiz lines
};

#endif /* __FONT_H_INCL__ */

in your case it must be similar exept representation the characters for example 'A'

    {
        "  *   ",
        " * *  ",
        "*   * ",
        "*   * ",
        "***** ",
        "*   * ",
        "*   * "
    },

instead of

{ 0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C },

base character is selected as ' ' (whitespace).

in our case array declaration must bee like

unsigned char font6_8[][7][7] = { /* array elems .... */ }

example of array declaration

unsigned char glyphs[][7][7] =
    {
        {
            "      ",
            "      ",
            "      ",
            "      ",
            "      ",
            "      ",
            "      "
        },   // sp
        {
            "  *   ",
            "  *   ",
            "  *   ",
            "  *   ",
            "      ",
            "  *   ",
            "  *   "
        },   // !
        // .... elems .....
        {
            "  *   ",
            " * *  ",
            "*   * ",
            "*   * ",
            "***** ",
            "*   * ",
            "*   * "
        },   // A
        { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B
        { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C
        { 0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D
        { 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E
        { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F
        { 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G
        { 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H
        { 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I
        { 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J
        { 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K
        { 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L
        { 0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M
        { 0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N
        { 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O
        { 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P
        { 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q
        { 0x00, 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R
        { 0x00, 0x46, 0x49, 0x49, 0x49, 0x31 },   // S
        { 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T
        { 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U
        { 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V
        { 0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W
        { 0x00, 0x63, 0x14, 0x08, 0x14, 0x63 },   // X
        { 0x00, 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y
        {
            "***** ",
            "   *  ",
            "  *   ",
            " *    ",
            "*     ",
            "*     ",
            "***** "
        },   // Z
        { 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [
        { 0x00, 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // 55
        { 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]
        { 0x00, 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^
        { 0x00, 0x40, 0x40, 0x40, 0x40, 0x40 },   // _
        { 0x00, 0x00, 0x01, 0x02, 0x04, 0x00 },   // '
        { 0x00, 0x20, 0x54, 0x54, 0x54, 0x78 },   // a
        { 0x00, 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b
        { 0x00, 0x38, 0x44, 0x44, 0x44, 0x20 },   // c
        { 0x00, 0x38, 0x44, 0x44, 0x48, 0x7F },   // d
        { 0x00, 0x38, 0x54, 0x54, 0x54, 0x18 },   // e
        { 0x00, 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f
        { 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C },   // g
        { 0x00, 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h
        { 0x00, 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i
        { 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00 },   // j
        { 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k
        { 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l
        { 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m
        { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n
        { 0x00, 0x38, 0x44, 0x44, 0x44, 0x38 },   // o
        { 0x00, 0xFC, 0x24, 0x24, 0x24, 0x18 },   // p
        { 0x00, 0x18, 0x24, 0x24, 0x18, 0xFC },   // q
        { 0x00, 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r
        { 0x00, 0x48, 0x54, 0x54, 0x54, 0x20 },   // s
        { 0x00, 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t
        { 0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u
        { 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v
        { 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w
        { 0x00, 0x44, 0x28, 0x10, 0x28, 0x44 },   // x
        { 0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C },   // y
        { 0x00, 0x44, 0x64, 0x54, 0x4C, 0x44 },   // z
        { 0x00,0x00, 0x06, 0x09, 0x09, 0x06 }    // horiz lines
    };

so you myst just replace { 0x00,0x00, 0x06, 0x09, 0x09, 0x06 } like values with your own glyphs.

Can someone help me in private, to ask some questions because I am a beginner and it is very hard to understad everything? — Trex00, Nov 04 '15 at 00:05
Can you give me contacts ot something just to ask you? I am in a very hard situation — Trex00, Nov 04 '15 at 00:10
You can ask me here. Just comment in this or other my post with @Mykola to send a message to me. — Mykola, Nov 04 '15 at 00:13
I want to write you in private, but don't know where to find it — Trex00, Nov 04 '15 at 00:19
@Mykola I can't understand this part " printf("%s", alphabet[line[j] - 'A'][i]);" and also when I compile the code it is said " incompatible implicit declaration of built-in function ‘strlen’ " should it be separated the function strlen. — Trex00, Nov 04 '15 at 00:27
error with strlen is very odd, are you sure that you pasted my code correctly? — Mykola, Nov 04 '15 at 00:30
@Trex00: This error occures when, the compiler can not find function declaration in our case `strlen`. it is declared in `string.h` header file — Mykola, Nov 04 '15 at 00:32
@Mykola It worked I pasted some text with the code. So it works, but this part with the printf I can't understand, because I need to adjust the program to work with lowercase letters, signs and numbers. Because I am new to programming and I can't understand some things, sorry for bodering you. — Trex00, Nov 04 '15 at 00:35
@Trex00: alphabet[line[j] - 'A'][i] just selects the proper string from array you created. As the alphabeth starts with A, the character number also starts with 'A' and ends up with 'Z', so as our created array is in aphabethical order alphabet[line[j] - 'A'][i] will defines our glyph posiition. — Mykola, Nov 04 '15 at 00:40
@Mykola So if I try to do it with the lowecase letters and signs I should do it the same way right. I will have another array for lowercase letters, for signs and numbers. — Trex00, Nov 04 '15 at 00:43
for example our string contain this info 'ABBAC', we can get any character number referencing to ASCII table http://cnautique-saintcast.com/tag-image-table-ascii__.html — Mykola, Nov 04 '15 at 00:44
Where did the other A came from "so if we substract {'A'} from 'A' i.m. 65 - 65 we get 0." I marked it with { } — Trex00, Nov 04 '15 at 00:51
we simply get the character from input string and substract from it our base character in our case 'A' — Mykola, Nov 04 '15 at 00:53
So I need to substract from 33 to appear "!", and then the rest — Trex00, Nov 04 '15 at 00:54
as I mentioned before for all printable chars base index is 32 — Mykola, Nov 04 '15 at 00:55
so you 3d array must starts with ' ' (32) character up to 127 — Mykola, Nov 04 '15 at 00:56
I actually have all the signs and numbers and letters made from asterisks, so if I implement them to the array will it work? — Trex00, Nov 04 '15 at 00:57
Yes, it is. You must define 95 separate array elements which represents printable chars by asperics and whitespaces — Mykola, Nov 04 '15 at 00:58
8 [1][7][7] and the next one will be 9[1][7][7], and the same with the signs — Trex00, Nov 04 '15 at 01:02
@Mykola sorry for the time I stole from you, and my stupid questions, my apologies — Trex00, Nov 04 '15 at 01:07
@Mykola, I can't do it this way, I am not allowed, I need to use simple codes and functions — Trex00, Nov 04 '15 at 01:11
@Mykola I can't use the codes you gave me for implementation, I have not studied, it is an assignment and it is my first month in university — Trex00, Nov 04 '15 at 01:15
I have update my answer to clear owerall situations with strange arrays. — Mykola, Nov 04 '15 at 12:50
To accept the answer simply click the accept icon under post rating. If you have reputation score of 15 you can also upvote posts. Accepting answer add +2 to reputation. — Mykola, Nov 04 '15 at 12:53
Upvoting is performed by simple click up arraw above post rating score. — Mykola, Nov 04 '15 at 13:27
@Trex00: Did you already figure out how to build this program. — Mykola, Nov 04 '15 at 18:51
@Mykola Could you show me how to write two letter in 3d array one next to other, because I need space in my code? — Trex00, Nov 04 '15 at 19:06
@Mykola And if I made all the letters in the 3d array one under other, how I am able to copy them to stadn next to each other, to have space. Because when I paste them the go very messy. — Trex00, Nov 04 '15 at 19:08
I think placing letters verticaly is the only way. Or you can place them in separate header file. — Mykola, Nov 04 '15 at 19:14
int arr[2][3][4] = { { {1, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} }, { {1, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} } }; — Trex00, Nov 04 '15 at 19:16
but it is posible but your code will looks like` { { " ", " ", " ", " ", " ", " ", " " } // sp }` — Mykola, Nov 04 '15 at 19:19
@Trex00: placing letters verticaly will be much more informative. — Mykola, Nov 04 '15 at 19:22
@Trex00: big plus is you can easly edit your character patterns — Mykola, Nov 04 '15 at 19:24
@Trex00: Place whitespace character pattern and draw character picture by *. — Mykola, Nov 04 '15 at 19:25
@Trex00: You can also evict your array out of `main.cpp` by create file `glyphs.h` and paste your array there. After simply place created `glyphs.h` near `main.cpp` and include your array to main by directive #include "glyphs.h". — Mykola, Nov 04 '15 at 19:32

Using 3D arrays — can't make the output

1 Answers1