Dibuja el arco de una pelota

35

Dibuja la trayectoria parabólica de una pelota lanzada.

La entrada es la velocidad ascendente inicial de la pelota, un número entero positivo v. Cada segundo, la bola mueve el 1espacio hacia la derecha y los vespacios verticalmente, y luego vdisminuye 1debido a la gravedad. Por lo tanto, la velocidad ascendente finalmente se baja de va 0y hacia abajo para -v, finalmente, volver a caer a su altura inicial.

Las posiciones de la pelota trazan una parábola. En posición horizontal x, su altura es y=x*(2*v+1-x)/2, con (0,0)la posición inicial de la pelota en la parte inferior izquierda.

Muestra el arte ASCII de la trayectoria de la pelota con Olas coordenadas que ocupa. El resultado debe ser un solo texto de varias líneas, no una animación de la ruta a lo largo del tiempo.

La salida no debe tener nuevas líneas principales y, como máximo, una nueva línea final. La línea inferior debe estar al ras con el borde izquierdo de la pantalla, es decir, no tener espacios iniciales adicionales. Los espacios finales están bien. Puede suponer que el ancho de la línea de salida se ajusta en el terminal de salida.

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

Relacionado: simulación de pelota que rebota

Tabla de clasificación:

Mostrar fragmento de código

code-golf  ascii-art  physics 
— xnor
fuente
¿Podemos superar una lista de líneas?
— Rɪᴋᴇʀ
@Riker No, cadena con nuevas líneas.
— xnor
vagamente relacionado: codegolf.stackexchange.com/q/110410
— Titus
¿Solo necesito dar cuenta de V> 0?
— nmjcman101
Sí, v será positivo.
— xnor

Respuestas:

17

Carbón , 18 16 13 bytes

-3 bytes gracias a @Neil !

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

Explicación

Ｆ⊕Ｎ«        »    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

Pruébalo en línea! El enlace es a código detallado.

— Solo ASCII
fuente
Este me gusta mucho, +1; También la salida de OP utiliza mayúsculas "O". (No es que importe en absoluto jajaja)
— Albert Renshaw
Si lo usa ↘O, puede pasar de 0 a N inclusive, lo que le ahorra dos bytes de inmediato.
— Neil
@Neil ¡Gracias! Además, esta es una publicación muy antigua: P (y me pregunto si debería estar usando funciones más nuevas. ¿Probablemente no?)
— ASCII-solo el
En sentido estricto sólo te he ahorrado 1 byte de la medida en que los otros dos bytes se le reemplazando ⁺¹con ⊕. Sin embargo, ahora que ha movido el ←de ‖Ｃal Opuede guardar otro byte escribiendo ↙OＭι↓, así que vuelvo a guardar un byte de dos bytes nuevamente.
— Neil
También olvidó actualizar su enlace TIO. Y técnicamente creo que ahora permitimos nuevas funciones, pero no puedo reclamar crédito por esos bytes.
— Neil
6

C, 93 92

(Nota, alguien llegó a 87 en los comentarios)

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("");}}

Pruébalo en línea!

Legible: 

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:

Puedo contraer ambos bucles en uno solo para iterar el número total de líneas generadas, que se obtiene mediante la 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("");
}

Pero termina siendo aún más bytes que simplemente usando dos bucles for separados

— Albert Renshaw
fuente
Puede guardar un byte incrementando sal principio, así: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
@Steadybox no compilará para mí. También obtuve 90 bytes cuando conté eso (después de eliminar los espacios en blanco)
— Albert Renshaw
Todo lo que hice estaba añadiendo el ++s;al principio y luego cambiar y<=sa y<sy s-y+1a s-yy s+1-na s-n, por lo que debe compilar (y debería ser de 91 bytes).
— Steadybox
Parece que hay algo mal con la codificación del bloque de código en mi comentario. Copiar y pegar el código del comentario tampoco me compilará.
— Steadybox
1
— ceilingcat
5

GNU sed, 41

  • La puntuación incluye +1 de -rbanderas a sed.
s/$/OO/
:
s/(\s*) O( *)O$/&\n\1O \2 O/
t

La entrada está en unario, como una cadena de espacios: la longitud de la cadena es la entrada.

Pruébalo en línea .

— Trauma digital
fuente
4

Python 2, 76 bytes

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

Bastante simple. El i-x+1and ies para evitar un montón de nuevas líneas finales.

— Hiperneutrino
fuente
Mover la nueva línea al comienzo de la impresión, como '\n'*(i-1)ahorra 7 bytes mientras evita las nuevas líneas finales.
— Emigna
4

