Dessiner l'arc d'une balle

35

Tracez la trajectoire parabolique d’une balle lancée.

L'entrée est la vitesse ascendante initiale de la balle, un entier positif v. Chaque seconde, la balle se déplace à 1droite de l' espace et des vespaces verticalement, puis vdiminue 1à cause de la gravité. Ainsi, la vitesse vers le haut les étapes finalement vers le bas de vla 0bas pour -v, finalement tomber vers le bas à sa hauteur initiale.

Les positions de la balle tracent une parabole. En position horizontale x, sa hauteur est y=x*(2*v+1-x)/2, avec (0,0)la position initiale de la balle en bas à gauche.

Affiche l'art de la trajectoire de la balle en ASCII avec Oles coordonnées qu'elle occupe. La sortie doit être un texte unique de plusieurs lignes, et non une animation du chemin sur une période donnée.

La sortie ne doit pas comporter de nouvelles lignes majeures et au plus une nouvelle ligne. La ligne du bas doit être au même niveau que le bord gauche de l’écran, c’est-à-dire qu’elle ne doit pas contenir d’espace de lecture supplémentaire. Les espaces de fin sont OK. Vous pouvez supposer que la largeur de la ligne de sortie correspond au terminal de sortie.

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

Connexes: simulation de balle qui rebondit

Classement:

Afficher l'extrait de code

code-golf  ascii-art  physics 
— Xnor
source
Peut-on sortir une liste de lignes?
— Rɪᴋᴇʀ
@Riker Nope, chaîne avec des nouvelles lignes.
— xnor
— Titus
Dois-je seulement tenir compte de V> 0?
— nmjcman101
Oui, v sera positif.
— xnor

Réponses:

17

Charbon de bois , 18 16 13 octets

-3 octets grâce à @Neil !

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

Explication

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

Essayez-le en ligne! Le lien est en code verbeux.

— ASCII seulement
source
J'aime beaucoup celui-ci, +1; La sortie d'OP utilise également la lettre majuscule "O". (Pas que ça compte du tout lol)
— Albert Renshaw
Si vous utilisez ↘Oalors vous pouvez utiliser la boucle de 0 à N inclus, ce qui vous évite immédiatement deux octets.
— Neil
@Neil Merci! En outre, ceci est un très vieux post: P (et je me demande si je devrais utiliser de nouvelles fonctionnalités. Probablement pas?)
— ASCII seulement
Strictement parlant , je ne vous ai sauvé 1 octet pour autant que les deux autres octets ont été vous remplacer ⁺¹avec ⊕. Cependant, maintenant que vous avez déplacé le ←de le ‖Ｃvers le, Ovous pouvez enregistrer un autre octet en écrivant ↙OＭι↓. Je suis donc revenu à l'enregistrement sur deux octets.
— Neil
Aussi, vous avez oublié de mettre à jour votre lien TIO. Et techniquement, je pense que nous autorisons désormais les nouvelles fonctionnalités, mais je ne peux pas demander de crédit pour ces octets.
— Neil
6

C, 93 92

(Remarque, quelqu'un a 87 dans les commentaires)

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

Essayez-le en ligne!

Lisible: 

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

Remarques:

Je peux réduire les deux boucles for en une boucle en itérant le nombre total de lignes générées, ce qui est donné par la formule: 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("");
}

Mais il finit par être encore plus d'octets que d'utiliser simplement deux boucles for séparées.

— Albert Renshaw
source
Vous pouvez enregistrer un octet en incrémentant sau début, comme 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("");}}
— suit
@Steadybox ne compilera pas pour moi. Aussi, j'ai eu 90 octets quand j'ai compté ça (après avoir enlevé les caractères d'espacement)
— Albert Renshaw
Tout ce que je n'ajoutais le ++s;début, puis changer y<=sà y<set s-y+1à s-yet s+1-nà s-n, il devrait donc compiler (et devrait être 91 octets).
— Steadybox
Il semble qu'il y ait un problème avec l'encodage du bloc de code dans mon commentaire. Copier et coller le code du commentaire ne me compilera pas non plus.
— Steadybox
1
— ceilingcat
5

GNU sed, 41

  • Le score inclut +1 des -rdrapeaux au sed.
s/$/OO/
:
s/(\s*) O( *)O$/&\n\1O \2 O/
t

L'entrée est unaire, comme une chaîne d'espaces - la longueur de la chaîne est l'entrée.

Essayez-le en ligne .

— Trauma numérique
source
4

Python 2, 76 octets

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

Assez simple. Le i-x+1and iest d'éviter un tas de nouvelles lignes de fuite.

— HyperNeutrino
source
Déplacez la nouvelle ligne au début de l'impression, comme si vous '\n'*(i-1)enregistriez 7 octets tout en évitant les nouvelles lignes.
— Emigna
4

MATL , 19 17 octets

Q:tqYsQ79Z?PtPv!c

Essayez-le sur MATL Online! Ou vérifiez tous les cas de test .

Explication

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

05AB1E , 18 14 octets

4 octets sauvés grâce à Adnan

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

Essayez-le en ligne!

Explication

ƒ                   # 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
source
Pour 14 octets: ƒ¶N×'ONúRÂJ}.c:)
— Adnan
@Adnan Merci! J'ai essayé .cavec une version différente, mais cela n'a pas bien fonctionné à ce moment-là. Oublié d'essayer avec celui-ci et complète oublié qui úexiste :)
— Emigna
Certainement mieux que la méthode zip que j'ai choisie, approche intéressante verticalement.
— Magic Octopus Urn
4

JavaScript (ES6), 98 92 89 84 78 octets

(-20 octets grâce à Arnauld!)

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

Une solution récursive. Ceci est ma première jamais réponse en JavaScript, donc s'il vous plaît soyez doux! J'apprends encore tout ce que ce langage a à offrir, alors les astuces pour jouer au golf sont très appréciées. :)

