简报

高尔夫球法典问题的难度可以这样计算：

v问题的观看次数在哪里

这a是一个问题的答案数

和⌈ X ⌉是天花板操作。

也：

这个问题的当前难度：***

任务

编写一个将使用两个整数(v and a)并输出的难度的程序asterisks (*)。

输入可以采用数组，分隔字符串或分隔函数参数的形式

测试数据

Views   Answers Difficulty  Program Output
163     2       2           **
548     22      1           *
1452    24      1           *
1713    37      1           *
4162    32      2           **
3067    15      3           ***
22421   19      10          **********

伪代码示例

v: 1713    
a: 37
out = clamp(ceil(((v/a)/700)*10), 0, 10); // evaluates to 1
//program will output '*'

以字节为单位的最短代码胜出！允许尾随/前导空格。

JavaScript（ES6），40 39字节

v=>a=>"**********".substring(10-v/a/70)

因为substring提供了所需的夹紧和“吊装”性能。编辑：通常我懒得打扰，但是因为它有4票赞成票，所以我遵循@MarsUltor的建议，以节省1个字节。

我一直想这样做...

HTML + CSS 491 487 485字节

-4字节归功于Conor O'Brien
-2字节归功于释放氦核

输入作为页面窗口的宽度和高度；width是视图数，height是答案数。