MATL , 19 17 bytes

Q:tqYsQ79Z?PtPv!c

¡Pruébalo en MATL Online! O verificar todos los casos de prueba .

Explicación

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
fuente
4

05AB1E , 18 14 bytes

Guardado 4 bytes gracias a Adnan

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

Pruébalo en línea!

Explicación

ƒ                   # 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
fuente
Para 14 bytes: ƒ¶N×'ONúRÂJ}.c:)
— Adnan
@Adnan Gracias! Intenté .ccon una versión diferente, pero no funcionó bien entonces. Olvidé probarlo con este y olvidé que úexiste :)
— Emigna
Definitivamente mejor que el método zip que elegí, enfoque interesante verticalmente.
— Magic Octopus Urn
4

JavaScript (ES6), 98 92 89 84 78 bytes

(-20 bytes gracias a Arnauld!)

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

Una solución recursiva. Este es también mi primera vez respuesta en JavaScript, por favor suave! Todavía estoy aprendiendo todo lo que este lenguaje ordenado tiene para ofrecer, por lo que los consejos de golf son muy apreciados. :)

Fragmento de prueba

Es posible que deba desplazarse para ver la salida completa.

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 fragmento

— R. Kap
fuente
Además, incluir variables dentro de cadenas de retroceso con ${}solo guarda bytes cuando la parte variable está rodeada por partes estáticas. Como tal, estas cadenas siempre deben comenzar y terminar con partes estáticas.
— Luke
@Arnauld ¡Gracias por todos los consejos! ¡Realmente lo aprecio! :)
— R. Kap
@Luke Gracias por el consejo. Eso será util. :)
— R. Kap
Puede usarlo con seguridad en 0lugar de "0". Serán obligados a las cuerdas. Y pensándolo bien: en i++<v&&irealidad es un byte más corto que (i<v)*++i.
— Arnauld
@Arnauld ¡Gracias una vez más! :)
— R. Kap
3

RProgN 2 , 37 bytes

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

Entrar en mi tipo de lenguaje de golf antes de que entren los idiomas de golf adecuados.

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.
};              #

Pruébalo en línea!

— Un taco
fuente
3

Retina, 29 19 bytes

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

Pruébalo en línea!

Toma entrada en unario como una serie de espacios. Puerto de mi respuesta de JavaScript. Editar: Guardado 10 bytes gracias a @ MartinEnder ♦.

— Neil
fuente
Solo estoy esperando que alguien presente un spin-off de Retina llamado 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

Solo funciona en una terminal ya que usa secuencias de escape ANSI . ›representa el byte CSI ( 0x9b ).

Prueba de funcionamiento

$ # 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
fuente
Puede usar sed $nqpara guardar un byte.
— zepelín
Tristemente no. Tendría que usar el sed ${n}qque es más largo.
— Dennis
Argh, ya veo, puedes hacerlo sed $n\q, pero eso tampoco tiene mucho sentido, ¡ya que sería el mismo número de bytes que head!
— zepelín
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="")
  • Cree una matriz de espacios (la variable a es el ancho de esta matriz, ahorrando un par de bytes)
  • Complete "o" s en las ubicaciones requeridas, trabajando desde la parte superior del arco hacia abajo y hacia afuera
  • Agregue una nueva línea al final de cada fila de la matriz
  • Contraiga la matriz en una sola cadena e imprima

Este es mi primer intento de golf, comentarios bienvenidos ...

— usuario2390246
fuente
3

Röda , 53 52 bytes

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

Pruébalo en línea!

Uso: main { f(5) }

Versión sin golf:

function f(n) {
    seq(0, n) | for i do
        push("\n"*i, " "*(n-i), "O", " "*i*2, "O")
    done
}
— fergusq
fuente
¿Se puede usar una nueva línea literal en lugar de \ny guardar 1 byte?
— Kritixi Lithos
@KritixiLithos Eso funciona. ¡Gracias!
— fergusq
2

Befunge, 75 73 bytes

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

Pruébalo en línea!

La primera línea lee en la velocidad, v , y guarda una copia en la memoria. La segunda línea luego cuenta regresivamente de v a cero, con el índice i , y en cada iteración empuja una secuencia de pares de caracteres / longitud en la pila.

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

Esta secuencia representa un tipo de codificación de longitud de ejecución de la salida requerida a la inversa. Las últimas dos líneas simplemente eliminan estos pares de caracteres / longitud de la pila, generando apariciones de longitud de cada carácter , hasta que la pila esté vacía.

