PROGRAM MINIM(INPUT,OUTPUT);                      
(*MINIMIERUNG VON SCHALTNETZEN. METHODE AUS:    *)
(*LOG. ENTW. DIG. SYSTEME S.122-132 (D.PETZOLD) *)
(*FLORIAN MATTHES 13.3.1985                     *)
CONST MAXTABLEN=30;                               
      MAXVAR   =15;                               
      MAXZ     =150;                              
      MAXS     =40;                               
                                                  
TYPE TERM=(NULL,EINS,EGAL);                       
     ERG =(FALSCH,WAHR);                          
     TINDEX=0..MAXTABLEN;                         
      INDEX=0..MAXZ;                              
     SINDEX=0..MAXS;                              
     TSPALTE=ARRAY[SINDEX]OF TERM;                
                                                  
VAR TABELLE:ARRAY[TINDEX]OF                       
             RECORD                               
              X:ARRAY[0..MAXVAR]OF TERM;          
              Y:ERG                               
             END;                                 
    A:ARRAY[INDEX]OF                              
             RECORD                               
              SPALTE:TSPALTE;                     
              GESTR:BOOLEAN  (*KUERZEN *)         
             END;                                 
    E,OB,Q :TINDEX;                               
    P,T,U,I:INDEX;                                
    LEN,L  :SINDEX;                               
    J,K    :INTEGER;                              
    DOPPELT,GLEICH,ERSTER:BOOLEAN;                
    DRUCKER:CHAR;                                 
    DRU:TEXT;                                     
                                                  
 PROCEDURE ERROR*                                 
                                                  
 PROCEDURE DISTRIB*                               
                                                  
BEGIN(*MAIN*)                                     
 WRITE(CHR(147),CHR(14));                         
 WRITELN("  *****************");                  
 WRITELN("  *ÍINIMIERUNG VON*");                  
 WRITELN("  * ÓCHALTNETZEN: *");                  
 WRITELN("  *****************");WRITELN;          
 REPEAT                                           
  WRITE("ÌAENGE DER ÔABELLE:");READLN(OB);        
  IF OB<1 THEN WRITELN("ZU KURZ!");               
  IF OB>MAXTABLEN THEN WRITELN("ZU GROSS!");      
 UNTIL(OB>=1)AND(OB<=MAXTABLEN);                  
 REPEAT                                           
  WRITE("ÁNZAHL UNABH. ÖAR.:");READLN(LEN);       
  IF LEN<1 THEN WRITELN("ZU WENIGE!");            
  IF LEN>MAXVAR THEN WRITELN("ZU VIELE!");        
 UNTIL(LEN>=1)AND(LEN<=MAXVAR);                   
 REPEAT                                           
  WRITE("ÄRUCKERAUSGABE: N?");READLN(DRUCKER)     
 UNTIL(DRUCKER="J")OR(DRUCKER="N");               
 IF DRUCKER="J" THEN OPEN(DRU,4,7)                
                ELSE OPEN(DRU,3,0);               
 WRITELN("ÅINGABE DER ÔABELLE:");                 
 WRITELN("····················");                 
 WRITELN("(0/1 BZW. * FUER EGAL)");               
 OB:=OB-1;LEN:=LEN-1;L:=LEN;                      
 FOR K:=0 TO L  DO WRITE(CHR(65+K));WRITELN("ÝY");
 FOR K:=0 TO L  DO WRITE("À");WRITELN("ÛÀ");      
 FOR E:=0 TO OB DO EINLESEN(E);                   
                                                  
 P:=0;(*ARBEITSTABELLE A IST LEER*)               
 FOR E:=0 TO OB DO                                
 IF TABELLE[E].Y=WAHR THEN                        
  BEGIN (*FUER ALLE EINSTERME:*)                  
   T:=P;EINSNULL(E,T);                            
   KUERZE(P,T);                                   
   DISTRIB(P,T,U);                                
   KUERZE(T,U);                                   
   (*STREICHE DOPPELTE PRIMTTERME:*)              
   FOR I:=T TO U-1 DO                             
    WITH A[I] DO                                  
     BEGIN J:=0;DOPPELT:=FALSE;                   
      WHILE NOT DOPPELT AND(J<P)DO                
       BEGIN K:=0;                                
        REPEAT                                    
         DOPPELT:=SPALTE[K]=A[J].SPALTE[K];       
         K:=K+1                                   
        UNTIL NOT DOPPELT OR(K>L);                
        J:=J+1;                                   
       END;                                       
      IF NOT DOPPELT THEN                         
       BEGIN(*PRIMTERM UEBERTRAGEN*)              
         A[P].SPALTE:=SPALTE;                     
        P:=P+1;                                   
       END                                        
     END                                          
  END;                                            
 WRITELN("ÐRIMTERME:");                           
 WRITELN("··········");                           
 FOR I:=0 TO P-1 DO BEGIN AUSGABE(I);WRITELN END; 
                                                  
 IF P>MAXS THEN ERROR(3);                         
 (*TEST IMPLIKATION PRIMTERM, EINSTERM         *) 
 (*ERGEBNIS ==>A[P..T-1]                       *) 
 T:=P;                                            
 FOR Q:=0 TO OB DO                                
  IF TABELLE[Q].Y=WAHR THEN                       
  WITH TABELLE[Q] DO                              
   BEGIN                                          
    IF T>MAXZ THEN ERROR(2);                      
    FOR J:=0 TO P-1 DO                            
     BEGIN K:=0;                                  
      REPEAT                                      
       CASE A[J].SPALTE[K] OF                     
        EGAL:GLEICH:=TRUE;                        
        NULL:GLEICH:=X[K]=NULL;                   
        EINS:GLEICH:=X[K]=EINS                    
       END;(*CASE*)                               
       K:=K+1                                     
      UNTIL NOT GLEICH OR (K>L);                  
      IF GLEICH THEN A[T].SPALTE[J]:=EINS         
                ELSE A[T].SPALTE[J]:=EGAL;        
     END;                                         
    T:=T+1                                        
   END;                                           
                                                  
 L:=P-1;(*LAENGE:=ANZAHL DER PRIMTERME*)          
 KUERZE(P,T);                                     
 DISTRIB(P,T,U);                                  
                                                  
 WRITELN("ÆUNKTIONSGLEICHUNGEN:");                
 WRITELN("·····················");                
 FOR I:=T TO U-1 DO                               
  BEGIN ERSTER:=TRUE;WRITE(DRU,"Y=");             
   FOR K:=0 TO L DO                               
    IF A[I].SPALTE[K]=EINS THEN                   
     BEGIN                                        
      IF NOT ERSTER THEN WRITE(DRU,"+");          
      ERSTER:=FALSE;AUSGABE(K)                    
     END;                                         
   WRITELN;                                       
  END;                                            
 CLOSE(DRU)                                       
END.