वार्ता

एक कोड गोल्फ प्रश्न की कठिनाई की गणना इस तरह की जा सकती है:

सूत्र

vएक प्रश्न के विचारों की संख्या कहां है

और aएक प्रश्न के उत्तर की संख्या है

और and x ceiling सीलिंग ऑपरेटर है ।

इसके अलावा:

दबाना

इस प्रश्न की वर्तमान कठिनाई: ***

कार्य

एक प्रोग्राम लिखें जो दो पूर्णांकों को ले जाएगा (v and a)और इसमें कठिनाई को आउटपुट करेगा asterisks (*)।

इनपुट एक सरणी, एक अलग स्ट्रिंग या अलग फ़ंक्शन तर्क के रूप में हो सकता है

परीक्षण डेटा

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

स्यूडोकोड के साथ उदाहरण

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

बाइट्स में सबसे छोटा कोड जीतता है! ट्रेलिंग / अग्रणी स्थानों की अनुमति है।

code-golf math

— शॉन वाइल्ड
स्रोत

3

मुझे लगता है कि LaTeX को समझना मुश्किल है कि एक सरल सूत्र स्ट्रिंग .. लेकिन जो भी बहुमत मुझे लगता है वह चाहते हैं ..

— शॉन वाइल्ड

3

आपको प्रश्न को कम करके आंका जाना चाहिए ।

— अड्म

5

यह एक कोड गोल्फ प्रश्न है। साइट में वास्तविक प्रणाली लागू नहीं की जा रही है। अगर यह अनुचित है तो कौन परवाह करता है?

— शॉन वाइल्ड

13

इसके थोड़े जल्दी तो मुझे यहाँ कुछ याद आ रहा है, लेकिन /700 * 10इसके बजाय क्यों /70?

— केविन एल

4

@KevinL Ssshhhh;)

— शॉन वाइल्ड

49

जावास्क्रिप्ट (ईएस 6), 40 39 बाइट्स

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

क्योंकि substringआवश्यक क्लैम्पिंग और "छत" आईएनजी व्यवहार प्रदान करता है। संपादित करें: आम तौर पर मैं परेशान करने के लिए बहुत आलसी हूं, लेकिन क्योंकि यह 4 अपवोट्स मिला है, मैंने करीने से 1 बाइट बचाने के लिए @ मार्सुलेटर की सलाह का पालन किया है।

— नील
स्रोत

ओह, यह

— प्रतिस्थापन

7

करीने का प्रयोग करें:v=>a=>

— ASCII-only

3

क्या आप substrइसके बजाय उपयोग कर सकते हैं ? मुझे पता है कि दूसरा पैरामीटर एक अंतर बनाता है, लेकिन पहले के बारे में निश्चित नहीं ...

— डोम हेस्टिंग्स

1

@DomHastings: हाँ, हालांकि sliceइससे भी कम होगा।

— 1829 में Y29295

5

@DomHastings नहीं, दोनों substrऔर sliceस्ट्रिंग के अंत से वापस गिनती के रूप में एक नकारात्मक तर्क की व्याख्या करते हैं।

— नील

38

मैं कुछ समय के लिए ऐसा करना चाहता हूं ...

HTML + CSS 491 487 485 बाइट्स

कोन ओ'ब्रायन
-2 बाइट्स के लिए -4 बाइट्स धन्यवाद हीलियम नाभिक जारी करने के लिए

इनपुट को विंडो की चौड़ाई और ऊंचाई के रूप में लिया जाता है; चौड़ाई दर्शाव की संख्या है, और ऊँचाई उत्तर की संख्या है।

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

आप इसे अपने ब्राउज़र में दर्ज करके देख सकते हैं

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

एक नए टैब में एक यूआरएल के रूप में।

— Yay295
स्रोत

11

+1 बॉक्स से बाहर सोचने के लिए

— एहम

2

क्या आपको समापन पी टैग की आवश्यकता है?

— कॉनर ओ'ब्रायन

मैं प्यार करता हूँ कि यह कैसे अद्यतन करता है क्योंकि मैं खिड़की का आकार बदलता हूं।

— YSC

@ ConorO'Brien: अच्छी बात है!

— Yay295

1

आपको अंतिम दो }s की भी आवश्यकता नहीं है।

— betseg

12

05AB1E, 11 बाइट्स

/70/î'*T×s£

व्याख्या

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

इसे ऑनलाइन आज़माएं

— Emigna
स्रोत

12

