एक संख्या nऔर एक ऊपरी सीमा को देखते हुए lउन संख्याओं को सूचीबद्ध किया जा सकता है जो दो या अधिक संख्याओं को गुणा करके बनाई जा सकती हैं, जिसमें केवल लंबाई की लंबाई nया उससे कम होती हैं l। A161145 इस चुनौती के करीब है, हालांकि, आप 7, 77, 777, 7777, 77777, आदि को शामिल नहीं करेंगे।

उदाहरण

n=anything, l<49 परिणाम होगा:

[]

n=1, l=49 परिणाम होगा:

7*7=49

f(1,49)=[49]

n=1, l=343 परिणाम होगा:

7*7   =49
7*7*7 =343

f(1,343)=[49,343]

n=2,l=6000 परिणाम होगा:

7*7    =49
7*7*7  =343
7*7*7*7=2401
7*77   =539
7*7*77 =3773
77*77  =5929

f(2,6000)=[49,343,539,2401,3773,5929]

n=3, l=604000 परिणाम होगा:

[49, 343, 539, 2401, 3773, 5439, 5929, 16807, 26411, 38073, 41503, 59829, 117649, 184877, 266511, 290521, 418803, 456533, 603729]

आदि...

नियम

आपको मध्यवर्ती चरणों का उत्पादन करने की आवश्यकता नहीं है, यह स्पष्टता के लिए किया गया था।
आउटपुट एक सरणी के रूप में हो सकता है या किसी भी चरित्र (यहां तक कि नईलाइन) द्वारा अलग किया जा सकता है।
आउटपुट संख्यात्मक क्रम में होना चाहिए, उच्चतम से कम।
शीर्षक को प्रासंगिक बनाने के लिए, उच्चतम nजिसे संभाला जाना चाहिए , वह हैn=77 (यदि आप उस उच्च को संभाल नहीं सकते, तो ध्यान दें कि - भाषा प्रतिबंध स्वीकार्य हैं, आलस्य नहीं है)। यह सीमा उन लोगों के लिए बाधा है जो पूरे सुपरसेट को स्मृति में बनाने के लिए देख रहे हैं।
यदि TIO n=77आपके कोड के लिए नहीं चल सकता है , तो यह बताएं कि क्या प्राप्त करने के लिए चश्मा आवश्यक था n=77।
किसी उत्पाद के वैध होने के लिए उसमें कम से कम 2 नंबर होने चाहिए।
यह कोड-गोल्फ निम्नतम बाइट-काउंट है जिसे विजयी माना जाएगा।
आप सूची को चुन सकते हैं जिसमें आइटम से कम lया उससे कम / के बराबर आइटम हों l।
BONUS : यदि आपका कोड 77 बाइट्स है, तो मेरी ओर से यश; बेकार, मुझे पता है।

code-golf sequence

— जादू ऑक्टोपस Urn
स्रोत

मैं मुसीबत पार्स "सूची संख्या बनाया जा सकता है कि लंबाई के केवल सात से मिलकर दो या अधिक संख्याओं को गुणा करके आ रही है nकी तुलना में कम कर रहे हैं या उससे कम है कि l"

— xnor

क्या कुछ संख्याओं का उत्पादन एक से अधिक बार करना स्वीकार्य है?

— गणित के नशेड़ी

नियम 5 बहुत व्यर्थ है, क्या कोई कोड दिया जाएगा n=77और l=7**7**7, उदाहरण के लिए?

— जोनाथन एलन

1

क्या हम यह मान सकते हैं कि परिणाम खाली नहीं होगा?

— टाइटस

@JonathanAllan सच।

— मैजिक ऑक्टोपस Urn

1

05AB1E , 19 बाइट्स

L7×1¸ì©IF®âPD²‹Ïê®K

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

व्याख्या

बहुत अकुशल। TIO लिंक परफॉर्म करता हैceil(l^(1/7))l बड़े परीक्षण को आसान बनाने के लिए गोल्फ संस्करण में उपयोग किए जाने वाले पुनरावृत्तियों के बजाय पुनरावृत्तियों का ।

