Bài tập về vòng lặp cho người mới bắt đầu

BÀI 01: MÃ HÓA 1 ĐOẠN VĂN BẢN​

A

B

C

D

E

F

T

S

4

B

I

Q

TOI YEU GIAI PHAP EXCEL TU 2006

G

H

I

J

K

L

R

A

5

C

J

V

M

N

O

P

Q

R

U

0

6

D

K

W

?

S

T

U

V

W

X

O

1

7

E

L

X

Y

Z

0

1

2

3

N

2

8

F

M

Y

4

5

6

7

8

9

G

3

9

H

P

Z

N

M

Ta có bảng N với 36 ký tự & ký số được sắp xếp theo 1 trật tự qui ước



& bảng M cũng những kí tự & ký số đó ta bố trí theo mật mã có chìa khóa là 'TRUONG SA'

Đề bài yêu cầu chúng ta mã hòa câu "TOI YEU GIAI PHAP EXCEL TU 2006"

Xin lưu ý: Đề bài chỉ dành ch những lập trình viên VBA trình độ sơ cấp
Rất mong nhận được nhiều ý kiến & lời giải

[Gọi ý lần 1] (Sau 3 giờ): 'YEU' => 'NI7'

 

Thay vì phải sử dụng ví dụ mã hóa chuỗi cho vòng lặp cơ bản ta có thể tham khảo một số code dưới đây:

Một số ví dụ về vòng lặp:
1. Lặp sử dụng Step:

For I = 1 to 10 Step 2
   Debug.Print I
Next

2. Lặp sử dụng phương pháp thêm bớt giá trị:

For I = 1 to 10 Step 1
   Debug.Print I
   I = I + 1
Next
For J = 10 to 1 Step -1
   Debug.Print J
   J = J - 1
Next

3. "Nhảy" trong Vòng Lặp lòng một Vòng Lặp sử dụng Goto:

For I = 1 to 10
   For J = 1 to 10
      If J = 7 Then Goto LockCondition
   Next J
   If False Then
LockCondition:
     J = J + 3
   End If
Next I

4. "Nhảy" trong Vòng Lặp lòng một Vòng Lặp sử dụng Gosub:

Sub Exam_00A()
For I = 1 to 10
   For J = 1 to 10
      If J = 7 Then Gosub LockCondition: Exit For
   Next J
Next I
Exit Sub
LockCondition:
   J = J + 3
Return
End Sub

5. Vòng lặp Biến I nằm trong Vòng lặp của Biến I:

Sub Exam_00B()
  Dim I&
  For I = 1 To 100
    GoSub NewI
    Debug.Print I
  Next I
  Exit Sub
NewI:
  For I = I To I + 1
    If 100 Mod I = 2 Then Exit For
  Next I
Return
End Sub

Tất cả các phương thức Vòng lặp trong VBA:

Sub basic_loop_For()
'For...Next()'
Dim I As Long
For I = 0 To 1

Next I
'For Each...Next()'
Dim Ia:
For Each Ia In Array(1, 2, 3)
  Exit For
Next Ia
'Do ... Loop  ----> Endless Loop - sTop by Exit Do'
Do
  DoEvents
  If True Then Exit Do
Loop
I = 1
Do While I < 5 '(Loop If True <> Exit If False)'
  I = I + 1
  Debug.Print "Do While", I
Loop
I = 1
Do
  I = I + 1
  Debug.Print "Loop While", I
Loop While I < 5 '(Loop If True <> Exit If False)'
I = 0
Do Until I > 5 '(Loop If False <> Exit If True)'
  I = I + 1
  Debug.Print "Do Until", I
Loop
I = 0
Do
  I = I + 1
  Debug.Print "Loop Until", I
Loop Until I > 5 '(Loop If False <> Exit If True)'
'While ... Wend  -----> sTop by Condition False'
I = 0
While I <= 10
  Debug.Print "While Wend", I
  I = I + 1
