35

绘制抛球的抛物线轨迹。

输入是球的初始向上速度，为正整数v。每秒，球向右移动1空间并v垂直移动，然后由于重力而v减小1。所以，向上的速度最终从下台v到0，向下-v，最终下跌回落到其初始高度。

球的位置描绘出抛物线。在水平位置x，其高度为y=x*(2*v+1-x)/2，(0,0)球的初始位置在左下方。

输出球轨迹的ASCII艺术作品，O其所占据的坐标为。输出应该是一条多行文本，而不是随时间变化的路径动画。

输出不应包含前导换行符，并且最多应包含尾随换行符。底线应与屏幕的左边缘齐平，即没有多余的前导空格。尾随空格可以。您可以假定输出线宽适合输出端子。

v = 1

 OO 
O  O

v = 2

  OO  
 O  O 

O    O

v = 3

   OO   
  O  O  

 O    O 


O      O

v = 4

v = 10

          OO          
         O  O         

        O    O        


       O      O       



      O        O      




     O          O     





    O            O    






   O              O   







  O                O  








 O                  O 









O                    O

木炭，18 16 13字节

-3个字节，感谢@Neil！

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

在线尝试！链接是详细代码。

— 仅ASCII
source

我非常喜欢这个，+ 1；OP的输出也使用大写的“ O”。（这一点都不重要）

— Albert Renshaw

如果使用，↘O则可以从0到N（含0）循环，这样可以立即为您节省两个字节。

— 尼尔

@尼尔谢谢！另外，这是一个非常古老的帖子：P（我想知道我是否应该使用较新的功能。可能不是吗？）

— ASCII码，仅ASCII

严格说来我只救了你1个字节，只要其他两个字节都被你替换⁺¹用⊕。但是现在你已经移动了←从‖Ｃ到O你可以写节省另一个字节↙OＭι↓，所以我回来了长达两个字节重新保存。

— 尼尔

您也忘记更新您的TIO链接。从技术上讲，我相信我们现在允许更新的功能，但是我不能称赞这些字节。

— 尼尔

6

C，93 92

（请注意，有人在评论中得到87分）

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

在线尝试！

可读性：

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

笔记：

通过迭代输出的总行数，可以将两个for循环折叠为一个for循环，这由公式给出： 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("");
}

但是它最终比使用两个单独的for循环还要更多的字节数

— 阿尔伯特·伦肖
source

您可以通过s在开头增加一个字节来保存一个字节，如下所示：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，2017年

@Steadybox不会为我编译。当我数完（删除空格字符后）时，我也得到了90个字节

— Albert Renshaw

我所做的只是添加++s;一开始，然后改变y<=s到y<s和s-y+1到s-y和s+1-n到s-n，所以它应该编译（应该是91个字节）。

— Steadybox'3

我的注释中的代码块编码似乎有问题。复制和粘贴注释中的代码对我来说也不会编译。

— Steadybox'3

1

87个字节

— 吊顶猫

5

Python 2，65个字节

f=lambda n,x=0:(n and f(n-1,x+1)or'')+'\n'*n+' '*x+'O'+'  '*n+'O'

在线尝试！

— 竿
source

5

GNU sed，41岁

分数包括从-r标志到sed的+1 。

s/$/OO/
:
s/(\s*) O( *)O$/&\n\1O \2 O/
t

输入为一元，为一串空格-字符串的长度为输入。

在线尝试。

— 数字创伤
source

4

Python 2，76个字节

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

很简单的目的i-x+1and i是防止一堆尾随换行符。

— 超中微子
source

将换行符移动到打印的开头，例如'\n'*(i-1)节省7个字节，同时避免尾随换行符。

— Emigna

4

MATL，19 17字节

Q:tqYsQ79Z?PtPv!c

在MATL在线上尝试一下！或验证所有测试用例。

说明

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

— 路易斯·门多
source

4

05AB1E，18 14字节

感谢Adnan，节省了4个字节

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

在线尝试！

说明

ƒ                   # 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

— 艾米尼亚
source

对于14个字节：ƒ¶N×'ONúRÂJ}.c:)

— Adnan

@Adnan谢谢！我尝试.c使用其他版本，但当时效果不佳。忘了尝试使用这一工具，并完全忘了ú存在的方法：）

— Emigna

绝对比我选择的zip方法好，垂直的有趣方法。

— Magic Octopus Urn'Mar

4

JavaScript（ES6），98 92 89 84 78字节