L7×                   # create the list ['7', '77', '777' ...] 
                      # with the final item having n 7's 
   1¸ì©               # prepend a 1 and store a copy in register
       IF             # l times do:
         ®â           # cartesian product between current list and the list in register 
           P          # product of each sublist
            D²‹Ï      # keep only numbers smaller than l
                ê     # remove duplicates and sort
                 ®K   # remove 1, 7, 77, 777 ... from the list

— Emigna
स्रोत

$L7×‚˜- 5 बाइट पाने की कोशिश की, नहीं कर सका।

— मैजिक ऑक्टोपस Urn

@carusocomputing: हाँ, मुझे लगता है कि 6 बाइट्स बहुत ज्यादा हैं, लेकिन मैं वास्तव में एक छोटा रास्ता नहीं देख सकता। मैं उम्मीद कर रहा था कि आप मुझे एक छोटे तरीके से स्कूल करेंगे;)

— एमिग्ना

मैं सोच रहा था .pया .sबहुत, लेकिन अब भी लगता है। मैंने गलती से रन के बजाय अपने उदाहरण कार्यान्वयन के साथ TIO पृष्ठ पर 'ताज़ा' मारा, इसे अस्तित्व से हटा दिया। मुझे लगता है कि यह 26 था।

— मैजिक ऑक्टोपस Urn

1

@ क्रूसोकोम्पुटिंग: इसीलिए आपको हमेशा लिंक बटन को नियमित रूप से दबाना चाहिए। कंप्यूटर को रिफ्रेश या रिबूट करके कुछ भी ढीला न करें। हालांकि इतिहास को ढीला करने के लिए थोड़ा परेशान :)

— एमिग्ना

7

जेली , 21 20 19 18 बाइट्स

R7ẋḌµ;ŒċP€⁹f€FµÐLḟ

ध्यान दें कि आउटपुट ओपी से मेल नहीं खाता है। मैंने एक टिप्पणी छोड़ दी है।

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

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

R7ẋḌµ;ŒċP€⁹f€FµÐLḟ  Main link. Left argument: n. Right argument: l

R                   Range; yield [1, ..., n].
 7ẋ                 Times; yield [[7], ..., [7] * n].
   Ḍ                Undecimal; yield s := [7, 77, ...].
    µ         µÐL   Begin a new chain with argument s and call the chain between 
                    until the results no longer chain.
                    Return the last unique result.
      Œċ            Combinations; return all unordered pairs in integers in the
                    return value.
     ;              Concatenate the return value and its pairs.
        P€          Take the product of each individual integer and each pair in
                    the result.
          ⁹f€       Filter each; for each j in [1, ..., l], intersect [j] with the
                    array of products. The result is sorted and contains no 
                    duplicates.
                 ḟ  Filterfalse; remove the elements of s from the result.

— डेनिस
स्रोत

6

पायथन 2 , 116 113 109 बाइट्स

n,l=input()
r=t={1}
exec't|={10**n/9*7};n-=n>1;r=r|{x*y for x in r for y in t if l/x/y};'*l
print sorted(r-t)

ध्यान दें कि TIO के पास अंतिम परीक्षण मामले के लिए पर्याप्त मेमोरी नहीं है।

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

— डेनिस
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 103 101 बाइट्स

करी सिंटैक्स में इनपुट लेता है (n)(l)।

n=>l=>(a=[],g=(n,m,p,i)=>(p>l||g(n,m,(a[i>1?p:a]=p)*m,-~i),--n?g(n,m+7,p,i):a.filter(n=>n)))(n,'7',1)

परीक्षण के मामलों

अंतिम परीक्षण का मामला पूरा होने में कुछ सेकंड लग सकते हैं।

कोड स्निपेट दिखाएं

let f =

n=>l=>(a=[],g=(n,m,p,i)=>(p>l||g(n,m,(a[i>1?p:a]=p)*m,-~i),--n?g(n,m+7,p,i):a.filter(n=>n)))(n,'7',1)

console.log(f(1)(49))
console.log(f(1)(343))
console.log(f(2)(6000))
console.log(f(3)(604000))

Expand snippet

— Arnauld
स्रोत

4

PHP, 142 बाइट्स

$r=[];for([,$n,$l]=$argv;$n--;)f($v[]=$z.=7);function f($t){global$v,$l,$r;while($c=$t*$v[+$i++])$l<$c?:f($c)&$r[$c]=$c;}sort($r);print_r($r);