Wend
End Sub

 

Cách truyền đạt của bạn là rất bài bản & thường được coi là thời thượng;
Còn cách của mình làm cho đối tương thích thú, hứng khỏi trước & chủ yếu sẽ phải tự học sau này các món truyền thống đó thôi!
Rất cám ơn bạn nhiều vì những bài viết rất bổ ích trong loạt bài đăng này!

 

Vì đây chỉ là "bài tập" cho nên tôi không muốn đi sâu gì nhiều.

Muốn nói về lý thuyết vòng lặp thì khá dài, vì đầu tiên là phải phân loại:
1. Loại vòng lặp xác định vật thể để đếm hoặc để duyệt (vòng lặp For-Next)
2. Loại vòng lặp không xác định, chủ yếu là để lặp lại một đoạn code (vòng lặp Do-Loop [while/until], While-Wend]

1. Loại xác định thì chia ra hai loại là loại For biến=[Trị Đầu] To [Trị Cuối] (*) và loại For Each [variant] In [Collection]
(a) Loại For Each là ngôn ngữ tương đối mới cho nên khá chuẩn.
(b) Loại For biến = ... To ...là loại cổ điển, đây là loại cần đào sâu thêm về tính chất, bởi vì mỗi ngôn ngữ có thể theo tiêu chuẩn khác nhau.
Điều này tôi đã đề cập vài lần trong các thớt liên quan đến sử dụng vòng lập cấp cao.

2. Loại Do-Loop [While/Until (biểu thức điều kiện)] là kinh điển lý thuyết vòng lặp thô. Nó tự giải thích (**)

Chú thích:
(*) For biến=[Trị Đầu] To [Trị Cuối] nó có kỹ thuật cao về biến.

(**) cần để ý là kiểu code sau đây bảo đảm vòng lặp chạy ít nhất 1 lần. Các kiểu khác chưa chắc bảo đảm.
Do
(code ở đây)
Loop While/Until (điều kiện)

(***) While/Until : chỉ là điều kiện nghịch nhau. Cùng mọt trị biểu thức điều kiện. Dùng cái nào tuỳ theo tình trạng điều kiện nào đọc dễ hiểu hơn.

(****) While-Wend là loại code cổ lắm rồi. Không cần biết tới nữa. Những gì While-Wend làm được Do While-Loop đều làm được và nhiều hơn.

(*****) có kiểu lặp code cổ hơn một bậc. Đó là kiểu dùng goto để vòng ngược lại một label đã được cho trước. Cũng như While-Wend những gì nó làm được Do-Loop While đều làm được và nhiều hơn.
Label: code BASIC đời mới lập không có label, và mỗi câu lệnh phải được xác định bằng một con số dòng, ngừoi ta dùng số dòng này để Goto

 

*Nhân tiện vô đây viết bài mới, chúc mừng Bác SA_DQ, bài viết đã được vào "hiệu sách".

Hôm trước đăng bài lại quên những cơ chế vòng lặp khác, hôm nay xin củng cố thêm kiến thức về vòng lặp không sử dụng For, Do, While.
Các bạn có thể xem lại bài trước tại đây

I. Vòng lặp sử dụng GoTo:
*Điều quan trọng với GoTo kết hợp GoSub: Thuộc cấp lập trình "Siêu cao", khó bị đánh cắp mã.
Vì sao vậy? Đơn giản là vì cấu trúc GoTo và GoSub quá khó để đọc, nếu có đến hàng 100 nhánh đi kèm thuật toán ma trận rẽ nhánh.

1. Gợi nhớ lại kiến thức về GoTo: GoTo là một phương thức rẽ nhánh vô điều kiện. Sử dụng GoTo sẽ đi đến một phân nhánh trong cùng một thủ tục được khai báo ở đầu dòng là một số nguyên hoặc một khai báo như tên biến kèm dấu hai chấm ":" , và GoTo không thể đi từ ngoài vào trong nhánh một thủ tục Con (Thủ tục con GoSub là gì? ở cuối bài).
Cấu trúc:
+ GoTo <đích >
+ On <biểu thức > GoTo <đích>

