Desenhe o arco de uma bola

35

Desenhe a trajetória parabólica de uma bola lançada.

A entrada é a velocidade inicial ascendente da bola, um número inteiro positivo v. A cada segundo, a bola move o 1espaço para a direita e os vespaços na vertical e depois vdiminui 1devido à gravidade. Assim, a velocidade ascendente finalmente desce do vque 0e para baixo para -v, finalmente, caindo de volta para sua altura inicial.

As posições da bola traçam uma parábola. Na posição horizontal x, sua altura é y=x*(2*v+1-x)/2, com (0,0)a posição inicial da bola no canto inferior esquerdo.

Arte ASCII de saída da trajetória da bola com Os nas coordenadas que ela ocupa. A saída deve ser um único pedaço de texto com várias linhas, não uma animação do caminho ao longo do tempo.

A saída não deve ter novas linhas iniciais e, no máximo, uma nova linha final. A linha inferior deve estar nivelada com a borda esquerda da tela, ou seja, sem espaços à esquerda extras. Os espaços à direita estão OK. Você pode assumir que a largura da linha de saída se encaixa no terminal de saída.

v = 1

 OO 
O  O

v = 2

  OO  
 O  O 

O    O

v = 3

   OO   
  O  O  

 O    O 


O      O

v = 4

    OO    
   O  O   

  O    O  


 O      O 



O        O

v = 10

          OO          
         O  O         

        O    O        


       O      O       



      O        O      




     O          O     





    O            O    






   O              O   







  O                O  








 O                  O 









O                    O

Related: Simulação de bola quicando

Entre os melhores:

Mostrar snippet de código

code-golf  ascii-art  physics 
— xnor
fonte
Podemos enviar uma lista de linhas?
— Rɪᴋᴇʀ
@Riker Nope, string com novas linhas.
— Xnor
Relacionado livremente: codegolf.stackexchange.com/q/110410
— Titus
Preciso apenas contabilizar V> 0?
— nmjcman101
Sim, v será positivo.
— Xnor

Respostas:

17

Carvão , 18 16 13 bytes

-3 bytes graças a @Neil !

Ｆ⊕Ｎ«←OＭ⊕ι↓»‖Ｃ

Explicação

Ｆ⊕Ｎ«        »    For ι (implicitly from 0) to (1 + input as number)
       ←O          Print O, with print direction rotated 180 degrees
         Ｍ⊕ι↓     Move 1+ ι units down

                ‖Ｃ Reflect (in the default direction, right), leaving original intact

Experimente online! Link é um código detalhado.

— Somente ASCII
fonte
Eu gosto muito deste, +1; A saída do OP também usa "O" maiúsculo. (Não que isso importe em tudo lol)
— Albert Renshaw
Se você usar ↘O, poderá fazer um loop de 0 a N, inclusive, o que economiza dois bytes imediatamente.
— Neil
@ Neil Obrigado! Além disso, este é um post muito antiga: P (e eu me pergunto se eu deveria estar usando os recursos mais recentes Provavelmente não.?)
— ASCII-only
Estritamente falando Eu só te salvou 1 byte medida em que os outros dois bytes que você estava substituindo ⁺¹com ⊕. No entanto, agora que você moveu ←de do ‖Ｃpara o, Opode salvar outro byte escrevendo ↙OＭι↓, então voltarei ao salvamento de dois bytes novamente.
— Neil
Você também esqueceu de atualizar seu link TIO. E tecnicamente acredito que agora permitimos recursos mais novos, mas não posso reivindicar crédito por esses bytes.
— Neil
6

C 93 93

(Note, alguém chegou a 87 nos comentários)

y,n;f(s){for(y=0;y<=s;){printf("%*c%*c",s-y+1,79,y*2+1,79);for(n=++y;s+1-n&&n--;)puts("");}}

Experimente online!

Legível: 

