Comece com os

18

Dado um número inteiro estritamente positivo n , siga estas etapas:

  1. Crie uma matriz A com n 1 s.
  2. Se A tiver apenas um elemento, termine. Caso contrário, a partir do primeiro elemento, substituir cada par de A com a sua soma, deixando o último elemento como é se um comprimento 's é estranho, e repita esta etapa.

A saída deve conter um estado 's depois de cada passo, a fim do primeiro passo para o último. É proibido o uso de brechas padrão . Este é um desafio do código-golfe , portanto a solução com o menor número de bytes em cada idioma vence.

Casos de teste

Cada linha na saída desses exemplos é um estado. Você pode imprimir através de qualquer formato razoável.

Entrada: 1

[1]

Entrada: 4

[1, 1, 1, 1]
[2, 2]
[4]

Entrada: 13

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 1]
[8, 5]
[13]

Entrada: 15

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 3]
[8, 7]
[15]
code-golf  arithmetic 
— Erik, o Outgolfer
fonte
Posso copiar essa idéia de perguntas pela ordem inversa? Dado o número n, imprima a etapa A e assim sucessivamente até chegar a n 1s?
— pixma140 22/08
9
@ pixma140 Esse seria essencialmente o mesmo desafio, apenas com a saída revertida posteriormente. A modificação é trivial.
— Erik the Outgolfer

Respostas:

4

MATL , 10 bytes

:g`t2estnq

Experimente online!

Como funciona

:     % Input n (implicit). Range [1 2 ... n]
g     % Convert to logical. Gives [1 1 ... 1]
`     % Do...while
  t   %   Duplicate
  2   %   Push 2
  e   %   Reshape as 2-column matrix, in column-major order, padding with 0 if needed
  s   %   Sum of each column
  t   %   Duplicate
  n   %   Number of elements
  q   %   Subtract 1. This will be used as loop condition
      % End (implicit). If top of the stack is not zero run new iteration
      % Display stack, bottom to top (implicit)
— Luis Mendo
fonte
4

Python 3 , 57 bytes