जावास्क्रिप्ट (ईएस 6), 37 36 बाइट्स

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

1 बाइट को करीने से सहेजा, 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)) // **********

स्निपेट का विस्तार करें

— Arnauld
स्रोत

3

के v=>a=>बजाय आप का उपयोग कर सकते हैं (v,a)=>?

— TheLethalCoder

@ लेथलॉकर - अपडेट किया गया। धन्यवाद!

— अरनौलड

2

v=70, a=1इसके लिए काम नहीं करता है?

— नील

1

@ नील - यह सही है। यदि उत्तरों की संख्या विचारों की संख्या का सटीक विभाजक है तो यह 1 अंक से बंद है। या दूसरे शब्दों में कहें, तो यह अगले दृश्य की आशंका है। ;-)

— अरनुलड

11

गणितज्ञ, 38 35 बाइट्स

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

3 बाइट्स के लिए @MartinEnder को धन्यवाद

— u54112
स्रोत

1

नमस्कार, और PPCG में आपका स्वागत है! यह एक महान जवाब है!

— NoOneIsHere

@NoOneIsHere धन्यवाद! मूल रूप से मैं सोच रहा था Clip, जिसमें ओपी के क्लैम्प के रूप में बहुत अधिक वाक्यविन्यास है, लेकिन फिर मैंने देखा कि StringRepeatट्रंकेशन के लिए वैकल्पिक तीसरा तर्क है।

— u54112

3

बाएं और दाएं छत कोष्ठक के लिए यूनिकोड वर्ण हैं जो आप के लिए आवश्यक 9 के बजाय केवल 6 बाइट्स बनाते हैं Ceiling[]।

— मार्टिन एंडर

9

EXCEL, 29 बाइट्स

यदि आप एक्सेल को VBA एक्सेल के प्रतिनिधित्व के रूप में गिनते हैं, तो आप उपयोग कर सकते हैं

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

कहां vऔर aसंदर्भ कोशिकाओं के नाम हैं।

— अनास्तासिया-रोमानोवा ova
स्रोत

3

नमस्ते, और PPCG में आपका स्वागत है! यह एक अच्छी पहली पोस्ट है! और मान्य भी।

— 22

हाय भी @EasterlyIrk। गर्मजोशी से स्वागत के लिए धन्यवाद :)

— अनास्तासिया-रोमानोवा '

8

CJam, 18 15 14 बाइट्स

पीटर टेलर के लिए 1 बाइट धन्यवाद और अदनान के लिए 3 बाइट्स बचा

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

इसे ऑनलाइन आज़माएं

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

— बिजनेस कैट
स्रोत

8

सी #, 68 49 48 बाइट्स

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

यह नील द्वारा इस उत्कृष्ट उत्तर का # संस्करण है ।

नील की बदौलत एक और 19 बाइट्स बचाई

— TheLethalCoder
स्रोत

कोशिश करो (int)System.Math.Floor(10-v/a/70)या बस (int)(10-v/a/70)।

— नील

@ नील मुझे लगता है कि मुझे 70dअकेला छोड़ना पड़ा, लेकिन बेहतर काम करता है धन्यवाद

— TheLethalCoder

1

क्षमा करें, dवहाँ नहीं देखा ।

— नील

एक और जवाब जो करीने से एक बाइट को बचा सकता है, मुझे लगता है:v=>a=>

— ब्रायन मैककचून

@BrianMcCutchon को यह भी एहसास नहीं हुआ कि मैं इसे C # धन्यवाद में कैसे कर सकता हूं

— TheLethalCoder

7

जावा 8, 57 बाइट्स

बाइट्स को बचाने के लिए एक लैम्ब्डा का उपयोग करता है, जवाब वापस करने के लिए गणना और सबस्ट्रिंग करता है।

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

यहाँ इसका परीक्षण करने के लिए मेरी कक्षा है।

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

अपडेट करें

-3 [१६-०ger- १ ९] पूर्णांक विभाजन का उपयोग किया
-10 [१६-० import-१r] अनावश्यक आयात हटा दिया, @ ओलिवियरग्रेगायर के लिए धन्यवाद !
-18 [16-08-17] प्रिंट के बजाय वापसी स्ट्रिंग

— NonlinearFruit
स्रोत

2

अच्छा है, एक जावा जवाब है कि एक ट्रेन नहीं है!

— इस्माइल मिगुएल

4

java.lang.डिफ़ॉल्ट शामिल पैकेज के बाद से इसकी कोई आवश्यकता नहीं है ।