（感谢Arnauld -20个字节！）

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

递归解决方案。这也是我用JavaScript的第一个答案，请保持温柔！我仍在学习所有这些简洁的语言，因此非常感谢打高尔夫球的技巧。:)

测试片段

您可能需要滚动查看整个输出。

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>

展开摘要

— 卡普
source

同样，在反引号字符串内包含变量时，${}仅当变量部分被静态部分包围时才保存字节。因此，这些字符串应始终以静态部分开头和结尾。

— 路加福音

@Arnauld感谢所有提示！对此，我真的非常感激！:)

— R. Kap's

@Luke感谢您的建议。那将派上用场。:)

— R. Kap's

您可以放心使用0来代替"0"。它们将被强制为字符串。再三考虑：i++<v&&i实际上比短一字节(i<v)*++i。

— Arnauld

@Arnauld再次感谢您！:)

— R. Kap's

3

RProgN 2，37字节

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

在使用适当的高尔夫球语言之前，请先使用我的英语语言。

讲解

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

在线尝试！

— 阿塔科
source

3

视网膜，29 19字节

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

在线尝试！

将一元输入作为一系列空格。我的JavaScript回答的端口。编辑：由于@ MartinEnder♦，节省了10个字节。

— 尼尔
source

我只是在等待有人提出一个名为Retsina的Retina衍生产品。

— 泰特斯

3

Bash，76个字节

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

因为它使用ANSI转义序列，所以仅在终端中有效。›表示CSI字节（0x9b）。

测试运行

$ # 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

— 丹尼斯
source

您可以sed $nq用来保存一个字节。

— 齐柏林飞艇

可悲的是没有。我必须使用sed ${n}q更长的时间。

— 丹尼斯

恩，我知道，您可以sed $n\q代替，但是那也没有太大意义，因为它的字节数与head！相同。

— 齐柏林飞艇

3

视网膜，35

@MartinEnder节省了2个字节

我的sed答案的端口：

