요약 보고

코드 골프 질문의 어려움은 다음과 같이 계산할 수 있습니다.

v질문의 견해는 어디에 있습니까?

및 a답변의 수는 질문이 있습니다

그리고 ⌈ x the는 천장 운영자 입니다.

또한:

이 질문의 현재 어려움 : ***

태스크

두 개의 정수 (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 '*'

바이트 단위의 가장 짧은 코드가 이깁니다! 후행 / 선행 공간이 허용됩니다.

자바 스크립트 (ES6), 40 39 바이트

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

때문에이 substring필요한 클램핑과 행동을 보내고 "천장을 만들다"를 제공합니다. 편집 : 일반적으로 귀찮게하기에는 너무 게으르지 만 4 개의 공감대를 얻었으므로 @MarsUltor의 조언에 따라 1 바이트를 카레로 저장했습니다.

나는 이것을 잠시 동안하고 싶었습니다 ...

HTML + CSS 491 487 485 바이트

Conor O'Brien 덕분에 -4 바이트,
Helium Nuclei 릴리스 덕분에 -2 바이트

입력은 페이지 창의 너비와 높이로 간주됩니다. width는 Views의 수이고 height는 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>**********

당신은 입력하여 브라우저에서 시도 할 수 있습니다

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

온라인으로 사용해보십시오

자바 스크립트 (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⌉]&

3 바이트에 대한 @MartinEnder 덕분에

엑셀, 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 # 버전입니다 .

Neil 덕분에 19 바이트 더 절약

자바 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 바이트

Leaky Nun 덕분에 3 + 2 바이트를 저장하고 하나의 오류로 수정했습니다.

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

Neils의 답변과 비슷합니다. Python2가 정수 나누기를한다는 사실을 사용합니다.

하스켈, 35 바이트

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

[1..min(ceiling$v/a/70)10]1부터 계산 난이도 (난이도 0에 대한 빈 목록)까지의 범위를 만듭니다. a>>b목록을 b length a자주 반복합니다 .

파이크, 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 덕분에 몇 바이트 절약

펄, 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

테스트 스위트.

자바 스크립트 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');
}

자바 스크립트 : 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⌊분 (10 ...
⎕÷입력 나눈
70×칠십 회
⎕입력

TryAPL 온라인!

해파리 , 18 바이트

P
#'*
mM/%i
10 %70

형식으로 입력을 [a v]받습니다. 온라인으로 사용해보십시오!

설명

• %역수이므로 %701/70도 마찬가지입니다.
• i 는 요소를 2 개 가진 배열로 입력됩니다.
• /%입력 값을 i가지며 초기 값으로 플립 분할 %70하여 배열 i을 줄 %70입니다. 즉, v / (a ​​/ (1/70))을 계산 하며 이는 v / (70 * a)와 같습니다 .
• M이 값의 상한값을 m취하고 최대 값을 취합니다 10.
• #'*리터럴 *문자를 여러 번 반복합니다 .
• P 따옴표없이 결과를 인쇄합니다.

MATLAB, 34 33 바이트

나는이 challange를 너무 좋아하기 때문에 여기에 MATLAB (후미 공백 출력)이 있습니다.

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

@Luis Mendo의 답변에서 영감을 얻었습니다. 1 바이트를 저장해 준 @pajonk에게 감사합니다.

m4, 136135 바이트

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 바이트

슬라이싱이 중요하지 않기 때문에 이것은 두껍습니다. 또한 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)

하스켈, 35 바이트

이 솔루션은 이 사소한 일에 대해 얻는 것처럼 Laikoni 의 답변 과 완전히 다릅니다 . 그러나 현재 점수는 동일합니다.

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

이것은 10 개의 별을 생성 한 다음 일부를 면도합니다. 무한 목록으로 임의의 난이도로 쉽게 확장 할 수 있습니다.

나는 더 많은 바이트를 깎아 내었다. 그러나 모든 테스트 사례가 작동하지만 일반적으로 올바른 것은 아닙니다.

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

TI 기본, 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은 은행가의 반올림을 수행하므로 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 -> **********

파이썬 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