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

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: ***

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.

• I find that LaTeX harder to understand that a simple formula string.. but whatever the majority wants I guess.. Commented Aug 17, 2016 at 13:07
• You should almost add [underhanded] for the question being underhanded.
Commented Aug 17, 2016 at 13:28
• This is a Code Golf question. Not an actual system being implemented into the site. Who cares if it's unfair? Commented Aug 17, 2016 at 14:11
• its kinda early so I may be missing something here, but why /700 * 10 instead of /70? Commented Aug 17, 2016 at 14:21
• @KevinL Ssshhhh ;) Commented Aug 17, 2016 at 14:34

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

• Oh, that is a nice use of substring :-) Commented Aug 17, 2016 at 12:32
• Use currying: v=>a=> Commented Aug 17, 2016 at 12:53
• Can you use substr instead? I know the second parameter makes a difference, but not sure about the first... Commented Aug 17, 2016 at 18:25
• @DomHastings: Yes, though slice would be even shorter. Commented Aug 17, 2016 at 18:57
• @DomHastings No, both substr and slice interpret a negative argument as counting back from the end of the string.
– Neil
Commented Aug 17, 2016 at 19:07

I've been wanting to do this for a while...

## HTML + CSS 491487 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.

• +1 for thinking out of the box – ehm, thinking of the box...
Commented Aug 18, 2016 at 5:24
• Do you need the closing p tag? Commented Aug 18, 2016 at 6:21
• I love how it updates as I change the window's size.
– YSC
Commented Aug 18, 2016 at 11:36
• @ConorO'Brien: Good point! Commented Aug 18, 2016 at 13:27
• You don't need the last two }s too. Commented Aug 18, 2016 at 23:24

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

## 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)) // **********

• Can you use v=>a=> instead of (v,a)=>? Commented Aug 17, 2016 at 14:56
• @TheLethalCoder - Updated. Thanks! Commented Aug 17, 2016 at 15:02
• Doesn't work for v=70, a=1 does it?
– Neil
Commented Aug 17, 2016 at 19:09
• @Neil - That's right. It is off by 1 point if the number of answers is an exact divisor of the number of views. Or put in other words, it's anticipating the next view. ;-) Commented Aug 18, 2016 at 10:55

# Mathematica, 38 35 bytes

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


Thanks to @MartinEnder for 3 bytes

• Hello, and welcome to PPCG! This is a great answer! Commented Aug 17, 2016 at 15:06
• @NoOneIsHere Thanks! Originally I was thinking of Clip, which has pretty much the same syntax as OP's Clamp, but then I saw that StringRepeat has the optional third argument for truncation.
– user58632
Commented Aug 18, 2016 at 6:47
• There are Unicode characters for the left and right ceiling bracket which together make up only 6 bytes instead of the 9 you need for Ceiling[]. Commented Aug 18, 2016 at 7:31

## CJam, 1815 14 bytes

Saved 1 byte thanks to Peter Taylor and 3 bytes thanks to Adnan

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


Try it online

'*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


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

• Hi, and welcome to PPCG! This is a nice first post! And valid also. Commented Aug 20, 2016 at 22:08
• Hi too @EasterlyIrk. Thanks for the warm welcome :) Commented Aug 20, 2016 at 22:12

## C#, 6849 48 bytes

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


This is the C# version of this excellent answer by Neil.

Saved another 19 bytes thanks to Neil

• Try (int)System.Math.Floor(10-v/a/70) or just (int)(10-v/a/70).
– Neil
Commented Aug 17, 2016 at 13:16
• @Neil Looks like I had to leave the 70d alone but works better thanks Commented Aug 17, 2016 at 13:44
• Sorry, didn't see the d there.
– Neil
Commented Aug 17, 2016 at 15:07
• Another answer that could save one byte with currying, I think: v=>a=> Commented Aug 18, 2016 at 3:10
• @BrianMcCutchon Didn't even realise how I could do it in C# thanks Commented Aug 18, 2016 at 8:11

# 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
• Nice, a Java answer that isn't a train! Commented Aug 17, 2016 at 20:40
• No need for java.lang. since it's the default included package. Commented Aug 18, 2016 at 7:25
• You are rounding not ceiling!
– user54187
Commented Aug 18, 2016 at 11:34
• @Advancid I tested it and System.out.println((int)2.99); prints 2 and since I take the pre-floored value from 10 and then floor it, it is the same as taking the ceiling away from 10. Commented Aug 18, 2016 at 12:53

# MATL, 12 bytes

/70/0:9>42*c


Try it online!

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


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

• fails when v=70 and a=1 Commented Aug 17, 2016 at 13:26
• The f= can be removed Commented Aug 17, 2016 at 13:27
• v, a can become v,a Commented Aug 17, 2016 at 13:27
• thanks! should work now. May be wrong for v=0, a=1 now, but this case cannot exist, can it? Commented Aug 17, 2016 at 13:50
• That would not be wrong for v=0, a=1. Commented Aug 17, 2016 at 13:51

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.