y,n;f(s){
    for(y=0;y<=s;){
        printf("%*c%*c",s-y+1,79,y*2+1,79);
        for(n=++y;s+1-n&&n--;)puts("");
    }
}

Notas:

Posso recolher ambos os loops em apenas um loop for iterando o número total de linhas emitidas, que é fornecido pela fórmula: n*-~n/2+1

y,n,r;f(s){
    for(r=s,y=n=0;r<s*-~s/2+1;)
        y==n?printf("%*c%*c",s-y+1,79,y*2+1,79),y=0,++n:r++,y++,puts("");
}

Mas acaba sendo ainda mais bytes do que apenas usar dois for-loops separados

— Albert Renshaw
fonte
Você pode salvar um byte incrementando sno início, desta forma:y,n;f(s){++s;for(y=0;y<s;){printf("%*c%*c",s-y,79,y*2+1,79);for(n=++y;s-n&&n--;)puts("");}}
— Steadybox 2/17/17
@Steadybox não será compilado para mim. Também eu tenho 90 bytes quando eu contei que (após a remoção de espaços em branco)
— Albert Renshaw
Tudo o que fiz foi adicionar o ++s;início e depois mudar y<=spara y<se s-y+1para s-ye s+1-npara s-n, portanto, ele deve ser compilado (e deve ter 91 bytes).
— Steadybox #
Parece que há algo errado com a codificação do bloco de código no meu comentário. Copiar e colar o código do comentário também não será compilado para mim.
— Steadybox #
11
— ceilingcat
5

GNU sed, 41

  • A pontuação inclui +1 de -rsinalizadores para sed.
s/$/OO/
:
s/(\s*) O( *)O$/&\n\1O \2 O/
t

A entrada é unária, como uma sequência de espaços - o comprimento da sequência é a entrada.

Experimente online .

— Trauma Digital
fonte
4

Python 2, 76 bytes

x=input()
for i in range(x):print' '*(x-i),'O'+' '*i*2+'O'+'\n'*(i-x+1and i)

Bem simples. O i-x+1and iobjetivo é evitar um monte de novas linhas finais.

— HyperNeutrino
fonte
Mover a nova linha para o início da impressão, como '\n'*(i-1)economiza 7 bytes, evitando as novas linhas à direita.
— Emigna
4

MATL , 19 17 bytes

Q:tqYsQ79Z?PtPv!c

Experimente no MATL Online! Ou verifique todos os casos de teste .

Explicação

Q        % Implicitly input v. Add 1
:        % Push [1 2 ... v+1]
tq       % Duplicate and subtract 1: pushes [0 1 ... v]]
Ys       % Cumulative sum: gives [0 1 3 6 ...]
Q        % Add 1: gives [1 2 4 7 ...]
79       % Push 79 (ASCII for 'O')
Z?       % Create sparse matrix from column indices [1 2 3 4 ...],
         % row indices [1 2 4 7 ...], and data 79
P        % Flip vertically
tP       % Duplicate, flip vertically
v        % Concatenate the two matrices vertically
!        % Transpose
c        % Convert to char. Implicitly display. Char 0 is shown as space
— Luis Mendo
fonte
4

05AB1E , 18 14 bytes

Guardado 4 bytes graças a Adnan

ƒ¶N×'ONúRÂJ}.c

Experimente online!

Explicação

ƒ                   # for N in [0 ... input]
 ¶N×                # push N newlines
    'O              # push "O"
      Nú            # pad with N spaces in front
        RÂ          # reverese and create a reversed copy
          J         # join everything to a string
           }        # end loop
            .c      # pad lines until centered
— Emigna
fonte
Para 14 bytes: ƒ¶N×'ONúRÂJ}.c:)
— Adnan
@Adnan Thanks! Eu tentei .ccom uma versão diferente, mas não funcionou bem na época. Esqueceu sobre a tentativa lo com um presente e completa esqueceu que úexiste :)
— Emigna
Definitivamente melhor do que o método zip que eu escolhi, abordagem interessante verticalmente.
— Magic Octopus Urn
4

