Setenta e Sete Setes

19

Dado um número ne um limite superior, llista os números que podem ser criados multiplicando dois ou mais números que consistem em apenas setes de comprimento nou menos que são menores que l. O A161145 está próximo desse desafio, no entanto, você NÃO incluirá os 7, 77, 777, 7777, 77777, etc.

Exemplos

n=anything, l<49 resultaria em:

[]

n=1, l=49 resultaria em:

7*7=49

f(1,49)=[49]

n=1, l=343 resultaria em:

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

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

n=2,l=6000 resultaria em:

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 resultaria em:

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

Etc ...

Regras

  1. Você não precisa emitir etapas intermediárias, isso foi feito para maior clareza.
  2. A saída pode ser como uma matriz ou separada por qualquer caractere (mesmo novas linhas).
  3. A saída deve estar em ordem numérica, do menor para o maior.
  4. Para tornar o título relevante, o mais alto nque deve ser tratado é n=77(se você não conseguir lidar com esse nível, observe o porquê - restrições de idioma são aceitáveis, preguiça não). Essa limitação é para impedir aqueles que desejam criar o superconjunto inteiro na memória.
  5. Se o TIO não puder executar o n=77seu código, explique quais especificações foram necessárias para atingir n=77.
  6. Para um produto ser válido, ele deve consistir em pelo menos 2 números.
  7. Essa contagem de bytes mais baixa do será considerada vitoriosa.
  8. Você pode escolher a lista para conter itens menores lou iguais a / iguais a l.
  9. BÔNUS : Se o seu código tiver exatamente 77 bytes, parabéns meu; inútil, eu sei.
Urna de polvo mágico
fonte
Eu estou tendo "lista os números que podem ser criados pela multiplicação dois ou mais números que consistem em apenas setes de comprimento problemas de análise nou menos que são menos do que l"
xnor
É aceitável que alguns números sejam exibidos mais de uma vez?
matemática viciado em
A regra 5 é bastante inútil. Algum código será fornecido n=77e l=7**7**7, por exemplo?
Jonathan Allan
11
Podemos assumir que o resultado não estará vazio?
Titus
@JonathanAllan true.
Magic Octopus Urn

Respostas:

1

05AB1E , 19 bytes

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

Experimente online!

Explicação

Muito ineficiente. O link TIO executa ceil(l^(1/7))iterações em vez das literações usadas na versão golfed para testar com facilidade casos de teste grandes.

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
fonte
$L7ׂ˜- tentou obter 5 bytes, não conseguiu.
Urna de polvo mágico
@carusocomputing: Sim, sinto que 6 bytes são demais, mas realmente não consigo ver uma maneira mais curta. Eu estava esperando que você escola me com um caminho mais curto;)
Emigna
Eu estava pensando .pou .smuito, mas mesmo aqueles que parecem mais tempo. Eu acertei acidentalmente 'refresh' na página TIO com meu exemplo de implementação, em vez de executar, excluí-o da existência. Eu acho que tinha 26 anos.
Urna Mágica do Polvo
11
@carusocomputing: É por isso que você sempre deve pressionar o botão de link regularmente. Não perca nada atualizando ou reiniciando o computador. Um pouco chato perder história embora :)
Emigna
7

Geléia , 21 20 19 18 bytes

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

Observe que a saída não corresponde aos OPs. Eu deixei um comentário.

Experimente online!

Como funciona

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.
Dennis
fonte
6

Python 2 , 116 113 109 bytes

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)

Observe que o TIO não possui memória suficiente para o último caso de teste.

Experimente online!

Dennis
fonte
4

JavaScript (ES6), 103 101 bytes

Recebe entrada na sintaxe de currying (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)

Casos de teste

O último caso de teste pode levar alguns segundos para ser concluído.

Arnauld
fonte
4

PHP, 142 bytes

$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 bytes removendo $r=[];e substituindo sort($r);por@sort($r);

Versão Online

Expandido

Uma função recursiva faz todas as permutações, incluindo o limite

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

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

Expandido

um loop até incluir o limite, verifique todos os valores divisíveis por 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);

Versão Online

alguns bytes a mais e uma matriz associativa pode ser criada, digite o número e, como valor, uma matriz dos setes usados

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

Versão Online

