Anweisung

Die Schwierigkeit einer Code Golf-Frage kann folgendermaßen berechnet werden:

Wo vist die Anzahl der Aufrufe einer Frage?

und aist die Anzahl der Antworten, die eine Frage hat

und ⌈ x ⌉ ist der Deckenantrieb .

Ebenfalls:

Die aktuelle Schwierigkeit dieser Frage: ***

Aufgabe

Schreiben Sie ein Programm, das zwei ganze Zahlen enthält (v and a)und die Schwierigkeit in ausgibt asterisks (*).

Die Eingabe kann in Form eines Arrays, einer separaten Zeichenfolge oder als separate Funktionsargumente erfolgen

Testdaten

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

Beispiel mit Pseudocode

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

Der kürzeste Code in Bytes gewinnt! Nachgestellte / führende Leerzeichen sind erlaubt.

JavaScript (ES6), 40 bis 39 Byte

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

Denn es substringsorgt für das erforderliche Klemm- und "Decken" -Verhalten. Edit: Normalerweise bin ich zu faul, um mir die Mühe zu machen, aber weil es 4 positive Stimmen gab, habe ich @ MarsUltors Rat befolgt, um 1 Byte durch Curry zu sparen.

Ich wollte das schon eine Weile machen ...

HTML + CSS 491 487 485 Bytes

-4 Bytes dank Conor O'Brien
-2 Bytes dank der Freisetzung von Heliumkernen

Die Eingabe wird als Breite und Höhe des Seitenfensters verwendet. width ist die Anzahl der Aufrufe und height die Anzahl der Antworten.

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

Sie können es in Ihrem Browser versuchen, indem Sie eingeben

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

als URL in einem neuen Tab.

05AB1E, 11 Bytes

/70/î'*T×s£

Erläuterung

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

Probieren Sie es online aus

Javascript (ES6), 37-36 Bytes

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

Dank TheLethalCoder 1 Byte durch Currying eingespart

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⌉]&

Danke an @MartinEnder für 3 Bytes

EXCEL, 29 Bytes

Wenn Sie Excel als eine Darstellung von VBA Excel zählen, können Sie verwenden

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

wo vund asind die Namen der Referenzzellen.

CJam, 18 15 14 Bytes

1 Byte dank Peter Taylor und 3 Byte dank Adnan gespeichert

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

Probieren Sie es online aus

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

Dies ist die C # -Version dieser hervorragenden Antwort von Neil.

Weitere 19 Bytes dank Neil gespeichert

Java 8, 57 Bytes

Verwendet ein Lambda zum Speichern von Bytes, führt die Berechnung durch und Teilzeichenfolgen, um die Antwort zurückzugeben.

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

Hier ist meine Klasse zum Testen.

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

Aktualisieren

• -3 [16-08-19] Verwendete Ganzzahldivision
• -10 [16-08-18] Unnötiger Import wurde entfernt, dank @ OlivierGrégoire !
• -18 [16-08-17] String zurückgeben, anstatt zu drucken

MATL , 12 Bytes

/70/0:9>42*c

Probieren Sie es online!

Erläuterung

Das Aufrunden und Klemmen erfolgt gleichzeitig wie folgt: Die Anzahl x = v/a/70wird mit jedem Element des Arrays verglichen [0 1 ... 9]. Die Zahlen dieses Arrays, die von überschritten werden, xwerden zu Sternchen und der Rest sind Leerzeichen.

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

3 + 2 Bytes gespeichert und dank Leaky Nun um einen Fehler korrigiert

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

ähnlich wie Neils Antwort. Verwendet die Tatsache, dass Python2 eine Ganzzahldivision durchführt.

Haskell, 35 Bytes

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

[1..min(ceiling$v/a/70)10]Erstellt einen Bereich von 1 bis zur berechneten Schwierigkeit (eine leere Liste für die Schwierigkeit 0). a>>bwiederholt die Liste b length aoft.

Pyke, 13 9 Bytes

/70/\**T<

Probieren Sie es hier aus!

Erläuterung:

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

Dank Adám 10 Bytes gespart

Ein paar Bytes gespart dank Arnauld

Perl, 35 32 Bytes

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

Verwenden Sie -E, sayum die Argumente in umgekehrter Reihenfolge zu aktivieren und anzugeben:

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

Wenn Argumente für STDIN zulässig sind, sind 29 Byte zulässig:

(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 setzt implizit eine min auf die Zahl 0.

Vielen Dank an @plannapus und @ Anastasiya-Romanova 秀, die meinen Fehler entdeckt haben.

Pyth , 17 13 Bytes

Luis Mendo für seinen Algorithmus 4 Bytes gutgeschrieben .

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

Testsuite.

Javascript ES6, 48 Bytes

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

C, 54 , 51 , 50 , 49 Bytes

Unter der Annahme, dass vpositiv oder null und apositiv ist, wird der x < minKlemmfall niemals erfüllt, da das Ergebnis des Deckenbetriebs auf keinen Fall negativ sein kann. Darüber hinaus ergibt eine Ganzzahlberechnung mit nicht negativen Werten immer den Grundwert des Ergebnisses. Wir addieren also 1, um die Obergrenze zu ermitteln.

Diese Lösung benötigt eine writeFunktion, funktioniert zumindest unter Linux.

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

Testleitung:

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

• Ich habe ein paar Bytes gespart, nachdem Adám darauf hingewiesen hatte, dass ich die / 700 * 10 = / 70 und das Entfernen von Parens übersehen habe

Dyalog APL , 15 Bytes

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

'*'⍴⍨das Zeichen wurde so oft wiederholt:
10⌊min (10, ...
⎕÷Eingabe geteilt durch
70×siebzig mal
⎕Eingabe

TryAPL online!

Qualle , 18 Bytes

P
#'*
mM/%i
10 %70

Übernimmt Eingaben im Format [a v]. Probieren Sie es online!

Erläuterung

• %ist wechselseitig, so %70ist 1/70.
• i wird als Array mit zwei Elementen eingegeben.
• /%mit Eingängen iund %70reduziert das Array idurch gespiegelte Division mit dem Anfangswert %70. Mit anderen Worten, es berechnet v / (a ​​/ (1/70)) , was gleich v / (70 * a) ist .
• MNimmt die Obergrenze dieses Wertes und mnimmt das Maximum von diesem und 10.
• #'*wiederholt das wörtliche *Zeichen so oft.
• P druckt das Ergebnis ohne Anführungszeichen.

MATLAB, 34 33 Bytes

Da mir diese Herausforderung so gut gefällt, gibt es hier eine für MATLAB (gibt nachgestellte Leerzeichen aus):

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

Inspiriert von der Antwort von @Luis Mendo. Vielen Dank an @pajonk für das Speichern eines Bytes.

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

Definiert ein Makro, fdas die korrekte Ausgabe annimmt vund aund erweitert. Der größte Teil des Programms ist eine Umsetzung der Obergrenze.

Gleichstrom, 110 108 104 98 Bytes

Dies war ein Trottel, da das Schneiden keine Sache ist. Außerdem manipuliert DC keine Strings. Ich habe nur wirklich auf einen String gewartet, der <5 Stunden Codierung sein würde. Auf der positiven Seite habe ich endlich angefangen, gängige Konstrukte aufzuschreiben, wie zum Beispiel für Schleifen. Musste auch Rundung / Decke formulieren, also danke dafür.

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

In bash aufgerufen:

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

Ersetzen (oben) durch den Code vund adurch die entsprechenden oben genannten Gegenstücke. Die einfachen Anführungszeichen sind wichtig (ansonsten erhalten Sie die Geschichte der Bash).

Erklärt:

[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

Dies ist wahrscheinlich besser zum Golfen geeignet, aber ich habe versucht, es fertigzustellen, um eine vorzeitige Optimierung zu vermeiden.

• 2 Bytes werden durch Duplizieren, Speichern und Laden gespeichert
• 4 Bytes gespart, geteilt durch 70
• 6 bytes aus danieros vorschlägen (non-strings, stattdessen ASCII nums; 10 => I)

Haskell, 35 Bytes

Diese Lösung unterscheidet sich von Laikonis Antwort so sehr, wie es für etwas so Triviales gilt. Dennoch ist die Punktzahl (vorerst) genau die gleiche.

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

Das bringt zehn Sterne hervor und schert dann einige ab. Einfach mit einer unendlichen Liste auf beliebige Schwierigkeitsgrade zu erweitern.

Ich habe es geschafft, ein weiteres Byte zu entfernen. Aber während alle Testfälle funktionieren, sollte dies im Allgemeinen nicht korrekt sein.

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 Byte

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

Etwas eine Portierung von @ Neils JavaScript-Antwort .

Nimmt Eingaben $argsund dividiert sie, dividiert sie dann durch 70und addiert sie .499. Da PowerShell die Banker-Rundung durchführt , erfolgt dies effektiv ceilauf zwei Dezimalstellen genau. Wenn zusätzliche Präzision erforderlich ist, heften Sie so viele zusätzliche 9s an, wie erforderlich sind.

Zusammen mit 1..bildet dies einen Bereichsindex in eine Zeichenfolge. Der String ist '*'*11, dh '***********'. Das ergibt ein char-Array, also fassen wir -joines wieder zu einem String zusammen. Diese Zeichenfolge verbleibt in der Pipeline und die Ausgabe ist implizit. Wie Neils Antwort "klemmt" dies die Ausgabe effektiv so, dass sie zwischen 1 und 10 Sternen liegt.

Test Suite

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

Ich wollte die Antwort von Python 2 nicht kopieren, daher ist meine etwas länger.

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

Dank Program man 1 Byte gespeichert

Eigentlich 14 Bytes

:70a\\u9ukm'**

Probieren Sie es online!

Nutzt die Tatsache aus, dass 0 Aufrufe und 0 Antworten unmöglich sind und somit ceil(v/a) > 0.

Erläuterung:

: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