-5 बाइट्स को दूर करने $r=[];और बदलने के sort($r);साथ@sort($r);

ऑनलाइन संस्करण

विस्तारित

एक पुनरावर्ती कार्य सीमा सहित सभी क्रमपरिवर्तन करता है

$r=[];
for([,$n,$l]=$argv;$n--;)
  f($v[]=$z.=7);
function f($t){
    global$v,$l,$r;
    while($c=$t*$v[+$i++])
      $l<$c?:f($c)&$r[$c]=$c;
}
sort($r);
print_r($r);

PHP, 145 बाइट्स

for([,$n,$l]=$argv;$n;)$t[]=str_pad(7,$n--,7);for(;$l>=$i+=49;$v>1?:$u[]=$r)for($v=$i,$r=!$c=0;$d=$t[$c];)$v%$d?$c++:($v/=$d)&$r*=$d;print_r($u);

विस्तारित

सीमा तक एक लूप 49 तक विभाज्य है हर मान की जाँच करें

for([,$n,$l]=$argv;$n;)
  $t[]=str_pad(7,$n--,7);
for(;$l>=$v=$i+=49;$v>1?:$u[]=$r)
  for($r=!$c=0;$d=$t[$c];)
    $v%$d?$c++:($v/=$d)&$r*=$d;
print_r($u);

ऑनलाइन संस्करण

कुछ बाइट्स अधिक और एक साहचर्य सरणी को संख्या की कुंजी के रूप में बनाया जा सकता है और उपयोग किए गए सेवियों की एक सरणी मान के रूप में

for([,$n,$l]=$argv;$n;)
  $t[]=str_pad(7,$n--,7);
for(;$l>=$v=$i+=49;$v>1?:$u[array_product($r)]=$r)
  for($r=[],$c=0;$d=$t[$c];)
    $v%$d?$c++:($v/=$d)&$r[]=$d;
print_r($u);

ऑनलाइन संस्करण

— जार्ग हुल्सरमैन
स्रोत

while($c=$t*$v[+$i++])$l<$c?f($c)&$r[$c]=$c;3 बाइट्स बचाता है; लेकिन यह होना चाहिए $l<=$c। $r?sort($r)&print_r($r):0;के बजाय $r=[];एक बचाता है।

— टाइटस

1

$z.=7;5 बाइट्स से छोटा है $z=$z*10+7;।

— टाइटस

और @एक और 4 बाइट्स से छोटा है $r?...:0;। (साभार @Christoph)

— टाइटस

@ टिट्स यह क्यों होना चाहिए $l<=$c? ऐसा लगता है कि कल मेरे लिए नहीं था $z.=7और अतिरिक्त 2 बाइट्स जो मुझे मिली हैं। मैं आपके अन्य दो सुझावों पर पहले विचार कर रहा हूं। आप :लूप में याद करते हैं

— Jörg Hülsermann

Ive ने ओपी को स्पष्ट करने के लिए कहा। विवरण में वह परिणामों के बारे में बात करता है that are less than l, अपने उदाहरणों में वे are less than or equal। स्पष्टीकरण के आधार पर, $c>$l||.../ $c>$l?:...या $c<$l&&...सबसे कम हैं।

— टाइटस

4

रूबी, 89 86 बाइट्स

एक पुनरावर्ती समाधान।

-3 बाइट्स को याद करते हुए कि कुछ भी 0 0 है।

f=->n,l,b=1{n*l>0?(f[n,l/k=eval(?7*n),b*k]+f[n-1,l,b]+(b>1&&l>=k ?[k*b]:[])).sort: []}

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

— मूल्य स्याही
स्रोत

3

पायथ , 22 बाइट्स

JsM._*\7Eu@s*LR+JGJSQJ

JsM._*\7E
        E               second input
     *\7                repeat "7" as many times as the above
   ._                   all prefixes of above
 sM                     convert each to integer
