Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Dev - C++ » hice un problema,compilo y ahora me piden el mismo, pero con funciones, no me sale ayuda

Dev - C++ - hice un problema,compilo y ahora me piden el mismo, pero con funciones, no me sale ayuda

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil

hice un problema,compilo y ahora me piden el mismo, pero con funciones, no me sale ayuda

Publicado por Deeby (4 intervenciones) el 15/11/2016 04:21:28
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <conio.h>
int main ()
{
int i,p,j;
char matrizA[3][3]={
							' ',' ','|',
							' ',' ','|',
							'_','_','|'};
char matrizB[3][3]={
							'|',' ','|',
							'|',' ','|',
							'|','_','|'};
char matrizC[3][3]={
							'|',' ',' ',
							'|',' ',' ',
							'|','_','_'};
char matrizD[3][3]={
							'-','-','-',
							' ',' ','|',
							'_','_','_'};
char matrizE[3][3]={
							'|','-','|',
							'|',' ','|',
							'|','_','|'};
char matrizF[3][3]={
							'-','-','-',
							'|',' ',' ',
							'_','_','_'};
char matrizG[3][3]={
							'-','-','|',
							' ',' ','|',
							' ',' ','|'};
char matrizH[3][3]={
							'|','-','|',
							'|',' ','|',
							'|',' ','|'};
char matrizI[3][3]={
							'|','-','-',
							'|',' ',' ',
							'|',' ',' '};
char matrizJ[3][3]={
							' ',' ','|',
							' ','.','|',
							'_','_','|'};
char matrizK[3][3]={
							'|',' ','|',
							'|','.','|',
							'|','_','|'};
char matrizL[3][3]={
							'|',' ',' ',
							'|','.',' ',
							'|','_','_'};
char matrizM[3][3]={
							'-','-','-',
							' ','.','|',
							'_','_','_'};
char matrizN[3][3]={
							'|','_','|',
							'|','.','|',
							'|','_','|'};
char matrizO[3][3]={
							'-','-','-',
							'|','.',' ',
							'_','_','_'};
char matrizP[3][3]={
							'-','-','|',
							' ','.','|',
							' ',' ','|'};
char matrizQ[3][3]={
							'|','-','|',
							'|','.','|',
							'|',' ','|'};
char matrizR[3][3]={
							'|','-','-',
							'|','.',' ',
							'|',' ',' '};
char matrizS[3][3]={
							' ',' ',' ',
							'\\',' ','/',
							' ','V',' '};
char matrizT[3][3]={
							' ','\\',' ',
							' ',' ','>',
							' ','/',' '};
char matrizU[3][3]={
							' ','/',' ',
							'<',' ',' ',
							' ','\\',' '};
char matrizV[3][3]={
							' ','^',' ',
							'/',' ','\\',
							' ',' ',' '};
char matrizW[3][3]={
							' ',' ',' ',
							'\\','.','/',
							' ','V',' '};
char matrizX[3][3]={
							' ','\\',' ',
							' ','.','>',
							' ','/',' '};
char matrizY[3][3]={
							' ','/',' ',
							'<','.',' ',
							' ','\\',' '};
char matrizZ[3][3]={
							' ','^',' ',
							'/','.','\\',
							' ',' ',' '};
char cadena [1024];
printf ("Introduzca texto a cifrar: ");
fgets (cadena, 1024, stdin);
cadena[strlen(cadena)-1]='\0';
for(p=0;p<strlen(cadena);p++){
 
if( isalpha(cadena[p]) ){
printf("\n");
printf("\n");
switch(cadena[p]){
case 'A':
case 'a':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizA[i][j]);}
             printf("\n");}break;
case 'B':
case 'b':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizB[i][j]);}
             printf("\n");}break;
case 'C':
case 'c':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizC[i][j]);}
             printf("\n");}break;
case 'D':
case 'd':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizD[i][j]);}
             printf("\n");}break;
