Briefing

La difficulté d'une question Code Golf peut être calculée comme suit:

Où vest le nombre de points de vue qu'une question a

et aest le nombre de réponses qu'une question a

et ⌈ x est l' opérateur de plafond .

Également:

La difficulté actuelle de cette question: ***

Tâche

Ecrivez un programme qui prendra deux entiers (v and a)et affichera la difficulté en asterisks (*).

L'entrée peut être sous la forme d'un tableau, d'une chaîne séparée ou d'arguments de fonction séparés

Données de test

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

Exemple avec pseudocode

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

Le code le plus court en octets gagne! Les espaces de fin / fin sont autorisés.

JavaScript (ES6), 40 39 octets

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

Parce que substringfournit le comportement de serrage et de "plafond" requis. Edit: Normalement, je suis trop fainéant pour le déranger, mais comme il a reçu 4 votes positifs, j’ai suivi le conseil de @ MarsUltor de sauvegarder 1 octet en curry.

Je voulais faire ça depuis un moment ...

HTML + CSS 491 487 485 octets

-4 octets grâce à Conor O'Brien
-2 octets grâce à la libération des noyaux d'hélium

L'entrée est prise en tant que largeur et hauteur de la fenêtre de page; width étant le nombre de vues et height le nombre de réponses.

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

Vous pouvez l'essayer dans votre navigateur en entrant

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

comme une URL dans un nouvel onglet.

05AB1E, 11 octets

/70/î'*T×s£

Explication

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

Essayez-le en ligne

Javascript (ES6), 37 36 octets

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

Sauvé 1 octet en currying, grâce à 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 octets

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

Merci à @MartinEnder pour 3 octets

EXCEL, 29 octets

Si vous comptez Excel comme une représentation de VBA Excel, vous pouvez utiliser

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

où vet asont le nom des cellules de référence.

CJam, 18 15 14 octets

Sauvé 1 octet grâce à Peter Taylor et 3 octets grâce à Adnan

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

Essayez-le en ligne

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

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

Ceci est la version C # de cette excellente réponse de Neil.

A sauvé 19 autres octets grâce à Neil

Java 8, 57 octets

Utilise un lambda pour enregistrer des octets, effectue le calcul et des sous-chaînes pour renvoyer la réponse.

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

Voici ma classe pour le tester.

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

Mise à jour

• -3 [16-08-19] Division de nombre entier utilisé
• -10 [16-08-18] Suppression de l'importation inutile, grâce à @ OlivierGrégoire !
• -18 [16-08-17] Renvoie la chaîne au lieu de print

MATL , 12 octets

/70/0:9>42*c

Essayez-le en ligne!

Explication

L'arrondi et le bridage se font simultanément comme suit: le nombre x = v/a/70est comparé à chaque élément du tableau [0 1 ... 9]. Les nombres de ce tableau qui sont dépassés xdeviendront des astérisques et le reste sera constitué d'espaces.

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

sauvegardé 3 + 2 octets et corrigé d'une erreur grâce à Leaky Nun

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

semblable à Neils répondre. Utilise le fait que Python2 effectue une division entière.

Haskell, 35 octets

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

[1..min(ceiling$v/a/70)10]crée une plage allant de 1 à la difficulté calculée (liste vide pour la difficulté 0). a>>brépète b length asouvent la liste .

Pyke, 13 à 9 octets

/70/\**T<

Essayez-le ici!

Explication:

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

C #, 97 89 87 77 42 41 octets

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

10 octets sauvés grâce à Adám

Enregistré quelques octets grâce à Arnauld

Perl, 35 32 octets

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

Utilisez -Epour activer sayet donner les arguments dans l'ordre inverse:

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

Si les arguments sur STDIN sont autorisés, 29 octets sont les suivants:

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

R, 68, 50 52 octets

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

rep place implicitement une minute sur le nombre 0.

Merci à @plannapus et @ Anastasiya-Romanova pour avoir repéré mon erreur.

Pyth , 17 à 13 octets

4 octets de crédit à Luis Mendo pour son algorithme .

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

Suite de tests.

Javascript ES6, 48 octets

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

C, 54 , 51 , 50 , 49 octets

En supposant que ce vsoit positif ou nul et apositif, le x < mincas de serrage n'est jamais rempli, car il n'y a aucun moyen que le résultat de l'opération de plafond puisse être négatif. De plus, le calcul des nombres entiers sur les valeurs non négatives donne toujours le plancher du résultat; nous ajoutons donc 1pour obtenir le plafond.