JavaScript (ES6), 98 92 89 84 78 bytes

(-20 bytes graças a Arnauld!)

f=(v,i=0)=>i>v?"":" "[r="repeat"](v-i)+0+" "[r](2*i)+0+`
`[r](i++<v&&i)+f(v,i)

Uma solução recursiva. Esta é também a minha primeira vez resposta em JavaScript, então por favor seja gentil! Ainda estou aprendendo tudo o que essa linguagem interessante tem a oferecer, por isso as dicas de golfe são muito apreciadas. :)

Snippet de teste

Pode ser necessário rolar para ver a saída inteira.

f=(v,i=0)=>i>v?"":" "[r="repeat"](v-i)+0+" "[r](2*i)+0+`
`[r](i++<v&&i)+f(v,i)
<input id=i min=1 type=number><button onclick=alert(f(document.getElementById("i").value))>Submit</button>
Expandir snippet

— R. Kap
fonte
Além disso, a inclusão de variáveis ​​dentro de cadeias de backtick com ${}apenas salva bytes quando a parte variável é cercada por partes estáticas. Como tal, essas cadeias sempre devem começar e terminar com peças estáticas.
— Lucas
@ Arnauld Obrigado por todas as dicas! Eu realmente gostei disso! :)
— R. Kap
@ Luke Obrigado pelo conselho. Isso será útil. :)
— R. Kap
Você pode usar com segurança em 0vez de "0". Eles serão coagidos a cordas. E pensando bem: i++<v&&ina verdade, é um byte menor que (i<v)*++i.
— Arnauld
@ Arnauld Obrigado mais uma vez! :)
— R. Kap
3

RProgN 2 , 37 bytes

