การบรรยายสรุป

ความยากของคำถาม Code Golf สามารถคำนวณได้ดังนี้:

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

ตัวอย่างด้วย pseudocode

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 upvotes ฉันได้ทำตามคำแนะนำของ @ MarsUltor เพื่อประหยัด 1 ไบต์โดยการแกง

ฉันต้องการทำสิ่งนี้มาระยะหนึ่งแล้ว ...

HTML + CSS 491 487 485 ไบต์

-4 ไบต์ขอบคุณ Conor O'Brien
-2 ไบต์ขอบคุณ Helium Nuclei ที่ปล่อยออกมา

อินพุตถูกใช้เป็นความกว้างและความสูงของหน้าต่างหน้า ความกว้างคือจำนวนการดูและความสูงคือจำนวนคำตอบ

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

เป็น URL ในแท็บใหม่

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)

บันทึก 1 ไบต์ด้วยการขอบคุณขอบคุณ 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)) // **********

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 ไบต์

บันทึก 1 ไบต์ขอบคุณ Peter Taylor และ 3 ไบต์ขอบคุณ Adnan

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

นี่คือรุ่น C # ของคำตอบที่ยอดเยี่ยมนี้โดย Neil

บันทึกอีก 19 ไบต์ด้วย Neil

Java 8, 57 ไบต์

ใช้แลมบ์ดาเพื่อบันทึกไบต์ทำการคำนวณและสตริงย่อยเพื่อส่งคืนคำตอบ

(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 ไบต์

บันทึก 3 + 2 ไบต์และแก้ไขโดยข้อผิดพลาดเดียวเนื่องจาก Leaky Nun

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

บันทึก 10 ไบต์ขอบคุณAdám

บันทึกไม่กี่ไบต์ด้วย 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 ไบต์

4 ไบต์ในเครดิตให้กับหลุยส์ Mendo สำหรับขั้นตอนวิธีการของเขา

* \ * 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และการกำจัด parens

Dyalog APL ขนาด 15 ไบต์

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

'*'⍴⍨อักขระซ้ำหลายครั้ง:
10⌊นาที (10, ...
⎕÷อินพุตหารด้วยอินพุต
70×เจ็ดสิบครั้ง
⎕

ลองใช้ออนไลน์!

แมงกะพรุนขนาด 18 ไบต์

P
#'*
mM/%i
10 %70

[a v]จะเข้าในรูปแบบ ลองออนไลน์!

คำอธิบาย

• %คือส่วนกลับซึ่ง%70ก็คือ 1/70
• i คืออินพุตเป็นอาร์เรย์สององค์ประกอบ
• /%กับปัจจัยการผลิตiและ%70ลดอาร์เรย์ตามหมวดพลิกกับค่าเริ่มต้นi %70ในคำอื่น ๆ ก็คำนวณv / (A / (1/70))ซึ่งมีค่าเท่ากับv / (70 * ก)
• Mใช้เวลาเพดานของค่านี้และใช้เวลาสูงสุดนั้นและm10
• #'*ซ้ำตัวอักษร*ตัวอักษรที่หลายต่อหลายครั้ง
• 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และขยายไปยังเอาต์พุตที่ถูกต้อง โปรแกรมส่วนใหญ่เป็นการใช้งานบนเพดาน

dc, 110 108 104 98 ไบต์

นี่เป็น doozy ตั้งแต่การหั่นไม่ใช่เรื่อง นอกจากนี้ dc ไม่ได้จัดการสตริง ฉันแค่รอสตริงที่จะเข้ารหัส <5 ชั่วโมง ในด้านบวกในที่สุดฉันก็เริ่มเขียนโครงสร้างทั่วไปเช่นลูป ยังต้องกำหนดการปัดเศษ / เพดานดังนั้นขอบคุณสำหรับสิ่งนั้น

[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
• 6 ไบต์จากคำแนะนำของ daniero (ไม่ใช่สตริง, ASCII nums แทน; 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)])

ค่อนข้างพอร์ตของนีล @ คำตอบ JavaScript

จะเข้า$argsและแบ่งพวกเขาแล้วแบ่งว่าด้วยและเพิ่ม70 .499เนื่องจาก PowerShell ทำการปัดเศษของนายธนาคารนี่จึงเป็นceilความแม่นยำทศนิยมสองตำแหน่งอย่างมีประสิทธิภาพ หากต้องการความแม่นยำเพิ่มเติมให้ยึดหมุดเพิ่มเติม9ตามที่ต้องการ

นอกจาก1..นี้ยังมีการจัดทำดัชนีช่วงเป็นสตริง สตริงเป็นเช่น'*'*11 '***********'นั่นส่งผลให้เป็น char-array ดังนั้นเรา-joinจึงกลับมารวมกันเป็นสตริง สตริงนั้นจะถูกทิ้งไว้บนไปป์ไลน์และเอาท์พุทนั้นเป็นนัย เช่นเดียวกับคำตอบของ Neil สิ่งนี้จะ "บีบ" เอาต์พุตให้อยู่ระหว่าง 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))*'*')

บันทึก 1 ไบต์ต้องขอบคุณ Program man

จริงแล้ว 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