Test Snippet

Vous devrez peut-être faire défiler pour voir la sortie entière.

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>
Développer l'extrait

— R. Kap
source
En outre, l'inclusion de variables dans les chaînes de pièces jointes avec ${}uniquement l'enregistrement des octets lorsque la partie variable est entourée de parties statiques. En tant que tels, ces chaînes doivent toujours commencer et se terminer par des parties statiques.
— Luc
@Arnauld Merci pour tous les conseils! J'apprécie vraiment cela! :)
— R. Kap
@ Luke Merci pour le conseil. Cela vous sera utile. :)
— R. Kap
Vous pouvez utiliser en toute sécurité 0au lieu de "0". Ils seront forcés à des ficelles. Et à la réflexion: i++<v&&iest en fait un octet plus court que (i<v)*++i.
— Arnauld
@Arnauld Merci encore une fois! :)
— R. Kap
3

RProgN 2 , 37 octets

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

Entrer dans ma langue de golfy avant que les langauges golfy appropriés n'interviennent.

A expliqué

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

Essayez-le en ligne!

— ATaco
source
3

Retina, 29 19 octets

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

Essayez-le en ligne!

Prend des entrées unaires comme une série d'espaces. Port de ma réponse JavaScript. Edit: 10 octets enregistrés grâce à @ MartinEnder ♦.

— Neil
source
Je n'attends que quelqu'un qui propose Retsina.
— Titus
3

Bash , 76 octets

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

Ne fonctionne que dans un terminal car il utilise des séquences d'échappement ANSI . ›représente l'octet CSI ( 0x9b ).

Essai

$ # 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
source
Vous pouvez utiliser sed $nqpour sauvegarder un octet.
— Zeppelin
Malheureusement non. Je devrais utiliser sed ${n}qce qui est plus long.
— Dennis
Argh, je vois, vous pouvez le faire à la sed $n\qplace, mais cela n’a pas beaucoup de sens non plus, car ce serait le même nombre d’octets que head!
— Zeppelin
3

R, 89 octets

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="")
  • Créer une matrice d'espaces (la variable a est la largeur de cette matrice, économisant quelques octets)
  • Remplissez les "o" aux endroits requis, en partant du haut de l’arc vers le bas et vers l’extérieur.
  • Ajouter une nouvelle ligne à la fin de chaque ligne de la matrice
  • Réduire la matrice en une seule chaîne et imprimer

Ceci est ma première tentative de golf, commentaires bienvenus ...

— utilisateur2390246
source
3

Röda , 53 52 octets

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

Essayez-le en ligne!

Usage: main { f(5) }

Version non-golfée:

function f(n) {
    seq(0, n) | for i do
        push("\n"*i, " "*(n-i), "O", " "*i*2, "O")
    done
}
— Fergusq
source
Pouvez-vous utiliser un saut de ligne au lieu de \net économiser 1 octet?
— Kritixi Lithos
@KritixiLithos Cela fonctionne. Merci!
— Fergusq
2

Befunge, 75 73 octets

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

Essayez-le en ligne!

La première ligne lit la vélocité, v , et enregistre une copie en mémoire. La deuxième ligne décompte ensuite de v à zéro, avec l’indice i , et à chaque itération pousse une séquence de paires caractère / longueur sur la pile.

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

Cette séquence représente une sorte de codage de longueur d'exécution de la sortie requise en sens inverse. Les deux dernières lignes séparent alors simplement ces paires caractère / longueur de la pile, en affichant les occurrences de longueur de chaque caractère , jusqu'à ce que la pile soit vide.

— James Holderness
source
2

Java 8, 129 124 109 octets

Golfé:

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