x=0xR{y@xy-` *`o` y2**`o...2y{[` };};

Entrando no meu tipo de linguagem de golfe antes que os idiomas adequados de golfe entrem.

Explicado

x=              # Set 'x' to the input
0xR{            # For everything between the input and 0
    y@          # Set the iteration value to y, for this function only.
    xy-` *      # Subtract y from x, repeat the string " " that many times.
    `o          # Push an "o" to the stack.
    ` y2**      # Push 2*y " "'s to the stack
    `o          # Push another "o" to the stack
    ...         # Concatenate the parts of this string together, giving us the two balls.
    2y{[` };    # For all numbers between 2 and y, add a newline.
};              #

Experimente online!

— ATaco
fonte
3

Retina, 29 19 bytes

 ?
$.`$*¶$&$'O$`$`O

Experimente online!

Recebe entrada como unário como uma corrida de espaços. Porta da minha resposta JavaScript. Editar: salvou 10 bytes graças a @ MartinEnder ♦.

— Neil
fonte
Só estou esperando que alguém faça um spin off da Retina chamado Retsina.
— Titus
3

Bash , 76 bytes

for((n=$1+1;--n;));{
yes ''|head -$n
r=$r›${n}AO
t=›${n}BO$t
}
echo O${r}O$t

Funciona apenas em um terminal, pois utiliza seqüências de escape ANSI . ›representa o byte CSI ( 0x9b ).

Execução de teste

$ # The terminal's encoding must be set to ISO-8859-1.
$
$ xxd -g 1 arc.sh
0000000: 66 6f 72 28 28 6e 3d 24 31 2b 31 3b 2d 2d 6e 3b  for((n=$1+1;--n;
0000010: 29 29 3b 7b 0a 79 65 73 20 27 27 7c 68 65 61 64  ));{.yes ''|head
0000020: 20 2d 24 6e 0a 72 3d 24 72 9b 24 7b 6e 7d 41 4f   -$n.r=$r.${n}AO
0000030: 0a 74 3d 9b 24 7b 6e 7d 42 4f 24 74 0a 7d 0a 65  .t=.${n}BO$t.}.e
0000040: 63 68 6f 20 4f 24 7b 72 7d 4f 24 74              cho O${r}O$t
$
$ bash arc.sh 1
 OO
O  O
$ bash arc.sh 2
  OO
 O  O

O    O
$ bash arc.sh 3
   OO
  O  O

 O    O


O      O
$ bash arc.sh 4
    OO
   O  O

  O    O


 O      O



O        O
— Dennis
fonte
Você pode usar sed $nqpara salvar um byte.
— Zeppelin #
Infelizmente não. Eu teria que usar o sed ${n}qque é mais longo.
— Dennis
Argh, entendo, você pode fazer isso sed $n\q, mas isso também não faz muito sentido, pois seria a mesma contagem de bytes que head!
— zeppelin
3

R, 89 bytes

a=2*v+3
x=matrix(" ",a,v^2+1)
for(k in 0:v)x[c(1-k,k+2)+v,k^2+1]="o"
x[a,]="\n"
cat(x,sep="")
  • Crie uma matriz de espaços (a variável a é a largura dessa matriz, economizando alguns bytes)
  • Preencha "o" s nos locais necessários, trabalhando de cima para baixo e para fora do arco
  • Adicione uma nova linha no final de cada linha da matriz
  • Recolha a matriz em uma única sequência e imprima

Esta é a minha primeira tentativa de golfe, comentários bem-vindos ...

— user2390246
fonte
3

Röda , 53 52 bytes

f n{seq 0,n|{|i|["
"*i," "*(n-i),"O"," "*i*2,"O"]}_}

Experimente online!

Uso: main { f(5) }

Versão não destruída:

function f(n) {
    seq(0, n) | for i do
        push("\n"*i, " "*(n-i), "O", " "*i*2, "O")
    done
}
— fergusq
fonte
Você pode usar uma nova linha literal em vez de \nsalvar 1 byte?
— Kritixi Lithos
@KritixiLithos Isso funciona. Obrigado!
— fergusq
2

Befunge, 75 73 bytes

<vp00:&
1<-1_:v#\+55:g01\-g01g00" O"1\*2g01" O"1p0
#@_\:v>$$:!
1\,:\_^#:-

Experimente online!

A primeira linha lê a velocidade, ve salva uma cópia na memória. A segunda linha faz uma contagem regressiva de v para zero, com o índice ie , em cada iteração, empurra uma sequência de pares de caracteres / comprimento para a pilha.

Length  Character
-----------------
1       'O'
i*2     ' '
1       'O'
v-i     ' '
i       LINEFEED

Essa sequência representa um tipo de codificação de execução da saída necessária no sentido inverso. As duas últimas linhas simplesmente retiram esses pares de caracteres / comprimento da pilha, produzindo ocorrências de comprimento de cada caractere , até que a pilha esteja vazia.

— James Holderness
fonte
2

Java 8, 129 124 109 bytes

Golfe:

v->{String s="",t="";for(int j,y=0;y<=v;++y){for(j=0;j<v;++j)s+=j<y?"\n":" ";s+="o"+t+"o";t+="  ";}return s;}

Experimente online!

Ungolfed:

public class DrawTheArcOfABall {

  public static void main(String[] args) {
    for (int i = 1; i < 6; ++i) {
      System.out.println(f(v -> {
        String s = "", t = "";
        for (int j, y = 0; y <= v; ++y) {
          for (j = 0; j < v; ++j) {
            s += (j < y ? "\n" : " ");
          }
          s += "o" + t + "o";
          t += "  ";
        }
        return s;
      } , i));
      System.out.println();
      System.out.println();
    }
  }

  private static String f(java.util.function.IntFunction<String> f, int v) {
    return f.apply(v);
  }
}
— Puxão
Para o segundo aninhado for loop, acho for(;j<v;++)que funcionaria, porque neste momento j==y. Além disso, você pode remover a terceira adicionando uma segunda variável de cadeia dentro do loop for principal String t="";(12) e t+=" ";(8) dentro do primeiro loop aninhado. Em seguida, o terceiro ciclo só se tornas+="o"+t+"o";
— nmjcman101
Além disso, você pode combinar os dois primeiros loops aninhados para for(j=0;j<v;++j)s+=j<y?"\n":" ";embora eu não tenho certeza como isso malhas com o meu comentário anterior sobret
— nmjcman101
Você pode inicializar t=""junto s no início, e depois adicionar t+=" "cada laço em torno depois de fazers+="o"+t+"o"
— nmjcman101
2

Haskell, 69 bytes

r=replicate
f n=[0..n]>>= \a->r a '\n'++r(n-a)' '++'O':r(2*a)' '++"O"

Exemplo de uso: f 3-> " OO\n O O\n\n O O\n\n\nO O". Experimente online! .

— nimi
fonte
2

VBA, 124 112 85 88 66 63 59 bytes

For i=0To[A1]:?Space([A1]-i)"O"Space(2*i)"O"String(i,vbCr):Next

Economizado 29 bytes no total graças a Taylor Scott

Isso deve ser executado na janela Imediata do VBA e imprimir o resultado da mesma forma.

Expandido / Formatado, torna-se:

For i=0 To [A1]
   Debug.Print Space([A1]-i) & "O" & Space(2*i) & "O" & String(i,vbCr)
Next

(Acontece que a concatenação em um comando de impressão é automática sem um operador.)

— Engenheiro Toast
fonte
b & s &Alerta de espaços!
— CalculatorFeline
Eu tentei e errou pela primeira vez. Voltando, percebi que ele se expandirá, b &s &Stringmas não b&s&String. Além disso, no começo, pensei que você pretendia usar a Spacefunção que eu deveria ter e que acabou economizando mais bytes.
— Engenheiro Toast
Você pode condensar for i=0 To ve debug.? bpara for i=0To ve Debug.?b, respectivamente, para -2bytes. E só assim você sabe, o consenso da comunidade é que para idiomas com formatação automática, você pode contar antes de ser Autoformatted, ou seja, depois de fazer essas alterações, você deve ter uma contagem de bytes de 85 Bytes
— Taylor Scott
Em uma segunda olhada, este é um trecho - não uma função ou sub-rotina; portanto, não é uma solução válida. Acredito que você poderia corrigir isso convertendo-o em uma função de janela imediata do Excel VBA e obtendo a entrada de [A1]( v=[A1]) Além disso, não acho que você realmente precise da svariável.
— Taylor Scott
11
@ TaylorScott Isso parece uma melhoria óbvia em retrospecto, mas eu não sabia que a concatenação não exigia um operador na janela imediata. Isso me poupará alguns bytes no futuro. Eu tive que adicionar um ;no final do comando de impressão, porque ele continuava adicionando uma quebra de linha extra por padrão. Obrigado!
— Engineer Toast
2

05AB1E , 18 13 bytes

ÝηRO«ð×'O«ζ»

Experimente online!

Ý                # [0..n]
 €LRO            # [0.sum(), 0..1.sum(), ..., 0..n-1.sum(), 0..n.sum()]
     «          # Mirror image the array [0, 0..n.sum(), 0]
       ð×'O«     # Push that many spaces with an O appended to it.
            .B   # Pad small elements with spaces to equal largest element length.
              ø» # Transpose and print.
— Urna de polvo mágico
fonte
1

Geléia , 17 16 bytes

‘Ḷ+\Ṛ⁶ẋ;€”Om0z⁶Y

Experimente online!

Quão?

‘Ḷ+\Ṛ⁶ẋ;€”Om0z⁶Y - Main link: v         e.g. 3
‘                - increment: v+1            4
 Ḷ               - lowered range             [0,1,2,3]
  +\             - reduce with addition      [0,1,3,6]
    Ṛ            - reverse                   [6,3,1,0]
     ⁶           - a space                   ' '
      ẋ          - repeat (vectorises)       ['      ','   ',' ','']
       ;€        - concatenate each with
         ”O      -     an 'O'                ['      O','   O',' O','O']
           m0    - concatenate reflection    ['      O','   O',' O','O','O','O ','O   ','O      ']
             z⁶  - transpose with space fill ['   OO   ','  O  O  ','        ',' O    O ','        ','        ','O      O']
               Y - join with line feeds      ['   OO   \n  O  O  \n        \n O    O \n        \n        \nO      O']
                 - implicit print
— Jonathan Allan
fonte
1

PHP, 76 bytes

for(;$argn>=0;$s.="  ")echo($r=str_repeat)("
",$i++),$r(" ",$argn--),o,$s,o;

Execute echo <v> | php -nR '<code>'ou teste on-line .

lacetes $argnpara baixo a partir da entrada para 0e $ia partir de 0;
imprime - nessa ordem - em cada iteração

  • $i novas linhas (nenhuma na primeira iteração)
  • preenchimento esquerdo: $argnespaços
  • bola esquerda: o
  • estofamento interno: 2*$i espaços
  • bola direita: o
— Titus
fonte
1

V , 23 19 bytes

2éoÀñYço/^2á O
HPJ>

Experimente online!

Explicar

2éo            " Insert two 'o's
   Àñ          " <Arg> times repeat
     Y         " Yank the current (top) line.  This is always '\s*oo'
      ço/      " On every line that matches 'o'
         ^     " Go to the first non-whitespace character (the 'o')
          2á   " Append two spaces (between the two 'o's
             O " Add a blank line on top of the current one
H              " Go to the first line
 P             " Paste in front ('\s*oo')
  J            " Join this line with the blank line immediately after it
   >           " Indent once
— nmjcman101
fonte
1

JavaScript (ES6), 87 bytes

f=
n=>' '.repeat(n+1).replace(/./g,"$`#$'O$`$`O").replace(/ *#/g,s=>[...s].fill``.join`
`)
<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>
Expandir snippet

Solução não recursiva. O requisito de indexação era irritante, tanto na solução recursiva anterior quanto nos seguintes 62 bytes (não sei se resultaria em uma porta Retina mais curta):

f=n=>~n?` `.repeat(n)+`OO`+f(n-1).replace(/^ *O/gm,`
$&  `):``
— Neil
fonte
0

Empilhados, 67 63 bytes

args 0#1+:@x:>{!n x\-1-' '*'O'+n 2*' '*+'O'+x 1-n!=n*LF*+out}"!

Tentativa inicial, 67 bytes

args 0# :@v 1+2*:>[:v:+1+\-2/*' '*'O'+''split]"!fixshape tr rev out

Programa completo. Gera algo como:

('O'
 ' ' 'O'
 ' ' 'O'
 'O')

Qual é o preenchido, transposto, revertido e emitido.

— Conor O'Brien
fonte
0

Lote, 163 bytes

@set l=@for /l %%i in (1,1,%1)do @call
@set s=
%l% set s= %%s%%
@set t=
%l%:c&for /l %%j in (2,1,%%i)do @echo(
:c
@echo %s%O%t%O
@set s=%s:~1%
@set t=  %t%
— Neil
fonte
0

Ruby, 52 bytes

->x{(0..x).map{|a|$><<$/*a+' '*(x-a)+?O+' '*a*2+?O}}

Nenhuma nova linha final (permitida pelas regras: " no máximo uma nova linha final ")

— GB
fonte
0

AHK, 93 bytes

m=0
n=1
f=%1%-1
Loop,%1%{
r=%r%{VK20 %f%}O{VK20 %m%}O{`n %n%}
m+=2
n++
f--
}
FileAppend,%r%,*

Se eu conseguisse descobrir como fazer matemática, pressionando repetidamente as teclas, isso seria ótimo.
- VK20equivale a um espaço
- FileAppendgera como stdoutse o nome do arquivo for*

— Engenheiro Toast
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.