Sub VongLap_GoTo()
    Dim K%:
    K = 1
    'On K GoTo 2
    'On K GoTo 1, 2, 3, 4, Goto2
    GoTo 1
Goto1: K = K + 1
1  K = K + 1
2  K = K + 1
3  K = K + 1
4  K = K + 1
Goto2: K = K + 1
Debug.Print K
End Sub

2. Vòng lặp sử dụng GoTo

Sub VongLap_GoTo()
  Dim K%
Lap1:
  K = K + 1
  If K > 10 Then GoTo Lap2
GoTo Lap1
Lap2:
  K = K + 1
  If K > 20 Then GoTo Lap3
GoTo Lap2
Lap3:
  If K > 30 Then GoTo Het
GoTo Lap3
Het:
End Sub

II. Vòng lặp do Lỗi:

Sub VongLap_GoTo_Error()
  Dim K%, N, I
  N = -10
On Error GoTo Lap1
  I = -N / K
Exit Sub
Lap1:
  N = N + 1
  K = IIf(N < 0, 0, N)
  Debug.Print N
  Err.Clear
  Resume
End Sub

====================================



====================================

*Thủ tục con: Gồm 1 hoặc nhiều khai báo như tên biến kèm dấu hai chấm ":" nằm ở đầu dòng Code,miễn sao kết thúc khối lệnh này là return. Tất cả các Thủ tục con luôn luôn nằm trong một thủ tục và nằm sau một Khai báo kết thúc Thủ tục chính (Như Exit Sub , Exit Function, ...).
GoTo Chỉ có thể rẽ nhánh từ trong rẽ trong nhánh hoặc ra ngoài Nhánh GoSub. GoTo không thể từ ngoài rẽ vào nhánh GoSub.
Cấu trúc:
+ GoSub <đích >
+ On <biểu thức > GoSub <đích>

Ví dụ:

Sub VongLap_GoTo()
   Dim K%
    GoSub SubConLaDay1
    GoSub SubConLaDay2
    GoSub SubConLaDay3

    GoTo GoToODaySeDuoc
Exit Sub
SubConLaDay1:
    GoTo SubConLaDay3
SubConLaDay2:
SubConLaDay3:
  K = K + 1
  Debug.Rpint K
  If True Then Return
Return
GoToODaySeDuoc:

End Sub

Tags: vòng lặp goto, gosub, resume next, on error

 

Dân lập trình "siêu cao" thì chỉ muốn trao đổi chứ đâu lại muốn "khó bị đánh cắp mã"? Chả nhẽ "siêu cao" đi đôi với "siêu ích kỷ"?
Viết code khó đọc đồng thời cũng có nghĩa là đi trái với đường lối "reusable code" (code viết một lần, dùng nhiều lần)

Từ thuở biết nói chuyện lập trình đến nay, mình chỉ nghe nói "viết sao cho dễ đọc". Đây là lần đầu tiên được mở mắt với chính sách "viết cho khó đọc".

 

Trước đây được biết về vòng lặp không thấy nói đến vòng lặp goto hay là go...
Nếu goto cũng gọi là vòng lặp thì đệ quy có thể gọi là 1 kiểu vòng lặp?

 

Dân lập trình "siêu cao" thì chỉ muốn trao đổi chứ đâu lại muốn "khó bị đánh cắp mã"? Chả nhẽ "siêu cao" đi đôi với "siêu ích kỷ"?
Viết code khó đọc đồng thời cũng có nghĩa là đi trái với đường lối "reusable code" (code viết một lần, dùng nhiều lần)