.+
$* OO
+`(\s*) (O *)O$
$&¶$1O $2 O

在线尝试。

— 数字创伤
source

3

R，89个字节

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="")

创建一个空格矩阵（变量a是此矩阵的宽度，节省了几个字节）
在所需位置填写“ o”，从弧的顶部向下和向外
在每个矩阵行的末尾添加换行符
将矩阵折叠成单个字符串并打印

这是我第一次打高尔夫球，欢迎发表评论...

— 用户名
source

3

Röda，53 52字节

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

在线尝试！

用法： main { f(5) }

非高尔夫版本：

function f(n) {
    seq(0, n) | for i do
        push("\n"*i, " "*(n-i), "O", " "*i*2, "O")
    done
}

— Fergusq
source

您可以使用文字换行符代替\n并保存1个字节吗？

— Kritixi Lithos

@KritixiLithos可行。谢谢！

— fergusq

2

Befunge，75 73字节

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

在线尝试！

第一行读取速度v，并将副本保存在内存中。然后第二行从v倒数到零，索引为i，并且在每次迭代时将一系列字符/长度对压入堆栈。

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

此序列表示所需输出的一种游程长度编码，反过来。然后，最后两行只是将这些字符/长度对从堆栈中弹出，输出每个字符的出现长度，直到堆栈为空。

— 詹姆斯·霍尔德尼斯
source

2

Java 8，129 124 109字节

打高尔夫球：

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

在线尝试！

取消高尔夫：

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

在线尝试！

— 戳

对于第二个嵌套的for循环，我认为for(;j<v;++)这是可行的，因为在此时j==y。同样，您可以通过在第一个嵌套循环内的主for循环String t="";（12）和t+=" ";（8）内添加第二个字符串变量来删除第三个字符串。然后第三个循环变为s+="o"+t+"o";

— nmjcman101 '17

此外，您可以将前两个嵌套循环组合在一起，for(j=0;j<v;++j)s+=j<y?"\n":" ";尽管我不确定这与我先前关于t

— nmjcman101的

您可以t=""在开始时与s一起初始化，然后在执行之后添加t+=" "每个循环s+="o"+t+"o"

— nmjcman101，2017年

2

Haskell，69个字节

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

用法示例：f 3-> " OO\n O O\n\n O O\n\n\nO O"。在线尝试！。

— 妮米
source

2

VBA，124 112 85 88 66 63 59个字节

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

_{^{泰勒·斯科特（Taylor Scott）总共节省了29个字节}}

这必须在“ VBA立即”窗口中运行，并在同一窗口中打印结果。

展开/格式化，它变成：

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

_{（事实证明，打印命令中的连接是自动的，无需操作员。）}

— 工程师吐司
source

b & s &空间警报！

— CalculatorFeline

我尝试过，它第一次出错。回过头来，我意识到它会扩展，b &s &String但不会扩展b&s&String。另外，起初我以为您打算使用Space我完全应该拥有的功能，最终节省了更多字节。

— Engineer Toast

您可以凝结for i=0 To v，并debug.? b以for i=0To v和Debug.?b为，分别-2字节。众所周知，社区的共识是对于具有自动格式设置的语言，您可以在进行自动格式设置之前进行计数，这意味着在进行这些更改之后，您应该拥有85字节的字节数

— Taylor Scott

再看一看，这是一个片段-不是函数或子例程；因此这不是有效的解决方案。我相信您可以通过将其转换为Excel VBA立即窗口函数并从[A1]（v=[A1]）获取输入来解决此问题，而且我认为您实际上并不需要该s变量。

— 泰勒·斯科特

1

@TaylorScott回想起来似乎是一个明显的改进，但我不知道并不需要在立即窗口中使用运算符。将来可以为我节省一些字节。不过，我确实必须;在print命令的末尾添加a ，因为默认情况下它一直在添加额外的换行符。谢谢！

— 工程师吐司

2

05AB1E，18 13字节

ÝηROÂ«ð×'O«ζ»

在线尝试！

Ý                # [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.

— 魔术章鱼缸
source

1

果冻，17 16 字节

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

在线尝试！

怎么样？

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

— 乔纳森·艾伦
source

1

PHP，76字节

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

在线运行echo <v> | php -nR '<code>'或对其进行测试。

环$argn向下从输入到0和$i向上从0;
在每次迭代中以该顺序打印

$i 换行符（第一次迭代中没有）
左填充：$argn空格
左球： o
内部填充：2*$i空格
右球： o

— 泰特斯
source

1

V，23 19字节

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

在线尝试！

说明

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个字节

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>

展开摘要

非递归解决方案。在以上和以下的62字节（我不知道是否会导致较短的Retina端口）递归解决方案中，索引要求很烦人：

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

— 尼尔
source

1

Perl 5，48个字节

47个字节的代码+ 1 for -n。

$_++;print$/x$-,$"x$_,O,$"x($-++*2),O while$_--

在线尝试！

— 唐·黑斯廷斯
source

0

堆叠，67 63字节

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

初次尝试，67字节

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

完整程序。产生类似：

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

这是填充，转置，反转和输出。

— 科纳·奥布莱恩
source

0

批次，163字节

@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%

— 尼尔
source

0

Ruby，52个字节

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

没有尾随换行符（规则允许：“ 最多一个尾随换行符 ”）

— 国标
source

0

AHK，93个字节

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%,*

如果我能在重复的按键操作中弄清楚如何进行数学运算，那将是很好的。
- VK20相当于一个空间
- FileAppend输出到stdout如果文件名是*

— 工程师吐司
source

0

Haskell，77个字节

n!x=[1..n]>>x
-1#i=[]
x#i=(x-1)#(i+1)++x!"\n"++i!" "++'O':(2*x)!" "++"O"
(#0)

在线尝试！用法：(#0) 5

— 莱科尼
source

0

Python 2，59个字节

f=lambda n,r='O':(r*n and f(n-1,' '+r))+'\n'*n+r+'  '*n+'O'

在线尝试！

— 异或
source

画圆弧

木炭，18 16 13字节

说明

C，93 92

Python 2，65个字节

GNU sed，41岁

Python 2，76个字节

MATL，19 17字节

说明

05AB1E，18 14字节

JavaScript（ES6），98 92 89 84 78字节

测试片段

RProgN 2，37字节

讲解

视网膜，29 19字节

Bash，76个字节

测试运行

视网膜，35

R，89个字节

Röda，53 52字节

Befunge，75 73字节

Java 8，129 124 109字节

Haskell，69个字节

VBA，124 112 85 88 66 63 59个字节

05AB1E，18 13字节

果冻，17 16 字节

怎么样？

PHP，76字节

V，23 19字节

JavaScript（ES6），87个字节

Perl 5，48个字节

堆叠，67 63字节

批次，163字节

Ruby，52个字节

AHK，93个字节

Haskell，77个字节

Python 2，59个字节