— James Holderness
fuente
2

Java 8, 129 124 109 bytes

Golfizado:

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;}

Pruébalo en línea!

Sin golf:

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);
  }
}
— Poke
Para el segundo bucle anidado, creo for(;j<v;++)que funcionaría, porque en este momento j==y. Además, puede eliminar el tercero agregando una segunda variable de cadena dentro del bucle principal for String t="";(12) y t+=" ";(8) dentro del primer bucle anidado. A continuación, el tercer bucle sólo se convierte ens+="o"+t+"o";
— nmjcman101
Además, puede combinar los dos primeros bucles anidados, for(j=0;j<v;++j)s+=j<y?"\n":" ";aunque no estoy seguro de cómo t
— encaja
Puede inicializar t=""junto a s al principio, y luego agregar t+=" "cada ciclo después de hacerlos+="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"

Ejemplo de uso: f 3-> " OO\n O O\n\n O O\n\n\nO O". Pruébalo en línea! .

— nimi
fuente
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

Ahorró 29 bytes en total gracias a Taylor Scott

Esto debe ejecutarse en la ventana Inmediato de VBA e imprimir el resultado en el mismo.

Ampliado / formateado, se convierte en:

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

(Resulta que la concatenación en un comando de impresión es automática sin un operador).

— Tostadas de ingeniero
fuente
b & s &Espacios alerta!
— CalculatorFeline
Lo intenté y erró la primera vez. Volviendo, me di cuenta de que se expandirá b &s &Stringpero no b&s&String. Además, al principio pensé que querías usar la Spacefunción que debería tener totalmente y que terminó ahorrando más bytes.
— Engineer Toast
Puede condensar for i=0 To vy debug.? bhacia for i=0To vy Debug.?b, respectivamente, por -2bytes. Y para que lo sepas, el consenso de la comunidad es que para los idiomas con autoformato, puedes contar antes de que se autoformete, lo que significa que después de realizar estos cambios deberías tener un recuento de bytes de 85 bytes
— Taylor Scott
En una segunda mirada, este es un fragmento, no una función o subrutina; entonces no es una solución válida. Creo que podría solucionar esto convirtiéndola en una función de ventana inmediata de Excel VBA y tomando la entrada de [A1]( v=[A1]) Además, no creo que realmente necesite la svariable.
— Taylor Scott
1
@TaylorScott Eso parece una mejora obvia en retrospectiva, pero no sabía que la concatenación no requería un operador en la ventana inmediata. Eso me ahorrará algunos bytes en el futuro. Sin embargo, tuve que agregar un ;al final del comando de impresión, porque seguía agregando un salto de línea adicional de forma predeterminada. ¡Gracias!
— Engineer Toast
2

05AB1E , 18 13 bytes

ÝηRO«ð×'O«ζ»

Pruébalo en línea!

Ý                # [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 pulpo mágico
fuente
1

Jalea , 17 16 bytes

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

Pruébalo en línea!

¿Cómo?

‘Ḷ+\Ṛ⁶ẋ;€”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
fuente
1

PHP, 76 bytes

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

Ejecutar echo <v> | php -nR '<code>'o probarlo en línea .

$argnbaja en bucle desde la entrada hasta 0y$i hacia arriba desde 0;
imprime, en ese orden, en cada iteración

  • $i nuevas líneas (ninguna en la primera iteración)
  • relleno izquierdo: $argn espacios
  • bola izquierda: o
  • acolchado interior: 2*$i espacios
  • bola derecha: o
— Titus
fuente
1

V , 23 19 bytes

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

Pruébalo en línea!

Explique

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
fuente
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 fragmento

Solución no recursiva. El requisito de indexación era molesto, tanto en lo anterior como en la siguiente solución recursiva de 62 bytes (no sé si resultaría en un puerto Retina más corto):

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

Apilado, 67 63 bytes

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

Intento inicial, 67 bytes

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

Programa completo Genera algo como:

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

Cuál es el acolchado, transpuesto, invertido y emitido

— Conor O'Brien
fuente
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
fuente
0

Ruby, 52 bytes

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

Sin nueva línea final (permitido por las reglas: " como máximo una nueva línea final ")

— GB
fuente
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%,*

Si pudiera descubrir cómo hacer matemáticas dentro de la repetición de pulsaciones de teclas, sería genial.
- VK20equivale a un espacio
- da como FileAppendresultado stdoutsi el nombre de archivo es*

— Tostadas de ingeniero
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.