— ओलिवियर ग्रेजायर

आप छत नहीं गोल कर रहे हैं!

1

@ एडवांसिड मैंने इसका परीक्षण किया और System.out.println((int)2.99);प्रिंट किया 2और चूंकि मैं 10 से पूर्व- फ़्लोरेड मान लेता हूं और फिर इसे फ़्लोर करता हूं, यह 10. को छत से दूर ले जाने के समान है

— नॉनलाइनियरफ्रूट

6

MATL , 12 बाइट्स

/70/0:9>42*c

इसे ऑनलाइन आज़माएं!

व्याख्या

राउंडिंग अप और क्लैम्पिंग एक साथ निम्नानुसार किया जाता है: संख्या x = v/a/70की तुलना एरे के प्रत्येक तत्व के साथ की जाती है [0 1 ... 9]। उस सरणी की संख्या जो कि पार xहो गई है, तारांकन बन जाएगी, और बाकी रिक्त स्थान होंगे।

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

— लुइस मेंडो
स्रोत

5

पायथन 2, 32 बाइट्स

3 + 2 बाइट्स को बचाया और लीक नन की बदौलत एक गलती से सुधारा

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

नील जवाब के समान। इस तथ्य का उपयोग करता है कि पायथन 2 पूर्णांक विभाजन करता है।

— mathause
स्रोत

विफल रहता है v=70औरa=1

— लीक Nun

f=हटाया जा सकता है

— लीकी नून

v, aबन सकता हैv,a

— लीक नून

धन्यवाद! अब काम करना चाहिए। अब v = 0, a = 1 के लिए गलत हो सकता है, लेकिन यह मामला मौजूद नहीं हो सकता है, क्या यह हो सकता है?

— Mathause

यह v = 0, a = 1 के लिए गलत नहीं होगा।

— लीक नन

5

हास्केल, 35 बाइट्स

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

[1..min(ceiling$v/a/70)10]1 से गणना की गई कठिनाई के लिए एक सीमा बनाता है (कठिनाई के लिए एक खाली सूची 0)। a>>bसूची को b length aअक्सर दोहराता है ।

— Laikoni
स्रोत

4

पाइके, 13 9 बाइट्स

/70/\**T<

यहाँ यह कोशिश करो!

स्पष्टीकरण:

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

— नीला
स्रोत

4

सी #, 97 89 87 77 77 42 41 बाइट्स

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

Adám के लिए धन्यवाद, 10 बाइट्स बचाए

अरनौलद को धन्यवाद देते हुए कुछ बाइट्स बचाए

— TheLethalCoder
स्रोत

आप इसके द्वारा प्रतिस्थापित (int)System.Math.Ceiling(v/a/70d)करके बहुत कुछ बचा सकते हैं (v+69)/(70*a)... ध्यान दें कि इसके अलावा v / a ऋणात्मक नहीं हो सकता है, इसलिए cइसे बहुत सरल बनाया जा सकता है क्योंकि आपको इसके लिए जांच करने की आवश्यकता नहीं है।

— टॉम वैन डेर ज़ंडेन

4

पर्ल, 35 32 बाइट्स

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

रिवर्स ऑर्डर में तर्कों -Eको सक्रिय करने sayऔर देने के लिए उपयोग करें :

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

अगर STDIN पर बहस की अनुमति दी जाती है, तो निम्नलिखित 29 बाइट्स हैं:

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

— टन हास्पेल
स्रोत

मुझे याद नहीं है कि क्या यह बिल्कुल वैसा ही होगा, लेकिन क्या आप इसके 0|बजाय हो सकते हैं $-=? (सोचता है कि ऑपरेटर की प्राथमिकता सही नहीं हो सकती है ...)

— डोम हेस्टिंग्स

@DomHastings 0|एक बड़ी संख्या में एक ऋणात्मक संख्या बनाता है (शून्य *s की ओर जाता है), $-=क्लिप से 0 (दस *s तक अग्रणी ), जो कि मुझे यहाँ चाहिए

— Ton Hospel

आह, ज़ाहिर है, यह केवल एक सकारात्मक पूर्णांक है! याद दिलाने के लिए धन्यवाद। मुझे यकीन है कि मैं इसे भूल जाऊंगा जब मुझे इसकी आवश्यकता होगी ... ast

— डोम हेस्टिंग्स

4

आर, 68, 50 52 बाइट्स

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