Cette solution nécessite une writefonction, fonctionne au moins sur Linux.

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

Test 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 octets

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

• sauvé quelques octets après qu'Adám eut fait remarquer que j'avais oublié le / 700 * 10 = / 70 , et la suppression des parens

Dyalog APL , 15 octets

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

'*'⍴⍨le caractère répété plusieurs fois:
10⌊min (10, ...
⎕÷entrée divisée par
70×soixante-dix fois l'
⎕entrée

TryAPL en ligne!

Méduse , 18 octets

P
#'*
mM/%i
10 %70

Prend l'entrée dans le format [a v]. Essayez-le en ligne!

Explication

• %est réciproque, donc %701/70.
• i est entrée, sous forme de tableau à deux éléments.
• /%avec des entrées iet %70réduit le tableau ipar division inversée avec la valeur initiale %70. En d'autres termes, il calcule v / (a ​​/ (1/70)) , ce qui est égal à v / (70 * a) .
• Mprend le plafond de cette valeur, et mprend le maximum de cela et 10.
• #'*répète le *caractère littéral à plusieurs reprises.
• P affiche le résultat sans guillemets.

MATLAB, 34 33 octets

Parce que j'aime tant ce défi, en voici un pour MATLAB (affiche les espaces à la fin):

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

Inspiré par la réponse de @Luis Mendo. Merci à @pajonk pour avoir sauvegardé un octet.

m4, 136 135 octets

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

Définit une macro fqui prend vet a, et se développe jusqu'à la sortie correcte. La majeure partie du programme est une mise en œuvre du plafond.

dc, 110 108 104 98 octets

C'était un doozy puisque trancher n'est pas une chose. En outre, dc ne manipule pas les chaînes. J'attendais vraiment une chaîne qui nécessiterait moins de 5 heures de codage. Sur le plan positif, j'ai finalement commencé à écrire des constructions communes, comme des boucles for. Aussi dû formuler arrondi / plafond, alors merci pour cela.

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

Invoqué dans 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:
**
>> 

Remplacer (ci-dessus) par le code, et vet aavec leurs homologues respectifs ci-dessus. Les guillemets simples sont importants (sinon, vous obtiendrez des informations sur l'histoire de bash).

A expliqué:

[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

C’est probablement plus facile à jouer au golf, mais j’essayais de le terminer pour éviter une optimisation prématurée.

• 2 octets enregistrés en dupliquant-enregistrez au lieu d'enregistrer-charger
• 4 octets enregistrés divisant par 70
• 6 octets des suggestions de daniero (non-chaînes, chiffres ASCII à la place; 10 => I)

Haskell, 35 octets

Cette solution est tout aussi différente de la réponse de Laikoni car elle procure un résultat aussi trivial. Pourtant, le score (pour l'instant) est exactement le même.

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

Cela produit dix étoiles, puis en rase certaines. Facile à étendre à la difficulté arbitraire avec une liste infinie.

J'ai réussi à supprimer un octet de plus. Mais bien que tous les cas de test fonctionnent, cela ne devrait pas être correct en général.

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

TI-Basic, 39 octets

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

PowerShell v2 +, 47 octets

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

Un peu la réponse JavaScript de @ Neil .

Prend les entrées $argset les divise, puis les divise en 70et ajoute .499. Etant donné que PowerShell effectue l’arrondissement bancaire, laceil précision est de deux décimales. Si une précision supplémentaire est requise, fixez autant de points supplémentaires 9que nécessaire.

Avec 1.., cela forme un index de plage dans une chaîne. La chaîne est '*'*11, c'est à dire '***********'. Cela donne un tableau de caractères, donc nous -joinle regroupons dans une chaîne. Cette chaîne est laissée sur le pipeline et la sortie est implicite. Comme la réponse de Neil, cela "pince" efficacement la sortie entre 1 et 10 étoiles.

Suite de tests

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 octets

Je ne voulais pas copier la réponse Python 2, alors la mienne est un peu plus longue.

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

Sauvé 1 octet grâce à l'homme du programme

En fait, 14 octets

:70a\\u9ukm'**

Essayez-le en ligne!

Profite du fait que 0 vues et 0 réponses sont impossibles, et donc ceil(v/a) > 0.

Explication:

: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