case 'E':
case 'e':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizE[i][j]);}
             printf("\n");}break;
case 'F':
case 'f':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizF[i][j]);}
             printf("\n");}break;
case 'G':
case 'g':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizG[i][j]);}
             printf("\n");}break;
case 'H':
case 'h':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizH[i][j]);}
             printf("\n");}break;
case 'I':
case 'i':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizI[i][j]);}
             printf("\n");}break;
case 'J':
case 'j':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizJ[i][j]);}
             printf("\n");}break;
case 'K':
case 'k':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizK[i][j]);}
             printf("\n");}break;
case 'L':
case 'l':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizL[i][j]);}
             printf("\n");}break;
case 'M':
case 'm':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizM[i][j]);}
             printf("\n");}break;
case 'N' :
case 'n' :
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizN[i][j]);}
             printf("\n");}break;
case 'O':
case 'o':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizO[i][j]);}
             printf("\n");}break;
case 'P':
case 'p':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizP[i][j]);}
             printf("\n");}break;
case 'Q':
case 'q':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizQ[i][j]);}
             printf("\n");}break;
case 'R':
case 'r':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizR[i][j]);}
             printf("\n");}break;
case 'S':
case 's':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizS[i][j]);}
             printf("\n");}break;
case 'T':
case 't':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizT[i][j]);}
             printf("\n");}break;
case 'U':
case 'u':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizU[i][j]);}
             printf("\n");}break;
case 'V':
case 'v':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizV[i][j]);}
             printf("\n");}break;
case 'W':
case 'w':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizW[i][j]);}
             printf("\n");}break;
case 'X':
case 'x':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizX[i][j]);}
             printf("\n");}break;
case 'Y':
case 'y':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizY[i][j]);}
             printf("\n");}break;
case 'Z':
case 'z':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizZ[i][j]);}
             printf("\n");}break;}
         }
     }
//}else {

for(p=0;p<strlen(cadena);p++)
{
      if( isdigit(cadena[p]) ){
          printf( "\n %c :Este numero no es cifrable \n", cadena[p] );
}else{
      if (ispunct(cadena[p])){
      printf( "\n %c :Este caracter no es cifrable \n", cadena[p] );}
	  }
	  }
 
getch();
}

este es el codigo que funciona pero esta sin funciones.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <conio.h>
int p;
char matrizA[3][3];
char matrizB[3][3];
char matrizC[3][3];
char matrizD[3][3];
char matrizE[3][3];
char matrizF[3][3];
char matrizG[3][3];
char matrizH[3][3];
char matrizI[3][3];
char matrizJ[3][3];
char matrizK[3][3];
char matrizL[3][3];
char matrizM[3][3];
char matrizN[3][3];
char matrizO[3][3];
char matrizP[3][3];
char matrizQ[3][3];
char matrizR[3][3];
char matrizS[3][3];
char matrizT[3][3];
char matrizU[3][3];
char matrizV[3][3];
char matrizW[3][3];
char matrizX[3][3];
char matrizY[3][3];
char matrizZ[3][3];
void Declaraciones();
void valiacion();
void letras();
 
 
void main ()
{
     void Declaraciones();
     void valiacion(char cadena[p]);
     void letras(char cadena[p],int i,int j);
     getch();
     }
 
