Riunione

La difficoltà di una domanda di Code Golf può essere calcolata come tale:

Dov'è vil numero di visualizzazioni di una domanda

ed aè il numero di risposte di una domanda

e ⌈ x ⌉ è l' operatore del soffitto .

Anche:

La difficoltà attuale di questa domanda: ***

Compito

Scrivi un programma che prenderà due numeri interi (v and a)e fornirà la difficoltà asterisks (*).

L'input può essere sotto forma di un array, una stringa separata o come argomenti di funzioni separate

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

Esempio con pseudocodice

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

Vince il codice più breve in byte! Sono ammessi spazi finali / iniziali.

JavaScript (ES6), 40 39 byte

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

Perché substringfornisce il bloccaggio richiesto e il comportamento "a soffitto". Modifica: Normalmente sono troppo pigro per disturbare, ma poiché ha ottenuto 4 voti positivi, ho seguito i consigli di @ MarsUltor per salvare 1 byte dal curry.

Ho voglia di farlo per un po '...

HTML + CSS 491 487 485 byte

-4 byte grazie a Conor O'Brien
-2 byte grazie al rilascio di Helium Nuclei

L'input viene preso come larghezza e altezza della finestra della pagina; larghezza indica il numero di visualizzazioni e altezza indica il numero di risposte.

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

Puoi provarlo nel tuo browser inserendo

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

come url in una nuova scheda.

05AB1E, 11 byte

/70/î'*T×s£

Spiegazione

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

Provalo online

Javascript (ES6), 37 36 byte

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

Salvato 1 byte dal curry, grazie 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 byte

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

Grazie a @MartinEnder per 3 byte

EXCEL, 29 byte

Se si considera Excel come rappresentazione di VBA Excel, è possibile utilizzare

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

dove ve asono il nome delle celle di riferimento.

CJam, 18 15 14 byte

Salvato 1 byte grazie a Peter Taylor e 3 byte grazie ad Adnan

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

Provalo 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 byte

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

Questa è la versione C # di questa eccellente risposta di Neil.

Salvati altri 19 byte grazie a Neil

Java 8, 57 byte

Utilizza un lambda per salvare i byte, esegue il calcolo e le sottostringhe per restituire la risposta.

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

Ecco la mia classe per testarlo.

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

Aggiornare

• -3 [16-08-19] Divisione intera utilizzata
• -10 [16-08-18] Rimossa importazione non necessaria, grazie a @ OlivierGrégoire !
• -18 [16-08-17] Restituisce la stringa anziché la stampa

MATL , 12 byte

/70/0:9>42*c

Provalo online!

Spiegazione

L'arrotondamento e il bloccaggio vengono eseguiti simultaneamente come segue: il numero x = v/a/70viene confrontato con ciascun elemento dell'array [0 1 ... 9]. I numeri di quell'array che vengono superati xdiventeranno asterischi e il resto saranno spazi.

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

salvato 3 + 2 byte e corretto da un errore grazie a Leaky Nun

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

simile alla risposta di Neils. Usa il fatto che Python2 fa divisione intera.

Haskell, 35 byte

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

[1..min(ceiling$v/a/70)10]crea un intervallo da 1 alla difficoltà calcolata (un elenco vuoto per la difficoltà 0). a>>bripete b length aspesso l'elenco .

Pyke, 13 9 byte

/70/\**T<

Provalo qui!

Spiegazione:

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

C #, 97 89 87 77 42 41 byte

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

Risparmiato 10 byte grazie ad Adám

Risparmio di pochi byte grazie ad Arnauld

Perl, 35 32 byte

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

Utilizzare -Eper attivare saye fornire gli argomenti in ordine inverso:

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

Se sono consentiti argomenti su STDIN, il seguente è 29 byte:

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

R, 68, 50 52 byte

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

rep posiziona implicitamente un minuto sul numero di 0.

Grazie a @plannapus e @ Anastasiya-Romanova 秀 per aver individuato il mio errore.

Pyth , 17 13 byte

4 byte in credito a Luis Mendo per il suo algoritmo .

