Matematica: determina se tutti gli interi in una lista sono inferiori a un numero?

Question

Esiste un modo in Mathematica per determinare se tutti gli interi in una lista sono inferiori a un numero impostato. Per esempio se voglio sapere se tutti i numeri in una lista sono inferiori a 10:

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

Grazie per il vostro aiuto.

Answer 1

Cerca negli elenchi Max function, che restituisce il numero più grande nell'elenco. Da lì, puoi verificare se questo valore è inferiore a un certo numero.

Answer 2

Questo tipo di test è facile da costruire usando 'Fold':

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

La frase '(# 2 < val)' è il test di ciascun elemento della lista ('# 2'). Potresti inserire qualsiasi test che desideri qui, in modo che tu possa fare test più potenti di quelli che puoi con una funzione come Max.

'& & # 1' quindi combina il risultato per l'elemento corrente con il risultato per tutti gli elementi precedenti.

E 'True' è il caso base - il risultato per una lista vuota.

Per vedere come funziona, è possibile passare in alcuni valori non definiti e vedere ciò che l'espressione si espande a:

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

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

Answer 3

Prima di offrire la mia soluzione fammi commento delle due precedenti soluzioni. Chiamiamo la soluzione magica di Joey Robert magicFunction1 e la soluzione magic di Eric2.

magicFunction1 è molto breve ed elegante. Quello che non mi piace è che se ho una lista molto grande di numeri e il primo è già più grande di 10, continuerà a fare tutto il lavoro per capire il numero più grande che non è necessario. Questo vale anche per magicFunction2

ho sviluppato le seguenti due soluzioni:

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

e

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

Facendo un punto di riferimento che ho trovato

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} 

Quindi la mia risposta migliore è magicFunction4, ma ancora non so perché è più lento di magicFunction1. Ignorerò anche il motivo per cui esiste una differenza di prestazioni così grande tra magicFunction3 e magicFunction4.