void Declaraciones()
{
matrizA={
' ',' ','|',
' ',' ','|',
'_','_','|'};
matrizB={
'|',' ','|',
'|',' ','|',
'|','_','|'};
matrizC={
'|',' ',' ',
'|',' ',' ',
'|','_','_'};
matrizD={
'-','-','-',
' ',' ','|',
'_','_','_'};
matrizE={
'|','-','|',
'|',' ','|',
'|','_','|'};
matrizF={
'-','-','-',
'|',' ',' ',
'_','_','_'};
matrizG={
'-','-','|',
' ',' ','|',
' ',' ','|'};
matrizH={
'|','-','|',
'|',' ','|',
'|',' ','|'};
matrizI={
'|','-','-',
'|',' ',' ',
'|',' ',' '};
matrizJ={
' ',' ','|',
' ','.','|',
'_','_','|'};
matrizK={
'|',' ','|',
'|','.','|',
'|','_','|'};
matrizL={
'|',' ',' ',
'|','.',' ',
'|','_','_'};
matrizM={
'-','-','-',
' ','.','|',
'_','_','_'};
matrizN={
'|','_','|',
'|','.','|',
'|','_','|'};
matrizO={
'-','-','-',
'|','.',' ',
'_','_','_'};
matrizP={
'-','-','|',
' ','.','|',
' ',' ','|'};
matrizQ={
'|','-','|',
'|','.','|',
'|',' ','|'};
matrizR={
'|','-','-',
'|','.',' ',
'|',' ',' '};
matrizS={
' ',' ',' ',
'\\',' ','/',
' ','V',' '};
matrizT={
' ','\\',' ',
' ',' ','>',
' ','/',' '};
matrizU={
' ','/',' ',
'<',' ',' ',
' ','\\',' '};
matrizV={
' ','^',' ',
'/',' ','\\',
' ',' ',' '};
matrizW={
' ',' ',' ',
'\\','.','/',
' ','V',' '};
matrizX={
' ','\\',' ',
' ','.','>',
' ','/',' '};
matrizY={
' ','/',' ',
'<','.',' ',
' ','\\',' '};
matrizZ={
' ','^',' ',
'/','.','\\',
' ',' ',' '};
     } // declaracion de matrices (dibujo) para cada letra

 
void cifrador_letras(char cadena[p],int j,int i)
{
printf ("Introduzca texto a cifrar: ");
fgets (cadena, 1024, stdin);
cadena[strlen(cadena)-1]='\0';
for(p=0;p<strlen(cadena);p++){
 
if( isalpha(cadena[p]) ){
printf("\n");
printf("\n");
switch(cadena[p]){
case 'A':
case 'a':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizA[i][j]);}
             printf("\n");}break;
case 'B':
case 'b':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizB[i][j]);}
             printf("\n");}break;
case 'C':
case 'c':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizC[i][j]);}
             printf("\n");}break;
case 'D':
case 'd':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizD[i][j]);}
             printf("\n");}break;
case 'E':
case 'e':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizE[i][j]);}
             printf("\n");}break;
case 'F':
case 'f':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizF[i][j]);}
             printf("\n");}break;
case 'G':
case 'g':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizG[i][j]);}
             printf("\n");}break;
case 'H':
case 'h':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizH[i][j]);}
             printf("\n");}break;
case 'I':
case 'i':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizI[i][j]);}
             printf("\n");}break;
case 'J':
case 'j':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizJ[i][j]);}
             printf("\n");}break;
case 'K':
case 'k':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizK[i][j]);}
             printf("\n");}break;
case 'L':
case 'l':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizL[i][j]);}
             printf("\n");}break;
case 'M':
case 'm':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizM[i][j]);}
             printf("\n");}break;
case 'N' :
case 'n' :
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizN[i][j]);}
             printf("\n");}break;
case 'O':
case 'o':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizO[i][j]);}
             printf("\n");}break;
case 'P':
case 'p':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizP[i][j]);}
             printf("\n");}break;
case 'Q':
case 'q':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizQ[i][j]);}
             printf("\n");}break;
case 'R':
case 'r':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizR[i][j]);}
             printf("\n");}break;
case 'S':
case 's':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizS[i][j]);}
             printf("\n");}break;
case 'T':
case 't':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizT[i][j]);}
             printf("\n");}break;
case 'U':
case 'u':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizU[i][j]);}
             printf("\n");}break;
case 'V':
case 'v':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizV[i][j]);}
             printf("\n");}break;
case 'W':
case 'w':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizW[i][j]);}
             printf("\n");}break;