Jörg Hülsermann
fonte
while($c=$t*$v[+$i++])$l<$c?f($c)&$r[$c]=$c;salva 3 bytes; mas deveria ser $l<=$c. $r?sort($r)&print_r($r):0;em vez de $r=[];salva um.
Titus
11
$z.=7;é 5 bytes menor que $z=$z*10+7;.
Titus
e @é mais 4 bytes menor que $r?...:0;. (Obrigado @Christoph)
Titus
@Titus Por que deveria ser $l<=$c? Parece que ontem não era o meu dia para os $z.=72 bytes adicionais que encontrei. Estou pensando primeiro nas suas outras duas sugestões. Você perdeu o :loop enquanto
Jörg Hülsermann
Pedi ao OP para esclarecer. Na descrição, ele fala sobre resultados that are less than l, em seus exemplos eles are less than or equal. Dependendo do esclarecimento, $c>$l||.../ $c>$l?:...ou $c<$l&&...são os mais curtos.
Titus
4

Ruby, 89 86 bytes

Uma solução recursiva.

-3 bytes, lembrando que qualquer coisa que seja 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: []}

Experimente online!

Value Ink
fonte
3

Pitão , 22 bytes

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

Experimente online!

Especificações

  • Entrada: l[newline]n
  • Resultado: array containing the sorted result
Freira Furada
fonte
3

PHP, 128 125 130 129 127 123 bytes

funcionará até 22 7s, mas arredondará valores maiores (7 ** 23 é ponto flutuante em uma máquina de 64 bits).

3 bytes salvos por Jörg, 3 por mim, 5 4 1 adicionados para evitar aviso de resultados vazios.

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

recebe entrada de argumentos de linha de comando; execute -nrou experimente online .

demolir

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
Titus
fonte
11
for([,$c,$z]=$argv,$n=1+$c;$c<$z;em vez defor($n=1+$c=$argv[1];$c<$z=$argv[2];
Jörg Hülsermann 26/04
11
Use em @vez de $r&&para suprimir o aviso? $p<$z&&$r[$p]=$p
Christoph
Acabei de notar que deve ser $p>$z?:$r[$p]=$pdo exemplo n=1, l=343, é claro que ldeve ser incluído. Portanto, não há economia ao usar $p>$z||$r[$p]=$pou $p>$z?:$r[$p]=$p.
Christoph
11
@Christoph pedi ao OP para esclarecer. Obrigado por me lembrar @; será editado quando o OP responder.
Titus
11
@Christoph ambos parecem estar bem; e Indiferente realmente importa wether $p>$z||ou $p<$z&&. Eu vou ficar com a descrição.
Titus
3

Braquilog , 28 bytes

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

Há muito espaço para melhorias no próprio idioma, aqui; algumas coisas que escrevi parecem óbvias com algumas mudanças no design da linguagem. Esta é a maneira mais curta que encontrei na versão atual. Posso muito bem fazer algumas sugestões para o Brachylog que tornariam este programa mais eficiente, mais curto e mais legível.

Muito, muito devagar; O TIO atinge o tempo limite, mesmo na resposta não trivial mais simples possível; portanto, não faz muito sentido fornecer um link TIO. Eu verifiquei este programa executando-o localmente.

Esta é uma função (não um programa completo), cuja saída é um gerador (ao contrário de uma lista). Adicione .w⊥ao final da função se você quiser ver todas as saídas, em vez de apenas a primeira. (Observe que isso realmente não importa na prática, porque como o programa é muito lento para o TIO de qualquer maneira, você deve executá-lo localmente e o interpretador Brachylog local é executado em um REPL que pode descrever um gerador muito bem.)

Explicação

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.

fonte
2

Utilitários Bash + GNU, 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

Experimente online . O TIO leva cerca de um minuto para o último caso de teste. Meus resultados correspondem @ Dennis.

Trauma Digital
fonte
1

Pitão - 57 51 49 42 bytes

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

Tente

Maria
fonte
2
Bem-vindo ao PPCG! Existem muitos atalhos disponíveis, que podem reduzir seu código em muitos bytes. Você pode ir à nossa sala de chat e me mandar um ping, se quiser saber mais.
Freira vazada
11
Infelizmente, seu programa atual não gera os resultados corretos, a saber, que inclui 7e 77para sua entrada atual.
Leaky Nun
11
As maneiras de reduzir bytes incluem: usando em mvez de Fou Vetc. (programação funcional x controle de execução); usando em hQvez de @Q0; usando em eQvez de @Q1; usando em i*hQ]7Tvez do loop for longo para gerar 777...7.
Leaky Nun
@LeakyNun Muito obrigado pelas sugestões e pelo link da sala de bate-papo. Além disso, eu consertei.
Maria