Cuộc họp

Độ khó của câu hỏi Code Golf có thể được tính như sau:

Trong trường hợp vlà số lần xem một câu hỏi có

và alà số câu trả lời của một câu hỏi

và ⌈ x là toán tử trần .

Cũng thế:

Câu hỏi khó hiện tại: ***

Bài tập, nhiệm vụ

Viết chương trình sẽ lấy hai số nguyên (v and a)và đưa ra độ khó asterisks (*).

Đầu vào có thể ở dạng một mảng, một chuỗi tách biệt hoặc là các đối số hàm riêng biệt

Kiểm tra dữ liệu

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í dụ với mã giả

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

Mã ngắn nhất tính bằng byte thắng! Trailing / không gian hàng đầu được cho phép.

JavaScript (ES6), 40 39 byte

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

Bởi vì substringcung cấp hành vi kẹp và "trần" cần thiết. Chỉnh sửa: Thông thường tôi quá lười để làm phiền, nhưng vì nó có 4 upvote, tôi đã làm theo lời khuyên của @ MarsUltor để tiết kiệm 1 byte bằng cách curry.

Tôi đã muốn làm điều này trong một thời gian ...

HTML + CSS 491 487 485 byte

-4 byte nhờ Conor O'Brien
-2 byte nhờ Phát hành hạt nhân Helium

Đầu vào được lấy là chiều rộng và chiều cao của cửa sổ trang; chiều rộng là số lượt xem và chiều cao là số câu trả lời.

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

Bạn có thể thử nó trong trình duyệt của bạn bằng cách nhậ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>**********

như một url trong một tab mới.

05AB1E, 11 byte

/70/î'*T×s£

Giải trình

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

Dùng thử trực tuyến

Javascript (ES6), 37 36 byte

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

Đã lưu 1 byte bằng cách currying, nhờ 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)) // **********

Toán học, 38 35 byte

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

Cảm ơn @MartinEnder cho 3 byte

EXCEL, 29 byte

Nếu bạn tính Excel là đại diện của VBA Excel, thì bạn có thể sử dụng

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

trong đó vvà alà tên của các ô tham chiếu.

CJam, 18 15 14 byte

Đã lưu 1 byte nhờ Peter Taylor và 3 byte nhờ Adnan

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

Dùng thử trực tuyến

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

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

Đây là phiên bản C # của câu trả lời xuất sắc này của Neil.

Đã lưu thêm 19 byte nhờ Neil

Java 8, 57 byte

Sử dụng lambda để lưu byte, thực hiện phép tính và chuỗi con để trả về câu trả lời.

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

Đây là lớp học của tôi để thử nghiệm nó.

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

Cập nhật

• -3 [16-08-19] Phân chia số nguyên được sử dụng
• -10 [16-08-18] Đã xóa nhập không cần thiết, nhờ @ OlivierGrégoire !
• -18 [16-08-17] Trả về chuỗi thay vì in

MATL , 12 byte

/70/0:9>42*c

Hãy thử trực tuyến!

Giải trình

Việc làm tròn và kẹp được thực hiện đồng thời như sau: số lượng x = v/a/70được so sánh với từng phần tử của mảng [0 1 ... 9]. Số lượng của mảng vượt quá xsẽ trở thành dấu hoa thị và phần còn lại sẽ là khoảng trắng.

/      % 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 byte

đã lưu 3 + 2 byte và sửa lỗi bằng một lỗi nhờ Leaky Nun

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

tương tự như câu trả lời của Neils. Sử dụng thực tế là Python2 không phân chia số nguyên.

Haskell, 35 byte

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

[1..min(ceiling$v/a/70)10]tạo phạm vi từ 1 đến độ khó được tính toán (danh sách trống cho độ khó 0). a>>blặp lại danh sách b length athường xuyên.

Pyke, 13 9 byte

/70/\**T<

Hãy thử nó ở đây!

Giải trình:

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

C #, 97 89 87 77 42 41 byte

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

Đã lưu 10 byte nhờ Adám

Đã lưu một vài byte nhờ Arnauld

Perl, 35 32 byte

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

Sử dụng -Eđể kích hoạt sayvà đưa ra các đối số theo thứ tự ngược lại:

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

Nếu các đối số trên STDIN được cho phép, thì sau đây là 29 byte:

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

R, 68, 50 52 byte

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

rep ngầm đặt một phút trên số 0.

Cảm ơn @plannapus và @ Anastasiya-Romanova vì đã phát hiện ra lỗi của tôi.

Bình thường , 17 13 byte

4 byte tín dụng cho Luis Mendo cho thuật toán của mình .

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

Bộ thử nghiệm.

Javascript ES6, 48 byte

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

C, 54 , 51 , 50 , 49 byte

Giả sử vlà dương hoặc bằng 0 và adương, x < mintrường hợp kẹp không bao giờ được đáp ứng, vì không có cách nào kết quả của hoạt động trần có thể âm. Ngoài ra, toán học số nguyên trên các giá trị không âm luôn mang lại kết quả cuối cùng, vì vậy chúng tôi thêm 1vào để có được mức trần.