Essayez-le en ligne!

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);
  }
}
— Poke
Pour la deuxième boucle imbriquée, je pense que for(;j<v;++)cela fonctionnerait, car pour le moment j==y. En outre, vous pouvez supprimer la troisième en ajoutant une deuxième variable de chaîne à l'intérieur de la boucle principale for String t="";(12) et t+=" ";(8) à l'intérieur de la première boucle imbriquée. La troisième boucle devient alorss+="o"+t+"o";
— nmjcman101
En outre, vous pouvez combiner les deux premières boucles imbriquées à for(j=0;j<v;++j)s+=j<y?"\n":" ";bien que je ne sois pas sûr que cela corresponde à mon commentaire précédent à propos det
— nmjcman101
Vous pouvez initialiser t=""aux côtés de s au début, puis ajouter t+=" "chaque boucle après celas+="o"+t+"o"
— nmjcman101
2

Haskell, 69 octets

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

Exemple d'utilisation: f 3-> " OO\n O O\n\n O O\n\n\nO O". Essayez-le en ligne! .

— nimi
source
2

VBA, 124 112 85 88 66 63 59 octets

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

Enregistrement de 29 octets au total grâce à Taylor Scott

Ceci doit être exécuté dans la fenêtre Immédiate VBA et imprimer le résultat dans le même état.

Développé / Formaté, il devient:

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

(Il s'avère que la concaténation dans une commande d'impression est automatique sans opérateur.)

— Rôti d'ingénieur
source
b & s &Espaces alerte!
— CalculatorFeline
J'ai essayé et il s'est trompé la première fois. En revenant, j'ai réalisé que ça allait s'étendre b &s &Stringmais pas b&s&String. De plus, au début, je pensais que vous vouliez utiliser la Spacefonction que j’aurais dû et qui a permis d’économiser plus d’octets.
— Ingénieur Toast
Vous pouvez condenser for i=0 To vet debug.? bto for i=0To vet Debug.?b, respectivement pour les -2octets. Et juste pour que vous sachiez, le consensus de la communauté est que pour les langues avec autoformatting, vous pouvez compter avant qu'elle ne soit autoformaté, ce qui signifie qu'après avoir apporté ces modifications, vous devriez avoir un nombre d'octets de 85 Octets
— Taylor Scott
En deuxième regard, il s’agit d’un extrait de code - et non d’une fonction ou d’un sous-programme; donc ce n'est pas une solution valable. Je pense que vous pourriez résoudre ce problème en convertissant une fonction de fenêtre immédiate Excel VBA et en prenant les entrées de [A1]( v=[A1]). De plus, je ne pense pas que vous ayez besoin de la svariable.
— Taylor Scott
1
@TaylorScott Cela semble être une amélioration évidente rétrospectivement, mais je ne savais pas que la concaténation ne nécessitait pas d'opérateur dans la fenêtre immédiate. Cela me sauvera quelques octets dans le futur. Je devais cependant ajouter un ;à la fin de la commande print, car cela continuait à ajouter un saut de ligne supplémentaire par défaut. Merci!
— Ingénieur Toast
2

05AB1E , 18 à 13 octets

ÝηRO«ð×'O«ζ»

Essayez-le en ligne!

Ý                # [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.
— Urne Magique De Pieuvre
source
1

Gelée , 17 à 16 octets

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

Essayez-le en ligne!

Comment?

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

PHP, 76 octets

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

Courez avec echo <v> | php -nR '<code>'ou testez-le en ligne .

boucles $argnvers le bas à partir de l' entrée 0et $ià partir de 0;
imprime - dans cet ordre - à chaque itération

  • $i nouvelles lignes (aucune dans la première itération)
  • rembourrage gauche: $argnespaces
  • balle gauche: o
  • rembourrage intérieur: 2*$iespaces
  • balle droite: o
— Titus
source
1

V , 23 19 octets

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

Essayez-le en ligne!

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
source
1

JavaScript (ES6), 87 octets

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>
Développer l'extrait

Solution non récursive. L'exigence d'indexation était ennuyeuse, à la fois dans la solution récursive ci-dessus et dans les 62 octets suivants (je ne sais pas si cela entraînerait un port de rétine plus court):

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

Empilé, 67 à 63 octets

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

Tentative initiale, 67 octets

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

Programme complet. Génère quelque chose comme:

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

Qui est le rembourré, transposé, inversé et sorti.

— Conor O'Brien
source
0

Lot, 163 octets

@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
source
0

Ruby, 52 octets

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

Pas de nouvelle ligne finale (autorisée par les règles: " au plus une nouvelle ligne finale ")

— GB
source
0

AHK, 93 octets

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 je pouvais comprendre comment faire les mathématiques en répétant les frappes au clavier, ce serait formidable.
- VK20équivaut à un espace
- FileAppendrenvoie stdoutsi le nom du fichier est*

— Rôti d'ingénieur
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.