Bir sayı nve bir üst sınır verildiğinde l, yalnızca yediden uzun nveya daha küçük olan iki veya daha fazla sayıyı çarparak oluşturulabilecek sayılar l. A161145 bu mücadeleye yakındır, ancak 7, 77, 777, 7777, 77777 vb. Dahil DEĞİLDİR.

Örnekler

n=anything, l<49 sonuç:

[]

n=1, l=49 sonuç:

7*7=49

f(1,49)=[49]

n=1, l=343 sonuç:

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

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

n=2,l=6000 sonuç:

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 sonuç:

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

Vb...

kurallar

1. Sen yok bu netlik için yapıldığını, çıkış ara adımlara sahiptir.
2. Çıktı bir dizi olarak olabilir veya herhangi bir karakterle (hatta yeni satırlar) ayrılabilir.
3. Çıktı sayısal sırada, en düşükten en yükseğe doğru olmalıdır.
4. Başlığı alakalı hale getirmek için, nele alınması gereken en yüksek değer şudur n=77(bu kadar üstesinden gelemiyorsanız, neden - dil kısıtlamalarının kabul edilebilir olduğunu, tembellik olmadığını unutmayın). Bu sınırlama, üst kümenin tamamını bellekte oluşturmak isteyenleri engellemektir.
5. TIO n=77kodunuz için çalışamazsa hangi özellikleri elde etmek gerektiğini açıklayın n=77.
6. Bir ürünün geçerli olabilmesi için en az 2 rakamdan oluşması gerekir.
7. Bu kod-golf en düşük bayt-sayısı muzaffer olarak kabul edilecektir.
8. Listeden küçük lveya eşit olan öğeleri içerecek listeyi seçebilirsiniz l.
9. BONUS : Kodunuz tam olarak 77 bayt ise, benden kudos; değersiz, biliyorum.

05AB1E , 19 bayt

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

Çevrimiçi deneyin!

açıklama

Çok verimsiz. TIO bağlantısı ceil(l^(1/7)), lbüyük test senaryolarını daha kolay test etmek için golf versiyonunda kullanılan iterasyonlar yerine iterasyonlar gerçekleştirir .

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

Jöle , 21 20 19 18 bayt

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

Çıktının OP'lerle eşleşmediğini unutmayın. Bir yorum bıraktım.

Çevrimiçi deneyin!

Nasıl çalışır

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.

Python 2 , 116 113 109 bayt

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'nun son test durumu için yeterli belleğe sahip olmadığını unutmayın.

Çevrimiçi deneyin!

JavaScript (ES6), 103 101 bayt

Körili sözdiziminde girdi alır (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)

Test senaryoları

Son test senaryosunun tamamlanması birkaç saniye sürebilir.

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))

PHP, 142 Bayt

$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 bayt çıkarma $r=[];ve değiştirme sort($r);ile@sort($r);

Çevrimiçi sürüm

Expanded

Özyinelemeli işlev, sınır dahil tüm permütasyonları yapar

$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 Bayt

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);

Expanded

49 ile bölünebilen her değeri sınır kontrolüne dahil eden bir döngü

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);

Çevrimiçi sürüm

birkaç bayt fazla ve ilişkilendirilebilir bir dizi oluşturulabilir, sayı ve anahtar olarak kullanılan yedilerin bir dizisi

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);

Çevrimiçi sürüm

Yakut, 89 86 bayt

Özyinelemeli bir çözüm.

0'ın 0 olduğu herhangi bir şeyin 0 olduğunu hatırlayarak -3 bayt.

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: []}

Çevrimiçi deneyin!

Pyth , 22 bayt

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

Çevrimiçi deneyin!

gözlük

• Giriş: l[newline]n
• Çıktı: array containing the sorted result

PHP, 128 125 130 129 127 123 bayt

22 7s'ye kadar çalışacaktır ancak daha büyük değerleri yuvarlayacaktır (7 ** 23, 64 bitlik bir makinede kayan noktadır).

Jörg tarafından kaydedilen 3 bayt, benim tarafımdan 3 bayt, boş sonuçlar için uyarıyı önlemek için 5 4 1 eklendi.

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);

komut satırı bağımsız değişkenlerinden girdi alır; ile çalıştırın -nrveya çevrimiçi deneyin .

Yıkmak

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

Brachylog , 28 bayt

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

Burada, dilin kendisinin geliştirmesi için çok fazla alan var; yazdığım birkaç şey, dilin tasarımındaki bazı değişikliklerle açıkça geliştirilebilecek gibi görünüyor. Bu, geçerli sürümle bulduğum en kısa yol. Bu programı daha verimli, daha kısa ve daha okunabilir hale getirecek Brachylog için bazı önerilerde bulunabilirim.

Çok, çok yavaş; TIO, mümkün olan en basit önemsiz cevapta bile zaman aşımına uğradığından, bir TIO bağlantısı sağlamanın pek bir anlamı yoktur. Bu programı yerel olarak çalıştırarak doğruladım.

Bu, çıktısı bir jeneratör (bir listenin aksine) olan bir işlevdir (tam bir program değil). .w⊥İlkinden ziyade tüm çıktıları görmek istiyorsanız işlevin sonuna ekleyin . (Bunun uygulamada gerçekten önemli olmadığını unutmayın, çünkü program yine de TIO için çok yavaş olduğundan, yerel olarak çalıştırmanız gerekir ve yerel Brachylog yorumlayıcısı bir jeneratörü iyi tanımlayabilen bir REPL'de çalışır.)

açıklama

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.

Bash + GNU yardımcı programları, 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

Çevrimiçi deneyin . TIO, son test senaryosu için yaklaşık bir dakika sürer. Benim sonuçları maç Dennis adlı @.

Pyth - 57 51 49 42 bayt

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

Dene