Instrucciones

La dificultad de una pregunta de Code Golf se puede calcular como tal:

¿Dónde vestá el número de visitas que tiene una pregunta?

y aes el número de respuestas que tiene una pregunta

y ⌈ x ⌉ es el operador del techo .

También:

La dificultad actual de esta pregunta: ***

Tarea

Escriba un programa que tomará dos enteros (v and a)y generará la dificultad asterisks (*).

La entrada puede estar en forma de una matriz, una cadena separada o como argumentos de función separados

Datos de prueba

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

Ejemplo con pseudocódigo

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

¡El código más corto en bytes gana! Se permiten espacios finales / iniciales.

JavaScript (ES6), 40 39 bytes

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

Porque substringproporciona la sujeción requerida y el comportamiento de "techo". Editar: Normalmente soy demasiado vago para molestarme, pero debido a que recibió 4 votos a favor, he seguido el consejo de @ MarsUltor para ahorrar 1 byte al curry.

He estado queriendo hacer esto por un tiempo ...

HTML + CSS 491 487 485 bytes

-4 bytes gracias a Conor O'Brien
-2 bytes gracias a Release Helium Nuclei

La entrada se toma como el ancho y alto de la ventana de la página; ancho es el número de Vistas y alto es el número de Respuestas.

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

Puedes probarlo en tu navegador ingresando

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 una URL en una nueva pestaña.

05AB1E, 11 bytes

/70/î'*T×s£

Explicación

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

Pruébalo en línea

Javascript (ES6), 37 36 bytes

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

Ahorré 1 byte al curry, gracias 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⌉]&

Gracias a @MartinEnder por 3 bytes

EXCEL, 29 bytes

Si cuenta Excel como una representación de VBA Excel, puede usar

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

donde vy ason el nombre de las celdas de referencia.

CJam, 18 15 14 bytes

Guardado 1 byte gracias a Peter Taylor y 3 bytes gracias a Adnan

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

Pruébalo en línea

'*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 es la versión C # de esta excelente respuesta de Neil.

Ahorró otros 19 bytes gracias a Neil

Java 8, 57 bytes

Utiliza una lambda para guardar bytes, realiza el cálculo y las subcadenas para devolver la respuesta.

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

Aquí está mi clase para probarlo.

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

Actualizar

• -3 [16-08-19] División entera utilizada
• -10 [16-08-18] Se eliminó la importación innecesaria, gracias a @ OlivierGrégoire !
• -18 [16-08-17] Devolver cadena en lugar de imprimir

MATL , 12 bytes

/70/0:9>42*c

Pruébalo en línea!

Explicación

El redondeo y la sujeción se realizan simultáneamente de la siguiente manera: el número x = v/a/70se compara con cada elemento de la matriz [0 1 ... 9]. Los números de esa matriz que se exceden xse convertirán en asteriscos, y el resto serán espacios.

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

guardado 3 + 2 bytes y corregido por un error gracias a Leaky Nun

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

similar a la respuesta de Neils. Utiliza el hecho de que Python2 hace división entera.

Haskell, 35 bytes

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

[1..min(ceiling$v/a/70)10]crea un rango de 1 a la dificultad calculada (una lista vacía para la dificultad 0). a>>brepite la lista a b length amenudo.

Pyke, 13 9 bytes

/70/\**T<

Pruébalo aquí!

Explicación:

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

Guardado 10 bytes gracias a Adám

Guardado algunos bytes gracias a Arnauld

Perl, 35 32 bytes

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

Use -Epara activar sayy dar los argumentos en el orden inverso:

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

Si se permiten argumentos en STDIN, el siguiente es 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 implícitamente coloca un min en el número de 0

Gracias a @plannapus y @ Anastasiya-Romanova 秀 por detectar mi error.

Pyth , 17 13 bytes

4 bytes en crédito a Luis Mendo por su algoritmo .

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

Banco de pruebas.

Javascript ES6, 48 bytes

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

C, 54 , 51 , 50 , 49 bytes

