[Question]
  [
# Briefing
The difficulty of a Code Golf question can be calculated as such:
$$\text{clamp} \left( \left\lceil \left( \frac v a \div 700 \right) \times 10 \right\rceil, 0, 10 \right)$$
Where \$v\$ is the number of views a question has
and \$a\$ is the number of answers a question has
and \$‚åàx‚åâ\$ is the [ceiling operator](https://en.wikipedia.org/wiki/Floor_and_ceiling_functions).
Also:
$$\text{clamp}(x, min, max) = \begin{cases}
min & x < min \\
x & min \le x \le max \\
max & max < x
\end{cases}$$
This question's current difficulty: `***`
# Task
Write a program that will take two integers `(v and a)` and output the difficulty in `asterisks (*)`.
The input can be in the form of an array, a separated string or as separate function arguments
# Test Data
```
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          **********
```
### Example with pseudocode
```
v: 1713    
a: 37
out = clamp(ceil(((v/a)/700)*10), 0, 10); // evaluates to 1
//program will output '*'
```
The shortest code in bytes wins! Trailing/ leading spaces are allowed.
  
[Answer]
## JavaScript (ES6), ~~40~~ 39 bytes
```
v=>a=>"**********".substring(10-v/a/70)
```
Because `substring` provides the required clamping and "ceil"ing behaviour. Edit: Normally I'm too lazy to bother, but because it got 4 upvotes, I've followed @MarsUltor's advice to save 1 byte by currying.
[Answer]
I've been wanting to do this for a while...
## HTML + CSS ~~491~~ ~~487~~ 485 bytes
*-4 bytes thanks to Conor O'Brien*  
*-2 bytes thanks to Releasing Helium Nuclei*
Input is taken as the width and height of the page window; width being the number of Views, and height being the number of Answers.
```
<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>**********
```
You can try it in your browser by entering
```
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>**********
```
as a url in a new tab.
[Answer]
## 05AB1E, 11 bytes
```
/70/√Æ'*T√ós¬£
```
**Explanation**
```
/            # 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
```
[Try it online](http://05ab1e.tryitonline.net/#code=LzcwL8OuJypUw5dzwqM&input=MTUKMzA2Nw)
[Answer]
## Javascript (ES6), ~~37~~ 36 bytes
```
v=>a=>"*".repeat((v/=a*70)<9?v+1:10)
```
*Saved 1 byte by currying, thanks to TheLethalCoder*
```
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)) // **********
```
[Answer]
# Mathematica, ~~38~~ 35 bytes
```
StringRepeat["*",10,‚åà#/#2/70‚åâ]&
```
*Thanks to @MartinEnder for 3 bytes*
[Answer]
## EXCEL, 29 bytes
If you count Excel as a representation of VBA Excel, then you can use
```
=REPT("*",MIN(1+v/(70*a),10))
```
where `v` and `a` are the name of reference cells.
[Answer]
## CJam, ~~18~~ ~~15~~ 14 bytes
*Saved 1 byte thanks to Peter Taylor and 3 bytes thanks to Adnan*
```
'*A*q~d/70/m]<
```
[Try it online](http://cjam.aditsu.net/#code='*A*%20%20%20%20%20%20%20%20%20%20%20%20e%23%20Push%20%22**********%22%0A%20%20%20%20q~d%2F%20%20%20%20%20%20%20%20e%23%20Get%20the%20input%20and%20divide%20the%20two%20numbers%0A%20%20%20%20%20%20%20%2070%2F%20%20%20%20%20e%23%20Divide%20by%2070%0A%20%20%20%20%20%20%20%20%20%20%20m%5D%20%20%20e%23%20Ceil%2C%20yielding%20x%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%3C%20%20e%23%20Slice%20the%20string%2C%20taking%20the%20first%20x%20elements&input=1452%2024)
```
'*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
```
[Answer]
## C#, ~~68~~ ~~49~~ 48 bytes
```
v=>a=>"**********".Substring((int)(10-v/a/70d));
```
This is the C# version of [this excellent answer](https://codegolf.stackexchange.com/a/90138/38550) by Neil.
*Saved another 19 bytes thanks to Neil*
[Answer]
# Java 8, 57 bytes
Uses a lambda to save bytes, performs the calculation and substrings to return the answer. 
```
(v,a)->"**********".substring(Math.max(0,(700*a-v)/70/a))
```
---
Here is my class for testing it.
```
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)))
        );
    }
}
```
---
**Update**
* **-3** [16-08-19] Utilized integer division
* **-10** [16-08-18] Removed unnecessary import, thanks to *@OlivierGr√©goire*!
* **-18** [16-08-17] Return string instead of print
[Answer]
# [MATL](https://github.com/lmendo/MATL), 12 bytes
```
/70/0:9>42*c
```
[**Try it online!**](http://matl.tryitonline.net/#code=LzcwLzA6OT40Mipj&input=MzA2NwoxNQ)
### Explanation
The rounding up and clamping are done simultaneously as follows: the number `x = v/a/70` is compared against each element of the array `[0 1 ... 9]`. The numbers of that array that are exceeded by `x` will become asterisks, and the rest will be spaces.
```
/      % 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
```
[Answer]
# Python2, 32 bytes
saved 3 + 2 bytes and corrected off by one error thanks to Leaky Nun
```
lambda v,a:('*'*10)[:~-v/a/70+1]
```
similar to Neils answer. Uses the fact that Python2 does integer division.
[Answer]
# Haskell, 35 bytes
```
v#a=[1..min(ceiling$v/a/70)10]>>"*"
```
`[1..min(ceiling$v/a/70)10]` creates a range from 1 to the computed difficulty (an empty list for difficulty 0). `a>>b` repeats the list `b` `length a` often.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~17~~ 13 bytes
**4 bytes in credit to Luis Mendo for [his algorithm](https://codegolf.stackexchange.com/a/90141/48934).**
```
~~\*\\*htS[0T.EccFQ70~~
*\*s>LccFQ70T
```
[Test suite.](http://pyth.herokuapp.com/?code=%2a%5C%2as%3ELccFQ70T&test_suite=1&test_suite_input=163%2C2%0A548%2C22%0A1452%2C24%0A1713%2C37%0A4162%2C32%0A3067%2C15%0A22421%2C19&debug=0)
[Answer]
## Pyke, ~~13~~ 9 bytes
```
/70/\**T<
```
[Try it here!](http://pyke.catbus.co.uk/?code=%2F70%2F%5C%2a%2aT%3C&input=2%0A163&warnings=0)
Explanation:
```
/         -    num_1 / num_2
 70/      -   ^ / 70
    \**   -  "*" * ^
       T< - ^[:10]
```
[Answer]
## C#, ~~97~~ ~~89~~ ~~87~~ ~~77~~ ~~42~~ 41 bytes
```
v=>a=>new string('*',(v/=a*70)<9?v+1:10);
```
*Saved 10 bytes thanks to Ad√°m*
*Saved a few bytes thanks to Arnauld*
[Answer]
# Perl, ~~35~~ 32 bytes
```
say"*"x(10-($-=10-pop()/70/pop))
```
Use `-E` to activate `say` and give the arguments in the reverse order:
```
perl -E 'say"*"x(10-($-=10-pop()/70/pop))' 2 163
```
If arguments on STDIN are allowed the following is 29 bytes:
```
(echo 163; echo 2) | perl -pe '$_="*"x(10-($-=10-$_/70/<>))'
```
[Answer]
# R,  68, 50 52 bytes
```
f=function(v,a)cat(rep("*",1+min(v/a/70,10)),sep="")
```
`rep` implicitly places a min on number of 0.
Thanks to @plannapus and @Anastasiya-RomanovaÁßÄ for spotting my error.
[Answer]
# Javascript ES6, 48 bytes
```
a=>b=>"*".repeat(Math.ceil(Math.min(a/b/70,10)))
```
[Answer]
# m4, ~~136~~ 135 bytes
```
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)))')
```
Defines a macro `f` which takes `v` and `a`, and expands to the correct output. Most of the program is an implementation of ceiling.
[Answer]
# C, ~~54~~, ~~51~~, ~~50~~, 49 bytes
Assuming that `v` is positive or zero and `a` positive, the `x < min` clamping case is never met, since there is no way the result of the ceiling operation can be negative. Additionally, integer maths on non-negative values always yields the floor of the result, so we add `1` to get the ceiling.
This solution requires a `write` function, works on Linux at least.
```
F(v,a){write(1,"**********",(v/=a*70)>9?10:v+1);}
```
Test main:
```
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');
}
```
[Answer]
## javascript: ~~82~~ 73 bytes
```
 (v,a)=>console.log("*".repeat(Math.min(Math.max(0,Math.ceil(v/a/70),10)))
```
* *saved some bytes after Ad√°m pointed out I overlooked the /700\*10=/70*, and the removal of parens
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 15 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
'*'‚ç¥‚ç®10‚åä‚åà‚éï√∑70√ó‚éï
```
`'*'‚ç¥‚ç®` the character repeated this many times:  
`10‚åä` min(10,...  
`‚éï√∑` input divided by  
`70√ó` seventy times  
`‚éï` input
[TryAPL online!](http://tryapl.org/?a=%u2191%u2191%7B%27*%27%u2374%u23680%u230810%u230A%u2308%u237A%F770%D7%u2375%7D/%A8%28163%202%29%28548%2022%29%281452%2024%29%281713%2037%29%284162%2032%29%283067%2015%29%2822421%2019%29&run)
[Answer]
## [Jellyfish](https://github.com/iatorm/jellyfish), 18 bytes
```
P
#'*
mM/%i
10 %70
```
Takes input in the format `[a v]`. [Try it online!](http://jellyfish.tryitonline.net/#code=UAojJyoKbU0vJWkKMTAgJTcw&input=WzIgMTYzXQ)
## Explanation
* `%` is reciprocal, so `%70` is 1/70.
* `i` is input, as a two-element array.
* `/%` with inputs `i` and `%70` reduces the array `i` by flipped division with initial value `%70`. In other words, it computes **v/(a/(1/70))**, which is equal to **v / (70\*a)**.
* `M` takes the ceiling of this value, and `m` takes the maximum of that and `10`.
* `#'*` repeats the literal `*` character that many times.
* `P` prints the result without quotes.
[Answer]
# MATLAB, 34 33 bytes
Because I like this challange so much, here is one for MATLAB (outputs trailing whitespaces): 
```
@(v,a)[(ceil(v/a/70)>0:9)*42,'']
```
Inspired by @Luis Mendo's answer. Thanks to @pajonk for saving one byte.
[Answer]
# dc, ~~110 108 104~~ 98 bytes
This was a doozy since slicing isn't a thing. Also, dc doesn't manipulate strings. I just really was waiting for a string one that would be < 5 hours of coding. On the plus side, I finally started writing down common constructs, like for loops. Also had to formulate rounding/ceiling, so thanks for that.
```
[42P]sd[dsi[li0!=dli1-dsi0!=L]dsLx]sl[Isi[li0!=dli1-dsi0!=L]dsLx]sg[1+]saIk/70*0k1~0!=adI>ldI!>gIP
```
Invoked in 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:
**
>> 
```
Replacing (above) with the code, and `v` and `a` with their respective counterparts above. The single quotes are important (otherwise you get bash's history stuff).
---
Explained:
```
[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
```
This is probably more golf-able, but I was trying to get it finished to avoid premature optimization.
* 2 bytes saved by duplicating-saving instead of saving-loading
* 4 bytes saved dividing by 70
* 6 bytes from daniero's suggestions (non-strings, ASCII nums instead; 10 => I)
[Answer]
# Haskell, 35 bytes
This solution is as completely different from *Laikoni*s answer as it gets for something this trivial. Yet the score (for now) is exactly the same.
```
v%a=take(ceiling$v/a/70)[0..9]>>"*" 
```
This produces ten stars, then shaves off some. Easy to extend to arbitrary difficulty with an infinite list.
I did manage to shave off one more byte. But while all test cases work, this shouldn't be correct in general.
```
v%a=take(1+div v(a*70))[0..9]>>"*"
```
[Answer]
# TI-Basic, 39 bytes
```
Prompt V,A
sub("**********",1,max(0,min(10,int(V/A/70)+1
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 9 bytes
```
/70/·πô‚Ä∫\**
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%2F70%2F%E1%B9%99%E2%80%BA%5C**&inputs=1%0A306&header=&footer=)
[Answer]
## PowerShell v2+, 47 bytes
```
-join(('*'*11)[1..($args[0]/$args[1]/70+.499)])
```
Somewhat a port of @Neil's [JavaScript answer](https://codegolf.stackexchange.com/a/90138/42963).
Takes input `$args` and divides them, then divides that by `70`, and adds `.499`. Since PowerShell does [banker's rounding](https://msdn.microsoft.com/en-us/library/system.math.round(v=vs.110).aspx#Midpoint), this is effectively `ceil` to two decimal points of precision. If additional precision is required, tack on as many additional `9`s as required.
Along with the `1..`, this forms a range index into a string. The string is `'*'*11`, i.e. `'***********'`. That results in a char-array, so we `-join` it together back into a string. That string is left on the pipeline and output is implicit. Like Neil's answer, this effectively "clamps" the output to be between 1 and 10 stars.
### Test Suite
```
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 -> **********
```
[Answer]
# Python 3, ~~69~~ 68 bytes
I didn't want to copy the Python 2 answer, so mine is slightly longer.
```
from math import*
x=lambda v,a:print(max(0,min(ceil(v/a/70),10))*'*')
```
Saved 1 byte thanks to Program man
]