Từ thuở biết nói chuyện lập trình đến nay, mình chỉ nghe nói "viết sao cho dễ đọc". Đây là lần đầu tiên được mở mắt với chính sách "viết cho khó đọc".

Bài viết đâu có đoạn "khuyến khích các bạn nên siêu ích kỷ"

 

Dân lập trình "siêu cao" thì chỉ muốn trao đổi chứ đâu lại muốn "khó bị đánh cắp mã"? Chả nhẽ "siêu cao" đi đôi với "siêu ích kỷ"?
Viết code khó đọc đồng thời cũng có nghĩa là đi trái với đường lối "reusable code" (code viết một lần, dùng nhiều lần)

Từ thuở biết nói chuyện lập trình đến nay, mình chỉ nghe nói "viết sao cho dễ đọc". Đây là lần đầu tiên được mở mắt với chính sách "viết cho khó đọc".

Dùng vòng lặp hay viết code cho dễ đọc chỉ dành cho các đối tượng "hạng xoàng" như anh Vetmini thôi. Cấp độ "siêu cao" ưu việt hơn nhiều, tư duy và cách viết code phải khác biệt giữa đám đông. Anh Vetmini nên cố gắng tiếp thu và học tập tư duy "vòng lặp siêu cấp" để tiệm cận được cấp độ "siêu cao" nhé.

 

Trước đây được biết về vòng lặp không thấy nói đến vòng lặp goto hay là go...
Nếu goto cũng gọi là vòng lặp thì đệ quy có thể gọi là 1 kiểu vòng lặp?

Goto là một hình thức để thực hiện vòng lặp không có cấu trúc.
Định nghĩa cấu trúc trong ngữ cảnh vòng lặp:
Loại vòng lặp có cấu trúc được ngôn ngữ quy định cho nên chúng cũng có sự chặt chẽ của chúng. Điển hình là giới hạn (boundary) và phạm vi (scope) vòng lặp được xác định rõ rệt. Giới hạn: vòng lặp có đầu và đuôi (điển hình đầu For, đuôi Next), ở giữa là một nhóm code (block). Phạm vi: hai vòng lặp chỉ có thể chứa nhau chứ không thể móc vào nhau. Chính trình dịch sẽ kiểm soát hai luật này, không cho vi phạm.
Loại vòng lặp không cấu trúc hoàn toàn không có sự kiểm soát của trình dịch. Muốn mấy đầu mấy đuôi đều chả ai cản được. Muốn vòng chỗ nào thì vòng. Muốn móc chỗ nào thì móc.

Tuy nhiên, GoSub mà bảo làm vòng lặp thì gượng ép quá. GoSub là một lệnh cổ, thời ngôn ngữ chưa được cấu trúc hoá. Người ta bây giờ chỉ dùng nó làm một xảo thuật để lặp lại một nhóm code (lưu ý là từ "lặp" thì đúng, nhưng "vòng" thì gượng ép).
Nhiều người vẫn thích dùng GoSub vì có hai lý do:
1. cái "sub" mà GoSub nhảy vào vẫn còn nằm trọn trong Sub mẹ cho nên chia sẻ cùng tầm vực biến với Sub mẹ. Như vậy khỏi mất công truyền tham số mà vẫn tránh không phải dùng biến toàn cục. Lưu ý là cũng như biến toàn cục, được cái lợi chia biến thì cũng mang cái hại là khó kiểm soát biến.
2. khi GoSub thì VBA chỉ phải chép địa chỉ "Return" vào stack, không phải làm mấy thủ tục khác như khi Call cho nên GoSub nhanh hơn Call.

