आदेश देने के लिए चर समूहों के हर संयोजन को बनाएँ

Question

विनिर्देश

mचर को देखते हुए , ऑर्डर करने के लिए हर संयोजन बनाएं n। उदाहरण के लिए,

ऑर्डर करने के लिए दो चर ( aऔर b) मैपिंग का उत्पादन 1होगा:

• ए
• ख
• अब

ऑर्डर करने के लिए दो चर ( aऔर b) मैपिंग का उत्पादन 2होगा:

• ए
• एक ^२
• ख
• बी ^२
• अब
• एक ² बी
• ऐब ^२
• एक ² बी ²

ऑर्डर करने के लिए दो चर ( aऔर b) मैपिंग का उत्पादन 3होगा:

• ए
• एक ^२
• एक ^३
• ख
• बी ^२
• बी ^३
• अब
• एक ² बी
• एक ³ बी
• एक ^३ बी ^२
• ऐब ^२
• अब ^३
• एक ² बी ³
• एक ² बी ²
• ए ^३ बी ^३

मानचित्रण तीन चर (के उत्पादन a, bऔर cआदेश के लिए) 1होगा:

• ए
• ख
• सी
• अब
• बीसी
• एसी
• एबीसी

mऑर्डर करने के लिए वैरिएबल मैपिंग का आउटपुट nहोगा:

• आदि।

जीतनी बिटिया

ऊपर उल्लिखित के रूप में हर संभव संयोजन आउटपुट। आदेश मायने नहीं रखता। आपके कोड में आप स्क्रीन पर कहां प्रिंट करते हैं, इससे कोई फर्क नहीं पड़ता। यह सब मायने रखता है कि आपके आउटपुट में जो दिखता है वह सही है।

Comments

हम आउटपुट के लिए कैसे हैं? क्या हमें उपयोग करना चाहिए ^?

— तदर्थ गार्फ हंटर

क्या हम चीजों को शून्य या एक (उदाहरण के लिए ^ 1)

— एड हॉक गार्फ हंटर

क्या होगा यदि m26 से अधिक है? क्या हमें उच्च मूल्यों का समर्थन करना है?

— तदर्थ गार्फ हंटर

@ user1873073 यह समस्या अधिकतम क्रम नहीं बल्कि चर नामों की अधिकतम संख्या है।

— मार्टिन एंडर

चर कैसे दिए जाएंगे? टिप्पणियों में से कई मानते हैं कि इनपुट कई प्रकार के चर होंगे, लेकिन पाठ given m variablesका अर्थ है कि चर की एक सूची दी जाएगी। यदि केवल चर की संख्या दी गई है और 0,1,2,3..27,28,29 शक्तियों को उठाया गया है ^ 0, ^ 1, ^ 2 आदि स्वीकार्य आउटपुट है (जैसा कि मैं आपकी पिछली टिप्पणी से जिक्र कर रहा हूं) चीजें आसान हैं।

— लेवल रिवर सेंट

Answer 1

ब्रेकीलॉग , 6 बाइट्स

j₎o⊇ᵘb

एक जोड़े के रूप में इनपुट लेता है, जिसमें चर और क्रम की सूची होती है। आउटपुट वेरिएबल्स की सूची की एक सूची है, जहां शक्तियों को बार-बार चर द्वारा दर्शाया जाता है। (उदाहरण "a egb" है ["a", "a", "b"])

इसे ऑनलाइन आज़माएं!

j₎दूसरे इनपुट के अनुसार पहले इनपुट को कई बार जोड़ देता है। oप्राप्त की गई सूची का आदेश देता है, और फिर ⊇ᵘउस आदेशित सूची के सभी अनूठे सबसेट को ढूँढता है। अंत में, हम पहले तत्व को हटा देते हैं b, क्योंकि यह हमेशा खाली उत्तर होगा, जिसे चुनौती से नहीं माना जाता है।

Answer 2

एल ^ए टी _ई एक्स, 354 बाइट्स

जब मैंने यह देखा तो मुझे पता था कि यह लेटेक्स में किया जाना था। समीकरण बस लेटेक्स में इतने कुरकुरे और साफ दिखते हैं और मैं ^सत्ता के लिए इस्तेमाल नहीं कर सकता ।