J                       store list as J

         u@s*LR+JGJSQJ
         u              repeat the following until results not unique
                     J  starting from G = J
                        at each iteration, G is the current value
               +JG      append G to J
                  J     J
            *LR         multiply the elements of the above two, vectorizing each
           s            flatten list
          @        SQ   intersect with [1,2,3,...,first input]
                        this takes elements from [1,2,3,...,first input] and
                        check if each element is in the previous list
                        which ensures the result is sorted and unique

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

ऐनक

इनपुट: l[newline]n
आउटपुट: array containing the sorted result

— लीक नन
स्रोत

3

पीएचपी, 128 125 130 130 129 127 123 बाइट्स

22 तक काम करेंगे 7 एस लेकिन बड़े मानों को गोल करेगा (7 ** 23 एक 64 बिट मशीन पर फ्लोटिंग पॉइंट है)।

3 बाइट्स जोर्ग द्वारा बचाए गए, 3 मेरे द्वारा, ~~5 4~~ 1 खाली परिणामों के लिए चेतावनी से बचने के लिए जोड़ा गया।

for([,$c,$z]=$argv,$n=$c+1;$c<$z;$p<$z&&$r[$p]=$p)for($b=$c+=$p=1;$b|0;$b/=$n)$p*=str_pad(7,$b%$n,7);@sort($r);print_r($r);

कमांड लाइन तर्कों से इनपुट लेता है; साथ चलाएं -nrयाइसे ऑनलाइन प्रयास करें ।

टूट - फूट

for([,$c,$z]=$argv,$n=$c+1;         # $z=L, $n=N+1
    $c<$z;                          # loop $c from N to L-1:
    $p<$z&&$r[$p]=$p                    # 2. if product is < L, add to array
)                                       #    (key=val to avoid duplicates)
    for($b=$c+=$p=1;$b|0;$b/=$n)        # 1. loop $b through ++$c as base-N+1 number
        $p*=str_pad(7,$b%$n,7);             # take each base-N+1 digit as length
                                            # for a streak of 7s as factor
        // (str_pad is 1 byte shorter than str_repeat and saves 3 by ensuring positive $p)
@sort($r);                          # sort array (muted to avoid warning for empty result)
print_r($r);                        # print array

— टाइटस
स्रोत

1