Kết luận: Goto và GoSub là loại lệnh nhảy của code mỳ Ý (gú gô từ khoá spaghetti code). Trường phái chung chung viết code có cấu trúc không dùng.
Người dùng hai lệnh Goto/GoSub này thuộc về hai hạng:
a. viết code cẩu thả, không nắm vững cấu trúc.
b. viết code rất giỏi (vì vậy mới có cái chuyện tự phong "siêu cao" [sic] ở trên), và không màng tới cấu trúc. Tuy nhiên, họ tự có một số quy luật riêng để theo. Không có số quy luật này thì chắc chắn sẽ bị:
i) không kiểm soát được biến, không kiểm soát được các đường rẽ nhánh.
ii) vài tháng sau, đọc lại code sẽ chẳng hiểu mình viết gì.

Dùng vòng lặp hay viết code cho dễ đọc chỉ dành cho các đối tượng "hạng xoàng" như anh Vetmini thôi. Cấp độ "siêu cao" ưu việt hơn nhiều, tư duy và cách viết code phải khác biệt giữa đám đông. Anh Vetmini nên cố gắng tiếp thu và học tập tư duy "vòng lặp siêu cấp" để tiệm cận được cấp độ "siêu cao" nhé.

Ở môi trường tôi, người ta tính tiền công theo các Tiêu Chí Vận Hành (Functional Benchmarks) của code. Code "viết cho khó đọc" thì bên nghiệm thu họ lấy gì nghiệm thu mà trả tiền?
Chuyện code bị đánh cắp là chuyện của bên nhận code. Mấy chục năm làm việc với họ, tôi chưa hề nhận một hợp đồng nào có tiêu chí "code khó bị đánh cắp".
Chức vị "siêu cao" nhường cho mấy người muốn ngồi trên bục thờ đi. Tôi còn trần tục lắm, vẫn cần cơm ăn áo mặc.
Thực ra lúc về sau này tôi làm bên nghiệm thu nhiều hơn bên viết code. Code viết không chú thích đầy đủ là tôi xổ toẹt. Mấy thằng lập trình đống code bên Xi Lợt Lợt hoặc Ê Ét Em thì chỉ làm khổ xếp chúng (thằng Xi Nho) thôi. Tôi bắt thằng trưởng nhóm phải viết lại cái pseudo-code, và bảo đảm là code bên trong thực sự như vậy trước khi nghiệm thu.

 

Trước đây được biết về vòng lặp không thấy nói đến vòng lặp goto hay là go...
Nếu goto cũng gọi là vòng lặp thì đệ quy có thể gọi là 1 kiểu vòng lặp?

Nếu tư duy của bạn cao hơn bạn sẽ hiểu "lặp là gì".
Goto có thể lặp vô tận tương tự vòng Do, bởi vì goto là phương thức rẻ nhánh vô điều kiện, vòng for kết thúc ở giá trị cuối cùng, vòng while kết thúc ở giá trị false.
Goto , for, do, while đều gửi vào vùng nhớ tương tự nhau, nhưng for , do, while, có điều kiện để nhảy ra khỏi vùng nhớ đó. Trong khi Goto có thể đi đến bất kì vùng nhớ nào trong một Block không khóa. Còn bạn nghe theo Bác Vietmicritiki kia thì bạn theo bác ấy. Còn tôi chỉ mang cái biết của tôi trao cho người đọc. Còn chuyện phản bát chỉ là cái "tôi có mục đích".

 

nói chung cách hoạt động của mấy ngôn ngữ cấp cao thì cũng phải dựa vào nền tảng tập lệnh của vi xử lý , trong tập lệnh của vi xử lý muốn lặp lại 1 khối lệnh chỉ có hàm jump thoai , chắc đó là lý do mấy ngôn ngữ cấp cao giữ lại lệnh này , đệ quy cũng là cách lặp lại , tập lệnh vi xử lý có hỗ trợ , nhưng nó không lặp lại 1 khối lệnh , mà gọi ra 1 khối lệnh khác , nên nếu gọi nhiều quá sẽ tràn bộ đệm !

 