Suponiendo que ves positivo o cero y apositivo, el x < mincaso de sujeción nunca se cumple, ya que no hay forma de que el resultado de la operación del techo pueda ser negativo. Además, las matemáticas enteras en valores no negativos siempre producen el piso del resultado, por lo que agregamos 1para obtener el techo.

Esta solución requiere una writefunción, funciona en Linux al menos.

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

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

• guardé algunos bytes después de que Adám señaló que pasé por alto el / 700 * 10 = / 70 , y la eliminación de parens

Dyalog APL , 15 bytes

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

'*'⍴⍨el personaje repitió esto muchas veces:
10⌊min (10, ...
⎕÷entrada dividida por
70×setenta veces
⎕entrada

TryAPL en línea!

Medusa , 18 bytes

P
#'*
mM/%i
10 %70

Toma entrada en el formato [a v]. Pruébalo en línea!

Explicación

• %es recíproco, también lo %70es 1/70.
• i es input, como una matriz de dos elementos.
• /%con entradas iy %70reduce la matriz ipor división invertida con valor inicial %70. En otras palabras, calcula v / (a ​​/ (1/70)) , que es igual a v / (70 * a) .
• Mtoma el techo de este valor, y mtoma el máximo de eso y 10.
• #'*repite el *carácter literal que muchas veces.
• P imprime el resultado sin comillas.

MATLAB, 34 33 bytes

Debido a que me gusta mucho este desafío, aquí hay uno para MATLAB (salidas en blanco):

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

Inspirado por la respuesta de @Luis Mendo. Gracias a @pajonk por guardar un 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 una macro fque toma vy a, y se expande a la salida correcta. La mayor parte del programa es una implementación de techo.

dc, 110108104 98 bytes

Esto fue una maravilla ya que cortar no es una cosa. Además, dc no manipula cadenas. Realmente estaba esperando una cadena que sería <5 horas de codificación. En el lado positivo, finalmente comencé a escribir construcciones comunes, como for loops. También tuve que formular redondeo / techo, así que gracias por eso.

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

Invocado en 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:
**
>> 

Reemplazar (arriba) con el código, vy acon sus respectivas contrapartes arriba. Las comillas simples son importantes (de lo contrario, obtienes el historial de 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

Esto probablemente sea más apto para el golf, pero estaba tratando de terminarlo para evitar una optimización prematura.

• 2 bytes guardados al guardar y duplicar en lugar de guardar y cargar
• 4 bytes guardados dividiendo por 70
• 6 bytes de las sugerencias de daniero (sin cadenas, números ASCII en su lugar; 10 => I)

Haskell, 35 bytes

Esta solución es tan completamente diferente de la respuesta de Laikoni como lo es para algo tan trivial. Sin embargo, el puntaje (por ahora) es exactamente el mismo.

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

Esto produce diez estrellas, luego afeita algunas. Fácil de extender a dificultad arbitraria con una lista infinita.

Me las arreglé para afeitarme un byte más. Pero si bien todos los casos de prueba funcionan, esto no debería ser correcto en general.

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

Algo un puerto de la respuesta JavaScript de @ Neil .

Toma datos $argsy los divide, luego los divide por 70, y agrega .499. Como PowerShell realiza el redondeo bancario , esto es efectivamente ceilcon dos puntos decimales de precisión. Si se requiere precisión adicional, agregue tantos 9s adicionales como sea necesario.

Junto con el 1.., esto forma un índice de rango en una cadena. La cadena es '*'*11, es decir '***********'. Eso da como resultado una matriz de caracteres, por lo -joinque los unimos nuevamente en una cadena. Esa cadena se deja en la tubería y la salida es implícita. Al igual que la respuesta de Neil, esto efectivamente "sujeta" la salida para que esté entre 1 y 10 estrellas.

Banco de pruebas

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

No quería copiar la respuesta de Python 2, así que la mía es un poco más larga.

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

Guardado 1 byte gracias a Program man

En realidad, 14 bytes

:70a\\u9ukm'**

Pruébalo en línea!

Aprovecha el hecho de que 0 vistas y 0 respuestas es imposible, y por lo tanto ceil(v/a) > 0.

Explicación:

: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