Comprimentos de segmentos do conjunto Cantor generalizado

17

Problema

Vamos definir um conjunto de Cantores generalizados excluindo iterativamente alguns segmentos racionais de comprimento do meio de todos os intervalos que ainda não foram excluídos, iniciando em um único intervalo contínuo.

Dados os comprimentos relativos dos segmentos a serem excluídos ou não e o número de iterações a serem executadas, o problema é escrever um programa ou função que produza os comprimentos relativos dos segmentos que foram ou não foram excluídos após as niterações.

Exemplo 3,1,1,1,2

Exemplo: excluir iterativamente o quarto e o sexto oitavo

Entrada:

n - número de iterações, indexadas a partir de 0 ou 1

l- lista de comprimentos de segmentos como números inteiros positivos com gcd(l)=1e com comprimento ímpar, representando os comprimentos relativos das partes que permanecem como são ou são excluídas, iniciando em um segmento que não é excluído. Como o tamanho da lista é ímpar, o primeiro e o último segmento nunca são excluídos. Por exemplo, para o conjunto regular do Cantor, isso seria [1,1,1] para um terço que permanece, um terço que é excluído e novamente um terço que não.

Resultado:

Lista inteiro o, gcd(o)=1, de comprimentos de segmento em relação a nth iteração quando os segmentos que não foram eliminados na iteração anterior, é substituída por uma cópia reduzida da lista l. A primeira iteração é justa [1]. Você pode usar qualquer método de saída inequívoco , mesmo que unário.

Exemplos

n=0, l=[3,1,1,1,2] →                 [1]
n=1, l=[3,1,1,1,2] →     [3,    1,    1,    1,    2]
n=2, l=[3,1,1,1,2] → [9,3,3,3,6,8,3,1,1,1,2,8,6,2,2,2,4]

n=3, l=[5,2,3]     → [125,50,75,100,75,30,45,200,75,30,45,60,45,18,27]
n=3, l=[1,1,1]     → [1,1,1,3,1,1,1,9,1,1,1,3,1,1,1]

Você pode assumir que a entrada é válida. Isso é código-golfe , então o programa mais curto medido em bytes vence.

code-golf  sequence  fractal  recursion 
— Angs
fonte
Seria aceitável inserir e gerar os índices de segmentos não excluídos em vez dos comprimentos? Por exemplo, em [0, 1, 2, 4, 6, 7]vez de [3, 1, 1, 1, 2]?
@Mnemonic não está muito longe de ser unário, então eu diria que está tudo bem.
— Angs
Você poderia adicionar um (ou vários) casos de teste para listas de entrada de tamanho uniforme?
— Kevin Cruijssen 23/05
1
@KevinCruijssen as listas de entrada são garantidos para ser estranho porte
— Angs

Respostas:

6

Geléia ,  15 13  12 bytes

-2 graças a Dennis (o uso de um link em vez de uma cadeia permite que o direito seja usado implicitamente por ¡; Não há necessidade de agrupar a 1lista porque o Jelly imprime listas de um item da mesma forma que o item)
-1 graças a Erik the Outgolfer (use Ɗpara salvar a nova linha de usar Ç)

1×€³§JḤ$¦ẎƊ¡

Um programa completo que imprime uma lista no formato Jelly (assim [1]é impresso como 1)

Experimente online!

Quão?

1×€³§JḤ$¦ẎƊ¡ - Main link: segmentLengths; iterations
1            - literal 1 (start with a single segment of length 1)
           ¡ - repeat...
             - ...times: implicitly use chain's right argument, iterations
          Ɗ  - ...do: last 3 links as a monad (with 1 then the previous output):
   ³         - (1) program's 3rd argument = segmentLengths
 ×€          -  1  multiply €ach (e.g. [1,2,3] ×€ [1,2,1] = [[1,4,3],[2,4,2],[3,6,3]])
        ¦    -  2  sparse application... 
       $     - (2) ...to: indices: last two links as a monad:
     J       - (2)          range of length = [1,2,3,...,numberOfLists]
      Ḥ      - (2)          double            [2,4,6,...] (note: out-of bounds are ignored by ¦)
    §        - (2) ...of: sum each (i.e. total the now split empty spaces)
         Ẏ   -  3  tighten (e.g. [[1,2,3],4,[5,6,7]] -> [1,2,3,4,5,6,7])
             - implicit print
— Jonathan Allan
fonte
4

Haskell , 76 58 bytes