# Pyth, 17 13 bytes

4 bytes in credit to Luis Mendo for his algorithm.

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


Test suite.

• Also 13 bytes. Commented Feb 14, 2021 at 17:30

## Pyke, 13 9 bytes

/70/\**T<


Try it here!

Explanation:

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


## C#, 9789877742 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

• You can save a whole lot by replacing (int)System.Math.Ceiling(v/a/70d) by (v+69)/(70*a)... Note that moreover v/a can not be negative, so c can be simplified a lot because you don't need to check for that. Commented Aug 17, 2016 at 14:20

# 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/<>))'  • I can't remember if it'd exactly the same, but can you have 0| instead of $-=? (Thinking operator precedence might not be right...) Commented Aug 17, 2016 at 18:44
• @DomHastings 0| makes a negative number into a huge number (leading to zero *s), $-= clips to 0 (leading to ten *s), which is what I need here Commented Aug 17, 2016 at 18:59 • Ah, of course, it's only ever a positive integer! Thanks for reminding. I'm sure I'll forget that when I need it though... 😀 Commented Aug 17, 2016 at 19:30 # 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. • You can remove f= Commented Aug 18, 2016 at 18:11 • Outputs of your code are not equal to the Test Data. You should add 2 more bytes 1+ after min( in order to get the same outputs Commented Aug 22, 2016 at 7:02 # Javascript ES6, 48 bytes a=>b=>"*".repeat(Math.ceil(Math.min(a/b/70,10)))  # 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.

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

• Replacing (v=v/a/70) with (v/=a*70) saves 1 byte. Commented Aug 19, 2016 at 6:32
• Nice catch @ceilingcat! Commented Aug 19, 2016 at 9:35

## 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
• @Adám what's with the edit? Commented Aug 17, 2016 at 12:49
• @Adám If people read any of the answers they'll have the spoiler already. Rolling back, because currently that sentence is fairly useless and just makes people click on the revision history. Commented Aug 17, 2016 at 13:01
• @Adám That's what I usually use myself but I don't see any harm in the current version. Commented Aug 17, 2016 at 13:56
• No need to console.log it, returning is fine. You can also save a byte with v=>a=> instead of (v,a)=> Commented Aug 18, 2016 at 18:20

# Dyalog APL, 15 bytes

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


'*'⍴⍨ the character repeated this many times:
10⌊ min(10,...
⎕÷ input divided by
70× seventy times
⎕ input

TryAPL online!

• Would it be golfier to use Mendo's algorithm? Commented Aug 17, 2016 at 13:11
• @LeakyNun I don't think so: '*'/⍨(⎕÷70×⎕)>⍳10
Commented Aug 17, 2016 at 13:19

## Jellyfish, 18 bytes

P
#'*
mM/%i
10 %70


Takes input in the format [a v]. Try it online!

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

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

• Nice approach! I had a 40-byte one to post... BTW, you can save one byte using [... ''] instead of char(...). And do you really need the ceil when at the end you are comparing with integers? Commented Aug 17, 2016 at 15:44
• thanks @pajonk - one can really learn some things on this site to make my code even less readable ;) Commented Aug 17, 2016 at 15:56

# 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:
# 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 less-than
# case, which loops top-of-stack times.
|> dI!>g # Complement of the above, using the greater-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.

• 4 bytes saved dividing by 70
• 6 bytes from daniero's suggestions (non-strings, ASCII nums instead; 10 => I)
• [*]n => 42P. Every instance of 10 can be replaced by I. []p => IP Commented Aug 17, 2016 at 20:50

This solution is as completely different from Laikonis 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]>>"*"  # TI-Basic, 39 bytes Prompt V,A sub("**********",1,max(0,min(10,int(V/A/70)+1  # Vyxal, 9 bytes /70/ṙ›\**  Try it Online! ## PowerShell v2+, 47 bytes -join(('*'*11)[1..($args[0]/$args[1]/70+.499)])  Somewhat a port of @Neil's JavaScript answer. Takes input $args and divides them, then divides that by 70, and adds .499. Since PowerShell does banker's rounding, this is effectively ceil to two decimal points of precision. If additional precision is required, tack on as many additional 9s 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 -> **********


# 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

• You do need to include imports, but from math import * will save a couple bytes Commented Aug 17, 2016 at 18:20
• Included the import into the byte count
– Cody
Commented Aug 17, 2016 at 18:26
• According to the spec, 0 is the minimum stars, not 1. Also save a whole 1 byte by import* with no space. Commented Aug 17, 2016 at 18:32
• Oops I misread the minimum. Thanks for the tip
– Cody
Commented Aug 17, 2016 at 18:33
• @Programman Though the spec says 0 is minimum, division and multiplication of non-negative, non-zero integers is guaranteed to != 0, and the ceiling operator will make anything between 0-1 and make it 1. Although I suppose there could be the case of 0 views, however 0 views implies 0 answers, which leads to undefined behavior (division by 0). It's likely provable that 0 is impossible and should not even be mentioned. Commented Aug 17, 2016 at 19:02