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: 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.

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

Python 2 , 120 107 104 103 100 99 89 bytes

f=lambda n,l:n and[x*y for i,x in enumerate(l)for y in[f(n-1,l),[sum(l)**~-n]][i%2]]or[1]

Experimente online!

Salvou

• -10 bytes, graças a Neil

R , 94 bytes

f=function(n,a)"if"(n,unlist(Map(function(g,i)g(i),c(c,sum),split(m<-a%o%f(n-1,a),row(m)))),1)

Experimente online!

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!

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.

JavaScript (Node.js) , 71 bytes

l=>f=(n,c=1,e)=>n--?''+l.map(_=>(e=!e)?f(n,c*_):eval(l.join`+`)**n*c):c

Experimente online!

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`

Gelatina , 13 bytes

Ø1××S¥ƭ€³Ẏ$¡Ṗ

Experimente online!

Programa completo. Saídas em 1vez de [1]. Irritantemente, ḋnão funciona como ×S¥neste contexto e ƭnão funciona bem com nilads. > _ <

APL (Dyalog Classic) , 20 bytes

{(∊⊢×⍵(+/⍵)⍴⍨≢)⍣⍺,1}

Experimente online!

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

Ruby , 73 bytes

->a,l{r=[1];a.times{s=p;r=r.flat_map{|x|(s=!s)?l.map{|y|x*y}:x*l.sum}};r}

Experimente online!

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