case 'X':
case 'x':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizX[i][j]);}
             printf("\n");}break;
case 'Y':
case 'y':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizY[i][j]);}
             printf("\n");}break;
case 'Z':
case 'z':
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matrizZ[i][j]);}
             printf("\n");}break;
			 } //switch

         } //if

     }//for

}//void

 
void restricciones(char cadena[p])
{
for(p=0;p<strlen(cadena);p++)
{
      if( isdigit(cadena[p]) ){
          printf( "\n %c :Este numero no es cifrable \n", cadena[p] );
}else{
      if (ispunct(cadena[p])){
      printf( "\n %c :Este caracter no es cifrable \n", cadena[p] );}
	  }//else

	  }//for

 
}//void

este es el codigo que intente hacer con funciones, pero no funciona.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
sin imagen de perfil
Val: 417
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

hice un problema,compilo y ahora me piden el mismo, pero con funciones, no me sale ayuda

Publicado por Thanatos (199 intervenciones) el 15/11/2016 11:32:49
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
#include <stdio.h>    // printf(), fgets()

#include <ctype.h>    // tolower(), isalpha(), isdigit(), ispunct()

#include <string.h>   // strcspn()

#include <stdbool.h>  // bool

 
#define CAD_SIZE 1024
#define VEC_SIZE 9
 
void cifrar(char);
void mostrarVector(const char[]);
bool verificarCaracter(char, size_t);
 
int main(void)
{
    char cadena[CAD_SIZE] = { '\0' };
 
    printf("Introduzca el texto a cifrar: ");
    (void)fgets(cadena, CAD_SIZE, stdin);
    cadena[strcspn(cadena, "\r\n")] = '\0';
 
    for (size_t i = 0; i < strlen(cadena); ++i)
    {
        printf("\n\n");
        if (verificarCaracter(cadena[i], i))
        {
            cifrar(cadena[i]);
        }
    }
 
    (void)getchar();
    return 0;
}
 