\documentclass{article}\input tikz\usepackage{intcalc}\usepackage{ifthen}\begin{document}\typein[\a]{}\typein[\b]{}\foreach\x in{1,...,\intcalcPow{\b+1}{\a}}{\begin{equation}\foreach[count=\i]\y in{a,...,z}{\ifthenelse{\(\i<\a\)\OR\(\i=\a\)}{\y^\intcalcDiv{\intcalcMod{\x}{\intcalcPow{\b+1}{\i}}}{\intcalcPow{\b+1}{\i-1}}}{}}\end{equation}}\end{document}

व्याख्या

यहां काम पर तीन मुख्य बल हैं \typein जो हमें कमांड लाइन से इनपुट लेने की अनुमति देता है, वह intcalcपैकेज जो हमें अपने चर और लेटेक्स equationवातावरण के साथ गणना करने की अनुमति देता है ।

---

एक बार जब हम इनपुट में ले लेते हैं तो हम एक लूप शुरू करते हैं जिसे हम लूप \intcalcPow{\b+1}{\a}बार करते हैं, प्रत्येक परिणाम के लिए एक बार हम प्रिंट करना चाहते हैं। प्रत्येक लूप में हम वर्तमान अक्षर और रन की वर्तमान संख्या के लिए equationवर्णमाला रखने के माध्यम से एक वातावरण और लूप शुरू करते हैं । यदि हम इससे अधिक या इसके बराबर हैं तो हम कुछ भी नहीं छापते हैं (चश्मा के अनुसार यह कड़ाई से आवश्यक नहीं है लेकिन लेटेक्स 1 से अधिक मूल्यों के लिए अतिप्रवाह करेगा यदि हम ऐसा नहीं करते हैं)। फिर हम अपने समीकरण को प्रिंट करते हैं और इसे बढ़ाते हैं\y\i\i\a\y

\intcalcDiv{\intcalcMod{\x}{\intcalcPow{\b+1}{\i}}}{\intcalcPow{\b+1}{\i-1}}

उस पूरे मेस का सीधा सा मतलब है कि आधार \iका वें अंक लेना । यह सुनिश्चित करता है कि शक्तियों को ठीक से डिकोड किया गया है।\x\b+1

उदाहरण आउटपुट:

यहाँ 3, 2 के लिए आउटपुट है

Comments

ध्यान दें कि आपके आउटपुट में ^ 0 b ^ 0 c ^ 0 = 1 शामिल है, जबकि परीक्षण के मामले नहीं हैं। कहा जा रहा है, मुझे लगता है कि आप सही हैं और परीक्षण के मामले गलत हैं :)

— ग्रेग मार्टिन

@GregMartin हां, गणितीय रूप से खाली सेट बोलना en.wikipedia.org/wiki/Power_set

— Karl Napf

@KarlNapf 1 के बराबर एक अभिव्यक्ति खाली सेट नहीं है। और न ही एक शून्य है जिसमें 3 शून्य हैं।

— jpmc26

@ jpmc26 इस गोल्फ के विनिर्देशन में नहीं। यह खाली n सेट के बिना (n = 3 के लिए) a, a, a, b, b, b, c, c, c} की पॉवरसेट की तरह है

— Karl Napf

@KarlNapf यह गणितीय रूप से समान नहीं है। यहां कोई खाली सेट शामिल नहीं है। चुनौती में निर्दिष्ट लंबाई के tuples का एक सेट उत्पन्न करना शामिल है।

— jpmc26

Answer 3

गणितज्ञ, ५१ ५० बाइट्स