* \ * Hts [0T.EccFQ70
* \ * S> LccFQ70T

Suite di test.

Javascript ES6, 48 byte

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

C, 54 , 51 , 50 , 49 byte

Supponendo che vsia positivo o zero e apositivo, la x < minscatola di serraggio non viene mai soddisfatta, poiché non è possibile che il risultato dell'operazione a soffitto sia negativo. Inoltre, la matematica intera su valori non negativi fornisce sempre la base del risultato, quindi aggiungiamo 1per ottenere il massimale.

Questa soluzione richiede una writefunzione, funziona almeno su Linux.

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

Test principale:

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 byte

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

• salvato alcuni byte dopo che Adám ha sottolineato che ho trascurato il / 700 * 10 = / 70 e la rimozione delle parentesi

Dyalog APL , 15 byte

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

'*'⍴⍨il personaggio lo ha ripetuto molte volte:
10⌊min (10, ...
⎕÷input diviso per
70×settanta volte
⎕input

ProvaAPL online!

Medusa , 18 byte

P
#'*
mM/%i
10 %70

Accetta input nel formato [a v]. Provalo online!

Spiegazione

• %è reciproco, quindi %70è 1/70.
• i viene immesso, come una matrice a due elementi.
• /%con input ie %70riduce l'array imediante divisione capovolta con valore iniziale %70. In altre parole, calcola v / (a ​​/ (1/70)) , che è uguale a v / (70 * a) .
• Mprende il limite di questo valore e mprende il massimo di quello e 10.
• #'*ripete il *carattere letterale che molte volte.
• P stampa il risultato senza virgolette.

MATLAB, 34 33 byte

Perché mi piace così tanto questa sfida, eccone una per MATLAB (output trailing whitespace):

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

Ispirato dalla risposta di @Luis Mendo. Grazie a @pajonk per aver salvato un byte.

m4, 136 135 byte

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

Definisce una macro fche accetta ve si aespande nell'output corretto. Gran parte del programma è un'implementazione del massimale.

dc, 110 108 104 98 byte

Questo è stato un po 'sgradevole dal momento che tagliare non è una cosa. Inoltre, dc non manipola le stringhe. Stavo davvero aspettando una stringa che sarebbe <5 ore di codifica. Tra i lati positivi, ho finalmente iniziato a scrivere costrutti comuni, come per i loop. Inoltre ho dovuto formulare arrotondamenti / soffitto, quindi grazie per quello.

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

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

Sostituzione (sopra) con il codice e ve acon le rispettive controparti sopra. Le virgolette singole sono importanti (altrimenti otterrai la storia di bash).

Ha spiegato:

[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

Questo probabilmente è più in grado di giocare a golf, ma stavo cercando di farlo per evitare l'ottimizzazione prematura.

• 2 byte salvati duplicando-salvando anziché salvando-caricando
• 4 byte salvati dividendo per 70
• 6 byte dai suggerimenti di daniero (non stringhe, numeri ASCII invece; 10 => I)

Haskell, 35 byte

Questa soluzione è completamente diversa dalla risposta di Laikoni in quanto offre qualcosa di così banale. Eppure il punteggio (per ora) è esattamente lo stesso.

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

Questo produce dieci stelle, quindi ne rade alcune. Facile da estendere a difficoltà arbitrarie con un elenco infinito.

Sono riuscito a radere un altro byte. Ma mentre tutti i casi di test funzionano, questo non dovrebbe essere corretto in generale.

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

TI-Basic, 39 byte

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

Un po 'una porta della risposta JavaScript di @ Neil .

Prende input $argse li divide, quindi li divide per 70e aggiunge .499. Poiché PowerShell esegue l'arrotondamento del banchiere , si tratta effettivamente ceildi due punti decimali di precisione. Se è richiesta un'ulteriore precisione, attaccare quanti più 9s necessari.

Insieme a 1.., questo forma un indice di intervallo in una stringa. La stringa è '*'*11, cioè '***********'. Ciò si traduce in un array di caratteri, quindi torniamo -joininsieme in una stringa. Quella stringa viene lasciata sulla pipeline e l'output è implicito. Come la risposta di Neil, questo "blocca" efficacemente l'output tra 1 e 10 stelle.

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 byte

Non volevo copiare la risposta di Python 2, quindi la mia è leggermente più lunga.

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

Salvato 1 byte grazie a Program man

In realtà, 14 byte

:70a\\u9ukm'**

Provalo online!

Sfrutta il fatto che 0 visualizzazioni e 0 risposte sono impossibili, e quindi ceil(v/a) > 0.

Spiegazione:

: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