void cifrar(char caracter)
{
    const char A[VEC_SIZE] = { ' ', ' ', '|', ' ', ' ', '|', '_', '_', '|' };
    const char B[VEC_SIZE] = { '|', ' ', '|', '|', ' ', '|', '|', '_', '|' };
    const char C[VEC_SIZE] = { '|', ' ', ' ', '|', ' ', ' ', '|', '_', '_' };
    const char D[VEC_SIZE] = { '-', '-', '-', ' ', ' ', '|', '_', '_', '_' };
    const char E[VEC_SIZE] = { '|', '-', '|', '|', ' ', '|', '|', '_', '|' };
    const char F[VEC_SIZE] = { '-', '-', '-', '|', ' ', ' ', '_', '_', '_' };
    const char G[VEC_SIZE] = { '-', '-', '|', ' ', ' ', '|', ' ', ' ', '|' };
    const char H[VEC_SIZE] = { '|', '-', '|', '|', ' ', '|', '|', ' ', '|' };
    const char I[VEC_SIZE] = { '|', '-', '-', '|', ' ', ' ', '|', ' ', ' ' };
    const char J[VEC_SIZE] = { ' ', ' ', '|', ' ', '.', '|', '_', '_', '|' };
    const char K[VEC_SIZE] = { '|', ' ', '|', '|', '.', '|', '|', '_', '|' };
    const char L[VEC_SIZE] = { '|', ' ', ' ', '|', '.', ' ', '|', '_', '_' };
    const char M[VEC_SIZE] = { '-', '-', '-', ' ', '.', '|', '_', '_', '_' };
    const char N[VEC_SIZE] = { '|', '_', '|', '|', '.', '|', '|', '_', '|' };
    const char O[VEC_SIZE] = { '-', '-', '-', '|', '.', ' ', '_', '_', '_' };
    const char P[VEC_SIZE] = { '-', '-', '|', ' ', '.', '|', ' ', ' ', '|' };
    const char Q[VEC_SIZE] = { '|', '-', '|', '|', '.', '|', '|', ' ', '|' };
    const char R[VEC_SIZE] = { '|', '-', '-', '|', '.', ' ', '|', ' ', ' ' };
    const char S[VEC_SIZE] = { ' ', ' ', ' ', '\\', ' ', '/', ' ', 'V', ' '};
    const char T[VEC_SIZE] = { ' ', '\\', ' ', ' ', ' ', '>', ' ', '/', ' '};
    const char U[VEC_SIZE] = { ' ', '/', ' ', '<', ' ', ' ', ' ', '\\', ' '};
    const char V[VEC_SIZE] = { ' ', '^', ' ', '/', ' ', '\\', ' ', ' ', ' '};
    const char W[VEC_SIZE] = { ' ', ' ', ' ', '\\', '.', '/', ' ', 'V', ' '};
    const char X[VEC_SIZE] = { ' ', '\\', ' ', ' ', '.', '>', ' ', '/', ' '};
    const char Y[VEC_SIZE] = { ' ', '/', ' ', '<', '.', ' ', ' ', '\\', ' '};
    const char Z[VEC_SIZE] = { ' ', '^', ' ', '/', '.', '\\', ' ', ' ', ' '};
 
    caracter = (char)tolower(caracter);
    switch(caracter)
    {
        case 'a':
            mostrarVector(A);
            break;
        case 'b':
            mostrarVector(B);
            break;
        case 'c':
            mostrarVector(C);
            break;
        case 'd':
            mostrarVector(D);
            break;
        case 'e':
            mostrarVector(E);
            break;
        case 'f':
            mostrarVector(F);
            break;
        case 'g':
            mostrarVector(G);
            break;
        case 'h':
            mostrarVector(H);
            break;
        case 'i':
            mostrarVector(I);
            break;
        case 'j':
            mostrarVector(J);
            break;
        case 'k':
            mostrarVector(K);
            break;
        case 'l':
            mostrarVector(L);
            break;
        case 'm':
            mostrarVector(M);
            break;
        case 'n':
            mostrarVector(N);
            break;
        case 'o':
            mostrarVector(O);
            break;
        case 'p':
            mostrarVector(P);
            break;
        case 'q':
            mostrarVector(Q);
            break;
        case 'r':
            mostrarVector(R);
            break;
        case 's':
            mostrarVector(S);
            break;
        case 't':
            mostrarVector(T);
            break;
        case 'u':
            mostrarVector(U);
            break;
        case 'v':
            mostrarVector(V);
            break;
        case 'w':
            mostrarVector(W);
            break;
        case 'x':
            mostrarVector(X);
            break;
        case 'y':
            mostrarVector(Y);
            break;
        case 'z':
            mostrarVector(Z);
            break;
        default:
            break;
    }
}
 
void mostrarVector(const char vector[])
{
    for (size_t i = 0; i < VEC_SIZE; ++i)
    {
        printf(" %c ", vector[i]);
        if ((i + 1) % 3 == 0)
        {
            printf("\n");
        }
    }
}
 