<style>p{overflow:hidden;width:1ch}@media(max-aspect-ratio:70/2){p{width:1ch}}@media(max-aspect-ratio:70/3){p{width:2ch}}@media(max-aspect-ratio:70/4){p{width:3ch}}@media(max-aspect-ratio:70/5){p{width:4ch}}@media(max-aspect-ratio:70/6){p{width:5ch}}@media(max-aspect-ratio:70/7){p{width:6ch}}@media(max-aspect-ratio:70/8){p{width:7ch}}@media(max-aspect-ratio:70/9){p{width:8ch}}@media(max-aspect-ratio:7/1){p{width:9ch}}@media(max-aspect-ratio:70/11){p{width:10ch</style><p>**********

您可以通过输入以下内容在浏览器中进行尝试

data:text/html,<style>p{overflow:hidden;width:1ch}@media(max-aspect-ratio:70/2){p{width:1ch}}@media(max-aspect-ratio:70/3){p{width:2ch}}@media(max-aspect-ratio:70/4){p{width:3ch}}@media(max-aspect-ratio:70/5){p{width:4ch}}@media(max-aspect-ratio:70/6){p{width:5ch}}@media(max-aspect-ratio:70/7){p{width:6ch}}@media(max-aspect-ratio:70/8){p{width:7ch}}@media(max-aspect-ratio:70/9){p{width:8ch}}@media(max-aspect-ratio:7/1){p{width:9ch}}@media(max-aspect-ratio:70/11){p{width:10ch</style><p>**********

作为新标签中的网址。

05AB1E，11个字节

/70/î'*T×s£

说明

/            # divide v by a
 70/         # divide by 70
    î        # round up, call this n
     '*T×    # push 10 asterisks
         s£  # take n up to 10 asterisk
             # implicitly print

在线尝试

Javascript（ES6），37 36字节

v=>a=>"*".repeat((v/=a*70)<9?v+1:10)

多亏了TheLethalCoder，通过保存数据节省了1个字节

let F=
v=>a=>"*".repeat((v/=a*70)<9?v+1:10)

console.log("Test #1:", F(163)(2))    // **
console.log("Test #2:", F(548)(22))   // *
console.log("Test #3:", F(1452)(24))  // *
console.log("Test #4:", F(1713)(37))  // *
console.log("Test #5:", F(4162)(32))  // **
console.log("Test #6:", F(3067)(15))  // ***
console.log("Test #7:", F(22421)(19)) // **********

Mathematica，38 35字节

StringRepeat["*",10,⌈#/#2/70⌉]&

感谢@MartinEnder 3个字节

EXCEL，29个字节

如果将Excel视为VBA Excel的表示形式，则可以使用

=REPT("*",MIN(1+v/(70*a),10))

其中v和a是参考单元格的名称。

CJam，18 15 14字节

感谢Peter Taylor节省了1个字节，感谢Adnan节省了3个字节

'*A*q~d/70/m]<

在线尝试

'*A*            e# Push "**********"
    q~d/        e# Get the input and divide the two numbers
        70/     e# Divide by 70
           m]   e# Ceil, yielding x
             <  e# Slice the string, taking the first x elements

C＃，68 49 48字节

v=>a=>"**********".Substring((int)(10-v/a/70d));

这是Neil 出色回答的C＃版本。

多亏了尼尔，又节省了19个字节

Java 8，57字节

使用lambda保存字节，执行计算和子字符串以返回答案。

(v,a)->"**********".substring(Math.max(0,(700*a-v)/70/a))

这是我要测试的课程。

public class DifficultyCalculator{
    static interface h{ String f(int v, int a);}
    static void g(h H){
        System.out.print(H.f(163,2));System.out.println("\t**");
        System.out.print(H.f(548,22));System.out.println("\t*");
        System.out.print(H.f(1452,24));System.out.println("\t*");
        System.out.print(H.f(1713,37));System.out.println("\t*");
        System.out.print(H.f(4162,32));System.out.println("\t**");
        System.out.print(H.f(3067,15));System.out.println("\t***");
        System.out.print(H.f(22421,19));System.out.println("\t**********");
    }
    public static void main(String[] args) {
        g( // 70
            (v,a)->"**********".substring(java.lang.Math.max(0,(int)(10-v/70d/a)))
        );
    }
}

更新资料

• -3 [16-08-19]使用整数除法
• -10 [16-08-18]由于@OlivierGrégoire，删除了不必要的导入！
• -18 [16-08-17]返回字符串而不是打印

MATL，12字节

/70/0:9>42*c

在线尝试！

说明

舍入和钳位同时进行，如下所示：将数字x = v/a/70与数组的每个元素进行比较[0 1 ... 9]。该数组超出的数字x将变为星号，其余的将为空格。

/      % Take the two numbers implicitly. Divide. (Example: for inputs 3067, 15
       % we get 204.47)
70/    % Divide by 70 (we get 2.92)
0:9    % Push array [0 1  ... 9]
>      % See which of those are exceeded by the previous number (2.92 exceeds
       % 0, 1 and 2, so we get [1 1 1 0 ... 0]). This does the rounding up
       % and the clamping
42*    % Multiply by 42, which is the ASCII code of '*' (we get [42 42 42 0 ... 0])
       % Char 0 will be displayed as space
c      % Convert to char. Implicitly display

Python2，32个字节

由于Leaky Nun节省了3 + 2字节并纠正了一个错误

lambda v,a:('*'*10)[:~-v/a/70+1]

类似于尼尔的答案。使用Python2进行整数除法的事实。

Haskell，35个字节

v#a=[1..min(ceiling$v/a/70)10]>>"*"

[1..min(ceiling$v/a/70)10]创建一个从1到计算的难度的范围（难度为0的空白列表）。经常a>>b重复此列表b length a。

Pyke，13个 9字节

/70/\**T<

在这里尝试！

说明：

/         -    num_1 / num_2
 70/      -   ^ / 70
    \**   -  "*" * ^
       T< - ^[:10]

C＃，97 89 87 77 42 41字节

v=>a=>new string('*',(v/=a*70)<9?v+1:10);

感谢Adám，节省了10个字节

多亏了Arnauld，节省了几个字节

Perl，35 32字节

say"*"x(10-($-=10-pop()/70/pop))

使用-E激活say，并给予以相反的顺序的参数：

perl -E 'say"*"x(10-($-=10-pop()/70/pop))' 2 163

如果允许使用STDIN上的参数，则以下内容为29个字节：

(echo 163; echo 2) | perl -pe '$_="*"x(10-($-=10-$_/70/<>))'

R，68、50 52字节

f=function(v,a)cat(rep("*",1+min(v/a/70,10)),sep="")

rep 隐式地将最小值设置为0。

感谢@plannapus和@ Anastasiya-Romanova秀发现我的错误。

Pyth，17 13字节

路易斯·门多（Luis Mendo）为他的算法贡献了4个字节。

* \ * htS [0T.EccFQ70
* \ * s> LccFQ70T

测试套件。

Javascript ES6，48个字节

a=>b=>"*".repeat(Math.ceil(Math.min(a/b/70,10)))

C，54，51，50，49个字节

假设v为正数或零且为a正数，x < min则决不会遇到夹持情况，因为天花板操作的结果不可能为负数。此外，对非负值的整数运算始终会得出结果的下限，因此我们进行求和1以得出上限。

该解决方案需要一个write功能，至少在Linux上有效。

F(v,a){write(1,"**********",(v/=a*70)>9?10:v+1);}

测试主体：

int main() {
  F(163, 2);
  putchar('\n');
  F(548, 22);
  putchar('\n');
  F(1452, 24);
  putchar('\n');
  F(1713, 37);
  putchar('\n');
  F(4162, 32);
  putchar('\n');
  F(3067, 15);
  putchar('\n');
  F(22421, 19);
  putchar('\n');
}

JavaScript：82 73个字节

 (v,a)=>console.log("*".repeat(Math.min(Math.max(0,Math.ceil(v/a/70),10)))

• 在Adám指出我忽略了/ 700 * 10 = / 70并删除了括号后，保存了一些字节

Dyalog APL，15 字节

'*'⍴⍨10⌊⌈⎕÷70×⎕

'*'⍴⍨字符重复了很多次：
10⌊min（10，...
⎕÷输入除以
70×70
⎕输入

在线尝试APL！

水母，18字节

P
#'*
mM/%i
10 %70

接受格式为的输入[a v]。在线尝试！

说明

• %是倒数，所以%70是1/70。
• i 输入为两个元素的数组。
• /%输入i并通过初始值的翻转除法%70减少数组。换句话说，它计算v /（a /（1/70）），等于v /（70 * a）。i%70
• M取该值的上限，并m取和的最大值10。
• #'**多次重复文字字符。
• P 打印不带引号的结果。

MATLAB，34 33字节

因为我非常喜欢这个挑战，所以这里有一个MATLAB（输出尾随空白）：

@(v,a)[(ceil(v/a/70)>0:9)*42,'']

灵感来自@Luis Mendo的答案。感谢@pajonk节省了一个字节。

M4，136个 135字节

define(r,`ifelse($1,0,,eval($1>9),1,*`r(9)',*`r(decr($1))')')define(f,`r(ifelse(eval($1%($2*70)),0,eval($1/$2/70),eval($1/$2/70+1)))')

定义一个f采用v和的宏a，并扩展为正确的输出。大部分程序是天花板的实施。

直流，110个108 104 98字节

因为切片不是问题，所以这很麻烦。另外，dc不会操纵字符串。我只是真的在等待一个小于5小时的编码的字符串。从好的方面来说，我终于开始写下常见的构造，例如for循环。还必须制定舍入/上限，因此感谢您。

[42P]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[Isi[li0!=dli1-dsi0!=L]dsLx]sg[1+]saIk/70*0k1~0!=adI>ldI!>gIP

以bash调用：

echo 'v a (above)'|dc
# Wholly:
>> echo '163 2 [42P]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[Isi[li0!=dli1-dsi0!=L]dsLx]sg[1+]saIk/70*0k1~0!=adI>ldI!>gIP'|dc
# outputs:
**
>> 

更换（上图）与代码，并v和a与上述其各自的对应物。单引号很重要（否则您将获得bash的历史记录）。

解释：

[42P]sd   # Here we store a macro in register d to print 1 * without a newline

[dsi[li0!=dli1-dsi0!=L]dsLx]sl # Store the "less than" case, a for loop which
                        # uses the top-of the stack as it's number of iterations.
[Isi[li0!=dli1-dsi0!=L]dsLx]sg # Store the "greater than" case. It's the above,
                        # but it puts 10 on the stack to use instead.

[1+]sa # Store a macro to add 1 to whatever is the top-of-stack.


Ik # Set precision at non-zero to allow decimal division

/70* # Divide the top two of the stack, v/a; multiply by 70 (`/700*10` == `/70`)
             # dc is postfix and stack-based, so operators come after operands.

0k1~0!=a     # This is a ceiling function.
|> 0k  # set precision to 0 to perform integer division
|> 1~  # push the quotient of integer division by 1, and then the remainder. (r is top)
|> 0!=a # If the top-of-stack (decimal part) is not 0, add 1 to the quotient

dI>ldI!>g # Conditional statement
|> dI>l  # (d)uplicate the top, push 10 on. If 10 > the old top, execute the `l`ess-than
          # case, which loops top-of-stack times.
|> dI!>g # Complement of the above, using the `g`reater-than to loop 10 times.

IP # print a newline

这可能更适合高尔夫运动，但我试图将其完成以避免过早的优化。

• 通过复制保存而不是保存加载来保存2个字节
• 保存4字节除以70
• daniero建议的6个字节（非字符串，改为ASCII数字； 10 => I）

Haskell，35个字节

这个解决方案与Laikoni的回答完全不同，因为它可以解决这些琐碎的事情。但是分数（目前）是完全相同的。

v%a=take(ceiling$v/a/70)[0..9]>>"*" 

产生十颗星星，然后刮掉一些。易于扩展到具有无限列表的任意难度。

我确实设法减少了一个字节。但是，尽管所有测试用例都能正常工作，但总体而言这并不正确。

v%a=take(1+div v(a*70))[0..9]>>"*"

TI-Basic，39个字节

Prompt V,A
sub("**********",1,max(0,min(10,int(V/A/70)+1

PowerShell v2 +，47个字节

-join(('*'*11)[1..($args[0]/$args[1]/70+.499)])

@Neil的JavaScript answer的端口。

需要输入$args和分裂他们，然后除以通过70，并增加了.499。由于PowerShell进行banker的四舍五入，这实际上ceil可以精确到两位小数点。如果需要更高的精度，请9根据需要添加尽可能多的。

与一起1..，这会在字符串中形成范围索引。字符串是'*'*11，即'***********'。这导致一个字符数组，因此我们将-join其一起返回一个字符串。该字符串保留在管道上，并且输出是隐式的。像尼尔的答案一样，这有效地将输出“钳位”在1到10星之间。

测试套件

PS C:\Tools\Scripts\golfing> @(@(163,2), @(548,22), @(1452,24), @(1713,37), @(4162,32), @(3067,15), @(22421,19))|%{($_-join', ')+" -> " +(.\difficulty-of-a-question $_[0] $_[1])}
163, 2 -> **
548, 22 -> *
1452, 24 -> *
1713, 37 -> *
4162, 32 -> **
3067, 15 -> ***
22421, 19 -> **********

Python 3，69 68字节

我不想复制Python 2的答案，所以我的要更长一些。

from math import*
x=lambda v,a:print(max(0,min(ceil(v/a/70),10))*'*')

感谢Program man，节省了1个字节

实际上是14个字节

:70a\\u9ukm'**

在线尝试！

利用以下事实，即0个视图和0个答案是不可能的，因此ceil(v/a) > 0。

说明：

:70a\\u9ukm'**
:70             push 70 ([70 a v])
   a            invert stack ([v a 70])
    \\          integer division twice ([v//a//70])
      u         add 1 ([v//a//70 + 1])
       9uk      push 10, make stack into list ([[v//a//70+1, 10]])
          m     minimum of list
           '**  push "*", repeat