Siento molestar con estas cosas que se supone tendría que hacer yo solita, pero estoy muy atascada y no sé cómo salir de esta.

El caso es que el día del exámen tengo que entregar este ejercicio:
fin de curso

Bien, pues me he quedado en la primera fase, fase de asignación, en la que leo un fichero llamado datos.txt.

Los tipos de datos que he encontrado son:

Código Fuente:

type TipoPtrColor is  access all TipoColor; -- <-- Puntero del tipo color.
type TipoLetras is array ( 1 .. 8 ) of Character;

type TipoColor is
record
    letra                : TipoLetras;
    pcolor : TipoPtrColor;
end record;

type TipoNumero is array ( 1 .. 5 ) of Integer;

type TipoPtrCarton is acces all TipoAllCarton; -- <-- Útil para eliminar cartones que no son válidos. 
type TipoFila is
record
    color      : TipoColor;
    numero : TipoNumero;
end record;

type TipoCarton is array ( 1 .. 3 ) of TipoFila;

type TipoTodosLosCartones is array ( 1 .. 50 ) of TipoCarton;

type TipoAllCarton is
record
    carton       : TipoTodosLosCartones;
    pallcarton : TipoAllCarton;
end record;

type TipoJugador is array ( 1 .. 3 ) of TipoAllCarton;

Creo que se entiende bien lo que estoy haciendo... los registros tienen punteros ( la variable empieza por p y es del tipo TipoPtrXXX ) para poder acceder a los datos secuencialmente. Hasta ahí todo bien.

El problema lo tengo por el acceso a los datos. El año pasado a un amigo mío le tiraron por acceder de golpe a todos los datos porque "consumía mucha memoria".

Cabe decir que, en ADA, abres el archivo y si no lo lees hasta el final, siempre empiezas desde el ppio a leerlo (es decir, no puedo cerrar el archivo por cada jugador y volver a abrirlo porque entonces siempre me recogería el mismo cartón).

Mi problema es cómo distingo los números de los caracteres, ya que tengo que ir leyendolo todo caracter a caracter y luego poniendolo en su sitio...

A ver si se os ocurre como hacerlo, porque yo estoy bastante bloqueada...

Gracias a todos de antemano.

Deberías mirar si existe algún procedimiento is_digit que te permita verificar que el carácter, efectivamente, es un dígito. Si no, la forma más fácil de verificar, es verificando que el código del carácter está entre 47 y 58 ya que en ASCII '0' => 48 y '9' => 57.

En C es fácil verificar esto ya que se usa la representación de un carácter como el valor ASCII de este, ADA en este caso no sé si te permitirá hacer ésto. Por intentarlo...

No existe, y si existiese, me suspenderían porque sólo puedo usar programación estructurada ( for, while, repeat y instrucciones básicas como Put y Get ).

El caso es que el código del programa se ha quedado bastante grande ( voy por las 261 lineas casi sin comentar ).

El problema ahora lo tengo en la siguiente estructura:

Código Fuente:


       procedure EscribirColor ( color:TipoColor ) is
       jugador:TipoJugador;
       totalcartones:TipoTotalCartones;
       carton:TipoCarton;
       fila:TipoFila;
       begin
              Put ( jugador.totalcartones.carton.fila.color );
       end;


       procedure EscribirNumeros ( numero:TipoNumero ) is
       begin
              for contador in 1 .. N loop
                     Put ( jugador.totalcartones.carton.fila.numeros( contador ) );
              end loop;
       end;

       procedure EscribirFila ( fila : Tipofila ) is
       begin
              EscribirColor ( jugador.totalcartones.carton.fila.color);
              EscribirNumeros( jugador.totalcartones.carton.fila.numeros);
       end;


       procedure EscribirCarton ( carton: TipoCarton ) is
       begin
              for contador in 1 .. D loop
                     EscribirFila( jugador.totalcartones.carton.fila ( contador ) );
              end loop;
       end;


       procedure EscribirCartones ( carton:TipoTotalCartones ) is
       begin
              for contador in 1 .. D loop
                     EscribirCarton( jugador.totalcartones.carton ( contador ) );
              end loop;
       end;


       procedure EscribirJugador ( jugador:TipoJugador ) is
       begin
              for contador in 1 .. M loop
                     EscribirCartones( jugador.totaloscartones ( contador ) );
              end loop;
       end;

       procedure EscribirDatosFichero is
       jugador:TipoJugador;
       begin
              for contador in 1 .. J loop
                     EscribirJugador( jugador ( contador ) ) ;
              end loop;
       end;


Como podeis ver, es todo el rato lo mismo, solo que iterando.

Los errores que me da son los siguientes:

Código Fuente:

invalid prefix in selected component "carton"
       procedure EscribirColor ( color:TipoColor ) is
       jugador:TipoJugador;
       totalcartones:TipoTotalCartones;
       carton:TipoCarton;
       fila:TipoFila;
       begin
              Put ( jugador.totalcartones.carton.fila.color ); <-- Aquí
       end;


"jugador" is undefined (more references follow)

procedure EscribirNumeros ( numero:TipoNumero ) is
       begin
              for contador in 1 .. N loop
                     Put ( jugador.totalcartones.carton.fila.numeros( contador ) ); <-- Aquí
              end loop;
       end;

no selector "totaloscartones" for type "TipoJugador" defined at line 39

       procedure EscribirJugador ( jugador:TipoJugador ) is
       begin
              for contador in 1 .. M loop
                     EscribirCartones( jugador.totaloscartones ( contador ) );
                     procedure EscribirJugador ( jugador:TipoJugador ) is
       begin
              for contador in 1 .. M loop
                     EscribirCartones( jugador.totaloscartones ( contador ) ); <-- Aquí
              end loop;
       end;
end loop;
       end;


array type required in indexed component

       procedure EscribirDatosFichero is
       jugador:TipoJugador;
       begin
              for contador in 1 .. J loop
                     EscribirJugador( jugador ( contador ) ) ; <-- Aquí.
              end loop;
       end;



Y no sé lo que quieren decirme. ¿Alguna idea? Ya me quedo sin ellas para poder terminar la parte de escritura de los cartones...

Los tipos de datos son los siguientes:

Código Fuente:

              -- Declaración de constantes
       Max : constant Integer := 99;
       N : constant Integer := 5;
       D : constant Integer := 3;
       M : constant Integer := 3;
       J : constant Integer := 3;
              
              -- Definición de tipos.
subtype TipoRangoPalabra is Integer range 1 .. Max ;

type TipoPalabra is
record
       letras: String(TipoRangoPalabra) ;
       long : Natural;
end record;

type TIpoColor is ( rojo, azul, verde, amarillo );

type TipoNumero is array ( 1 .. N ) of Integer;
              -- La fila se compone de un color y 5 numeros.
type TipoFila is
record
       color: TipoColor;               
       numeros: TipoNumero;
end record;
              -- El carton son 3 lineas.
type TipoCarton is array ( 1 .. D ) of TipoFila;
              -- Hay 3 jugadores.
type TipoTotalCartones is array ( 1 .. M ) of TipoCarton;
type TipoJugador is
record
       totalcartones:TipoTotalCartones;
end record;

type TipoTotalJugadores is array ( 1 .. J ) of TipoJugador;
       
       function NumeroEnRango ( indice: Integer ) return Boolean is
       begin
              return ( indice < 100 );
       end;



A ver si veis algo más que yo no veo.

Thnks dude!

No veo ninguna regla moral en la programación estructurada que te impida utilizar una simple condición que eche un vistazo a un carácter.

Y mira, si quieres, puedes hacer un módulo de interacción con caracteres con funciones como "integer_to_string" "is_digit" "string_to_integer" (si es necesario). Tu profesor no podrá decir nada, al menos por la estructura del programa.

Esto <<

Código Fuente:


#include <stdio.h>
#include <ctype.h>

int main(int argc, char **argv)
{
  unsigned int it = 1;
  while (it < argc) {
      if (isdigit(argv[it][0])) {
        printf("El argumento %d comienza por un número.", it);
      }
      it++;
  }
  return 0;
}


>> es un programa estructurado y utilizo la función (procedimiento, método, rutina... llámalo como quieras) isdigit. La programación estructurada no te permite hacer saltos incondicionales a otras partes del programa, y, las funciones, tienen que tener un único return al final de ésta. No se van a quejar por una condición. Puedes mirarlo en cualquier fuente.

Y no conozco ADA así que mucho no puedo ayudarte en problemas de compilación , pero si tienes alguna duda sobre el algoritmo a usar yo puedo ayudarte (si estás en el feisbus y estoy conectado me das un grito en el pseudochat).

El problema es que el tío no me deja poner variables locales, ni subprogramas con más de 1 loop enlazado (es decir, lo quiere todo lo más estructurado posible ). Me parece genial, pero con tanto subprograma me pierdo.

Esto es más para ordenar mis ideas y, si tengo alguna mal, que me la podáis corregir.

Lo que me da error es el acceso a todos los datos. Yo tengo que poder poner unos datos que se encuentra en:

totaljugadores ( contadortotaljugadores ). jugador. cartones ( contadorcartones ). fila ( contadorfila ). color

y

totaljugadores ( contadortotaljugadores ). jugador. cartones ( contadorcartones ). fila ( contadorfila ). numeros

pero no puedo hacerlo por variables globales, tienen que ser todas locales (que es ahí donde me estoy perdiendo).

Entonces lo que yo pensé es

accedo a todos los jugadores
    accedo a cada jugador
        accedo a todos los cartones
              accedo al cartón que toque
                  accedo a la fila
                  pongo el color
                  pongo el chorreo de números.

Hasta aquí, ¿bien?