bool verificarCaracter(char caracter, size_t posicion)
{
    if (isdigit(caracter))
    {
        printf("[posicion %u] - numero no cifrable:   %c\n", posicion + 1, caracter);
        return false;
    }
    else if (ispunct(caracter))
    {
        printf("[posicion %u] - caracter no cifrable: %c\n", posicion + 1, caracter);
        return false;
    }
    return true;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 661
Bronce
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

hice un problema,compilo y ahora me piden el mismo, pero con funciones, no me sale ayuda

Publicado por agustin (522 intervenciones) el 15/11/2016 18:59:11
Uff todos esos arrais convierten el código en algo enorme a la hora de mirarlo. Mira a ver si te sirve asi:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <stdio.h>
#include <string.h>
//#include <ctype.h>

#include <conio.h>
#define SIZEMAX 1024
 
void imprimir_caracter_alfa (char caracter)
{
    char matriz[26][3][3]={{{' ',' ','|'}, {' ',' ','|'}, {'_','_','|'}}, //A

		           {{'|',' ','|'}, {'|',' ','|'}, {'|','_','|'}}, //B

	 		   {{'|',' ',' '}, {'|',' ',' '}, {'|','_','_'}}, //C

                           {{'-','-','-'}, {' ',' ','|'}, {'_','_','_'}}, //D

                           {{'|','-','|'}, {'|',' ','|'}, {'|','_','|'}}, //E

                           {{'-','-','-'}, {'|',' ',' '}, {'_','_','_'}}, //F

                           {{'-','-','|'}, {' ',' ','|'}, {' ',' ','|'}}, //G

                           {{'|','-','|'}, {'|',' ','|'}, {'|',' ','|'}}, //H

                           {{'|','-','-'}, {'|',' ',' '}, {'|',' ',' '}}, //I

                           {{' ',' ','|'}, {' ','.','|'}, {'_','_','|'}}, //J

                           {{'|',' ','|'}, {'|','.','|'}, {'|','_','|'}}, //K

                           {{'|',' ',' '}, {'|','.',' '}, {'|','_','_'}}, //L

                           {{'-','-','-'}, {' ','.','|'}, {'_','_','_'}}, // M

                           {{'|','_','|'}, {'|','.','|'}, {'|','_','|'}}, //N

			   {{'-','-','-'}, {'|','.',' '}, {'_','_','_'}}, //O

                           {{'-','-','|'}, {' ','.','|'}, {' ',' ','|'}}, //P

                           {{'|','-','|'}, {'|','.','|'}, {'|',' ','|'}}, // Q

                           {{'|','-','-'}, {'|','.',' '}, {'|',' ',' '}}, //R

                           {{' ',' ',' '}, {'\\',' ','/'}, {' ','V',' '}}, //S

                           {{' ','\\',' '}, {' ',' ','>'}, {' ','/',' '}}, //T

                           {{' ','/',' '}, {'<',' ',' '}, {' ','\\',' '}}, //U

                           {{' ','^',' '}, {'/',' ','\\'}, {' ',' ',' '}}, //V

                           {{' ',' ',' '}, {'\\','.','/'}, {' ','V',' '}},//W

		           {{' ','\\',' '}, {' ','.','>'}, {' ','/',' '}}, //X

                           {{' ','/',' '}, {'<','.',' '}, {' ','\\',' '}}, //Y

                           {{' ','^',' '}, {'/','.','\\'}, {' ',' ',' '}} //Z  

                                        };
     int i,j;
 
     for (i=0;i<3;i++)
     {
         for (j=0;j<3;j++)
         {
             printf(" %c ",matriz[toupper (caracter) - 'A'][i][j]);
             printf("\n");
         }
     }
}
 
int obtener_cadena(char buffer[], int sizebuffer)
{
    int length;
 
    printf ("Introduzca texto a cifrar: ");
    fgets (buffer, 1024, stdin);
    length = strlen(buffer);
    buffer[length - 1]='\0';
    return length;
}
 
void cifrar_cadena(char cadena[], int size)
{
	int p;
 
	for (p=0;p<size;p++){
        if ( isalpha(cadena[p]) ){
        	imprimir_caracter_alfa (cadena [p]);
            printf("\n\n");
        }else if ( isdigit(cadena[p]) ){
                printf( "\n %c :Este numero no es cifrable \n", cadena[p] );
        }else if (ispunct(cadena[p])){
            printf( "\n %c :Este caracter no es cifrable \n", cadena[p] );
       }
    }
}
 
int main ()
{
    int largo;
    char cadena [SIZEMAX];
    largo = obtener_cadena(cadena, SIZEMAX);
    cifrar_cadena(cadena,largo);
    getch();
    return 0;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar