O ziguezague sempre amplificador

24

Escreva um programa ou função que receba um número inteiro positivo N e emita os primeiros números N desse padrão em zigue-zague de amplificação, usando apenas as linhas necessárias:

                                         26
                                       25  27                                      .
         10                          24      28                                  .
        9  11                      23          29                              .
 2     8     12                  22              30                          44
1 3   7        13              21                  31                      43
   4 6           14          20                      32                  42
    5              15      19                          33              41
                     16  18                              34          40
                       17                                  35      39
                                                             36  38
                                                               37

Então, se N é 1a saída é

1

Se N for 2, a saída é

 2
1

Se N é 3a saída é

 2
1 3

Se N é 4a saída é

 2
1 3
   4

Se N é 10a saída é

         10
        9
 2     8
1 3   7
   4 6
    5

Se N é 19a saída é

         10
        9  11
 2     8     12
1 3   7        13
   4 6           14
    5              15      19
                     16  18
                       17

e assim por diante.

Notas

  • Cada pico ou calha do zigue-zague atinge seu ponto a mais uma linha da linha com a 1do que o pico ou calha anterior.

  • N não está limitado a 44. O ziguezague cresce no mesmo padrão e N maior deve ser suportado.

  • Números com vários dígitos devem "tocar" apenas nos cantos, conforme mostrado. Verifique se isso funciona quando N está 100acima.

  • Não deve haver linhas vazias (ou apenas espaço) na saída, exceto uma nova linha à direita opcional.

  • Qualquer linha pode ter qualquer quantidade de espaços à direita.

Pontuação

O código mais curto em bytes vence. O desempatador é a resposta anterior.

Passatempos de Calvin
fonte
Qual é o máximo possível de N?
Julie Pelletier
@JuliePelletier Em teoria, não há, mas você pode assumir que será menor que 2 ^ 16.
Passatempos de Calvin
É permitido o uso de caracteres de controle ou estamos limitados a espaços de dígitos e alimentações de linha?
Dennis
2
@ Dennis Vamos dizer não. Apenas dígitos / espaços / novas linhas.
Passatempos de Calvin
11
Alguém deveria enviar isso para o OEIS nesse formato como uma piada.
DanTheMan

Respostas:

10

Geléia , 41 37 29 bytes

RDµḌ’½Ċ-*_\x©L€Ṣ.ị®ạ€⁶ẋj"FZj⁷

Experimente online!

Como funciona

RDµḌ’½Ċ-*_\x©L€Ṣ.ị®ạ€⁶ẋj"FZj⁷  Main link. Argument: n (integer)

R                              Range; yield [1, ..., n].
 D                             Decimal; yield A =: [[1], ..., [1, 0], ...].
  µ                            Begin a new, monadic chain. Argument: A
   Ḍ                           Undecimal; convert back to falt range.
    ’                          Decrement to yield [0, ..., n-1].
     ½Ċ                        Take the square root and round up (ceil).
       -*                      Elevate -1 to each rounded square root.
         _\                    Cumulatively reduce by subtraction.
                               This yields [1, 2, 1, 0, -1, 0, ...], i.e., the
                               vertical positions of the digits in A.
             L€                Compute the length of each list in A.
           x                   Repeat the nth position l times, where l is the
                               nth length.
            ©                  Copy the result to the register.
               Ṣ               Sort.
                .ị             At-index 0.5; yield the last and first element,
                               which correspond to the highest and lowest position.
                  ạ€®          Take the absolute difference of each position in the
                               register and the extrema.
                               This yields the number of spaces above and below
                               the integers in r as a list of pairs.
                     ⁶ẋ        Replace each difference with that many spaces.
                         F     Flatten the list A.
                       j"      Join the nth pair of strings of spacing, separating
                               by the nth digit in flat A.
                          Z    Zip/transpose the result.
                           j⁷  Join, separating by linefeeds.
Dennis
fonte
2
Por que não criar uma função em seu idioma (Jelly) que faça isso em alguns caracteres enquanto você está nisso?
Julie Pelletier
19
@JuliePelletier A arte de escrever uma boa linguagem para o golfe é criar um conjunto de instruções (e sintaxe / semântica da linguagem) que permitem que você escreva soluções curtas para o maior número possível de tarefas, não sobre resolver uma questão muito específica. e desafio artificial em um único byte. Uma boa linguagem de golfe tende a ser realmente muito poderosa e expressiva, em vez de ser apenas uma coleção de itens internos que são inúteis para qualquer coisa, exceto a função específica que eles calculam.
Martin Ender
@JuliePelletier E isso também iria contra as regras do PPCG SE
Bálint
8

PHP, 211 177 164 163 bytes

Preveja os picos com $ne aumente a matriz dinamicamente em qualquer direção, usando ($x, $y)o cursor de saída.

Os números estão alinhados str_pad()e a saída final é a implode()dessa matriz de strings ( $g).

for($x=0,$d=-1,$h=$n=2,$y=$a=1;$a<=$argv[1];$y+=$d){$g[$y]=str_pad($g[$y],$x).$a;$x+=strlen($a);if($a++==$n){$h+=2;$n+=$h-1;$d*=-1;}}ksort($g);echo implode(~õ,$g);

Teste online!

Atualização: removidos 34 bytes, livrando-se do desnecessário array_pad (). Update2: seguiu o conselho de @ insertusernamehere para reduzi-lo um pouco mais. Update3: seguiu o conselho de @ Lynn de salvar mais um byte com ~ õ, o que impõe o uso do conjunto de caracteres LATIN-1. (não está disponível no emulador PHP online, portanto não está incluído)

Julie Pelletier
fonte
Apenas uma pergunta sobre esse código. Você não precisa inicializar a matriz $ g antes de acessar um elemento específico? Quero dizer, dando um comprimento ou inserindo as linhas? Não tenho muita experiência com PHP, então isso me parece estranho ... Obrigado.
Yotam Salmon
Não. Depois de definir $arr = [];, você pode consultar $arr[anything]. Alguns casos produzirão avisos, mas esses serão ignorados aqui. Observe que ler coisas como essa provavelmente não ajudará muito a aprender um idioma. Seu comentário me fez perceber que eu poderia reduzi-lo ainda mais, pois inicialmente pensei que precisaria preencher minha matriz, mas não preciso. :)
Julie Pelletier
Haha contente por ajudar;) Só percebi que em PHP uma matriz e um dicionário são inicializados da mesma forma e são completamente o mesmo quando se olha para a sintaxe (Por que, PHP ?!)
Yotam Salmon
Algumas pequenas melhorias - 164 bytes : for($x=0,$d=-1,$h=$n=2,$y=$a=1;$a<=$argv[1];$y+=$d){$g[$y]=str_pad($g[$y],$x).$a;$x+=strlen($a);if($a++==$n){$h+=2;$n+=$h-1;$d*=-1;}}ksort($g);echo implode("⏎",$g);(Substitua ⏎ com uma nova linha real.)
insertusernamehere
Eu acredito que se você configurar sua codificação correta (Latin-1, não UTF-8), é uma alternativa de dois bytes para "⏎".
Lynn
8

Pitão, 60 53 52 46 42 39 38 36 34 32 31 bytes

39: Agora está em pé de igualdade com a versão corrigida por bug do Jelly , e eu superei a versão concorrente de Dennis!

38: Eu tenho Dennis fora de golfe!

36: Dennis voltou a jogar golfe!

34: Ainda mais baixo que a versão corrigida por erros!

31: 32 -> 31 graças a Dennis.

[email protected] ++ *] * dl`hkabhSK`hk *] * dl`hkabeSKKd 
[email protected] *] * dl`hkhaeSKhSKabhSKhkKd 
J1K.u + N=J_WsI@Y2JtQZ=-RhSKKjsM.t.eX *] * dl`hkheSKbhkKd 
J1K.u+N=J_WsI@Y2JtQQj-#dsMC.eX *] * dl`hkheSKbhkK 
J1j- # dsMC.eX + Qbhkm = + Z = J_WsI @ td2J 
J1j- # dsMCmX *] *; l`hdyQ + Q = + Z = J_WsI @ td2Jhd 
J1j- # dsMCmX *] *; l`hdyQ + Q = + Z = J_WsI @ 
td2Jh - # dsMCmX *] *; l`hdyQ + Q = + Z = @ _ BJsI @ td2h 
j- # dsMCmX *] *; l`hdyQ + Q = + Zsty% s @ td2 2h 
j- # dsMCmX *] *; l `hdyQ + Q = + Z @ _B1.E @ d2h 
JQj- # dsMCmX *] *; l`hdyQ = + J @ _B1.E @ d2h 
JyQj- # dsMCmX *] *; l`hdJ = + Q @ _B1. E @ d2h
 j- # dsMCmX *] *; l`hdyQ = + Q @ _B1.E @ d2h
j- # dsMCmX *] *; l`hdyQ=+Q^_1.E@d2h

Experimente online!

Como funciona

