المهارات الرقمية فصل أول

 

القوائم (Lists)

 

• تُمثِّل القائمة في لغة البرمجة بايثون ( Python ) عددًا من القِيَم التي يُخزَّن بعضها مع بعض
• ترتبط معًا بمعنى وظيفي مشترك. فمثلًًا، يُمكِن للمُستخدِم تخزين أسماء الشوارع داخل إحدى المدن في قائمة، وكذلك تخزين أسعار البضائع التي اشتراها أحد العملاء، أو تخزين علامات الطلبة في الصف الحادي عشر.
• يتطلَّب استخدام القوائم في لغة البرمجة بايثون ( Python ) تعريف القائمة أوَّلًًا، ثمَّ تخزين العناصر داخلها.

يُمكِن تعريف إحدى القوائم باستخدام الأقواس المُربَّعة [ ]، والفصل بين عناصر القائمة بفواصل على النحو الآتي:
المقطع البرمجي التالي يعرّف قائمة باسم mylist تحتوي على أربعة عناصر، وكل عنصر في القائمة يحتوي على قيمة ثابتة واحدة تتكرر، وهي ' value 1'

mylist = ['value1','value1', 'value1','value1']

 

مثال:
يُبيِّن المقطع البرمجي الآتي تعريفًا لقائمة تُسمّى ( names )، وتتضمَّن ( 5) أسماء، وتعريفًا لقائمة أُخرى تُسمّى ( ages )، وتتضمَّن ( 4) أعمار لأشخاص وتعريفا لقائمة فارغة، أنظر الشكل (5- 1).

names = ['Ali', 'Salam', 'Joud', 'Omar', 'Jana']
ages = [10, 48, 33, 17]
a = []

 

لا يُشترَط في القائمة التي يراد إنشاؤها أنْ تحوي جميعها عناصر من النوع نفسه؛ إذ يُمكِن للمُستخدِم تخزين أرقام صحيحة، وأرقام عشرية، وسلاسل نصية، وقوائم أُخرى في القائمة نفسها كما في
المثال الآتي:

[[ 1, 2, 3 ] , mix = [1, 1.5, 'Yes', 24, 5

 

 

أُلاحِظ من المثال السابق أنَّ طول القائمة هو ( 6) عناصر، بالرغم من أنَّ بعض هذه العناصر مُركَّبة من عناصر أخرى

يُمكِن للمُستخدِم معرفة طول أيِّ قائمة باستخدام الدالة ()len   :

len length_of_names = len(names)
length_of_ages = len(ages)
length_of_mix = len(mix)
 

لطباعة الأطوال استخدام الدّالة () print  :

 

print("Length of names list:", length_of_names)
print("Length of ages list:", length_of_ages)
print("Length of mix list:", length_of_mix)

عند تشغيل البرنامج، ستظهر النتيجة الآتية على شاشة الحاسوب:

 

 

 

 

الوصول للعناصر في القائمة:
يُمكِن للمُستخدِم الوصول إلى أيِّ عنصر من عناصر القائمة باستخدام الأقواس المُربَّعة ورقم يُمثِّل موقع العنصر ( index ) في القائمة على النحو الآتي : 

mix = [1, 1.5, 'Yes', 24, 5, [1, 2, 3]]

print(mix[0])
print(mix[2])
print(mix[5])

عند تشغيل البرنامج، ستظهر النتيجة الآتية على شاشة الحاسوب:

 

 

 

 

 

 

أُلاحِظ أنَّ ترقيم مواقع العناصر قد بدأ بالرقم ( 0)، لا بالرقم ( 1). وهذا يعني أنَّ قائمة من ستة عناصر مثل (mix)سيكون أخر عنصر فيها في الموقع ( 5) لا في الموقع ( 6). وإذا حاول المُستخدِم استعمال رقم أعلى من( 5)، فإنَّ ذلك سيؤدّي إلى توقُّف البرنامج عن العمل، أنظر الشكل ( 5- 2).

 

 

كذلك تتيح لغة البرمجة بايثون ( Python ) للمُستخدِم استعمال أرقام سالبة للوصول إلى العناصر، حيث يرمز الرقم ( 1-) إلى العنصر الأخير، ويرمز الرقم ( 2-) إلى العنصر قبل الأخير وهكذا، أنظر الشكل ( 5- 3).

 

 

المرور على القوائم: 
قد يَلزم في بعض البرامج المرور على جميع العناصر في القائمة لأداء وظيفة ما، كما هو الحال في البرنامج الذي يُبيِّنه الشكل ( 5- 4)، والذي يطبع على سطر مُنفصِل كل عنصر من عناصر القائمة المُسمّاة (items)

 

 

 

كذلك يُمكِن كتابة البرنامج السابق باستخدام نوع آخر من حلقات التكرار، هو حلقة ( while )، أنظر الشكل (5- 5).

 

 

 

يُلاحَظ على هذا البرنامج ما يأتي:
1. استعمال المُتغيِّر ( i) للمرور على جميع مواقع العناصر في القائمة؛ إذ بدأت قيمة هذا المُتغيِّر  عند الرقم ( 0)، وهو موقع العنصر الأوَّل، وانتهت قيمته عند آخر موقع عنصر في القائمة.
2. الحاجة لمعرفة عدد المواقع التي سنقوم بالمرور عليها المرور عليها؛ ما ألزم استخدام len(items) التي تُبيِّن طول القائمة المُخزَّنة في (items)
3. استخدام شرط حلقة التكرار يتأكد من عدم وصول قيمة المتغير i لطول القائمة، وذلك لأنه لو كان طول القائمة 10 على سبيل المثال فإن آخر عنصر في القائمة موجود في الموقع 9 وليس في الموقع 10 .
مثال:
إذا افترضْتُ أنَّ القائمة ( readings ) في الشكل ( 5 - 6) تتضمَّن قراءات لجهاز استشعار، وأنَّ القراءات المتتابعة والمتساوية تدلُّ على وجود خطأ ما في القراءة، فإنَّه يُمكِنني التحقُّق من وجود عناصر متتابعة ومتساوية في القائمة كما يأتي:

 

 

 

 

 

العمليات في القوائم:
توجد عمليات عِدَّة يُمكِن تنفيذها في القوائم، مثل: الوصول إلى العناصر في قائمة ما، وإضافة عناصر جديدة إليها، وحذف عناصر منها، وترتيب العناصر فيها. وقد نُفِّذت بعض هذه العمليات بصورة فعلية في الأمثلة السابقة لهذا الدرس

 

 

 

عند استخدام عامل الجمع (+) بين قائمتين، تنتج قائمة جديدة تحوي عناصر القائمتين معًا. ومن ثَمَّ يُمكِن استعمال العامل (=+)لتعديل قائمة، بإضافة عناصر قائمة أُخرى إلى نهايتها كما يأتي:

 

كذلك يُمكِن استخدام هذا العامل في إنشاء قائمة خطوة بخطوة كما في الشكل ( 5- 7)؛ حيث يقوم البرنامج الموضح في المثال بقراءة أرقام وإضافتها إلى قائمة ويتوقف عند إدخال أي رقم سالب.

أُلاحِظ على هذا البرنامج أنَّه قد بدأ بقائمة فارغة، ثمَّ أُضيفت العناصر تِباعًا باستخدام العامل (=+).

 

• أُلاحِظ أيضًا أنَّ الرقم ( n) أُحيطت به الأقواس المُربَّعة [ n]؛ لأنَّ العامل (=+) يؤدّي وظيفته بين قائمتين؛ ما يجعل الجمل، مثل جملة numbers += n (من دون أقواس)، غير صحيحة بحسب قوانين لغة بايثون.

 

• إضافةً إلى العامل + والعامل * (يعمل على تكرار قائمة ما عددًا من المَرّات)، يُمكِن أيضًا المقارنة بين القوائم باستخدام عوامل المقارنة المنطقية (== و =! و > و => و < و=< )، التي تعمل على مقارنة كل عنصر في القائمة الأولى بالعنصر الذي يُقابِله في القائمة الثانية.

مثال:

• القائمة [ 3 , 2 , 1]> من القائمة [ 1 , 3]؛ لأنَّ العنصر الأوَّل( 1) في القائمة الأولى أقل من العنصر الأوَّل في القائمة الثانية

( 3).

• في حين أنَّ القائمة [ 3 , 2 , 1]< من القائمة [ 0 , 0 , 0 , 1]؛ لأنَّ العنصر الثاني ( 2) في القائمة الأولى أكبر من العنصر الثاني

( 0) في القائمة الثانية.

• كذلك يُمثِّل التحقُّق من وجود عنصر ما في القائمة واحدةً من العمليات المُهِمَّة في القوائم. وأسهل طريقة لعمل ذلك هي استخدام العامل ( in ) على النحو الآتي:

 

 

 

 

الدوالُّ الجاهزة لمعالجة القوائم:

تعرَّفْتُ سابقًا أنَّه يُمكِن استخدام (…) len في تحديد طول قائمة ما، والآن سأتعرَّف أنَّ العديد من الدوالِّ المُشابِهة تُوفِّرها اللغة للتعامل مع القوائم، أنظر الجدول ( 5- 1) الذي يعرض أمثلة على ذلك، علمًا بأنَّ جميع هذه الأمثلة مُطبَّقة على القائمة: [ 4 , 2 , 3 , 5 , 3 , numbers = [1

الجدول ( 5- 1): أمثلة على بعض الدوالِّ الجاهزة لمعالجة القوائم.

 

يتبيَّن من الجدول السابق وجود طريقتين مختلفتين لاستخدام الدوالِّ الجاهزة:

• الطريقة الأولى تُستخدَم في ( min )، و( max )، و( sorted)، و( len)، و( print )، وتتمثَّل في إرسال القائمة إلى الدالة.

 

•  الطريقة الثانية تُستخدَم في ( count )، و( index )، وتتمثَّل في استدعاء الوظيفة عن طريق ذكر اسم القائمة متبوعًا بنقطة، ثمَّ ذكر اسم الدالة.

يُذكَر أنَّ الدوال في كلتا الطريقتين لا تقوم بإجراء أيِّ تعديل على القائمة، وإنَّما تكتفي بالمرور على القائمة لحساب نتيجة ما، ثمَّ إعادة هذه النتيجة. غير أنَّ ذلك ليس مُطَّرِدًا في جميع الدوال، كما هو الحال في تلك الواردة في الجدول ( 5- 2)؛ إذ تعمل جميعها على تعديل القائمة.

الجدول (5- 2): أمثلة على وظائف جاهزة لمعالجة القوائم وتعديلها.

 

سلاسل الحروف (Strings):
يوجد تشابه بين سلاسل الحروف والقوائم، يتمثَّل في أنَّ كلتيهما تتألَّف من عناصر متتابعة. غير أنَّ جميع العناصر في السلسلة هي حروف (أيْ رموز تُمثِّل حروفًا أبجديةً، أو أرقامًا، أو علاماتِ ترقيم، أو غيرَ ذلك)؛ لذا يُمكِنني تطبيق معظم ما تعلَّمْتُه عن القوائم على سلاسل الحروف

 

يُمكِن الوصول إلى أيِّ حرف في السلسلة باستخدام الموقع (index )، ويُمكِن أيضًا استخدام الدوالِّ، مثل: (sorted) ، و( max) ، و( len) ، و( count) . وكذلك استخدام العوامل، مثل: (+) و(*) كما تعلَّمْتُ سابقًا، فضلًًا عن إمكانية اختبار وجود عنصر في السلسلة باستخدام العامل ( in ) والعامل  ،(not in) بالرغم من وجود فروق بسيطة بينها؛ إذ تتحقَّق العوامل في القوائم من وجود عنصر ما في إحدى القوائم، في حين تتحقَّق العوامل في السلاسل من وجود سلسلة أُخرى داخل السلسلة نفسها.

مثال :

يتحقَّق البرنامج الآتي من وجود السلسلة (' gov.jo .') ضمن السلسة (url ) :

("ما موقعك الإلكتروني؟") url = input if '.gov.jo' in url

: ('يبدو أنك أدخلت موقعاً حكومياً أردنياً') print
:else
('شكراً جزيلاً') print

الدوالُّ الجاهزة الخاصة بسلاسل الحروف:
توجد دوالُّ جاهزة تختصُّ بسلاسل الحروف، أنظر الجدول ( 5- 3) الذي يعرض أمثلة على ذلك، علمًا بأنَّ جميع هذه الأمثلة مُطبَّقة على السلسلة: ' .text = 'Hello there

 

تتمثَّل أهمُّ الفروق بين السلاسل والقوائم في أنَّ السلاسل في لغة البرمجة بايثون ( Python ) غير قابلة للتغيير ( Immutable)، وأنَّ القوائم قابلة للتغيير ( Mutable ). ولهذا لا يُمكِن -مثلًًا- تغيير أحد الحروف في السلسلة، في حين يُمكِن تغيير عنصر ما في القائمة، أنظر الشكل ( 5- 8).

 

 

numbers = [0, 1, 2]
numbers[0] = 9
print(numbers)
عند تشغيل البرنامج، ستظهر النتيجة الآتية على شاشة الحاسوب:

 

 

 

 

name = 'Jana'
name[0] = 'D'
print(name)
 

 

عند تشغيل البرنامج، ستظهر النتيجة الآتية على شاشة الحاسوب:

 

 

أُلاحِظ أنَّ جميع العمليات في الشكل السابق لا تُعْنى بتعديل السلسلة، وإنَّما تُعْنى بإنشاء نسخة جديدة مُعدَّلة منها. فمثلًًا، عند تنفيذ الجمل الآتية، فإنَّ السلسلة لن تتغيَّر:

 

 

 

وهذا يتأكَّد عند استدعاء () replace و () upper على السلسلة؛ إذ تُنشَأ نسخ جديدة مُعدَّلة. ونظرًا إلى عدم حفظ هذه النسخ أو طباعتها؛ فإنَّ السلسلة لم تتأثَّر بهذه العمليات. وبالرغم من ذلك، يُمكِن حفظ النسخ المُعدَّلة للسلسلة كما في الجمل الآتية:

 

 

 

 

 

كذلك يُمكِن المرور على عناصر القوائم المُركَّبة، وتطبيق بعض المهام عليها كما في القوائم البسيطة.
مثال:
عند إنشاء حساب جديد في موقع إلكتروني، فإنَّ هذا الموقع يتحقَّق من (جودة) كلمة السِّرِّ؛ سعيًا لتقليل خطر اكتشافها من طرف المُخترِقين.

يتضمَّن هذا المثال إنشاء برنامج يعمل على استيفاء كلمة السِّرِّ للشرطين الآتيين:

• اشتمال كلمة السِّرِّ على ( 10 ) أحرف فأكثر.
• احتواء كلمة السِّرِّ على أحرف إنجليزية صغيرة، وأحرف إنجليزية كبيرة، وأرقام، ورموز غير الأحرف والأرقام.

 

يبدأ البرنامج المرور على أحرف كلمة السِّرِّ، وعَدَّ مَرّات تكرار كلٍّ من الأحرف الأبجدية (الصغيرة والكبيرة) والأرقام والرموز، ثمَّ يتأكَّد أنَّ عدد مَرّات التكرار لكل ما سبق لا يساوي صفرًا، أنظر الشكل ( 5- 9).

 

الأحرف الخاصة:

تحمل بعض الأحرف معاني خاصة في لغة البرمجة بايثون (Python )؛ لذا يجب الانتباه عند استخدامها في السلاسل. فمثلًًا، تُستعمَل علامة التنصيص ' ' وعلامة التنصيص " " لتحديد بداية سلسلة الحروف ونهايتها؛ ما يجعل استخدام هذه العلامة حرفًا داخل السلسلة مشكلةً. ولهذا تسمحلغة بايثون ( Python ) بالتفرقة بين علامة التنصيص التي هي جزء من السلسلة وعلامة التنصيص التي تُحدِّد بداية السلسلة ونهايتها، وذلك عن طريق استخدام الرمز \ قبل علامة التنصيص كما يأتي:

 

 

 

أُلاحِظ أنَّ الرمز \ لم يُضَف قبل علامة التنصيص "؛ لأنَّ العلامة التي استُخدِمت في تحديد بداية السلسلة ونهايتها هي علامة'.

كذلك يُستخدَم الرمز \ قبل بعض الحروف لإعطائها معنًى خاصًّا، مثل: '\ n' التي تعني سطرًا جديدًا، و' t\' التي تعني مسافة مُطوَّلة:

 

 

 

ولكنْ، كيف يُستخدَم الرمز \ حرفًا داخل السلسلة إنْ كان يحمل معنًى خاصًّا؟ يُمكِن فعل ذلك عن طريق إضافة رمز \ آخر قبله كما يأتي:
 

 

 

القوائم المُركَّبة:
تعرَّفْتُ سابقًا أنَّ عناصر القائمة قد تحوي جملة من القوائم؛ ما يعني إمكانية إنشاء قائمة من مجموعة قوائم. وهذا النوع من القوائم المُركَّبة مُنتشِر ومُهِمٌّ لكثير من التطبيقات؛ إذ يُمكِن - مثلًًا- في الرياضيات تمثيل المصفوفة ثنائية الأبعاد( 2D Matrix ) في صورة قائمة مُركَّبة تحوي أرقامًا، وكذلك تمثيل رقعة الشطرنج في صورة مصفوفة ثنائية الأبعاد تحوي أحجارًا، وغير ذلك كثير.

إنشاء القوائم المُركَّبة:
يُمكِن إنشاء قائمة مُركَّبة كما في الجملة الآتية:

a = [[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]

أُلاحِظُ أنَّ هذه القائمة تتألَّف من ( 3) قوائم، وأنَّ كل قائمة منها تتألَّف من( 3) عناصر؛ أيْ إنَّ هذه القائمة المُركَّبة تحوي ( 3) صفوف و( 3) أعمدة.

يُمكِن الوصول إلى الصف الأوَّل باستخدام [ a[0 ، والوصول إلى الصف الثاني باستخدام [ ،a[1 وهكذا. كذلك يُمكِن الوصول إلى أيِّ عنصر من عناصر القائمة المُركَّبة عن طريق تحديد موقع
الصف، ثمَّ تحديد موقع العنصر داخل هذا الصف )أيْ رقم العمود(. فمثلًًا، العنصر الأوَّل في
القائمة المُركَّبة موجود في المكان [ 0][ a[0 ، والعنصر الأخير في هذه القائمة موجود في المكان
a[2][2] ، وهكذا.

 

مثال:
يعمل البرنامج الآتي على تعيين قيمة ) 99 ( للعنصر [ 2][ 1]، ثمَّ طباعة عناصر القائمة:

 

 

مثال :
يطبع البرنامج الآتي عناصر القائمة المُركَّبة، ويضع كل صف على سطر مُنفصِل:

 

 

إنَّ هذه الطريقة اليدوية في تعيين قِيَم العناصر تُستخدَم فقط في إنشاء القوائم المُركَّبة الصغيرة. أمَّا القوائم المُركَّبة الكبيرة (مثل مصفوفة تتألَّف من (1000 ) صف و( 2000 ) عمود) فيتطلَّب إنشاؤها استخدام حلقة تكرار، بَدْءًا بإعداد قائمة فارغة، وانتهاءً بإضافة كل صف إلى القائمة داخل حلقة التكرار كما يأتي:

a = []
for i in range(1000):
row = [0]*2000
a.append(row)

المرور على القوائم المُركَّبة:
لا يختلف المرور على القائمة المُركَّبة عن المرور على أيِّ قائمة أُخرى، لكنَّنا نحتاج كثيرًا إلى استخدام حلقات تكرار مُركَّبة (حلقة للمرور على كل صف داخلها، وحلقة للمرور على كل عنصر في الصف)؛ لأنَّ عناصر القائمة تتألَّف أساسًا من قوائم.
مثال:
يستخدم البرنامج الآتي حلقة التكرار في المرور على كل عنصر في رقعة (اسمها board ) مُخصَّصة للعبة ( XO )؛ بُغْيَةَ التحقُّق من عدم وجود أحرف في الرقعة، ما عدا ' X' أو ' O' أو '-':

board = [['-', 'X', 'P'],
['-', 'X', '-'],
['K', 'O', '-']]
for row in board:
   for c in row:
       if c != 'X' and c != 'O' and c != '-':
              print('Invalid character ' + c + ' in the board')
print('Finished checking the board')

عند تشغيل البرنامج، ستظهر النتيجة الآتية على شاشة الحاسوب:

 

 

صحيح أنَّ التعامل مع القوائم المُركَّبة يتطلَّب كثيرًا استخدام حلقات تكرار مُركَّبة، لكنَّ ذلك ليس شرطًا.

 

تطبيقات عملية:
سنستعرض الآن مثالين على كيفية المرور على القوائم المُركَّبة، وهما يُمثِّلان جزءًا من بعض الألعاب التي تُمارَس على رقعة يُمكِن تمثيلها في صورة قائمة مُركَّبة.
مثال:

 

تُعَدُّ لعبة كاسحة الألغام ( Minesweeper ) واحدة من الألعاب الكلاسيكية القديمة. وتقوم فكرة هذه اللعبة على محاولة تجنُّب الضغط على مُربَّع يحوي قنبلة؛ إذ تُقدِّم اللعبة تلميحات - عند الضغط على بعض المُربَّعات- عن عدد القنابل المَخْفية حول المُربَّع الذي يضغط عليه اللاعب.
 

في هذا المثال، لن نكتب برنامجًا كاملًًا لهذه اللعبة، وإنَّما سنكتفي بمحاكاة عملية العَدِّ لعدد القنابل الموجودة حول كل مُربَّع، وتخزين هذا العدد في المُربَّع نفسه.
 

لنفترض أنَّ اللعبة مُمثَّلة بقائمة مُركَّبة، تحوي في كل عنصر علامة '-' في حال عدم وجود قنبلة، أو علامة '*' في حال وجود قنبلة. ووظيفتنا في هذا البرنامج هي استبدال رقم يُمثِّل عدد القنابل المُلاصِقة لذلك المُربَّع (مراعين المُربَّعات التي على يمين المُربَّع المطلوب، والمُربَّعات التي على شماله، والمُربَّعات التي فوقه، والمُربَّعات التي تحته مباشرة) بكل علامة '-'، أنظر الشكل (10-5)

 

 

 

 

يكتفي البرنامج بالمرور على كل موقع في القائمة المُركَّبة، وعَدِّ القنابل التي حوله؛ أيْ إنَّه لن يمرَّ على كل عنصر في هذه الأثناء؛ لأنَّ الهدف ليس فقط معرفة قيمة العنصر، وإنَّما معرفة قيمة العناصر التي حوله أيضًا. ومن ثَمَّ يجب معرفة موقع العنصر؛ للتأكُّد من القِيَم المُخزَّنة في المواقع التي حوله، أنظر الشكل ( 5- 11 )الذي يُبيِّن كيف يُنفَّذ المطلوب بافتراض أنَّ القائمة المُركَّبة تُسمّى(board)
board = [
['-', '*', '-', '-'],
['-', '-', '*', '-'],
['*', '-', '-', '-'],
['-', '*', '-', '*']
]
for i in range(len(board)):
     for j in range(len(board[i])):
          if board[i][j] == '-':
             count = 0
         if i > 0 and board[i-1][j] == '*':
             count += 1
         if i < len(board) - 1 and board[i+1][j] == '*':
           count += 1
         if j > 0 and board[i][j-1] == '*':
            count += 1
        if j < len(board[i]) - 1 and board[i][j+1] == '*':
          count += 1
        board[i][j] = str(count)
for row in board:
    line = ' '.join(row)
    print(line)

الشكل ( 5- 11 ): صورة القائمة المُركَّبة للعبة كاسحة الألغام.
مثال:

 

 

 

 

 

تُعَدُّ لعبة ( XO ) واحدة من الألعاب المشهورة التي تُلعَب عادةً باستخدام رقعة حجمها 3x3 ، ويُمكِن ممارستها أيضًا باستخدام رقعة مُربَّعة بِغَضِّ النظر عن حجمها.

في هذا المثال، لن نكتب برنامجًا كاملًًا لهذه اللعبة، وإنَّما سنكتفي بكتابة الجزئية التي تتحقَّق من فوز أحد اللاعبين، وهو ما يتطلَّب المرور على ثلاثة أشياء، هي:

• كل صف.
• كل عمود.
•  القُطْران.

سنبدأ أوَّلًًا بالصفوف، ونتحقَّق من عدد ( X) وعدد ( O)في كل صف؛ فإذا كان العدد لأيٍّ منهما مساويًا لطول الصف، عَلِمْنا أنَّ أحد اللاعبين قد فاز.
 

# عدد الصفوف وهو نفسه عدد الأعمدة لأن الرقعة مربعة

N = len(board)
N = len(board)
for row in board:
      if row.count('X') == N:
            print('X wins!')
            break
     if row.count('O') == N:
            print('O wins!')
     break
 

 

 

 

أمّا بالنسبة إلى الأعمدة، فإنَّ الأمر مختلف بعض الشيء. فكل عمود يحوي عناصر من صفوف مختلفة؛ ما يتطلَّب المرور على كل عمود بصورة يدوية حيث ( j) يمثل موقع كل عمود و ( i) يمثل كل صف:

 

 

 

في هذا المثال، يؤدّي المقطع البرمجي ثلاث مهام في كل عمود (j)، هي:
1.تصفير عدّادين؛ أحدهما لحرف ( X)، والآخر لحرف(O)
2. المرور على جميع العناصر في العمود ) j( لعَدِّ مَرّات تكرار حرف ( X) وحرف ( O) في ذلك العمود، وذلك باستخدام حلقة تكرار تمرُّ على جميع الصفوف في القائمة المُركَّبة، وتتحقَّق من العنصر ( j) في تلك القائمة.
3. التأكُّد - بعد الانتهاء من عَدِّ الأحرف في العمود ( j ) - أنَّ العدد مساوٍ لطول العمود، وهو ما يعني أنَّ أحد اللاعبين قد فاز.
 

وأمّا القُطْران فيُمكِننا التحقُّق منهما باستخدام حلقة تكرار تعمل على تغيير الصف والعمود في كل دورة؛ إذ يبدأ القُطْر الأوَّل عند [ 0][ 0]، ثمَّ ينتقل إلى [ 1][ 1]، ثمَّ ينتقل إلى [ 2][ 2]، وهكذا

 

 

في حين يبدأ القُطْر الثاني عند [ 0][N-1 ]، ثمَّ ينتقل إلى [ 1][N-2 ]، ثمَّ ينتقل إلى [ 2][N-3 ]، وهكذا.