Mathematica: Xác định xem tất cả các số nguyên trong một danh sách có nhỏ hơn một số không?

Question

Có cách nào trong Mathematica để xác định xem tất cả các số nguyên trong một danh sách có nhỏ hơn một số đã đặt hay không. Ví dụ: nếu tôi muốn biết liệu tất cả các số trong danh sách có nhỏ hơn 10:

theList = {1, 2, 3, 10}; 
magicFunction[theList, 10]; --> returns False 

Cảm ơn sự giúp đỡ của bạn.

Answer 1

Nhìn vào số Max function cho danh sách, số này trả về số lớn nhất trong danh sách. Từ đó, bạn có thể kiểm tra xem giá trị này có nhỏ hơn một số nào đó không.

Answer 2

Đây là loại bài kiểm tra rất dễ dàng để xây dựng sử dụng 'Gấp':

magicFunction[ lst_, val_ ] := 
Fold[ ((#2 < val) && #1) &, True, lst ] 

Cụm từ '(# 2 < val)' là sự thử thách của mỗi phần tử danh sách ('# 2'). Bạn có thể đặt bất kỳ bài kiểm tra nào bạn muốn ở đây, vì vậy bạn có thể thực hiện các bài kiểm tra mạnh mẽ hơn mức có thể với một hàm có thể liệt kê như Max.

'& & # 1' sau đó kết hợp kết quả cho phần tử hiện tại của bạn với kết quả cho tất cả các phần tử trước đó.

Và 'True' là trường hợp cơ sở - kết quả cho danh sách trống.

Để xem cách nó hoạt động, bạn có thể vượt qua trong một số giá trị không xác định và xem những gì khái niệm mở rộng để:

In[10]:= magicFunction[ {a, b, c}, 10 ] 

Out[10]= c < 10 && b < 10 && a < 10 

Answer 3

Trước khi đưa ra giải pháp của tôi để cho tôi nhận xét hai giải pháp trước. Cho phép gọi giải pháp magicFunction1 của Joey Robert và giải pháp magicFunction2 của Eric.

magicFunction1 rất ngắn và thanh lịch. Những gì tôi không thích về nó là nếu tôi có một danh sách rất lớn các con số và một trong những đầu tiên đã lớn hơn 10 nó vẫn sẽ làm tất cả các công việc của việc tìm ra số lượng lớn nhất mà không cần thiết. Điều này cũng áp dụng cho magicFunction2

tôi đã phát triển hai giải pháp sau:

magicFunction3[lst_, val_] := 
Position[# < val & /@ lst, False, 1, 1] == {} 

và

magicFunction4[lst_, val_] := 
Cases[lst, x_ /; x >= val, 1, 1] == {} 

Làm một chuẩn mực tôi thấy

In[1]:= data = Table[RandomInteger[{1, 10}], {10000000}]; 

In[2]:= Timing[magicFunction1[data, 10]] 
Out[2]= {0.017551, False} 

In[2]:= Timing[magicFunction2[data, 10]] 
Out[2]= {10.0173, False} 

In[2]:= Timing[magicFunction3[data, 10]] 
Out[2]= {7.10192, False} 

In[2]:= Timing[magicFunction4[data, 10]] 
Out[2]= {0.402562, False} 

Vì vậy, câu trả lời tốt nhất của tôi là magicFunction4, nhưng tôi vẫn không biết tại sao nó chậm hơn magicFunction1. Tôi cũng bỏ qua lý do tại sao có một sự khác biệt hiệu suất lớn như vậy giữa magicFunction3 và magicFunction4.