брифинг

Сложность вопроса 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 байта благодаря выпуску ядра гелия

Ввод принимается как ширина и высота окна страницы; width - количество просмотров, а height - количество ответов.

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

Благодаря 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⌉]&

Спасибо @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]

похоже на ответ Нилса. Использует тот факт, что 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 байтов благодаря Адаму

Сохранено несколько байтов благодаря Арно

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 и удаление паренов

Дьялог АПЛ , 15 байт

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

'*'⍴⍨персонаж повторял это много раз:
10⌊min (10, ...
⎕÷input делится на
70×семьдесят раз
⎕input

Попробуй 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 Mendo. Спасибо @pajonk за сохранение одного байта.

м4, 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

Вызывается в 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 байтов из предложений Даниеро (не строки, вместо этого 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)])

Отчасти ответ @ Neil's на JavaScript .

Принимает входные данные $argsи делит их, затем делит на 70и добавляет .499. Поскольку PowerShell выполняет банковское округление , это дает ceilточность с точностью до двух десятичных знаков. Если требуется дополнительная точность, добавьте столько дополнительных 9значений, сколько требуется.

Наряду с 1.., это формирует индекс диапазона в строку. Строка '*'*11, то есть '***********'. Это приводит к массиву символов, поэтому мы -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