Odprawa

Trudność pytania Code Golf można obliczyć w ten sposób:

Gdzie vjest liczba wyświetleń pytania

i ajest liczbą odpowiedzi na pytanie

a ⌈ x ⌉ jest operatorem sufitowym .

Również:

Obecna trudność tego pytania: ***

Zadanie

Napisz program, który weźmie dwie liczby całkowite (v and a)i wyświetli trudność asterisks (*).

Dane wejściowe mogą mieć postać tablicy, oddzielnego łańcucha lub oddzielnych argumentów funkcji

Dane testowe

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

Przykład z pseudokodem

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

Najkrótszy kod w bajtach wygrywa! Dopuszczalne są spacje końcowe / wiodące.

JavaScript (ES6), 40 39 bajtów

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

Ponieważ substringzapewnia wymagane zachowanie mocowania i „sufitu”. Edycja: Zwykle jestem zbyt leniwy, aby zawracać sobie głowę, ale ponieważ otrzymałem 4 głosy poparcia, postąpiłem zgodnie z radą @ MarsUltor, aby zaoszczędzić 1 bajt, curry.

Od dłuższego czasu chciałem to zrobić ...

HTML + CSS 491 487 485 bajtów

-4 bajty dzięki Conor O'Brien
-2 bajty dzięki Releasing Helium Nuclei

Dane wejściowe przyjmuje się jako szerokość i wysokość okna strony; szerokość jest liczbą wyświetleń, a wysokość jest liczbą odpowiedzi.

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

Możesz spróbować w przeglądarce, wpisując

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

jako adres URL w nowej karcie.

05AB1E, 11 bajtów

/70/î'*T×s£

Wyjaśnienie

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

Wypróbuj online

JavaScript (ES6), 37 36 bajtów

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

Zaoszczędzono 1 bajt dzięki curry, dzięki 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 bajtów

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

Dzięki @MartinEnder za 3 bajty

EXCEL, 29 bajtów

Jeśli policzysz Excela jako reprezentację VBA Excel, możesz użyć

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

gdzie vi asą nazwą komórek referencyjnych.

CJam, 18 15 14 bajtów

Zaoszczędzono 1 bajt dzięki Peter Taylor i 3 bajty dzięki Adnan

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

Wypróbuj 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 bajtów

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

To jest wersja C # tej doskonałej odpowiedzi autorstwa Neila.

Zaoszczędził kolejne 19 bajtów dzięki Neilowi

Java 8, 57 bajtów

Używa lambda do zapisywania bajtów, wykonuje obliczenia i podciągi, aby zwrócić odpowiedź.

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

Oto moja klasa do testowania.

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

Aktualizacja

• -3 [16-08-19] Wykorzystany podział na liczby całkowite
• -10 [16-08-18] Usunięto niepotrzebne importowanie dzięki @ OlivierGrégoire !
• -18 [16-08-17] Zwraca ciąg zamiast drukowania

MATL , 12 bajtów

/70/0:9>42*c

Wypróbuj online!

Wyjaśnienie

Zaokrąglanie w górę i zaciskanie odbywa się jednocześnie w następujący sposób: liczba x = v/a/70jest porównywana z każdym elementem tablicy [0 1 ... 9]. Liczby tej tablicy, które zostaną przekroczone, xstaną się gwiazdkami, a pozostałe będą spacjami.

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

zapisano 3 + 2 bajty i poprawiono jednym błędem dzięki Dziurawej Zakonnicy

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

podobna do odpowiedzi Neilsa. Wykorzystuje fakt, że Python2 dokonuje podziału na liczby całkowite.

Haskell, 35 bajtów

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

[1..min(ceiling$v/a/70)10]tworzy zakres od 1 do obliczonej trudności (pusta lista dla trudności 0). często a>>bpowtarza listę b length a.

Pyke, 13 9 bajtów

/70/\**T<

Wypróbuj tutaj!

Wyjaśnienie:

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

C #, 97 89 87 77 42 41 bajtów

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

Zaoszczędzono 10 bajtów dzięki Adámowi

Zaoszczędź kilka bajtów dzięki Arnauldowi

Perl, 35 32 bajtów

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

Użyj, -Eaby aktywować sayi podać argumenty w odwrotnej kolejności:

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

Jeśli dozwolone są argumenty na STDIN, 29 bajtów to:

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

R, 68, 50 52 bajtów

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

rep domyślnie umieszcza min na liczbie 0.

Dzięki @plannapus i @ Anastasiya-Romanova 秀 za wykrycie mojego błędu.

Pyth , 17 13 bajtów

4 bajty przypisane Luisowi Mendo za jego algorytm .

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

Zestaw testowy.

JavaScript ES6, 48 bajtów

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

C, 54 , 51 , 50 , 49 bajtów

Zakładając, że vjest dodatnia lub zerowa i adodatnia, x < minprzypadek mocowania nigdy nie jest spełniony, ponieważ nie ma możliwości, aby wynik operacji sufitu mógł być ujemny. Dodatkowo, matematyka na liczbach całkowitych dla wartości nieujemnych zawsze daje dolną granicę wyniku, więc dodajemy, 1aby uzyskać pułap.

