Briefing

A dificuldade de uma pergunta do Code Golf pode ser calculada da seguinte forma:

Onde vestá o número de visualizações de uma pergunta

e aé o número de respostas que uma pergunta tem

e ⌈ x ⌉ é o operador de teto .

Além disso:

Dificuldade atual da pergunta: ***

Tarefa

Escreva um programa que use dois números inteiros (v and a)e produza a dificuldade asterisks (*).

A entrada pode estar na forma de uma matriz, uma sequência separada ou como argumentos de função separados

Dados de teste

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

Exemplo com pseudocódigo

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

O código mais curto em bytes vence! Espaços à direita / à direita são permitidos.

JavaScript (ES6), 40 39 bytes

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

Porque substringfornece o comportamento de fixação e "teto" necessário. Edit: Normalmente, eu sou muito preguiçoso para me preocupar, mas porque ele recebeu 4 votos positivos, segui o conselho da @ MarsUltor para economizar 1 byte ao currying.

Eu tenho vontade de fazer isso por um tempo ...

HTML + CSS 491 487 485 bytes

-4 bytes graças a Conor O'Brien
-2 bytes graças ao lançamento de núcleos de hélio

A entrada é considerada como a largura e a altura da janela da página; largura sendo o número de Visualizações e altura sendo o número de Respostas.

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

Você pode experimentá-lo no seu navegador digitando

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

como um URL em uma nova guia.

05AB1E, 11 bytes

/70/î'*T×s£

Explicação

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

Experimente online

Javascript (ES6), 37 36 bytes

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

Economizou 1 byte ao currying, graças a 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 bytes

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

Obrigado a @MartinEnder por 3 bytes

EXCEL, 29 bytes

Se você contar o Excel como uma representação do VBA Excel, poderá usar

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

onde ve asão o nome das células de referência.

CJam, 18 15 14 bytes

Economizou 1 byte graças a Peter Taylor e 3 bytes graças a Adnan

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

Experimente online

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

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

Esta é a versão em C # desta excelente resposta de Neil.

Guardou outros 19 bytes graças a Neil

Java 8, 57 bytes

Usa uma lambda para salvar bytes, executa o cálculo e as substrings para retornar a resposta.

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

Aqui está a minha turma para testá-lo.

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

Atualizar

• -3 [16-08-19] Divisão inteira utilizada
• -10 [16-08-18] Removida a importação desnecessária, graças a @ OlivierGrégoire !
• -18 [16-08-17] Retornar string em vez de print

MATL , 12 bytes

/70/0:9>42*c

Experimente online!

Explicação

O arredondamento e a fixação são feitos simultaneamente da seguinte forma: o número x = v/a/70é comparado com cada elemento da matriz [0 1 ... 9]. Os números dessa matriz excedidos xse tornarão asteriscos, e o restante serão espaços.

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

economizou 3 + 2 bytes e corrigido por um erro graças a Leaky Nun

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

semelhante à resposta de Neils. Usa o fato de que Python2 faz divisão inteira.

Haskell, 35 bytes

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

[1..min(ceiling$v/a/70)10]cria um intervalo de 1 à dificuldade calculada (uma lista vazia para a dificuldade 0). a>>brepete a lista b length afrequentemente.

Pyke, 13 9 bytes

/70/\**T<

Experimente aqui!

Explicação:

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

C #, 97 89 87 77 42 41 bytes

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

Economizou 10 bytes graças a Adám

Economizou alguns bytes graças a Arnauld

Perl, 35 32 bytes

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

Use -Epara ativar saye fornecer os argumentos na ordem inversa:

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

Se argumentos em STDIN são permitidos, o seguinte é 29 bytes:

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

R, 68, 50 52 bytes

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

rep coloca implicitamente um mínimo no número 0.

Obrigado a @plannapus e @ Anastasiya-Romanova 秀 por detectar meu erro.

Pitão , 17 13 bytes

4 bytes de crédito a Luis Mendo por seu algoritmo .

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

Suíte de teste.

Javascript ES6, 48 bytes

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

C, 54 , 51 , 50 , 49 bytes