rep अनुमानित रूप से 0 की संख्या पर एक मिनट रखता है।

मेरी त्रुटि के लिए @plannapus और @ Anastasiya-Romanova 秀 को धन्यवाद।

— user5957401
स्रोत

आप हटा सकते हैंf=

— Cyoce

1

आपके कोड के आउटपुट टेस्ट डेटा के बराबर नहीं हैं। आप 2 अधिक बाइट्स जोड़ना चाहिए 1+के बाद min(आदेश में एक ही आउटपुट प्राप्त करने के लिए

— अनास्टेशिया Romanova,秀

3

पायथ , 17 13 बाइट्स

अपने एल्गोरिथ्म के लिए लुइस मेंडो को क्रेडिट में 4 बाइट्स ।

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

परीक्षण सूट।

— लीक नन
स्रोत

3

जावास्क्रिप्ट ईएस 6, 48 बाइट्स

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

3

सी, 54 , 51 , 50 , 49 बाइट्स

यह मानते हुए कि vसकारात्मक या शून्य और aसकारात्मक है, x < minक्लैम्पिंग मामले को कभी पूरा नहीं किया जाता है, क्योंकि कोई रास्ता नहीं है जिससे सीलिंग ऑपरेशन का परिणाम नकारात्मक हो सकता है। इसके अतिरिक्त, गैर-नकारात्मक मानों पर पूर्णांक गणित हमेशा परिणाम के फर्श को जन्म देता है, इसलिए हम 1छत को प्राप्त करने के लिए जोड़ते हैं ।

इस समाधान के लिए एक writeफ़ंक्शन की आवश्यकता होती है , कम से कम लिनक्स पर काम करता है।

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

टेस्ट मुख्य:

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

— स्टेफानो सैनफिलिपो
स्रोत

1

जगह (v=v/a/70)के साथ (v/=a*70)1 बाइट की बचत होती है।

— सीलिंगकैट

नाइस कैच @ceilingcat!

— स्टेफानो सैनफिलिपो

2

जावास्क्रिप्ट: 82 73 बाइट्स

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

कुछ बाइट्स सहेजे जाने के बाद Adám ने बताया कि मैंने / =०० * १० = / Ad० और पार्न्स को हटाने की अनदेखी की

— डायलन मीस
स्रोत

@ Adám क्या संपादन के साथ है?

— मार्टिन एंडर

@ Adám यदि लोग किसी भी उत्तर को पढ़ते हैं तो उनके पास पहले से ही बिगाड़ने वाला होगा। वापस रोलिंग, क्योंकि वर्तमान में वह वाक्य काफी बेकार है और सिर्फ लोगों को संशोधन इतिहास पर क्लिक करता है।

— मार्टिन एंडर

@ Adám यह वही है जो मैं आमतौर पर खुद का उपयोग करता हूं लेकिन मुझे वर्तमान संस्करण में कोई नुकसान नहीं हुआ है।

— मार्टिन एंडर

इसकी कोई जरूरत नहीं console.logहै, लौटना ठीक है। आप v=>a=>इसकी जगह बाइट भी बचा सकते हैं(v,a)=>

— Cyoce

2

दिल्लोग एपीएल , 15 बाइट्स

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

'*'⍴⍨चरित्र ने इसे कई बार दोहराया:
10⌊मिनट (10, ...
⎕÷इनपुट
70×सत्तर गुना
⎕इनपुट से विभाजित

TryAPL ऑनलाइन!

— एडम
स्रोत

क्या यह मेंडोज़ के एल्गोरिथ्म का उपयोग करने के लिए गोल्फर होगा?

— लीक नन

@LeakyNun मुझे ऐसा नहीं लगता है:'*'/⍨(⎕÷70×⎕)>⍳10

— Adám

2

जेलिफ़िश , 18 बाइट्स

P
#'*
mM/%i
10 %70

प्रारूप में इनपुट लेता है [a v]। इसे ऑनलाइन आज़माएं!

व्याख्या

%पारस्परिक है, इसलिए %701/70 है।
i एक दो-तत्व सरणी के रूप में इनपुट है।
/%इनपुट के साथ iऔर प्रारंभिक मूल्य के साथ फ़्लिप डिवीजन द्वारा %70सरणी iको कम करता है %70। दूसरे शब्दों में, यह v / (a (1/70)) की गणना करता है , जो v / (70 * a) के बराबर है ।
Mइस मूल्य की छत लेता है, और mउस की अधिकतम लेता है और 10।
#'**कई बार शाब्दिक चरित्र को दोहराता है ।
P उद्धरण के बिना परिणाम प्रिंट करता है।

— Zgarb
स्रोत

2

MATLAB, 34 33 बाइट्स

क्योंकि मुझे यह चालान बहुत पसंद है, यहाँ MATLAB के लिए एक है (व्हाट्सएप पर आने वाले आउटपुट)

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

@Luis मेंडो के जवाब से प्रेरित। @ Byajonk के लिए धन्यवाद एक बाइट बचाने के लिए।

— mathause
स्रोत

अच्छा तरीका! मेरे पास पोस्ट करने के लिए एक 40 बाइट थी ... BTW, आप एक बाइट का उपयोग करके बचा सकते [... '']हैं char(...)। और क्या आप वास्तव में जरूरत है ceilजब अंत में आप पूर्णांक के साथ तुलना कर रहे हैं?

— पाजोंक

2

धन्यवाद @ पाजोंक - इस साइट पर कुछ चीजें मैं अपने कोड को और भी कम पठनीय बनाने के लिए सीख सकता हूं;)

— १५

2

एम 4, 136 135 बाइट्स

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

एक मैक्रो को परिभाषित करता है fजो लेता है vऔर a, और सही आउटपुट में फैलता है। अधिकांश कार्यक्रम सीलिंग का कार्यान्वयन है।

— प्रोग्राम मैन
स्रोत

2

डीसी, 110 108 104 98 बाइट्स

यह एक डोज था क्योंकि टुकड़ा करने की क्रिया कोई चीज नहीं है। इसके अलावा, डीसी स्ट्रिंग्स में हेरफेर नहीं करता है। मैं वास्तव में एक स्ट्रिंग के लिए इंतजार कर रहा था जो कोडिंग का <5 घंटे होगा। प्लस साइड पर, मैंने अंत में छोरों की तरह, सामान्य निर्माणों को लिखना शुरू कर दिया। इसके अलावा गोलाई / छत तैयार करना था, इसलिए उसके लिए धन्यवाद।

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

बैश में आमंत्रित:

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

(ऊपर) की जगह कोड के साथ, और vऔर aइसके बाद के संस्करण उनके संबंधित समकक्षों के साथ। एकल उद्धरण महत्वपूर्ण हैं (अन्यथा आपको बैश के इतिहास का सामान मिलता है)।

व्याख्या की:

[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

यह संभवतः अधिक गोल्फ-सक्षम है, लेकिन मैं समय से पहले अनुकूलन से बचने के लिए इसे समाप्त करने की कोशिश कर रहा था।

2 बाइट्स सेविंग-लोडिंग के बजाय डुप्लिकेट-सेविंग द्वारा सेव किए गए
4 बाइट्स ने 70 से भाग देने से बचाया
डेनियरो के सुझावों से 6 बाइट्स (गैर-स्ट्रिंग्स, ASCII अंक इसके बजाय; 10 => I)

— Delioth
स्रोत

[*]n=> 42P। के हर उदाहरण 10द्वारा प्रतिस्थापित किया जा सकता है I। []p=>IP

— डानिएरो

2

हास्केल, 35 बाइट्स

यह समाधान लैकोनी के उत्तर से पूरी तरह से अलग है क्योंकि यह इस तुच्छ चीज के लिए मिलता है। फिर भी स्कोर (अभी के लिए) बिल्कुल वैसा ही है।

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

यह दस तारे पैदा करता है, फिर कुछ बंद करता है। एक अनंत सूची के साथ मनमानी कठिनाई का विस्तार करना आसान है।

मैंने एक और बाइट को शेव करने का प्रबंधन किया। लेकिन जब सभी परीक्षण मामले काम करते हैं, तो यह सामान्य रूप से सही नहीं होना चाहिए।

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

— MarLinn
स्रोत

2

टीआई-बेसिक, 39 बाइट्स

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

— Timtech
स्रोत

1

PowerShell v2 +, 47 बाइट्स

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

@ नील के जावास्क्रिप्ट उत्तर का कुछ हिस्सा ।

इनपुट लेता है $argsऔर उन्हें विभाजित करता है, फिर उस से विभाजित करता है 70, और जोड़ता है .499। चूंकि PowerShell बैंकर के चक्कर लगाता है , यह प्रभावी रूप ceilसे परिशुद्धता के दो दशमलव बिंदुओं के लिए है। यदि अतिरिक्त परिशुद्धता की आवश्यकता है, तो आवश्यक के रूप में कई अतिरिक्त 9एस पर व्यवहार करें ।

के साथ 1.., यह एक स्ट्रिंग में एक सीमा सूचकांक बनाता है। स्ट्रिंग है '*'*11, अर्थात '***********'। यह चार-सरणी में परिणाम करता है, इसलिए हम -joinइसे एक स्ट्रिंग में वापस जोड़ते हैं। उस तार को पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है। नील के जवाब की तरह, यह प्रभावी रूप से 1 से 10 सितारों के बीच होने वाले आउटपुट को "क्लैम्प" करता है।

परीक्षण सूट

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

— AdmBorkBork
स्रोत

1

पायथन 3, 69 68 बाइट्स

मैं अजगर 2 जवाब की नकल नहीं करना चाहता था, इसलिए मेरा थोड़ा लंबा है।

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

प्रोग्राम मैन को 1 बाइट धन्यवाद दिया गया

— कोड़ी
स्रोत

आपको आयात को शामिल करने की आवश्यकता है, लेकिन from math import *कुछ जोड़े बाइट्स बचाएगी

— NonlinearFruit

आयात को बाइट काउंट में शामिल करें

— कोडी

युक्ति के अनुसार, 0 न्यूनतम तारे हैं, न कि 1. import*कोई अंतरिक्ष के साथ एक पूरे 1 बाइट को भी बचाता है।

— कार्यक्रम पुरुष

उफ़ मैं न्यूनतम गलतफहमी है। टिप के लिए धन्यवाद

— कोडी

1

@Programman हालांकि युक्ति कहती है कि 0 न्यूनतम है, गैर-ऋणात्मक, गैर-शून्य पूर्णांकों का विभाजन और गुणन करने की गारंटी है! = 0, और छत ऑपरेटर 0-1 के बीच कुछ भी बना देगा और इसे 1 बना देगा। हालाँकि मुझे लगता है कि 0 विचारों के मामले में, हालांकि 0 विचारों का अर्थ है 0 उत्तर, जो अपरिभाषित व्यवहार (0 से विभाजन) की ओर जाता है। यह संभावना है कि 0 असंभव है और इसका उल्लेख भी नहीं किया जाना चाहिए।

— 19

1

दरअसल, 14 बाइट्स

:70a\\u9ukm'**

इसे ऑनलाइन आज़माएं!

इस तथ्य का लाभ उठाता है कि 0 दृश्य और 0 उत्तर असंभव है, और इस प्रकार ceil(v/a) > 0।

स्पष्टीकरण:

: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

— मेगो
स्रोत

एक कोड गोल्फ प्रश्न की कठिनाई की गणना करें

वार्ता

इस प्रश्न की वर्तमान कठिनाई: ***

कार्य

परीक्षण डेटा

स्यूडोकोड के साथ उदाहरण

जावास्क्रिप्ट (ईएस 6), 40 39 बाइट्स

HTML + CSS 491 487 485 बाइट्स

05AB1E, 11 बाइट्स

जावास्क्रिप्ट (ईएस 6), 37 36 बाइट्स

गणितज्ञ, 38 35 बाइट्स

EXCEL, 29 बाइट्स

CJam, 18 15 14 बाइट्स

सी #, 68 49 48 बाइट्स

जावा 8, 57 बाइट्स

MATL , 12 बाइट्स

व्याख्या

पायथन 2, 32 बाइट्स

हास्केल, 35 बाइट्स

पाइके, 13 9 बाइट्स

सी #, 97 89 87 77 77 42 41 बाइट्स

पर्ल, 35 32 बाइट्स

आर, 68, 50 52 बाइट्स

पायथ , 17 13 बाइट्स

जावास्क्रिप्ट ईएस 6, 48 बाइट्स

सी, 54 , 51 , 50 , 49 बाइट्स

जावास्क्रिप्ट: 82 73 बाइट्स

दिल्लोग एपीएल , 15 बाइट्स

जेलिफ़िश , 18 बाइट्स

व्याख्या

MATLAB, 34 33 बाइट्स

एम 4, 136 135 बाइट्स

डीसी, 110 108 104 98 बाइट्स

हास्केल, 35 बाइट्स

टीआई-बेसिक, 39 बाइट्स

PowerShell v2 +, 47 बाइट्स

परीक्षण सूट

पायथन 3, 69 68 बाइट्स

दरअसल, 14 बाइट्स