Giải pháp này yêu cầu một writechức năng, hoạt động trên Linux ít nhất.

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

Kiểm tra chính:

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 byte

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

• đã lưu một số byte sau khi Adám chỉ ra rằng tôi đã bỏ qua / 700 * 10 = / 70 và loại bỏ các dấu ngoặc

APL Dyalog , 15 byte

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

'*'⍴⍨ký tự lặp lại nhiều lần:
10⌊min (10, ...
⎕÷đầu vào chia cho
70×bảy mươi lần
⎕đầu vào

Dùng thử trực tuyến!

Sứa , 18 byte

P
#'*
mM/%i
10 %70

Đưa đầu vào theo định dạng [a v]. Hãy thử trực tuyến!

Giải trình

• %là đối ứng, %701/70 cũng vậy .
• i là đầu vào, như là một mảng hai yếu tố.
• /%với đầu vào ivà %70giảm mảng ibằng cách lật phân chia với giá trị ban đầu %70. Nói cách khác, nó tính v / (a ​​/ (1/70)) , bằng với v / (70 * a) .
• Mlấy trần của giá trị này, và mlấy tối đa của giá trị đó và 10.
• #'*nhắc lại *nhân vật nghĩa đen nhiều lần.
• P in kết quả mà không có dấu ngoặc kép.

MATLAB, 34 33 byte

Bởi vì tôi thích challange này rất nhiều, đây là một cho MATLAB (xuất ra các khoảng trắng theo sau):

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

Lấy cảm hứng từ câu trả lời của @Luis Mendo. Cảm ơn @pajonk vì đã lưu một byte.

m4, 136 135 byte

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

Xác định một macro flấy vvà a, và mở rộng đến đầu ra chính xác. Hầu hết các chương trình là một thực hiện trần.

dc, 110 108 104 98 byte

Đây là một doozy vì cắt không phải là một điều. Ngoài ra, dc không thao tác chuỗi. Tôi thực sự đang chờ đợi một chuỗi có thể là <5 giờ mã hóa. Về mặt tích cực, cuối cùng tôi đã bắt đầu viết ra các cấu trúc phổ biến, như cho các vòng lặp. Cũng phải xây dựng làm tròn / trần, vì vậy cảm ơn vì điều đó.

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

Được gọi trong 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:
**
>> 

Thay thế (ở trên) bằng mã vvà avới các đối tác tương ứng của chúng ở trên. Các trích dẫn duy nhất rất quan trọng (nếu không bạn sẽ nhận được nội dung lịch sử của bash).

Giải thích:

[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

Đây có lẽ là khả năng chơi gôn nhiều hơn, nhưng tôi đã cố gắng hoàn thành nó để tránh tối ưu hóa sớm.

• 2 byte được lưu bằng cách sao chép-lưu thay vì lưu-tải
• 4 byte được lưu chia cho 70
• 6 byte từ các đề xuất của daniero (không phải chuỗi, số ASCII thay vào đó; 10 => I)

Haskell, 35 byte

Giải pháp này hoàn toàn khác với câu trả lời của Laikoni vì nó nhận được một cái gì đó tầm thường này. Tuy nhiên, điểm số (bây giờ) là hoàn toàn giống nhau.

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

Điều này tạo ra mười ngôi sao, sau đó loại bỏ một số. Dễ dàng mở rộng đến khó khăn tùy ý với một danh sách vô hạn.

Tôi đã quản lý để cạo thêm một byte. Nhưng trong khi tất cả các trường hợp thử nghiệm hoạt động, điều này không nên nói chung.

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

TI-Basic, 39 byte

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

PowerShell v2 +, 47 byte

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

Phần nào đó là một câu trả lời JavaScript của @ Neil .

Lấy đầu vào $argsvà chia chúng, sau đó chia nó cho 70và thêm .499. Vì PowerShell thực hiện làm tròn ngân hàng , điều này có hiệu quả ceilđến hai điểm thập phân chính xác. Nếu cần độ chính xác bổ sung, hãy giải quyết càng nhiều 9s theo yêu cầu.

Cùng với 1.., điều này tạo thành một chỉ mục phạm vi thành một chuỗi. Chuỗi là '*'*11, tức là '***********'. Điều đó dẫn đến một mảng char, vì vậy chúng tôi -joinkết hợp lại thành một chuỗi. Chuỗi đó được để lại trên đường ống và đầu ra là ẩn. Giống như câu trả lời của Neil, điều này thực sự "kẹp" đầu ra phải nằm trong khoảng từ 1 đến 10 sao.

Phòng thử nghiệm

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 byte

Tôi không muốn sao chép câu trả lời Python 2, vì vậy câu trả lời của tôi dài hơn một chút.

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

Đã lưu 1 byte nhờ Người đàn ông chương trình

Trên thực tế, 14 byte

:70a\\u9ukm'**

Hãy thử trực tuyến!

Lợi dụng thực tế là 0 lượt xem và 0 câu trả lời là không thể, và do đó ceil(v/a) > 0.

Giải trình:

: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