एन नोड्स के साथ सभी बाइनरी पेड़ों की गणना करें

Question

पूर्णांक एन को देखते हुए, एन आंतरिक नोड्स के साथ सभी संभव पूर्ण बाइनरी पेड़ों की गणना करें। (पूर्ण बाइनरी पेड़ों में प्रत्येक आंतरिक नोड पर ठीक 2 बच्चे हैं)। पेड़ की संरचना एक आंतरिक नोड का प्रतिनिधित्व करने वाले 1 के साथ पेड़ के पूर्व-क्रम ट्रैवर्सल के रूप में आउटपुट होनी चाहिए, और 0 एक बाहरी नोड (नल) का प्रतिनिधित्व करता है।

यहाँ पहले कुछ n के लिए उदाहरण दिए गए हैं:

0:
0

1:
100

2:
11000
10100

3:
1,110,000
1,101,000
1,100,100
1,011,000
1010100

यह एक कोड गोल्फ है जिसमें सबसे कम पात्रों को पुरस्कार दिया जाता है। पेड़ों को स्टैडआउट करने के लिए प्रति पंक्ति एक आउटपुट होना चाहिए। कार्यक्रम को कमांडलाइन या स्टडिन से एन पढ़ा जाना चाहिए।

Comments

मैं उस समस्या के बारे में सोच रहा था जब मैं एक भूलभुलैया जैसी लेखन प्रणाली बनाने की कोशिश कर रहा था

— मिंग-तांग

समाधान घोषित करने से पहले मानक समय सीमा क्या है?

— काइल बट

क्या इस समस्या की थोड़ी भिन्नता करने में कोई दिलचस्पी होगी, जहां आउटपुट को आदेश देने की आवश्यकता थी, और स्ट्रीमिंग?

— काइल बट

@ काइल बट बस मेरी राय है, लेकिन मुझे नहीं लगता कि मुझे दिलचस्पी होगी। मेरे लिए, इन समस्याओं के साथ मस्ती का हिस्सा वैकल्पिक तरीकों की कोशिश कर रहा है, और एक निश्चित आदेश की आवश्यकता होती है, जो व्यवहार्य एल्गोरिदम की संख्या को सीमित करेगा।

— मिगिमारू

Answer 1

पर्ल - 125 79 चार्ट

गणना में " -ln" विकल्पों के लिए 4 वर्ण शामिल हैं। स्टड से n लेता है।

नया रचनात्मक दृष्टिकोण:

@a=0;map{%a=();map{$a{"$`100$'"}=1while/0/g;}@a;@a=keys%a}1..$_;print for@a

N के लिए समाधान से प्रत्येक पेड़ में प्रत्येक पत्ती ("0") के बदले में एक नया आंतरिक नोड ("100"), प्रत्येक पत्ती में "n" के लिए समाधान का रूप दें।

(मैं इस अवधारणा को अन्य समाधानों के लिए मानता हूं जो आंतरिक नोड को पत्ती के लिए उपयोग करते हैं [100-> 0] क्रमिक रूप से उत्पन्न तारों के सत्यापन के लिए प्रतिस्थापन, और मुझे विश्वास है कि मैंने देखा - उस अवधारणा के आधार पर अपना उत्तर लिखने के बाद - यह वही है - 0- > किसी के मध्यवर्ती संपादन में निर्माण की 100 विधि।)

पिछला पुनरावर्ती दृष्टिकोण:

sub t{my$n=shift;if($n){--$n;for$R(0..$n){for$r(t($R)){for$l(t($n-$R)){push@_,"1$l$r"}}}}else{push@_,"0"}@_}print for t$_

पुनरावर्ती अपराजित:

sub tree {
  my ($n) = @_;
  my @result = ();
  if ( $n ) {
    for $right_count ( 0 .. $n-1 ) {
      for $right ( tree( $right_count ) ) {
        for $left ( tree( ($n-1) - $right_count ) ) {
          push @result, "1$left$right";
        }
      }
    }
  }
  else {
    push @result, "0";
  }
  return @result;
}
foreach $tree ( tree($_) ) {
  print $tree;
}

Answer 2

PHP (142) (138) (134) (113)

कमांड लाइन से चलता है, अर्थात "php golf.php 1" आउटपुट "100"।

संपादित करें: एक वैकल्पिक विधि के साथ 4 वर्णों को काटें, $ n से नीचे की बजाए 0 से स्ट्रिंग्स का निर्माण करना। छोटा टर्नररी ऑपरेटर के लिए PHP 5.3 का उपयोग करता है; अन्यथा, 2 और पात्रों की आवश्यकता है।

EDIT 2: छोरों में कुछ बदलाव के साथ 4 और पात्रों को बचाया।

EDIT 3: मैं एक अलग दृष्टिकोण की कोशिश कर रहा था और आखिरकार मैं इसे पुराने तरीके से नीचे ले आया।

सभी पेड़ों को 4 ^ n (या 0, जब n = 0) और 2 * ^ ^ n के बीच पूर्णांक का द्विआधारी प्रतिनिधित्व माना जा सकता है। यह फ़ंक्शन उस सीमा से गुजरता है, और प्रत्येक संख्या के बाइनरी स्ट्रिंग को प्राप्त करता है, फिर "100" को "0" के साथ बदलकर बार-बार कम करता है। यदि अंतिम स्ट्रिंग "0" है, तो यह एक वैध पेड़ है, इसलिए इसे आउटपुट करें।

