Брифінг

Складність питання 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          **********

Приклад з псевдокодом

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 відгуки, я дотримувався поради @ MarsUltor, щоб зберегти 1 байт, проклавши.

Я хотів це зробити деякий час ...

HTML + CSS 491 487 485 байт

-4 байти завдяки Conor O'Brien
-2 байту завдяки випуску гелієвого ядра

Введення приймається як ширина та висота вікна сторінки; ширина - кількість переглядів, а висота - кількість відповідей.

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

Математика, 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 байт завдяки Пітеру Тейлору та 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));

Це версія C # на відмінну відповідь Ніла.

Зберегли ще 19 байт завдяки Нілу

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]

схожий на Neils answer. Використовує той факт, що 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.

Пайк, 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

Збережено кілька байт завдяки Арнольду

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 байти в кредит на Луїса Мендо за його алгоритм .

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

• врятувало кілька байтів після того, як Адам зазначив, що я не помітив / 700 * 10 = / 70 і видалення паронів

Діалог APL , 15 байт

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

'*'⍴⍨персонаж повторював це багато разів:
10⌊хв (10, ...
⎕÷введення, поділене на введення
70×сімдесяти разів)
⎕

СпробуйтеAPL онлайн!

Медузи , 18 байт

P
#'*
mM/%i
10 %70

Здійснює введення у форматі [a v]. Спробуйте в Інтернеті!

Пояснення

• %є взаємною, так %70це 1/70.
• i вводиться як двоелементний масив.
• /%з входами iта %70зменшує масив i, перевернувши поділ з початковим значенням %70. Іншими словами, він обчислює v / (a ​​/ (1/70)) , що дорівнює v / (70 * a) .
• Mприймає стелю цього значення і mприймає максимум того і 10.
• #'*повторює буквальний *характер, що багато разів.
• P друкує результат без лапок.

MATLAB, 34 33 байт

Оскільки мені дуже подобається цей виклик, ось такий для MATLAB (виводить пробіли пробілів):

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

Натхненний відповіддю @Luis Мендо. Дякуємо @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, і розширюється до правильного виходу. Більшість програми - це реалізація стелі.

постійного струму, 110 108 104 98 байт

Це було дузі, оскільки нарізка - це не річ. Також 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

Викликається в баш:

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відповідними аналогами вище. Одиночні цитати є важливими (інакше ви отримуєте інформацію про історію баша).

Пояснили:

[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 байт із пропозицій даньєро (замість них рядки, ASCII чисел; 10 => I)

Haskell, 35 байт

Це рішення настільки ж відмінний від відповіді Лайконі , як і для чогось цього дріб'язкового. І все ж оцінка (поки що) точно така ж.

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 на Ніла @ Neil .

Бере введення $argsта ділить їх, потім ділить це на 70і додає .499. Оскільки PowerShell здійснює округлення банкіра , це фактично ceilдо двох десяткових точок точності. Якщо потрібна додаткова точність, застосуйте стільки додаткових 9s, скільки потрібно.

Поряд з 1.., це формує індекс діапазону в рядок. Рядок є '*'*11, тобто '***********'. Це призводить до масиву char, тому ми -joinразом повертаємося в рядок. Ця рядок залишена на конвеєрі, а вихід неявний. Як і у відповідь Ніла, це ефективно "затискає" вихід між 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 байт завдяки програмі 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