נסתכל על התוכנית הבאה:

if X=1 then writeln ('A');
if X=2 then writeln ('B');
if ((X=3) or (X=4) then writeln ('C');
if X=5 then writeln ('D');
if ((X=6) or (X=7)) then writeln ('E')'

האות שתודפס היא ברירה של הערך הנמצא בתוך X מסוג שלם.

ניתן להחליף את המבנה ב:

case X of    :1 ;('writeln('A       :2 ;('writeln('B       :3,4 ;('writeln('C       :5 ;('writeln('D       :6,7 ;('writeln('E       ;end

אחרי המילה case יופיע שם משתנה או ביטוי מסוג שלם,תווי או בוליאני בלבד. לאחריו תבוא המילה השמורה of.

אחרי ה-of  יופיעו הערכים שהם הברירה של המשתנה ואחריהם נקודתיים או רווח והוראה או רצף של הוראות בבלוק פנימי.

אם יש מספר ערכים המתאימים לאפשרות אחת,בין הערכים יופיע פסיק.

סיום  הcase -  מצוין על ידי end.

בכל מקרה שקיים ערך ב-X, שלא הובא בחשבון בברירה (X=9) לא יתבצע כלום והתוכנית תעבור לביצוע ההוראה שאחרי ה- end של ה-case .

אפשר להצמיד לcase -  גם  else, המגדיל בהרבה את כוחה של הוראה זו. במקרה שלנו:

case X of    :1 ;('writeln('A       :2 ;('writeln('B       :3,4 ;('writeln('C       :5 ;('writeln('D       :6,7 ;('writeln('E       else ;('writeln('H       ;end

כלומר אם לא נמצאה ברירה לביצוע,הרי שיודפס H.

דוגמא :

כאשר רושמים את מספר ת.ז שלנו אנו נדרשים לפעמים להוסיף ספרת ביקורת.

ספרת הביקורת היא ספרה הנוצרת מחישוב מסוים על מספר הזיהוי ובעזרתה ניתן לבדוק אם מספר הזיהוי שגוי.

אחת השיטות ליצירת ספרת ביקורת היא 1,3,7

למשל, אם נתון מספר 123456 אזי ספרת הביקורת תיווצר על פי האלגוריתם הבא:

נכפיל את הספרה ה-1 מצד שמאל ב-1 ונרשום את התוצאה:      1=1*1

נכפיל את הספרה ה-2 מצד שמאל ב-3 ונרשום את התוצאה:      6=3*2

נכפיל את הספרה ה-3 מצד שמאל ב-7 ונרשום את התוצאה:    21=7*3

נכפיל את הספרה ה-4 מצד שמאל שוב ב-1 ונרשום:                4=1*4

                                                                               15=3*5 

וכך הלאה עד סוף המספר...                                            42=7*6

                                                               סה"כ:         89  

וספרת הביקורת תהיה ספרת היחידות של התוצאה (כלומר 9).

תרגיל:

כתוב תוכנית הקולטת מחרוזת, המהווה מספר ומחשבת, מדפיסה מספר זה כאשר ספרת הביקורת מוצמדת לימין המספר.

פתרון:

program CHECK_DIGIT;
{ תוכנית לחישוב ספרת הביקורת}
var
   NUMBER: string[255]; (* מחרוזת הקלט *)
   I:integer; (*מונה הלולאה*)
   MUL:integer; (*הספרה בה יש להכפיל, כלומר 1,3,7*)           
   J:integer; (* MUL-באיזו סיפרה נמצאים במחרוזת כדי להכפיל ב *)
   SUM:integer; (* צובר המכפלות *)
begin  
   write('Enter number: ');
   readln(NUMBER);
   SUM:=0; (*אפס צובר*)
   for I:=1 to ord(NUMBER [0]) do (* עד סוף המחרוזת*)
   begin
      J:=I mod 3; (*האם נמצאים בספרה ה-1,2 או 3*)
      Case J of
        1: MUL:=1; (* שארית סיפרה ראשונה=1 *)
        2: MUL:=3;
        0: MUL:=7;                    
      end;
      SUM:=+SUM+(ord(NUMBER [I])-48)*MUL;
    end;
    SUM:=SUM mod 10; (* תישאר ספרת האחדות SUM –ב *)
    writeln(' The number and the BIKORET digit is: ' ,NUMBER,SUM);
end.

 להורדת הדוגמא לחץ כאן

דוגמת ריצה:

דוגמא נוספת:

נתונים שני מערכים:

מערך  A מכיל 30 תאים מסוג שלמים.

מערך  B מכיל 10 תאים מסוג ממשיים. 

נתון כי במערך A מאוחסנים עשר שלשות של מספרים שלמים.

המספר השלישי מבין כל שלושה מכיל קוד פעולה והשניים הראשונים מספרים כלשהם שלמים.לפי קוד הפעולה, מבוצעות הפעולות על שני המספרים שלפניו.

הקודים יכולים להיות רק:

1.כפל

2.חילוק

3.חיבור

4.חיסור

כתוב תת תוכנית אשר תבדוק את קודי הפעולה במערך A  ותבצע לפי קוד זה את הפעולה על שני המספרים שלפניו. את התוצאה תציב התוכנית למערך B.

פתרון:

program NAME;
var
   A:array[1...30] of  integer;
   B:array[1...10] of real;
   INDEX_A:integer; (*Aמשתנה הלולאה ומצביע על מספר התא במערך*)   
   INDEX_B:integer; (*Bמצביע על מספר התא במערך *)
        ·         
        ·         קטע הבא לפני תת-תוכנית זו
        ·         

procedure ARITHMETICS;
   {תת תוכנית לביצוע פעולות חשבון}
begin
    INDEX_A:=3;
    INDEX_B:=1;
    while INDEX_A<=30 do
    begin
       case A[INDEX_A] of
       1:B[INDEX_B]:=A[INDEX_A-1]*A[INDEX_A-2];(*כפל*)
       2:B[INDEX_B]:=A[INDEX_A-2]/A[INDEX_A-1];(*חילוק*)
       3:B[INDEX_B]:=A[INDEX_A-1]+A[INDEX_A-2];(*חיבור*)
       4:B[INDEX_B]:=A[INDEX_A-2]-A[INDEX_A-1];(*חיסור*)
    end;
       (*A קידום משתנה הלולאה המצביע על פעולה במערך *)
    INDEX_A:= INDEX_A+3;
       (*B קידום משתנה המצביע על מקום התוצאה במערך *)
    INDEX_B:= INDEX_B+1;
   end;
end;
       ·         
       ·         קטע הבא אחרי תת-תוכנית זו
       ·