def f(i,j=1):print(i//j*[j]+[i%j][:i%j]);i>j and f(i,j*2)

Experimente online!

Python 2 , 51 bytes

def f(i,j=1):print i/j*[j]+[i%j][:i%j];i>j>f(i,j*2)

Experimente online!

-6 bytes no total graças ao tsh

Função recursiva. Para cada etapa, ele constrói uma lista de potências de 2, de modo que a soma seja menor ou igual ao número inteiro especificado. Em seguida, acrescenta o restante, se for maior que 0.

— Jitse
fonte
1
Python 3 61 bytes: def f(i,j=1):l=i//j*[j]+[i%j][:i%j];print(l);i>j and f(i,j*2); Python 2 55 bytes:def f(i,j=1):l=i/j*[j]+[i%j][:i%j];print l;i>j>f(i,j*2)
— tsh
@tsh Claro, obrigado! i>jnão funcionou na minha solução anterior e esqueci-me de tentar depois.
— Jitse 23/08
3

R , 65 bytes

-1 byte graças a Giuseppe.

n=scan();while(T<2*n){cat(rep(+T,n%/%T),if(n%%T)n%%T,"\n");T=2*T}

Experimente online!

%/%%%k=2^in%/%kkn%%k2n−1

Aqui estou usando em Tvez de k, uma vez que é inicializado como o TRUEqual é convertido em 1. Ainda preciso imprimir em +Tvez de Tevitar um vetor de TRUEs na saída.

— Robin Ryder
fonte
Bata-me em cerca de 5 minutos e quase 60 bytes ... Mas Giuseppe está certo, não produz o passo final.
— Sumner18
@ Sumner18 Deve ser corrigido agora.
— Robin Ryder
+Té mais curto queT+0
— Giuseppe
@ Giuseppe Obrigado, eu sabia que estava esquecendo algo.
— Robin Ryder
3

Pitão , 10 bytes

.u+McN2m1

Experimente online!

.u          # Apply until a result is repeated, return all intermediate steps: lambda N,Y:
  +M        # map by + (reduce list on +):
    cN2     # chop N (current value) into chunks of 2, last one is shorter if needed
       m1Q  # map(1, range(Q)) (implicit Q = input)

-1 byte graças a FryAmTheEggman

— ar4093
fonte
2

JavaScript, 55 bytes

f=(n,t=1,r=n)=>r>t?t+[,f(n,t,r-t)]:n>t?r+`
`+f(n,t+t):r

Experimente online!

Esta é basicamente a versão básica dos seguintes códigos:

function f(n) {
  var output = '';
  t = 1;
  for (t = 1; ; t *= 2) {
    for (r = n; r > t; r -= t) {
      output += t + ',';
    }
    output += r;
    if (n <= t) break;
    output += '\n';
  }
  return output;
}
— tsh
fonte
2

Braquilog , 17 bytes

;1j₍ẹẉ₂{ġ₂+ᵐ}ⁱ.ẉȮ

Experimente online!

Como terrivelmente desde que este é, ainda sinto um pouco inteligente para usar .ẉȮ: a maneira mais óbvia para imprimir algo, em seguida, verifique se o seu comprimento é de 1 seria ẉ₂l1, ẉ₂~gou ẉ₂≡Ȯ, onde o ≡na última é necessária porque ẉ₂unifica a sua entrada e saída antes de imprimi-los e Ȯé pré-restringido para ser uma lista de comprimento 1, portanto a unificação falha se a entrada não for uma lista de comprimento 1. No final de um predicado, esse recurso ẉ₂pode ser contornado, no entanto, por usando a variável de saída em vez de assinar ẉ: .ẉȮprimeiro unifica sua entrada com a variável de saída, depois imprime a variável de saída e somente depois unifica a variável de saída com Ȯ.

— String não relacionada
fonte
2

Stax , 10 bytes

Çë⌐ⁿ┤5π»Å╡

Execute e depure

Procedimento:

  1. Gere um intervalo baseado em 0.
  2. Divida pela metade cada elemento repetidamente até que todos os itens sejam zero.
  3. Calcule os comprimentos de execução para cada matriz exclusiva.

Fonte anotada:

r       main:[0 .. 5] 
{{hmgu  main:[[0 .. 5], [0, 0, 1, 1, 2, 2], [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0]] 
m:GJ    main:"1 1 1 1 1 1"
— recursivo
fonte
1

Carvão , 19 bytes

ＮθＩＥ↨⊖⊗θ²Ｅ⪪Ｅθ¹Ｘ²κＬλ

Experimente online! Link é a versão detalhada do código. Usa o formato de saída padrão do Charcoal, que é um número por linha, com sub-matrizes com espaçamento duplo. Explicação:

Ｎθ                  Input `n` into a variable
       θ            `n`
      ⊗             Doubled
     ⊖              Decremented
    ↨   ²           Converted to base 2 (i.e. ceil(log2(input)))
   Ｅ                Map
           Ｅθ¹      List of `1`s of length `n`
          ⪪         Split into sublists of length
               ²    Literal `2`
              Ｘ     To power
                κ   Loop index
         Ｅ          Map over each sublist
                 Ｌλ Take the length
  Ｉ                 Cast to string for implicit print
— Neil
fonte
1

Perl 6 , 38 bytes

{1 xx$_,*.rotor(2,:partial)>>.sum...1}

Experimente online!

Há algum atalho para a rotação parcial que eu não estou lembrando agora ...

Explicação:

{                                    }  # Anonymous code block
                                 ...    # Return a sequence
 1 xx$_,            # Starting with a list of 1s with input length
        *           # Where each element is
         .rotor(2,:partial)        # The previous list split into chunks of 2 or less
                           >>.sum  # And each chunk summed
                                    1  # Until the list is length 1
— Brincadeira
fonte
1

Haskell , 75 bytes

g.pure
g x|x!!0<2=[x]|1>0=(g$(\z->filter(0/=)[-div(-z)2,div z 2])=<<x)++[x]

Experimente online!

Funciona de trás para frente a partir da lista [n]até atingir uma lista de apenas alguns.

Indo para a frente, eu poderia ter 80 bytes utilizando chunksofa partir Data.List.Split:

import Data.List.Split
f x=g$1<$[1..x]
g[n]=[[n]]
g x=x:(g$map sum$chunksOf 2 x)

Experimente online!

— Brincadeira
fonte
0

Gaia , 12 bytes

ċ)¦⟨:q2/Σ¦⟩ª

Experimente online!

ċ)¦		| generate array of n 1's (really, generate array of n 0's and increment each)
   ⟨      ⟩ª	| do the following until you get to a fixed point:
    :q		| dup and print with a newline
      2/	| split into groups of 2, with last group possibly being smaller
	Σ¦	| take the sum
— Giuseppe
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.