Bilgilendirme

Bir Code Golf sorununun zorluğu şu şekilde hesaplanabilir:

vBir sorunun sahip olduğu görüş sayısı nerede

ve abir sorunun cevabının sayısı

ve ⌈ x ⌉ olan tavan operatörü .

Ayrıca:

Bu sorunun şu anki zorluğu: ***

Görev

İki tamsayı alacak (v and a)ve zorluğu çıkaran bir program yazın asterisks (*).

Giriş bir dizi, ayrılmış bir dize veya ayrı işlev argümanları şeklinde olabilir

Test verisi

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

Sahte kod ile örnek

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

Bayt cinsinden en kısa kod kazanır! Sondaki / öndeki alanlara izin verilir.

JavaScript (ES6), 40 39 byte

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

Çünkü substringgerekli sıkıştırma ve "tavan" kurma davranışını sağlar. Düzenleme: Normalde rahatsız etmek için çok tembelim, ama 4 oy aldığından, @ MarsUltor'un tavsiyesini körerek 1 byte tasarruf etmek için izledim.

Bir süredir bunu yapmak istiyordum ...

HTML + CSS 491 487 485 bayt

Conor O'Brien sayesinde -4 byte
-3 Helyum Nuclei Serbest Bırakma sayesinde -2 byte

Giriş, sayfa penceresinin genişliği ve yüksekliği olarak alınır; Genişlik, Gösterim sayısı ve yükseklik ise Cevap sayısıdır.

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

Girerek tarayıcınızda deneyebilirsiniz.

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

Yeni bir sekmede bir URL olarak.

05AB1E, 11 bayt

/70/î'*T×s£

açıklama

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

Çevrimiçi deneyin

Javascript (ES6), 37 adet 36 bayt

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

TheLethalCoder sayesinde, 1 bayt kurutma oranında kaydedilir

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 bayt

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

@MartinEnder'e 3 bayt için teşekkürler

EXCEL, 29 bayt

Excel'i VBA Excel'in temsili olarak sayarsanız, kullanabilirsiniz.

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

referans hücrelerinin adı nerede vve anerededir?

CJam, 18 15 14 bayt

Peter Taylor sayesinde 1 byte, Adnan sayesinde 3 byte kaydedildi

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

Çevrimiçi deneyin

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

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

Bu, Neil'in bu mükemmel cevabının C # versiyonudur .

Neil sayesinde 19 bayt daha kaydedildi

Java 8, 57 bayt

Bayt kaydetmek için bir lambda kullanır, cevabı döndürmek için hesaplama yapar ve alt dizeleri uygular.

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

İşte benim sınama sınıfı.

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

Güncelleme

• -3 [16-08-19] Kullanılan tamsayı bölme
• -10 [16-08-18] @ OlivierGrégoire sayesinde gereksiz ithalat kaldırıldı !
• -18 [16-08-17] Baskı yerine dönüş dizesi

MATL , 12 bayt

/70/0:9>42*c

Çevrimiçi deneyin!

açıklama

Yuvarlama ve sıkma aşağıdaki gibi aynı anda yapılır: sayı x = v/a/70dizinin her bir elemanı ile karşılaştırılır [0 1 ... 9]. Bu dizinin aşıldığı numaralar xyıldızlara dönüşecek ve gerisi boşluklar olacaktır.

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

3 + 2 bayt kaydedildi ve Leaky Nun sayesinde bir hatayla düzeltildi

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

Neils cevap benzer. Python2'nin tamsayı bölme yaptığı gerçeğini kullanır.

Haskell, 35 bayt

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

[1..min(ceiling$v/a/70)10]1 ile hesaplanan zorluk arasında bir zorluk yaratır (zorluk için boş bir liste 0). a>>bListeyi b length asık sık tekrarlar .

Pyke, 13 9 bayt

/70/\**T<

Burada dene!

Açıklama:

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

C #, 97 89 87 77 42 41 bayt

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

Adám sayesinde 10 bayt kaydedildi

Arnauld sayesinde birkaç byte kurtarıldı

Perl, 35 32 bayt

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

Argümanları ters sırada -Eetkinleştirmek sayve vermek için kullanın :

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

STDIN üzerindeki bağımsız değişkenlere izin verilirse, aşağıdaki 29 bayttır:

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

R, 68, 50 52 bayt

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

rep Örtülü olarak 0'a bir dakika yerleştirir.

Hatamı tespit ettiği için @plannapus ve @ Anastasiya-Romanova 秀 'a teşekkür ederim.

Pyth , 17 13 bayt

Algoritması için Luis Mendo'ya 4 byte kredi verdi .