j-#dsMCmX*]*;l`hdyQ=+Q^_1.E@d2h      input: Q
j-#dsMCmX*]*;l`hdyQ=+Q^_1.E@d2hdQ    implicit filling arguments

       m                        Q    for each number d from 0 to Q-1:
                           @d2           yield the square root of d.
                         .E              yield its ceiling.
                      ^_1                raise -1 to that power. this
                                         yields the desired direction.
                   =+Q                   increment Q by this amount.

               hd                        yield d+1.
              `                          yield its string representation.
             l                           yield its length.
           *;                            repeat " " for that number of times
          ]                              yield a list containing the string above.
         *       yQ                      repeat the list for Q*2 times.
                                         the Q has changed, but Q*2 is
                                         an overshoot that is high
                                         enough, so we don't have to
                                         worry about it.

        X                                in that list, replace the
                                         element with index being the
                                         number generated above
                              hd         with d+1.

      C                              transpose the resulting array.
    sM                               flatten each element.
 -#d                                 remove lines containing only spaces.
                                     (filter on truthiness of set difference with space)
j                                    join by newlines.
Freira Furada
fonte
2
" 39: Igual a Jelly "; " 38: Tenho out-golfed Dennis! " Por algumas horas que você fez, mas parece que @ Dennis não gosta de apanhar no código-golfe: Jelly 37 bytes ;)
Kevin Cruijssen
11
@KevinCruijssen Done.
Leaky Nun
Agradável! xD M̶a̶y̶b̶e̶ Eu tenho uma imaginação selvagem, mas agora imagino que você olhou e olhou frustrado por horas até finalmente encontrar essa solução mais curta, e agora o @Dennis acorda casualmente e diminui seu código novamente. (Jk, eu espero que você fique abaixo Dennis!)
Kevin Cruijssen
@KevinCruijssen Tada! Agora é mais baixo que a versão corrigida por bug.
Leaky Nun
5

MATLAB, 148 bytes

n=input('');k=fix(n^.5);m=0;w=1;d=-1;for l=1:n;s=num2str(l);m(k+1,w:w+nnz(s)-1)=s;w=w+nnz(s);k=k+d;d=d*(-1)^(l^.5==fix(l^.5));end;[m(any(m,2),:),'']

Observe que os espaços estão ausentes no Oitava, pois o MATLAB imprime o caractere indexado com 0 como espaço, enquanto a oitava apenas omite esse caractere.

Explicação:

n=input('');
k=fix(n^.5);                    %caculate starting height
m=0;w=1;d=-1;                   %initialize counters and output matrix
for l=1:n;
    s=num2str(l);
    m(k+1,w:w+nnz(s)-1)=s;      %insert current index as a string
    w=w+nnz(s);                 %current horizontal position
    k=k+d;                      %current vertical position
    d=d*(-1)^(l^.5==fix(l^.5)); %if we reached a square number, change direction
end
[m(any(m,2),:),'']              %delete all zero rows
flawr
fonte
3

Haskell, 144 142 bytes

g n|k<-take n$scanl(+)0$[1..]>>= \x->(-1)^x<$[2..2*x]=unlines[[1..n]>>= \x->show x#(k!!(x-1)==y)|y<-[minimum k..maximum k]]
s#g|g=s|1<2=' '<$s

Exemplo de uso:

*Main> putStr $ g 19
         10                  
        9  11                
 2     8     12              
1 3   7        13            
   4 6           14          
    5              15      19
                     16  18  
                       17    

Como funciona:

s#g|g=s|1<2=' '<$s              -- # is a helper function that expects a string s
                                -- and a boolean g. It returns s if g is True, else
                                -- as many spaces as there a characters in s 

k<-take n$                      -- bind k to the first n elements of
 [1..]>>= \x->(-1)^x<$[2..2*x]  -- 2*x-1 copies of (-1)^x for each x in [1,2,3,...]
                                -- i.e. [-1, 1,1,1, -1,-1,-1,-1,-1, 1,1,1,1,1,1,1..]
 scanl(+)0                      -- build partial sums, starting with 0
                                -- i.e. [0,-1,0,1,2,1,0,-1,-2,-3,-2,-1...]
                                -- -> k is the list of y coordinates for the
                                --    numbers 1,2,3,...

 [  |y<-[minimum k..maximum k]] -- for all y coordinates in k 
      \x->show x#(k!!(x-1)==y)  -- map the # function
  [1..n]>>=                     -- over [1..n] (the x coordinates)
                                -- where # is called with
                                --  s -> a string representation of x 
                                --  g -> True if k at index x equals the current y
unlines                         -- join with newlines

Edit: Obrigado @Lynn por dois bytes!

nimi
fonte
2

JavaScript (ES6), 213 bytes

with(Math)n=>(a=[...Array(n)].map((_,i)=>n-=1+sqrt(--i)&1||-1).map((e,_,a)=>e-min(...a))).map((e,i)=>r[e][i]=++i,r=[...Array(1+max(...a))].map(_=>a.map((_,i)=>` `.repeat(1+log10(++i)))))&&r.map(a=>a.join``).join`\n`

Onde \nrepresenta um caractere literal de nova linha. Explicação:

with(Math)                          Bring functions into scope
 n=>                                Accepts one parameter
  (a=                               Intermediate result variable
   [...Array(n)].map(               For each number 0..n-1
    (_,i)=>n-=                      Accumulate index for each number
     1+sqrt(--i)&1||-1              Calculate the direction
    ).map((e,_,a)=>e-min(...a))     Scale the smallest index to zero
  ).map((e,i)=>r[e][i]=++i,         Overwrite the padding with 1..n
   r=[...Array(1+max(...a))].map(   Calculate number of lines
    _=>a.map((_,i)=>                For each number 1..n
     ` `.repeat(1+log10(++i)))))    Calculate the padding needed
  &&r.map(a=>a.join``).join`\n`     Join everything together

Para encurtar pow(-1,ceil(sqrt(i))), reescrevo-o, ​​pois, sqrt(i-1)&1||-1no entanto, isso não funciona, i=0portanto, para corrigir o problema, eu adiciono 1, mas isso muda o sinal do resultado e é por isso que eu acabo n-=.

Neil
fonte
ei, você recebeu um crachá de ouro! bom trabalho! e santo fuma você quase tem tanto representante quanto eu. continue!
Conor O'Brien
11
@ CᴏɴᴏʀO'Bʀɪᴇɴ Esse é "apenas" o distintivo Fanático. Aparentemente, estou muito perto de receber o crachá de ouro com código de golfe!
Neil
duplo fumo sagrado. Eu preciso me mover XD
Conor O'Brien
1

Python 2, 137 bytes

l={}
i=x=y=n=v=0
exec"v+=1;l[y]=l.get(y,'').ljust(x)+`v`;x+=len(`v`);i=-~i%-~n;y+=n%4-1;n+=2>>i*2;"*input()
for k in sorted(l):print l[k]

Veja a saída no ideone .

Lynn
fonte
Hum ... Não continua e continua e continua.
Zizouz212
@ Zizouz212 Sim, a ideona apenas possui uma saída fixa e quebra automaticamente as linhas que são muito longas.
flawr