Supondo que vseja positivo ou zero e apositivo, a x < mincaixa de fixação nunca é atendida, pois não há como o resultado da operação no teto ser negativo. Além disso, a matemática inteira com valores não negativos sempre produz o piso do resultado, então adicionamos 1para obter o teto.

Esta solução requer uma writefunção, funciona no Linux pelo menos.

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

Teste principal:

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 bytes

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

• salvei alguns bytes depois que Adám apontou que eu ignorava o / 700 * 10 = / 70 , e a remoção de parênteses

Dyalog APL , 15 bytes

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

'*'⍴⍨o caractere repetiu isso muitas vezes:
10⌊min (10, ...
⎕÷entrada dividida por
70×setenta vezes a
⎕entrada

TryAPL online!

Água-viva , 18 bytes

P
#'*
mM/%i
10 %70

Recebe entrada no formato [a v]. Experimente online!

Explicação

• %é recíproco, assim %70como 1/70.
• i é entrada, como uma matriz de dois elementos.
• /%com entradas ie %70reduz a matriz ipor divisão invertida com valor inicial %70. Em outras palavras, ele calcula v / (a ​​/ (1/70)) , que é igual a v / (70 * a) .
• Massume o teto desse valor e massume o máximo disso e 10.
• #'*repete o *caractere literal várias vezes.
• P imprime o resultado sem aspas.

MATLAB, 34 33 bytes

Como eu gosto muito desse desafio, aqui está um para o MATLAB (saídas à esquerda de espaços em branco):

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

Inspirado na resposta de @Luis Mendo. Agradecemos a @pajonk por salvar um byte.

m4, 136 135 bytes

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

Define uma macro fque leva ve a, e se expande para a saída correta. A maior parte do programa é uma implementação de teto.

dc, 110 108 104 98 bytes

Isso foi um delírio, já que fatiar não é uma coisa. Além disso, dc não manipula seqüências de caracteres. Eu realmente estava esperando por uma string que seria <5 horas de codificação. No lado positivo, finalmente comecei a escrever construções comuns, como para loops. Também tive que formular o arredondamento / teto, então obrigado por isso.

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

Chamado no 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:
**
>> 

Substituindo (acima) pelo código e / ve apor suas respectivas contrapartes acima. As aspas simples são importantes (caso contrário, você obtém o histórico do bash).

Explicado:

[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

Provavelmente é mais capaz de jogar golfe, mas eu estava tentando finalizá-lo para evitar a otimização prematura.

• 2 bytes salvos ao salvar duplicados em vez de salvar salvos
• 4 bytes salvos dividindo por 70
• 6 bytes das sugestões de daniero (sem strings, números ASCII; 10 => I)

Haskell, 35 bytes

Esta solução é tão completamente diferente da resposta de Laikoni quanto para algo tão trivial. No entanto, a pontuação (por enquanto) é exatamente a mesma.

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

Isso produz dez estrelas, depois raspa algumas. Fácil de estender à dificuldade arbitrária com uma lista infinita.

Eu consegui raspar mais um byte. Mas, embora todos os casos de teste funcionem, isso não deve estar correto em geral.

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

TI-Basic, 39 bytes

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

PowerShell v2 +, 47 bytes

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

De certa forma, um porto da resposta JavaScript de @ Neil .

Pega entrada $argse as divide, depois divide por 70e adiciona .499. Como o PowerShell faz o arredondamento do banqueiro , isso é efetivamente ceilduas casas decimais de precisão. Se for necessária precisão adicional, prenda quantos 9s adicionais forem necessários.

Junto com o 1.., isso forma um índice de intervalo em uma sequência. A cadeia é '*'*11, ie '***********'. Isso resulta em uma matriz de caracteres, para que -joinjuntos de volta em uma string. Essa cadeia é deixada no pipeline e a saída é implícita. Como a resposta de Neil, isso efetivamente "prende" a saída entre 1 e 10 estrelas.

Suíte de teste

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 bytes

Eu não queria copiar a resposta do Python 2, então a minha é um pouco mais longa.

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

Economizou 1 byte graças ao Program man

Na verdade, 14 bytes

:70a\\u9ukm'**

Experimente online!

Aproveita o fato de que 0 visualizações e 0 respostas são impossíveis e, portanto, ceil(v/a) > 0 ,.

Explicação:

: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