Nếu tư duy của bạn cao hơn bạn sẽ hiểu "lặp là gì".
Goto có thể lặp vô tận tương tự vòng Do, bởi vì goto là phương thức rẻ nhánh vô điều kiện, vòng for kết thúc ở giá trị cuối cùng, vòng while kết thúc ở giá trị false.
Goto , for, do, while đều gửi vào vùng nhớ tương tự nhau, nhưng for , do, while, có điều kiện để nhảy ra khỏi vùng nhớ đó. Trong khi Goto có thể đi đến bất kì vùng nhớ nào trong một Block không khóa. Còn bạn nghe theo Bác Vietmicritiki kia thì bạn theo bác ấy. Còn tôi chỉ mang cái biết của tôi trao cho người đọc. Còn chuyện phản bát chỉ là cái "tôi có mục đích".

Tôi có chính kiến của mình, bạn nghĩ thế nào thì tùy, không quan trọng.
Việc tham gia viết bài vào thớt này là để trao đổi kiến thức, không khẳng định tôi ta gì hết bạn.

"Nếu tư duy của bạn cao hơn bạn sẽ hiểu "lặp là gì". Về điều này thì tôi thấy tư duy của bạn tốt đấy, cứ dùng go... mà "lặp" nhé.

 

Nếu tư duy của bạn cao hơn bạn sẽ hiểu "lặp là gì".
Goto có thể lặp vô tận tương tự vòng Do, bởi vì goto là phương thức rẻ nhánh vô điều kiện, vòng for kết thúc ở giá trị cuối cùng, vòng while kết thúc ở giá trị false.
Goto , for, do, while đều gửi vào vùng nhớ tương tự nhau, nhưng for , do, while, có điều kiện để nhảy ra khỏi vùng nhớ đó. Trong khi Goto có thể đi đến bất kì vùng nhớ nào trong một Block không khóa. Còn bạn nghe theo Bác Vietmicritiki kia thì bạn theo bác ấy. Còn tôi chỉ mang cái biết của tôi trao cho người đọc. Còn chuyện phản bát chỉ là cái "tôi có mục đích".

Nhờ bạn tư duy xem đây có được gọi là lặp?
Chẳng có go, chẳng có for next, do...loop...

Dim i
Sub VLap1(i)
If i = 0 Then
    i = 1
Else
    i = 0
End If
VLap2 (i)
End Sub
Sub VLap2(i)
If i = 0 Then
    i = 1
Else
    i = 0
End If
VLap1 (i)
End Sub
Sub A()
Call VLap1(i)
End Sub

 

Nhờ bạn tư duy xem đây có được gọi là lặp?
Chẳng có go, chẳng có for next, do...loop...

Dim i
Sub VLap1(i)
If i = 0 Then
    i = 1
Else
    i = 0
End If
VLap2 (i)
End Sub
Sub VLap2(i)
If i = 0 Then
    i = 1
Else
    i = 0
End If
VLap1 (i)
End Sub
Sub A()
Call VLap1(i)
End Sub

"Go lặp", tôi có đăng duy nhất một bài Go lặp. "Phí lời". Đệ quy suy ra "lặp" phí lời.

 

Đã nói từ bài GoTo chuyển nhánh vô điều kiện tạo nên cơ chế lặp vô điều kiện, mà bác Vietmicritini bày "đủ trò". Toàn "ngồi không phách đốc". Tôi gọi bác "Vietmicritini" là ẩn ý của chính tôi, thực ra chẳng tồn tại. Bác chẳng hiểu cái câu khởi đầu của người ta viết, bác chẳng hiểu cái gọi là truyền kiến thức, chỉ mang cái nhỏ lẻ không tương xứng ra mò mẩm, giống như nồi cơm chỉ có một phần cơm cháy mà đem ra phân tích giống như Nhà khoa học xuất hiện như đấng cứu thế. Thực ra chỉ là "kẻ phá hoại".
"Vietmicritini - kẻ rên khóc"

 