To rozwiązanie wymaga writefunkcji, działa przynajmniej w systemie Linux.

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

Test główny:

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 bajty

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

• zapisałem kilka bajtów po tym, jak Adám zwrócił uwagę, że przeoczyłem / 700 * 10 = / 70 i usunięcie parens

Dyalog APL , 15 bajtów

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

'*'⍴⍨znak powtórzył to wiele razy:
10⌊min (10, ...
⎕÷wejście podzielone przez
70×siedemdziesiąt razy
⎕wejście

Wypróbuj APL online!

Meduza , 18 bajtów

P
#'*
mM/%i
10 %70

Pobiera dane wejściowe w formacie [a v]. Wypróbuj online!

Wyjaśnienie

• %jest wzajemna, podobnie jak %701/70.
• i jest wprowadzany jako tablica dwuelementowa.
• /%z wejściami ii %70zmniejsza tablicę ipoprzez odwrócenie podziału o wartości początkowej %70. Innymi słowy, oblicza v / (a ​​/ (1/70)) , co jest równe v / (70 * a) .
• Mprzyjmuje pułap tej wartości i mprzyjmuje maksimum tego oraz 10.
• #'*powtarza dosłowny *charakter wiele razy.
• P wypisuje wynik bez cudzysłowów.

MATLAB, 34 33 bajty

Ponieważ bardzo podoba mi się to wyzwanie, oto jedno dla MATLAB (wyjścia końcowe białe znaki):

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

Zainspirowany odpowiedzią @Luis Mendo. Dzięki @pajonk za zapisanie jednego bajtu.

m4, 136 135 bajtów

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

Określa makro, fktóre trwa vi a, i rozszerza się do właściwego wyjścia. Większość programu stanowi realizację pułapu.

dc, 110 108 104 98 bajtów

To było doozy, ponieważ krojenie nie jest niczym. Ponadto dc nie manipuluje ciągami. Po prostu naprawdę czekałem na ciąg, który byłby <5 godzin kodowania. Plusem jest to, że w końcu zacząłem zapisywać popularne konstrukcje, na przykład dla pętli. Musiałem również sformułować zaokrąglenie / sufit, więc dzięki za to.

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

Wywołany w 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:
**
>> 

Zastępując (powyżej) z kodem, a v, a az ich odpowiednikami powyżej. Pojedyncze cytaty są ważne (w przeciwnym razie dostajesz rzeczy związane z historią basha).

Wyjaśniono:

[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

Prawdopodobnie jest to bardziej możliwe do gry w golfa, ale starałem się go zakończyć, aby uniknąć przedwczesnej optymalizacji.

• 2 bajty zapisane przez kopiowanie-zapisywanie zamiast zapisywania-ładowania
• 4 bajty zapisane dzielone przez 70
• 6 bajtów z sugestii Daniero (nie ciągi, zamiast tego liczby ASCII; 10 => I)

Haskell, 35 bajtów

To rozwiązanie jest całkowicie odmienne od odpowiedzi Laikoni, gdy chodzi o coś tak trywialnego. Jednak wynik (na razie) jest dokładnie taki sam.

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

Powoduje to powstanie dziesięciu gwiazdek, a następnie ich golenie. Łatwa do rozszerzenia na dowolne trudności z nieskończoną listą.

Udało mi się ogolić jeszcze jeden bajt. Ale chociaż wszystkie przypadki testowe działają, ogólnie nie powinno to być poprawne.

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

TI-Basic, 39 bajtów

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

PowerShell v2 +, 47 bajtów

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

Nieco port odpowiedzi JavaScript @ Neila .

Pobiera dane wejściowe $argsi dzieli je, a następnie dzieli przez 70i dodaje .499. Ponieważ PowerShell wykonuje zaokrąglanie bankiera , jest to efektywne ceilz dokładnością do dwóch miejsc po przecinku. Jeśli wymagana jest dodatkowa precyzja, przyklej tyle dodatkowych 9s, ile potrzeba.

Wraz z 1..tym tworzy indeks zakresu w ciąg. Ciąg jest '*'*11, tj '***********'. Daje to tablicę -joinznaków , więc łączymy ją z powrotem w ciąg. Ten ciąg jest pozostawiony w potoku, a dane wyjściowe są niejawne. Podobnie jak odpowiedź Neila, to skutecznie „blokuje” moc wyjściową od 1 do 10 gwiazdek.

Pakiet testowy

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 bajtów

Nie chciałem kopiować odpowiedzi na Python 2, więc moja jest nieco dłuższa.

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

Zaoszczędzono 1 bajt dzięki programowi man

Właściwie 14 bajtów

:70a\\u9ukm'**

Wypróbuj online!

Wykorzystuje fakt, że 0 wyświetleń i 0 odpowiedzi jest niemożliwe, a zatem ceil(v/a) > 0.

Wyjaśnienie:

: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