for($i=$p=pow(4,$argv[1])-1;$i<=2*$p;){$s=$d=decbin($i++);while($o!=$s=str_replace(100,0,$o=$s));echo$s?:"$d\n";}

Answer 3

रूबी, 99 94 92 89 87 वर्ण

(n=4**gets.to_i).times{|i|s=(n+i-1).to_s 2;t=s*1;0while s.sub!'100',?0;puts t if s==?0}

स्टड से इनपुट पढ़ा जाता है।

> echo 2 | ruby binary_trees.rb
10100
11000

संपादित 1: परिवर्तित IO (लोवेज़र की टिप्पणियाँ देखें)

b=->n{n==0?[?0]:(k=[];n.times{|z|b[z].product(b[n-1-z]){|l|k<<=?1+l*''}};k)}
puts b[gets.to_i]

संपादित 2: परिवर्तित एल्गोरिथ्म।

b=->n{n==0?[?0]:(k=[];b[n-1].map{|s|s.gsub(/0/){k<<=$`+'100'+$'}};k.uniq)}
puts b[gets.to_i]

संपादन 3: संस्करण अब तीसरा दृष्टिकोण लेता है (मिगिमारू के विचार का उपयोग करके)।

संपादित 4: फिर से दो अक्षर। मिग्मारू का शुक्रिया।

Comments

यह एक ऐसा पात्र होगा जो स्टड से इनपुट स्वीकार करने के लिए छोटा होगा।

— लोजैकर

इसके अलावा, आपको इसकी आवश्यकता नहीं है *?\n, क्योंकि putsसरणी के प्रत्येक तत्व को अपनी लाइन में प्रिंट करता है।

— लोजैकर

@Lowjacker धन्यवाद।

— हावर्ड

मैंने बस रूबी को सीखने की कोशिश करना शुरू कर दिया, लेकिन मुझे लगता है कि आप {} के बजाय {0} का उपयोग करके एक चरित्र को बचा सकते हैं। कम से कम यह नेटबीन्स में काम करता है।

— मिगिमारू

इसके अलावा, उप! यहाँ gsub के बजाय पर्याप्त है!, ताकि एक और चरित्र आप बचा सके।

— मिगिमारू

Answer 4

रूबी 1.9 (80) (79)

गैर-पुनरावर्ती, रचनात्मक दृष्टिकोण का उपयोग करना, जिसका उपयोग DCharness द्वारा किया जाता है।

संपादित करें: सहेजा गया 1 वर्ण।

s=*?0;gets.to_i.times{s.map!{|x|x.gsub(?0).map{$`+'100'+$'}}.flatten!}
puts s&s

Answer 5

हास्केल 122 वर्ण

main=do n<-readLn;mapM putStrLn$g n n
g 0 0=[['0']]
g u r|r<u||u<0=[]
g u r=do s<-[1,0];map((toEnum$s+48):)$g(u-s)(r-1+s)

चूंकि IO हैसेल में कोड का एक गैर-तुच्छ हिस्सा है, शायद कोई अन्य भाषा में इसी तरह के समाधान का उपयोग कर सकता है। यदि विकर्ण को पार किया जाता है तो अनिवार्य रूप से नीचे से ऊपर दाईं ओर नीचे की ओर एक वर्ग में चलता है। निम्नलिखित के बराबर:

module BinTreeEnum where

import Data.List
import Data.Monoid

data TStruct = NonEmpty | Empty deriving (Enum, Show)
type TreeDef = [TStruct]

printTStruct :: TStruct -> Char
printTStruct NonEmpty = '1'
printTStruct Empty = '0'

printTreeDef :: TreeDef -> String
printTreeDef = map printTStruct

enumBinTrees :: Int -> [TreeDef]
enumBinTrees n = enumBinTrees' n n where
  enumBinTrees' ups rights | rights < ups = mempty
  enumBinTrees' 0   rights = return (replicate (rights+1) Empty)
  enumBinTrees' ups rights = do
    step <- enumFrom (toEnum 0)
    let suffixes =
          case step of
            NonEmpty -> enumBinTrees' (ups - 1) rights
            Empty -> enumBinTrees' ups (rights - 1)
    suffix <- suffixes
    return (step:suffix)

mainExample = do
  print $ map printTreeDef $ enumBinTrees 4

Comments

ध्यान दें कि मैं इसे उत्तर के रूप में स्वीकार करने का इरादा नहीं करता, बस मैंने सोचा कि मैं वहाँ से बाहर टॉस करूंगा।

— काइल बट

Answer 6

गोल्फस्क्रिप्ट, 60 83

~[1,]\,{;{[:l.,,]zip{({;}{~:a;[l a<~1 0.l a)>~]}if}/}%}/{n}%

मैंने इस पर काम करने के लिए Emacs के लिए एक गोल्फस्क्रिप्ट मोड बनाया , अगर किसी की दिलचस्पी है।