एक सरणी

Question

मैं नीचे की तरह एक सरणी संदर्भ में तत्वों से संयोजन तैयार करें:

my $output = [qw(qw([a],[b],[c],[d],[a,b],[a,c],[a,d],[b,c],[b,d],[c,d], [a,b,c],[a,b,d],[b,c,d],[a,b,c,d]))] 

मैं क्या करने की कोशिश की:

my $strings = [qw(a b c d)]; 

मैं हर संभव संयोजन के रूप में और के रूप में देता है की एक सरणी बनाना चाहते हैं :

foreach my $n(1..scalar(@array)) { 
    my $iter = combinations($strings, $n); 
    while (my $c = $iter->next) { 
     print "@$c\n"; 
    } 
} 

Answer 1

सभी संयोजनों को खोजने के लिए Algorithm::Combinatorics का उपयोग करना।

#!/#!/usr/bin/perl 
use strict; 
use warnings; 
use Data::Dumper; 
use Algorithm::Combinatorics qw(combinations); 
my @data = qw(a b c d); 
my $all_combinations; 
foreach (1..4){ 
    push @$all_combinations, combinations(\@data, $_); 
} 
print Dumper $all_combinations; 

आउटपुट:

$VAR1 = [ 
      [ 
      'a' 
      ], 
      [ 
      'b' 
      ], 
      [ 
      'c' 
      ], 
      [ 
      'd' 
      ], 
      [ 
      'a', 
      'b' 
      ], 
      [ 
      'a', 
      'c' 
      ], 
      [ 
      'a', 
      'd' 
      ], 
      [ 
      'b', 
      'c' 
      ], 
      [ 
      'b', 
      'd' 
      ], 
      [ 
      'c', 
      'd' 
      ], 
      [ 
      'a', 
      'b', 
      'c' 
      ], 
      [ 
      'a', 
      'b', 
      'd' 
      ], 
      [ 
      'a', 
      'c', 
      'd' 
      ], 
      [ 
      'b', 
      'c', 
      'd' 
      ], 
      [ 
      'a', 
      'b', 
      'c', 
      'd' 
      ] 
     ]; 

---

Answer 2

आपने मॉड्यूल "एल्गोरिथ्म :: संयोजन विज्ञान"

use Algorithm::Combinatorics "variations_with_repetition"; 
my @Variations = variations_with_repetition([qw(a b c d)], 4); 
print "@$_\n", for @Variations; 

Answer 3

वहाँ Math::Combinatorics है उपयोग कर सकते हैं।

#!/usr/bin/perl 
use strict; 
use warnings; 
use Math::Combinatorics qw(combine); 
use Data::Dumper; 

my @n = qw(a b c d); 
my @res; 
push @res, combine($_, @n) foreach (0..@n); 
print Dumper(\@res); 

आउटपुट:

$VAR1 = [ 
      [ 
      'b' 
      ], 
      [ 
      'c' 
      ], 
      [ 
      'a' 
      ], 
      [ 
      'd' 
      ], 
      [ 
      'c', 
      'a' 
      ], 
      [ 
      'c', 
      'd' 
      ], 
      [ 
      'c', 
      'b' 
      ], 
      [ 
      'a', 
      'd' 
      ], 
      [ 
      'a', 
      'b' 
      ], 
      [ 
      'd', 
      'b' 
      ], 
      [ 
      'b', 
      'a', 
      'd' 
      ], 
      [ 
      'b', 
      'a', 
      'c' 
      ], 
      [ 
      'b', 
      'd', 
      'c' 
      ], 
      [ 
      'a', 
      'd', 
      'c' 
      ], 
      [ 
      'b', 
      'c', 
      'd', 
      'a' 
      ] 
     ]; 

Answer 4

आप हाथ में मॉड्यूल की जरूरत नहीं है, और आप बाहरी स्तर आदेश के बारे में परवाह नहीं है: @output की

sub fu { 
    my ($base,@rest) = @_; 
    my @result = @$base && $base ||(); 
    push @result, fu([@$base, shift @rest], @rest) while @rest; 
    return @result; 
} 
my @output = fu([],qw(a b c d)); 

सामग्री:

[["a"],["a","b"],["a","b","c"],["a","b","c","d"],["a","b","d"],["a","c"],["a","c","d"],["a","d"],["b"],["b","c"],["b","c","d"],["b","d"],["c"],["c","d"],["d"]]