求解不等式算法

cujeson

回復(fù) 17# rubyish


只能?chē)@為觀(guān)止了，還是看不明白，尤其是嵌套try那里，還是感謝大神，大半夜還給我解答。

jzp520520

回復(fù) 20# jason680


    真是大牛！你與rubyish的寫(xiě)法最大不同之處在于：沒(méi)有使用map。是不是map對(duì)perl占用太大？
rubyish的寫(xiě)的非常精練，很酷！對(duì)我們新手來(lái)說(shuō)，還是不太懂。

stanley_tam

湊個(gè)熱鬧，這么多行，應(yīng)該能看得懂些把{:3_188:}

1. #!perl
   
2. package Cut;
   
3. use v5.12;
   
4. use warnings;
   
5. use Moose;
   
6. use List::Util qw {max min sum};
   
7. 
   
8. has 'sizes' => (
   
9.         is => 'rw',
   
10.         isa => 'ArrayRef',
    
11.         reader => 'get_sizes',
    
12.         writer => 'set_sizes',
    
13.         default => sub { [] },
    
14.         auto_deref => 1,
    
15.         required => 1,
    
16. );
    
17. 
    
18. has 'len' => (
    
19.         is => 'ro',
    
20.         isa => 'Num',
    
21.         reader => 'get_len',
    
22.         default => '10',
    
23.         required => 1,
    
24. );
    
25. 
    
26. sub min_cut_times {
    
27.         # not accurate....
    
28.         my ($self) = @_;
    
29.         my $max_size = max $self->get_sizes;
    
30.         return int ($self->get_len / $max_size);
    
31. }
    
32. 
    
33. sub max_cut_times {
    
34.         my ($self) = @_;
    
35.         my $max_size = min $self->get_sizes;
    
36.         return int ($self->get_len / $max_size);
    
37. }
    
38. 
    
39. sub possible_cut_times {
    
40.         my ($self) = @_;
    
41.         my $times_aref = [];
    
42.         my $pieces = @{$self->get_sizes};
    
43.         my $max_cut_times = $self->max_cut_times;
    
44.         my $min_cut_times = $self->min_cut_times;
    
45. 
    
46.         my $enumerate_max = join ',', 0 .. $max_cut_times;
    
47.         my $eval_str = '{$enumerate_max}:' x ($pieces-1) . '{$enumerate_max}';
    
48.         $eval_str = q{"} . $eval_str . q{"};
    
49. 
    
50.         my @possibles = glob eval $eval_str;
    
51. 
    
52.         for my $num (@possibles){
    
53.                 my @nums = split /:/, $num;
    
54.                 my $sum_of_nums = sum @nums;
    
55.                 if ($sum_of_nums <= $max_cut_times and $sum_of_nums >= $min_cut_times) {
    
56.                         push @{$times_aref}, \@nums;
    
57.                 }
    
58.         }
    
59. 
    
60.         return $times_aref;
    
61. }
    
62. 
    
63. no Moose;
    
64. 
    
65. 1;
    
66. 
    
67. package main;
    
68. use v5.12;
    
69. use warnings;
    
70. 
    
71. my $cut = Cut->new;
    
72. 
    
73. # define your sizes here
    
74. $cut->set_sizes([1.9, 2.5, 2.6]);
    
75. 
    
76. my @sizes = $cut->get_sizes;
    
77. my $times_aref = $cut->possible_cut_times;
    
78. 
    
79. say join "\t", ('sum', 'remain', @sizes);
    
80. for my $time_aref (@{$times_aref}){
    
81.         my $sum = 0;
    
82. 
    
83.         for my $i (0 .. $#sizes){
    
84.                 $sum += $sizes[$i] * $time_aref->[$i];
    
85.         }
    
86. 
    
87.         if ($sum > 8.1 and $sum <= 10) {
    
88.                 # body...
    
89.                 my $remain = $cut->get_len - $sum;
    
90.                 $remain = sprintf "%0.2f", $remain;
    
91.                 say join "\t", ($sum, $remain, @{$time_aref});
    
92.         }
    
93. }
    
94. 
    
95. __END__

復(fù)制代碼

rubyish

回復(fù) 20# jason680

3Q~ very fast!!

1. return if($sDiff < 0);

復(fù)制代碼

rubyish

回復(fù) 23# stanley_tam

不懂 Moose, 先收藏，再慢慢研究，謝謝了。{:3_188:} {:3_188:}
   

rubyish

回復(fù) 19# kggg

不是
   

rubyish

感謝 jason680   
my fast version:

1. #!/usr/bin/perl
   
2. 
   
3. my $length = 10;
   
4. my $count = '001';
   
5. my @data = sort { $b <=> $a }
   
6.   qw/2.5 2.6 1.9 3.5 2.0 4.0 4.5 5 4.7 3.2/;
   
7. 
   
8. print ' ' x 6, join( "\t", 'sum', 'rem', @data ), $/;
   
9. print $count++, '| ', join( "\t", @$_ ), $/
   
10.   for sort { $b->[0] <=> $a->[0] } collect();
    
11. 
    
12. sub collect {
    
13.     my ( $max, $check, $t, $i ) = ( $length - $data[-1], 1, 1, -1 );
    
14.     my @range = map [ 0 .. $length / $_ ], @data;
    
15.     my @elem  = map { $check *= @$_; scalar @$_ } @range;
    
16.     my @step  = reverse 1, map { $t = $t * $elem[ -$_ ] } 1 .. $#elem;
    
17.     my @collection;
    
18. 
    
19.     while ( $i++ < $check ) {
    
20.         my @num = map $range[$_][ $i / $step[$_] % $elem[$_] ], 0 .. $#elem;
    
21.         my $sum;
    
22. 
    
23.         for my $index ( 0 .. $#elem ) {
    
24.             $sum += $data[$index] * $num[$index];
    
25.             next if $sum <= $length;
    
26.             my $jump = ( $elem[$index] - $num[$index] ) * $step[$index];
    
27.             $jump > 1 and $i += $jump - 1;
    
28.             last;
    
29.         }
    
30. 
    
31.         $length >= $sum && $sum > $max and push @collection,
    
32.           [ sprintf( "%.1f", $sum ), sprintf( "%.2f", $length - $sum ), @num ];
    
33.     }
    
34.     @collection;
    
35. }

復(fù)制代碼

jason680

回復(fù) 22# jzp520520

It's NOT map function issue in this case
   

stanley_tam

我的是super slow version，尤其是塊數(shù)大于6塊的時(shí)候。哈哈{:3_198:}
回復(fù) 25# rubyish


   

104359176

回復(fù) 12# rubyish


    代碼很難看懂，更加不會(huì)調(diào)優(yōu)了。