nói chung cách hoạt động của mấy ngôn ngữ cấp cao thì cũng phải dựa vào nền tảng tập lệnh của vi xử lý , trong tập lệnh của vi xử lý muốn lặp lại 1 khối lệnh chỉ có hàm jump thoai , chắc đó là lý do mấy ngôn ngữ cấp cao giữ lại lệnh này , ...

Hiểu chết liền.
Ở đây tôi đang giải thích về sự khác biệt giữa cách viết code có cấu trúc và không cấu trúc.
Khi trình dịch đọc đến từ khoá FOR thì nó biết đây là mở đầu một vòng lặp, và nó tự biết rằng đến từ khoá NEXT gần nhất thì khẳng định đó là kết vòng lặp ấy. Nếu trước khi gặp NEXT mà gặp một FOR khác thì nó tự biết là cái FOR trước phải bọc ngoài cái FOR này. Đó là có cấu trúc.
Mặt khác, khi trình dịch đọc một cái Label thì nó chỉ biết đó là một cái địa chỉ (lưu ý: không phải từ khoá). Một lúc sau, khi đọc đến từ khoá GOTO <Label> thì nó cũng chỉ biết đấy là lệnh nhảy về cái địa chỉ kia. Tuy đối với người viết code, vòng ngược trở về thì có thể coi như vòng lặp, nhưng đối với trình dịch, nó không hề quan tâm đến chuyện đó (có muốn quan tâm cũng chẳng được). Đó là vòng lặp không cấu trúc.
Tóm lại, vòng lặp có cấu trúc được trình dịch kiểm soát. Vòng lặp không cấu trúc không được trình dịch kiểm soát vì chả có cách nào để nó kiểm soát cả.
GOSUB cũng tương tự như vậy. Cái thủ tục con này không bắt buộc phải bó trọn một nhóm code trong từ khoá mở đầu và từ khoá kết thúc. GOSUB <Label> đối với trình dịch chỉ là nhảy đến cái địa chỉ Label, cộng thêm một điều kiện là khi gặp lệnh RETURN thì quay trở về tiếp tục ở lệnh kế tiếp GOSUB. Theo nguyên tắc trình dịch thì đây là hình thức thủ tục con không cấu trúc.
(Thủ tục con có cấu trúc được xác định rõ rệt tầm vực là vùng giữa từ khoá SUB và từ khoá END SUB)

 

"Go lặp", tôi có đăng duy nhất một bài Go lặp. "Phí lời". Đệ quy suy ra "lặp" phí lời.

Có gì phí lời đâu bạn. Nhờ bạn mà tôi biết thêm tên gọi "lặp" mới đấy

 

Bây giờ đến lúc đem tiếng Anh ra bày trò nữa đây.
Hồi nào giờ chỉ biết vài ngôn ngữ có kỹ thuật "name mangling", điển hình để xử lý tên hàm. Bi giờ mới thấy kỹ thuật này được đem ra dùng để khoe tiếng ngoại.

 

Trong khi bài viết Bác SA_DQ đăng để học hỏi, thì toàn những "Kẻ Sĩ" đăng những bài "Xàm xí" làm cho những lớp mầm non muốn học hỏi cũng phải bị lây nhiễm "Triết lý phá hoại", thậm chí một bài viết xây dựng, đóng góp cũng không có. Cái nôi của học tập "nằm ở những kẻ này chăng". Thực là "Chân tài thực học" thì thêm bài đóng góp. Cứ "Quăng" cái bài của mình lên xem như mình là "Kẻ soi sáng văn minh nhân loại". Cứ như mình là người sáng tạo cái "Triết lí xã hội". Tài thì lấy cái tài của mình ra đóng góp. "Nhân văn" còn chưa nắm vững thì lấy đâu "cái trí đối nhân xử thế".

Đọc bài viết thì đọc thiếu trước hụt sau. Rồi phán "như thẩm phán Hollywood".

 

Đệ tử của Pythagoras luận tội Hippasus