0
votes

Ruby - Trier des matrices basées sur la somme et le type d'objet

J'ai une gamme de tableaux, de types d'objets variables et je souhaite extraire les tableaux du tableau de matrices si la somme des non entiers multiplié par deux est supérieure ou égale à la somme de l'ensemble de la matrice. Par exemple: xxx

comme la somme des cordes et des flotteurs sont supérieurs ou égaux à la somme des entiers.

object arrays ruby

0 commentaires

3 Réponses :

5
votes

Vous pouvez utiliser:

Array # Sélectionnez < / a> pour extraire les tableaux basés sur une condition
énumérable # grep_v < / a> pour extraire des non-entiers
Array # Somme < / a> Pour calculer les sommes (en utilisant to_f pour la conversion) xxx Vous pouvez également passer le to_f -call vers grep_v , c'est-à-dire ary.grep_v (INTEGER, &: to_f) .sum mais je préfère avoir des identiques -Calls des deux côtés.



                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Considérant que  ary.grep_v (INTEGER) .Sum (&: to_f) = ary.sum (&: to_f) - ary.grep (INTEGER) .Sum , il peut être plus efficace (en partie en partie sur la proportion de valeurs entières) pour écrire  2 * ary.grep (entier) .sum <= ary.sum (&: to_f) , bien que je ne pense pas que ce soit aussi clair ( Mais il évite que le lecteur réponde à la question: "Qu'est-ce que diable est  grep_v ?").


                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Créer un Lambda pour multiplier l'objet appelé. Nous devons convertir des chaînes aux flotteurs en tant que chaîne peut représenter entier ou flotteur. 
elements.select { |arr| arr.grep_v(Integer, &multiply).sum >= arr.map(&:to_f).reduce(:+) }

                                

                                                                    
                                    
                                    
                                        2 commentaires
                                        
                                                                                            
                                                    Je pense que la Lambda pourrait raisonnablement être réduite à  -> (x) {x.to_f * 2}  suivant le principe de typage du canard de Ruby. En ce moment, si vous dites  éléments  contenus  [[[[[[[[[[[[[[[[CODE> THE  GREP_V  collecterait le sous-réseau, puis  Multiplier  aboutirait à [12,12] cependant en ajoutant le message  to_f  une erreur serait soulevée qui semble plus conforme à l'intention du processus. Ou peut-être plus verbauly  -> (x) {x.to_r.to_f * 2}  pour gérer  string  site "1/2"                                                

                                                
                                                                                            
                                                    Correction à mon commentaire précédent  multiplier  aboutirait à  ["1", 2, "1", 2]                                                 

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                    a = elements[0]
  #=> [1, 2, "3", "4"] 
ints, non_ints = a.partition { |e| e.is_a? Integer }
  #=> [[1, 2], ["3", "4"]] 

a = elements[1]
  # => [1, "2", "3", 5] 
ints, non_ints = a.partition { |e| e.is_a? Integer }
  #=> [[1, 5], ["2", "3"]]  

                                

                                                                    
                                    
                                    
                                        0 commentaires