Rest[1##&@@@PowerRange[1,#^#2,#]~Distribute~List]&

"दिया गया mचर" मान लिया गया है, पहला इनपुट चर की एक सूची है।

यदि पहला इनपुट एक पूर्णांक है, तो 69 बाइट्स

Rest[1##&@@@PowerRange[v=Unique[]~Table~#;1,v^#2,v]~Distribute~List]&

चर रूप में हैं $<integer>(उदाहरण के लिए $5)

Comments

टीआईएल PowerRangeएक चीज है! मैं आपके पहले सबमिशन btw की व्याख्या से सहमत हूँ

— ग्रेग मार्टिन

Answer 4

हास्केल, 71 58 54 53 बाइट्स

n#m=tail$concat<$>mapM(\x->(\i->x<$[1..i])<$>[0..n])m

स्ट्रिंग की एक सूची देता है और आउटपुट स्वरूप का उपयोग करता "aabbb"लिए "a^2 b^3"।

प्रयोग उदाहरण: 3 # "ab"-> ["b","bb","bbb","a","ab","abb","abbb","aa","aab","aabb","aabbb","aaa","aaab","aaabb","aaabbb"]। इसे ऑनलाइन आज़माएं! ।

आउटपुट स्वरूपण के लिए कई बाइट्स खर्च किए जाते हैं। एक अधिक लचीला आउटपुट, उदाहरण के लिए (चर, शक्ति) -> [('a',2),('b',3),('c',1)]के "a^2 b^3 c^1"जोड़े बहुत कुछ बचाएंगे।

यह काम किस प्रकार करता है

    mapM(\x->    )m      -- for each variable x in the input list m
      \i->x<$[1..i]      -- make i copies of x
             <$>[0..n]   -- for all numbers from 0 to n
                         -- in fact mapM makes all possible combinations hereof, i.e.
                         -- [["",""], ["", "b"], ["", "bb"] ... ["a",""], ["a","b"], ...]
  concat<$>              -- join all inner lists 
                         --    e.g ["aa","bbb"]  -> "aabbb"
tail                     -- drop the first (all powers = ^0)

अधिकतम लचीलेपन के साथ, अर्थात (वैरिएबल, पॉवर) जोड़े के रूप में आउटपुट फॉर्मेट और इसमें ऑल-जीरो पॉवर ( "a^0 b^0 c^0") शामिल है, जो इसे उबालता है

हास्केल, 25 बाइट्स:

f n=mapM((<$>[0..n]).(,))

उपयोग उदाहरण f 2 "ab":

[[('a',0),('b',0)],
 [('a',0),('b',1)],
 [('a',0),('b',2)],
 [('a',1),('b',0)],
 [('a',1),('b',1)],
 [('a',1),('b',2)],
 [('a',2),('b',0)],
 [('a',2),('b',1)],
 [('a',2),('b',2)]]

कुल शून्य शक्तियों को छोड़ने पर कुल 30 के लिए 5 बाइट्स खर्च होते हैं f n=tail.mapM((<$>[0..n]).(,)):।

Comments

अपने दूसरे कोड के लिए, [('a',0),('b',0)]आउटपुट में नहीं होना चाहिए ...

— जंगहवान मिन

@JungHwanMin: मेरा 25-बाइट समाधान एक उत्तर होने के लिए नहीं है। यह दिखाने के लिए एक नोट है कि चुनौती के दहनशील हिस्से को कम से कम बाइट्स की आवश्यकता है - कम से कम हास्केल में। छोड़ने की a^0 b^0लागत 5 बाइट्स होती है। मैं एक और नोट जोड़ूंगा।

— नीमी

Answer 5

जेली , 20 17 बाइट्स

ṗj€“”Ṣ€
ŒPçЀj“”Q

एक डाइएडिक लिंक (फ़ंक्शन) जो चर नामों की एक सूची * और अधिकतम क्रम (एक पूर्णांक) को स्वीकार करता है और एक सूची देता है जहां प्रत्येक प्रविष्टि गुणन का पूरी तरह से विस्तारित प्रतिनिधित्व है (जैसे foo ⁰ बार ³ bof ² होगा ['bar', 'bar', 'bar', 'bof', 'bof']।

* चर नाम अद्वितीय वर्णों का एक तार हो सकता है (तार वर्णों की सूची बन जाते हैं)।

इसे ऑनलाइन आज़माएं! - पाद लेख लिंक को रंजक के रूप में कहता है और फिर पठन की सुगमता के लिए रिक्तियों की प्रत्येक पंक्ति को पंक्ति फ़ीड और प्रत्येक प्रविष्टि के रिक्त स्थान से अलग करता है।

नोट: इसमें 0 ऑर्डर (खाली उत्पाद) शामिल है, जिससे बचने के लिए, Ḋयहां डाला जा सकता ...ŒPḊç...है।

कैसे?

ṗj€“”Ṣ€ - Link 1, sorted results of a Cartesian power: elements, power
ṗ       - Cartesian power of elements with given power
 j€“”   - join €ach with "" (flatten each by one level)
     Ṣ€ - sort €ach

ŒPçЀj“”Q - Main link: variableNames, maximalOrder
ŒP        - power-set of variableNames (e.g for ['a','b','c'] this would be ['','a','b','c','ab','ac','bc','abc'])
   Ѐ     - for €ach mapped over right argument (i.e. over the range [1,2,...,maximalOrder])
  ç       -     call the last link (1) as a dyad (i.e. power-set results are the elements and one of the range values is the power)
     j“”  - join with "" (flatten by one level)
        Q - unique values

---

13 बाइट संस्करण जो केवल अद्वितीय वर्णों की एक स्ट्रिंग (या अद्वितीय वर्णों की सूची) के लिए काम करेंगे:

ŒPṗЀj“”F€Ṣ€Q

कोशिश करो

Answer 6

जावास्क्रिप्ट (ईएस प्रस्ताव), 142 बाइट्स

f=
(v,n)=>[...Array(++v**n)].map((_,i)=>i.toString(v).padStart(n,0).replace(/./g,(c,j)=>(+c?(10+j).toString(36):``)+(c>1?c.sup():``))).join`<br>`

<div oninput=o.innerHTML=f(v.value,n.value)><input id=v type=number min=1 value=1><input id=n type=number min=1 value=1><span id=o><br>a

दोनों के साथ एक ब्राउज़र की आवश्यकता है **और padStartसमर्थन है, इसलिए फ़ायरफ़ॉक्स 52 या क्रोम 57 का प्रयास करें।

Answer 7

गणितज्ञ 100 बाइट्स

निश्चित रूप से इसे पूरा करने का एक अधिक कुशल तरीका है!

4 को ऑर्डर करने के लिए दो चर:

(Times@@@(MapThread[Power,#]&/@Outer[List,{Alphabet[][[1;;#]]},Rest@Tuples[Range[0,#2],#],1][[1]])) &

Answer 8

बैश + सेड, ६०

मेरे पिछले उत्तर के लिए एक अलग, छोटा दृष्टिकोण।

कमांड-लाइन मापदंडों के रूप में इनपुट - mएक अल्पविराम से अलग-अलग चर नामों की सूची के रूप में दिया जाता है, और nएक पूर्णांक के रूप में:

p=eval\ printf
$p -vc %s {$1}^\\{0..$2}
$p '%s\\n' $c|sed 1d

इसे ऑनलाइन आज़माएं ।

---

पिछला उत्तर:

बैश + कोरुटिल्स, 91

आपका स्वागत है eval-भागने-ब्रेस नरक। कभी-कभी शेल-स्क्रिप्ट वास्तव में नौकरी के लिए सिर्फ सही उपकरण देती है। यह यहां मामला नहीं है, लेकिन यह काम करता है।

कमांड-लाइन मापदंडों के रूप में इनपुट - mवैरिएबल नामों की अल्पविराम से अलग सूची के रूप में दिया जाता है, और nपूर्णांक के रूप में। आउटपुट लॉन्गहैंड लिखा जाता है - उदाहरण a^2वास्तव में लिखा जाता है aa। यह इस टिप्पणी के अनुसार स्वीकार्य है ।

p=eval\ printf
$p -vc {%$[$2-1]s}
$p '%s\\n' $($p %s \{{$1}${c// /,}\\\,})|tr -d {}|sort -u

ऐसा करने के छोटे तरीके हो सकते हैं।

इसे ऑनलाइन आज़माएं ।

व्याख्या

• printf -vc {%$[$2-1]s}चर cको एक स्ट्रिंग पर असाइन करता है { }, जैसे कि रिक्त स्थान की संख्या क्रम है n- 1, इसलिए यदि n= 1, परिणाम है {}, यदि n= 2, परिणाम है { }, आदि।
• ${a[$1]}mसरणी के लिए एक सूचकांक के रूप में उपयोग करता है a, इसलिए यदि m3 है, तो परिणाम हैc
• \{{a..${a[$1]}}${c// /,}\\,} एक बहु-भाग ब्रेस विस्तार है:
  • \{ - एक शाब्दिक {
  • {$1}सूची का ब्रेस विस्तार है m, जैसे {a,b,c}याa b c
  • ${c// /,}रिक्त स्थान $cको कॉमा के साथ प्रतिस्थापित करता है , उदाहरण के {,,}लिए n= 3, जो एक ब्रेस विस्तार भी है जो प्रत्येक तत्व को प्रभावी ढंग से दोहराता {a..c} nहै
  • \\\,} - एक शाब्दिक ,}
• तो m= "a, b" और n= 2 के लिए, यह विस्तार होता है{a,} {a,} {b,} {b,}
• आंतरिक printfदेने के लिए रिक्त स्थान को हटा देता है {a,}{a,}{b,}{b,}, जो स्वयं एक ब्रेस विस्तार है
• इसका विस्तार होता है aabb aab aab aa abb ab ab a abb ab ab a bb b b
• बाहरी printfइनमें से प्रत्येक तत्व को अपनी लाइन पर रखता है
• sort -u डुप्लिकेट को निकालता है
• tr -d {}मामला संभाल करने जब है n1. = इस मामले चर में cहो जाएगा {}जो एक ब्रेस विस्तार नहीं है, लेकिन इसके बजाय शाब्दिक वर्णों डाला जाता है। trउन्हें निकालता है।

evalयह सुनिश्चित करने के लिए कि सभी विस्तार आवश्यक क्रम में होते \हैं, एस और एस्केप को बहुत सावधानी से रखा गया है।

Answer 9

रोड़ा , 49 48 46 बाइट्स

f n{r=[""]{|v|r=r...[seq(0,n)|[v.._]]}_;r[1:]}

इसे ऑनलाइन आज़माएं!

मुझे लगता है कि यह सही है। यह एक चर और इसके क्रम के बीच किसी विभाजक का उपयोग नहीं करता है। पिछले संस्करण का उपयोग किया गया था !, लेकिन मुझे एहसास हुआ कि इसकी सख्त आवश्यकता नहीं है।

व्याख्या की:

function f(n) {
    r := [""] /* r is a list with one empty string. */
    /* Loops over the variable names in the stream. */
    for var do
        /* Concatenates every element in r to */
        /* every element in the list that contains orders of */
        /* variable var. */
        r = r...[
            push(var..x) for x in [seq(0, n)]
        ]
    done
    r[1:] /* Return elements of r not counting the first. */
}

Answer 10

पायथन, 112 बाइट्स

import itertools as t
f=lambda n,v:[''.join(map(str.__mul__,v,I))for I in t.product(range(n),repeat=len(v))][1:]

उपयोग:

for x in f(3, 'ab'):
    print(x)

आउटपुट:

b
bb
a
ab
abb
aa
aab
aabb

115 बाइट्स में अच्छे प्रारूप :

import itertools as t
f=lambda n,v:[''.join(map('{}^{}'.format,v,I))for I in t.product(range(n),repeat=len(v))][1:]

आउटपुट (एक ही उपयोग):

a^0b^1
a^0b^2
a^1b^0
a^1b^1
a^1b^2
a^2b^0
a^2b^1
a^2b^2

125 बाइट्स में भी अच्छे :

import itertools as t
f=lambda n,v:[''.join(c+'^%s'%i for c,i in zip(v,I)if i)for I in t.product(range(n),repeat=len(v))][1:]

आउटपुट:

b^1
b^2
a^1
a^1b^1
a^1b^2
a^2
a^2b^1
a^2b^2

सभी में अंतिम 4 बाइट्स ( [1:]) खाली उत्पाद को हटाने के लिए हैं।

ये पायथन 2 और 3 दोनों में काम करते हैं।

Answer 11

सी ++ 14, 146 140 बाइट्स

-6 सरल आउटपुट स्वरूप के लिए बाइट।

बेनाम लैम्ब्डा, इनपुट संभालने sकी तरह std::stringऔर oके रूप में std::ostream:

[](auto s,int n,auto&o){int l=s.size(),k,c,*p=new int[l]{1};while(!c){for(c=1,k=0;k<l;o<<s[k]<<"^"<<p[k],p[k++]*=!(c=(p[k]+=c)>n));o<<" ";}}

उपयोग और स्पष्टीकरण:

#include<iostream>
#include<string>

auto f=
[](auto s, int n, auto&o){
 int l=s.size(),              //string length
     k,                       //running variable for l
     c,                       //carry for the increment
    *p=new int[l]{1};         //init array with first elem 1
 while(!c){                   //if carry was leftover, break
  for(
   k=0,c=1;                   //always start with carry                  
   k<l;                       
    o<<s[k]<<"^"<<p[k],       //output
    p[k++]*=!(c=(p[k]+=c)>n)  
//               p[k]+=c      //inc p[k]  
//            c=(p[k]+=c)>n   //if value is greater than order  
//  p[k++]*=!(c=(p[k]+=c)>n)  //set p[k] to 0 and inc k
  );
  o<<" ";                     
 }
}
;

main(){
 f(std::string("ab"),3,std::cout);
 std::cout << "\n";
 f(std::string("abc"),2,std::cout);
}

आउटपुट:

a^1b^0 a^2b^0 a^3b^0 a^0b^1 a^1b^1 a^2b^1 a^3b^1 a^0b^2 a^1b^2 a^2b^2 a^3b^2 a^0b^3 a^1b^3 a^2b^3 a^3b^3 
a^1b^0c^0 a^0b^1c^0 a^1b^1c^0 a^0b^0c^1 a^1b^0c^1 a^0b^1c^1 a^1b^1c^1