* \ * HTS [0T.EccFQ70
* \ * Lar> LccFQ70T

Test odası.

Javascript ES6, 48 bayt

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

C, 54 , 51 , 50 , 49 bayt

Bunun vpozitif veya sıfır olduğu ve apozitif olduğu varsayımıyla , x < minsıkma kasası asla karşılanmaz, çünkü tavanın çalışmasının sonucunun negatif olması mümkün değildir. Ek olarak, negatif olmayan değerler üzerindeki tamsayı matematik her zaman sonucun tabanını verir, bu nedenle 1tavana almak için ekleriz .

Bu çözüm bir writeişlev gerektirir , en azından Linux'ta çalışır.

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

Ana test:

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 bayt

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

• Adám’ın / 700 * 10 = / 70’in ve

Dyalog APL , 15 bayt

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

'*'⍴⍨karakter bunu defalarca tekrarladı:
10⌊min (10, ...
⎕÷giriş bölü
70×yetmiş kez
⎕girdi

TryAPL çevrimiçi!

Denizanası , 18 bayt

P
#'*
mM/%i
10 %70

Biçiminde giriş alır [a v]. Çevrimiçi deneyin!

açıklama

• %karşılıklı, %701/70.
• i İki elemanlı bir dizi olarak girdi.
• /%girişleri olan ive %70diziyi ibaşlangıç ​​değeri olan bölünmüş bölmeyle azaltır %70. Başka bir deyişle, v / (70 * a) 'ya eşit olan v / (a ​​/ (1/70)) değerini hesaplar .
• Mbu değerin tavanını alır, ve mmaksimumunu alır ve 10.
• #'*değişmez *karakteri birçok kez tekrarlar .
• P sonucu tırnak işaretleri olmadan yazdırır.

MATLAB, 34 33 bayt

Bu meydan okumayı çok sevdiğim için, işte MATLAB için bir tane (izleyen boşlukları çıktılar):

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

@Luis Mendo'nun cevabından ilham aldı. Bir bayt tasarrufu için @pajonk teşekkürler.

m4, 136 135 bayt

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

Bir makro tanımlar falır vve ave doğru çıkış genişler. Programın çoğu tavanın bir uygulamasıdır.

dC, 110 108 104 98 bayt

Dilimleme bir şey olmadığı için bu bir sıkıntı oldu. Ayrıca, dc dizeleri değiştirmez. Ben sadece gerçekten <5 saatlik kodlamanın geçeceği bir dize bekliyordum. Artı tarafta, nihayet döngüler gibi ortak yapılar yazmaya başladım. Ayrıca yuvarlama / tavan formüle etmek zorunda kaldı, bunun için teşekkürler.

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

Bash'ta çağrıldı:

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

Kodla (yukarıda) değiştirme, vvea yukarıda belirtilen ilgili benzerleriyle. Tekli alıntılar önemlidir (aksi halde bash’ın geçmişini alırsınız).

Açıklaması:

[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

Bu muhtemelen daha golf yapabiliyor, ama erken optimizasyondan kaçınmak için onu bitirmeye çalışıyordum.

• Kaydetme-yükleme yerine kopyalama-kaydetme ile kaydedilen 2 bayt
• 4 bayt 70 bölü kaydetti
• Daniero'nun önerilerinden 6 bayt (karakter dizisi olmayanlar, bunun yerine ASCII sayıları; 10 => I)

Haskell, 35 bayt

Bu çözüm, Laikoni'nin bu kadar önemsiz bir şey için verdiği cevaptan tamamen farklı . Yine de (şimdilik) puan tamamen aynı.

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

Bu on yıldız üretir, sonra bazılarını tıraş eder. Sonsuz bir liste ile keyfi zorluğa genişletmek kolaydır.

Bir bayt daha tıraş etmeyi başardım. Ancak tüm test durumları çalışırken, bu genel olarak doğru olmamalıdır.

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

TI-Basic, 39 bayt

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

PowerShell v2 +, 47 bayt

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

Biraz Neil'in JavaScript cevabının bir limanı .

Girdileri alır $argsve böler, sonra bunları böler 70ve ekler .499. PowerShell bankacının hizmetini tamamladığından , bu etkili ceiliki ondalık kesinlik puanıdır. Ek hassasiyet gerekiyorsa, istediğiniz kadar ilave 9s kullanın.

Bununla birlikte 1.., bu bir dizgede bir aralık endeksi oluşturur. Dize '*'*11yani '***********'. Bu bir karakter dizisine neden olur, bu yüzden -jointekrar bir dizgeye geri dönelim. Bu dize boru hattında bırakılır ve çıktı örtüktür. Neil'in cevabı gibi, bu da etkili bir şekilde 1 ila 10 yıldız arasında olan çıktıyı "sıkıştırır".

Test odası

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 bayt

Python 2'nin cevabını kopyalamak istemedim, bu yüzden benimki biraz daha uzun.

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

Program adamı sayesinde 1 bayt kurtarıldı

Aslında, 14 bayt

:70a\\u9ukm'**

Çevrimiçi deneyin!

0 görüş ve 0 yanıtın mümkün olmadığı gerçeğinden faydalanır ve bu nedenle ceil(v/a) > 0.

Açıklama:

: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