for([,$c,$z]=$argv,$n=1+$c;$c<$z;इसके बजायfor($n=1+$c=$argv[1];$c<$z=$argv[2];

— जार्ग हल्सरमैन

1

चेतावनी को दबाने के @बजाय उपयोग करें $r&&? $p<$z&&$r[$p]=$p

— क्रिस्टोफ

मैंने सिर्फ देखा कि यह $p>$z?:$r[$p]=$pउदाहरण से होना चाहिए n=1, l=343यह स्पष्ट है कि lइसे शामिल किया जाना चाहिए। इसलिए वहाँ कोई बचत का उपयोग करते समय $p>$z||$r[$p]=$pया $p>$z?:$r[$p]=$p।

— क्रिस्टोफ

1

@Christoph मैंने ओपी को स्पष्ट करने के लिए कहा। मुझे याद दिलाने के लिए धन्यवाद @; जब ओपी जवाब देगा तो संपादन करेगा।

— टाइटस

1

@ क्रिस्‍टोफ दोनों ही ठीक लगते हैं; और यह वास्तव में wether $p>$z||या बात नहीं करता है $p<$z&&। मैं वर्णन के साथ रहना होगा।

— टाइटस

3

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

h>.ḋ{p~c×ᵐ{=h7&l}ᵐobt≤~t?∧!}

भाषा में सुधार की बहुत गुंजाइश है, यहाँ; काफी कुछ चीजें जो मैंने लिखी हैं, जैसे वे स्पष्ट रूप से भाषा के डिजाइन में कुछ बदलावों के साथ काम करने योग्य हैं। यह वर्तमान संस्करण के साथ मुझे मिला सबसे छोटा तरीका है। मैं अच्छी तरह से Brachylog के लिए कुछ सुझाव दे सकता हूं जो इस कार्यक्रम को अधिक कुशल, कम और अधिक पठनीय बना देगा।

बहुत, बहुत धीमा; TIO बार भी सबसे सरल संभव उत्तर के उत्तर पर, इसलिए TIO लिंक प्रदान करने में कोई मतलब नहीं है। मैंने इस कार्यक्रम को स्थानीय स्तर पर चलाकर सत्यापित किया है।

यह एक फ़ंक्शन (पूर्ण प्रोग्राम नहीं) है, जिसका आउटपुट एक जनरेटर है (जैसा कि एक सूची के विपरीत)। जोड़ना.w⊥यदि आप केवल पहले के बजाय सभी आउटपुट देखना चाहते हैं, तो फ़ंक्शन के अंत में । (ध्यान दें कि यह वास्तव में व्यवहार में मायने नहीं रखता है, क्योंकि चूंकि कार्यक्रम TIO के लिए बहुत धीमा है, इसलिए आपको इसे स्थानीय रूप से चलाना होगा, और स्थानीय Brachylog दुभाषिया एक REPL में चलता है जो कि एक जनरेटर का ठीक वर्णन कर सकता है।)

व्याख्या

h>.ḋ{p~c×ᵐ{=h7&l}ᵐobt≤~t?∧!}
  .                           The desired output is
h>                            a number less than the first input
   ḋ p                        such that taking its prime factors in some order,
      ~c                      partitioning them,
        ×ᵐ                    and taking the product of each partition
          {     }ᵐ            produces a number for which each digit
           =h7                is composed only of 7s
              &l              and for which the lengths of those numbers
                  o           are in sorted order
                    t         and the last element
                   b          (which is not also the first element)
                     ≤        is less than or equal to
                      ~t?     the last input.
                         ∧    (Delete an unwanted implicit constraint.)
   ḋ{                     !}  Output each number only once.

2

बैश + जीएनयू उपयोगिताओं, 108

seq -f3o%gp $2|dc|sed -r "/0|1{$1}/d;s/./&7/g;s/1//g;s/2/*/g;/[*]/!d;s/^/a=7/;s/$/;if(a<=$2)a;/"|bc|sort -un

इसे ऑनलाइन आज़माएं । TIO को अंतिम टेस्टकेस के लिए लगभग एक मिनट लगता है। मेरे परिणाम @ डेनिस से मेल खाते हैं ।

— डिजिटल आघात
स्रोत

1

पायथ - 57 51 49 42 बाइट्स

FY}2eQKYJv*\7hQWJIqYJBW!%KJ=/KJ)=/JT)Iq1KY

कोशिश करो

— मारिया
स्रोत

2

PPCG में आपका स्वागत है! ऐसे कई शॉर्टकट उपलब्ध हैं, जो आपके कोड को बहुत सारे बाइट्स से काट सकते हैं। यदि आप अधिक जानना चाहते हैं तो आप हमारे चैट रूम में आ सकते हैं और मुझे पिंग कर सकते हैं ।

— लीके नन

1

दुर्भाग्य से, आपका वर्तमान कार्यक्रम सही परिणाम उत्पन्न नहीं करता है, अर्थात् इसमें शामिल है 7और 77आपके वर्तमान इनपुट के लिए।

— लीक

1

बाइट्स को काटने के तरीकों में शामिल हैं: या mइसके बजाय का उपयोग करना (कार्यात्मक प्रोग्रामिंग बनाम निष्पादन नियंत्रण); के बजाय का उपयोग कर ; के बजाय का उपयोग कर ; लंबे समय के लिए लूप के बजाय का उपयोग कर उत्पन्न करने के लिए । FVhQ@Q0eQ@Q1i*hQ]7T777...7

— लीक नून

@LeakyNun सुझावों और चैटरूम लिंक के लिए बहुत बहुत धन्यवाद। इसके अलावा, मैंने इसे ठीक किया।

— मारिया

सत्तर सात सेवंस

उदाहरण

नियम

05AB1E , 19 बाइट्स

जेली , 21 20 19 18 बाइट्स

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

पायथन 2 , 116 113 109 बाइट्स

जावास्क्रिप्ट (ईएस 6), 103 101 बाइट्स

परीक्षण के मामलों

PHP, 142 बाइट्स

रूबी, 89 86 बाइट्स

पायथ , 22 बाइट्स

ऐनक

पीएचपी, 128 125 130 130 129 127 123 बाइट्स

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

व्याख्या

बैश + जीएनयू उपयोगिताओं, 108

पायथ - 57 51 49 42 बाइट्स