l%0=[1]
l%n=do(x,m)<-l%(n-1)`zip`cycle[l,[sum l]];map(*x)m

Experimente online!

A função (%)usa a lista de comprimentos de linha lcomo primeiro argumento e o número de iterações ncomo segunda entrada.

Obrigado a Angs e Ørjan Johansen por -18 bytes!

— Laikoni
fonte
Você deve ser capaz de salvar pelo menos 7 bytes por mudar para uma recursão em ne soltando #por completo
— Angs
Independentemente da sugestão de @Angs, o original %pode ser reduzido para l%a=do(x,m)<-zip a$a>>[l,[sum l]];(*x)<$>m .
— Ørjan Johansen
3

JavaScript (Firefox 42-57), 80 bytes

f=(n,l,i=0)=>n--?[for(x of l)for(y of(i^=1)?f(n,l):[eval(l.join`+`)**n])x*y]:[1]

Precisa dessas versões específicas porque usa compreensão de matriz e exponenciação.

— Neil
fonte
2

Java 10, 261 bytes

L->n->{if(n<1){L.clear();L.add(1);}else if(n>1){var C=new java.util.ArrayList<Integer>(L);for(int l=C.size(),i,x,t,s;n-->1;)for(i=x=0;i<L.size();){t=L.remove(i);if(i%2<1)for(;i%-~l<l;)L.add(i,C.get((i++-x)%l)*t);else{x++;s=0;for(int c:C)s+=c;L.add(i++,t*s);}}}}

Modifica a lista de entrada em vez de retornar uma nova para salvar bytes.

Experimente online.

L->n->{                       // Method with List and integer parameters and no return-type
  if(n<1){                    //  If `n` is 0:
    L.clear();                //   Remove everything from the List
    L.add(1);}                //   And only add a single 1
                              //  Else-if `n` is 1: Leave the List as is
  else if(n>1){               //  Else-if `n` is 2 or larger:
    var C=new java.util.ArrayList<Integer>(L);
                              //   Create a copy of the input-List
    for(int l=C.size(),       //   Set `l` to the size of the input-List
        i,x,t,s;              //   Index and temp integers
        n-->1;)               //   Loop `n-1` times:
      for(i=x=0;              //    Reset `x` to 0
          i<L.size();){       //    Inner loop `i` over the input-List
        t=L.remove(i);        //     Remove the current item, saving its value in `t`
        if(i%2<1)             //     If the current iteration is even:
          for(;i%-~l<l;)      //      Loop over the copy-List
            L.add(i,C.get((i++-x)%l)*t);
                              //       And add the values multiplied by `t`
                              //       at index `i` to the List `L`
        else{                 //     Else (the current iteration is odd):
          x++;                //      Increase `x` by 1
          s=0;for(int c:C)s+=c;
                              //      Calculate the sum of the copy-List
          L.add(i++,t*s);}}}} //      Add this sum multiplied by `t`
                              //      at index `i` to the List `L`
— Kevin Cruijssen
fonte
2

K (ngn / k) , 27 bytes

{x{,/y*(#y)#x}[(y;+/y)]/,1}

Experimente online!

{ }é uma função com argumentos xey

(y;+/y)um par de ye sua soma

{ }[(y;+/y)]projeção (também conhecida como currying ou aplicação parcial) de uma função diádica com um argumento. xserá (y;+/y)e yserá o argumento quando aplicado.

,1 lista singleton contendo 1

x{ }[ ]/aplique os xtempos de projeção

(#y)#xremodelar para o comprimento do resultado atual, ou seja, alternar entre o exterior ye sua soma

y* multiplique cada elemento acima pelo elemento correspondente do resultado atual

,/ concatenar

— ngn
fonte
1

Pitão , 20 bytes

us.e?%k2*bsQ*LbQGE]1

A entrada é uma matriz de segmentos e l, em seguida, iterações n. Experimente online aqui ou verifique todos os casos de teste de uma vez aqui .

us.e?%k2*bsQ*LbQGE]1   Implicit, Q=1st arg (segment array), E=2nd arg (iterations)
u                E     Execute E times, with current value G...
                  ]1   ... and initial value [1]:
  .e            G        Map G, with element b and index k:
        *bsQ               Multiply b and the sum of Q {A}
            *LbQ           Multiply each value of Q by b {B}
    ?%k2                   If k is odd, yield {A}, otherwise yield {B}
 s                       Flatten the resulting nested array
— Sok
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.