सिलिकॉन वैली के "तीन-अल्पविराम क्लब" दृश्यों से प्रेरित होकर, इस एक की तरह , इस चुनौती में आप दस लोगों को "अल्पविराम क्लब" बता रहे हैं, जिसमें वे प्रत्येक हैं।

यदि आप "अल्पविराम क्लब" शब्द से अपरिचित हैं, तो मुझे समझाएं: यदि आपके पास जो धन है वह समावेशी सीमा $ 1,000.00 से $ 999,999.99 में है; यदि आप $ 1,000,000.00 से $ 999,999,999.99 की सीमा में हैं, तो दो-कॉमा क्लब में; ये "क्लब" तीन-कॉमा क्लब के माध्यम से दोहराते हैं, क्योंकि पृथ्वी पर कोई भी व्यक्ति (AFAIK) एक ट्रिलियन अमेरिकी डॉलर से अधिक का मालिक नहीं है (जापानी येन बहुत जल्दी एक अलग कहानी होगी)। तो, आपके बैंक खाते में कॉमा की संख्या, संयुक्त राज्य अमेरिका और ग्रेट ब्रिटेन में सबसे आम संकेतन मानकों के अनुसार, कॉमा क्लब को दर्शाती है कि आप किसके हैं। नकारात्मक संख्याओं के लिए समान "अल्पविराम" नियम लागू होते हैं (हालाँकि आप नकारात्मक अल्पविराम क्लब में नहीं होना चाहते हैं): समावेशी श्रेणी में नकारात्मक मात्रा [-0.01, -999।

परीक्षण के मामले

Friend    Amount
John      100000
Jamie     0.05
Kylie     1549001.10
Laura     999999999.99
Russ      986000000
Karla     1
Reid      99.99
Mark      999.99
Manson    1000.01
Lonnie    999999999999.00
Nelly     -123.45

सही उत्तर:

John is in the 1-comma club.
Jamie is in the 0-comma club.
Kylie is in the 2-comma club.
Laura is in the 2-comma club.
Russ is in the 2-comma club.
Karla is in the 0-comma club.
Reid is in the 0-comma club.
Mark is in the 0-comma club.
Manson is in the 1-comma club.
Lonnie is in the 3-comma club.
Nelly is in the 0-comma club.

जो भी सरणी सेटअप आपको एक friendsसरणी प्राप्त करने की आवश्यकता है और amountsसरणी आपके स्कोर की ओर नहीं गिनती है। तो पायथन के लिए, निम्नलिखित कोड की गिनती नहीं है:

f = ['John', 'Jamie', 'Kylie', 'Laura', 'Russ', 'Karla', 'Reid', 'Mark', 'Manson', 'Lonnie']
a = ['100000', '0.05', '1549001.10', '999999999.99', '986000000', '1', '99.99', '999.99', '1000.01', '999999999999.00']

संपादित करें: कृपया संशोधित परीक्षण मामलों को देखें

मैंने चीजों को थोड़ा और कठिन बनाने के लिए परीक्षण के मामलों से वास्तविक स्ट्रिंग कॉमा को हटा दिया, क्योंकि सिर्फ कॉमा की गिनती के विपरीत।

code-golf

— blacksite
स्रोत

2

मुझे नहीं लगता कि आपने आउटपुट प्रारूप को बहुत स्पष्ट कर दिया है। क्या कुछ "Name number,Name number,..."स्वीकार्य है?

— FryAmTheEggman

2

क्या एफ में प्रविष्टियां सकारात्मक होने की गारंटी है, या -$1,234.561-कॉमा क्लब में भी होगी?

— जोनाथन एलन

2

@not_a_robot क्या आप फ्राई की टिप्पणी को संबोधित कर सकते हैं? क्या यह किसी भी प्रारूप में नाम और संख्या के आउटपुट जोड़े के लिए पर्याप्त है?

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

1

@FryAmTheEggman नहीं, आउटपुट को प्रारूप में होना आवश्यक है"<name> is in the <number of commas>-club."

— Blacksite

1

परीक्षण के मामले कल्पना नहीं हैं। और यहां तक कि अगर वे थे, तो ऊपर जोनाथन एलन द्वारा उठाए गए बड़े नकारात्मक के मुद्दे को कवर करने वाला कोई परीक्षण मामला नहीं है।

— पीटर टेलर

10

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

a=>a.map(([s,n])=>s+` is in the ${n.toFixed(n<0?3:4).length/3-2|0}-comma club.`)

एक सरणी [मित्र, राशि] को ले जाता है और सरणी देता है "n-अल्पविराम क्लब में मित्र है।" तार। अतिरिक्त ट्रेलिंग शून्य जोड़कर काम करता है ताकि 0-कॉमा क्लब के लिए लंबाई 6-8, 1-कॉमा क्लब के लिए 9-11, 2-कॉमा क्लब के लिए 12-15 आदि।

https://jsfiddle.net/cau40vmk/1/

— नील
स्रोत

मुझे नहीं लगता कि यह नकारात्मक संख्याओं के लिए काम करता है। उदाहरण के लिए, यह 1-अल्पविराम क्लब में नेल्ली (-123.45) डाल देगा। मैं छोटी को सुझाव दूंगा Math.log10(n*n)/6|0।

— अरनुलद

@ अर्नुलद आह हां, मैं ट्रंकट्स |0को शून्य करना भूल गया हूं , इसलिए यह जेमी के लिए सही उत्तर देता है।

— नील

8

PostgreSQL, 61 बाइट्स

SELECT f||' is in the '||div(log(@a),3)||'-comma club.'FROM p

@xका पूर्ण मान है x, log(x)आधार -10 लघुगणक है और div(y, x)y / x के पूर्णांक भागफल की गणना करता है।

सेट अप:

CREATE TEMP TABLE p AS
SELECT * FROM (VALUES
    ('John', 100000),
    ('Jamie', 0.05),
    ('Kylie', 1549001.10),
    ('Laura', 999999999.99),
    ('Russ', 986000000),
    ('Karla', 1),
    ('Reid', 99.99),
    ('Mark', 999.99),
    ('Manson', 1000.01),
    ('Lonnie', 999999999999.00),
    ('Nelly', -123.45)
) AS p (f, a)

आउटपुट:

            ?column?            
--------------------------------
 John is in the 1-comma club.
 Jamie is in the 0-comma club.
 Kylie is in the 2-comma club.
 Laura is in the 2-comma club.
 Russ is in the 2-comma club.
 Karla is in the 0-comma club.
 Reid is in the 0-comma club.
 Mark is in the 0-comma club.
 Manson is in the 1-comma club.
 Lonnie is in the 3-comma club.
 Nelly is in the 0-comma club.
(11 rows)

— kennytm
स्रोत

प्रतिस्पर्धी एसक्यूएल जवाब देखकर अच्छा लगा - अच्छा किया!

— टोबी स्पाइट

6

जेली , 34 32 बाइट्स

AḞbȷL’⁶;“£ṙƬs⁾`¬ụṂ“¢<ỴȦ8£l»jµ€⁹żY

एक डाईएडिक लिंक (फ़ंक्शन) जो संख्याओं (दशमलव / पूर्णांक) के रूप में बैंक शेष की सूची लेता है और तार के रूप में नामों की सूची और तार की सूची लौटाता है।

इसे ऑनलाइन आज़माएं! - पाद लेखçYकेवल फ़ंक्शन को कॉल करता है और परिणामी सूची को लाइन फीड के साथ जोड़ता है ताकि पूर्ण प्रोग्राम के रूप में चलाने पर इसका अच्छा आउटपुट हो।

कैसे?

AḞbȷL’⁶;“£ṙƬs⁾`¬ụṂ“¢<ỴȦ8£l»jµ€⁹żY - Main link: bankBalances, names
                             €    - for each bankBalance:
A                                 - absolute value (treat negatives and positives the same)
 Ḟ                                - floor (get rid of any pennies)
  bȷ                              - convert to base 1000
    L                             - length (number of digits in base 1000)
     ’                            - decrement by one
      ⁶;                          - concatenate a space with that   ...because -------.
        “         “       »       - compressed list of strings:                       ↓
         £ṙƬs⁾`¬ụṂ                -     " is in the"  ← cannot compress a trailing space :(
                   ¢<ỴȦ8£l        -     "-comma club."
                           j      - join that list of strings with the "number plus space"
                            µ     - monadic chain separation (call that result L)
                              ⁹   - right argument (names)
                               ż  - zip with L

— जोनाथन एलन
स्रोत

4

PHP, 76 74 बाइट्स

// data as associative array
$d=[Poorman=>-1234,John=>100000,Jamie=>0.05,Kylie=>1549001.10,Laura=>999999999.99,Russ=>1000000000,Karla=>1,Reid=>99.99,Mark=>999.99,Manson=>1000.01,Lonnie=>999999999999.00];
// code
foreach($d as$n=>$a)printf("$n is in the %d-comma club.
",log($a*$a,1e6));

सौभाग्य से मुझे इंट में नहीं डालना है (जैसा कि मुझे सी में करना होगा); PHP ऐसा करता है %d।

— टाइटस
स्रोत

जी! क्या मैं वर्णों की गिनती के बजाय गणना करने वाला पहला व्यक्ति हूं?

— टाइटस

4

गणितज्ञ (86 बाइट्स)

सेट-अप (स्ट्रिंग के रूप में नाम, संख्या के रूप में पैसा):

n = {"John", "Jamie", "Kylie", "Laura", "Russ", "Karla", "Reid", "Mark", "Manson", "Lonnie", "Nelly"};
m = {100000, 0.05, 1549001.10, 999999999.99, 1000000000, 1, 99.99, 999.99, 1000.01, 999999999999.00, -123.45}

प्रयास:

MapThread[#~~" is in the "~~ToString@Max[Floor@Log[10^3,#2],0]~~"-comma club."&,{n,m}]

सभी गणितज्ञों के स्ट्रिंग फ़ंक्शन में नाम में "स्ट्रिंग" शामिल है, इसलिए मुझे लगता है कि लॉग कम हैं। Max[...,0]परेशान करने ऋणात्मक संख्याओं या लोग हैं, जो बीच -1 और 1 डॉलर के मालिक हैं के लिए नकारात्मक अनन्तता से निपटने के लिए है। एक ऋणात्मक संख्या के लॉग में काल्पनिक सामान शामिल है, लेकिन गणितज्ञ सहायक रूप से इस बात को अनदेखा करता है कि ए लेते समय Floor!

— पेड़ नहीं
स्रोत

4

जाप , 36 बाइट्स

यह पहली इनपुट के रूप में राशि में लेता है, दूसरे के रूप में नाम।

V+`   e {w0 x4 l /3-2|0}-¬mµ club

व्याख्या

V+`   e {w0 x4 l /3-2|0}-¬mµ club
V+                                   // Second input +
  `                                  // compressed string:
      e                              // " is in the " 
        {              }             // Insert here:
         w0                          //   The larger of 0 and the first input
            x4                       //   Rounded to the 4th decimal
               l                     //   Length
                        -¬mµ club    // "-comma club"
                                     // A closing backtick is auto-inserted at the end of the program

जाप स्ट्रिंग संपीड़न के लिए शुको लाइब्रेरी का उपयोग करता है ।

@ नील के समाधान से प्रेरित ।

सहेजे गए 7 बाइट्स @ETHproductions की बदौलत

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

— ओलिवर
स्रोत

1

मुझे लगता है कि आप Vw0 x4 l /3-2|0मध्य खंड में 6 बाइट्स बचा सकते हैं :-)

— ETHproductions

1

मुझे लगता है कि आप विपरीत क्रम में इनपुट लेकर एक बाइट को बचा सकते हैं:V+`...{w0...

— ETHproductions

3

MATL, 50 48 43 बाइट्स

`j' is in the 'i|kVn3/XkqV'-comma club'&hDT

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

व्याख्या

`                   % Do...While loop
  j                 % Explicitly grab the next input as a string
  ' is in the the ' % Push this string literal to the stack
  i                 % Grab the next input as a number
  |                 % Compute the absolute value
  k                 % Round towards zero
  V                 % Convert to a string
  n3/Xk             % Divide the length of the string by 3 and round up
  q                 % Subtract one
  V                 % Convert to a string
  '-comma club'     % Push this string literal to the stack
  &h                % Horizontally concatenate the entire stack
  D                 % Display the resulting string
  T                 % Push TRUE to the stack, causing an infinite loop which automatically
                    % terminates when we run out of inputs
                    % Implicit end of do...while loop

— Suever
स्रोत

3

आर, 68 बाइट्स

स्थापित करना:

f <- c('John', 'Jamie', 'Kylie', 'Laura', 'Russ', 'Karla', 'Reid', 'Mark', 'Manson', 'Lonnie', 'Nelly')
a <- c(100000, 0.05, 1549001.10, 999999999.99, 986000000, 1, 99.99, 999.99, 1000.01, 999999999999.00, -123.45)

समाधान:

cat(paste0(f, " is in the ",floor(log10(abs(a))/3)),"-comma club.\n"))

खाते के निरपेक्ष मान का आधार 10 लॉग लें, नीचे राउंड करें फिर नामों के साथ प्रिंट करें।

मुझे यकीन नहीं है कि अगर यह छोटा aहोगा तो एक चरित्र वेक्टर होगा ...

— जो
स्रोत

1

नेल्ली के मामले के बारे में, जिनके पास -123.45 डॉलर हैं? यह log10कॉल NaNनकारात्मक के लिए उत्पादन करेगा । लगता है log10(abs(a))काम करेंगे।

— ब्लैक

ओह, आप सही कह रहे हैं, ऊपर के नमूने में नेली शामिल नहीं थी। और मैंने विनिर्देश को गलत बताया ... मुझे समझ में आया कि नकारात्मक मूल्य 0 अल्पविराम क्लब होना चाहिए।

— जो

abs(x)उपयोग के बजाय pmax(a,1)- यह 1 से कम कुछ भी लेगा और इसे 1 बना देगा, नकारात्मक संख्याओं के लिए अच्छे परिणाम देगा। और, इसके बजाय floor(log10(...)/3)आप उपयोग कर सकते हैं log10(...)%/%3। मुझे लगता है कि यह 66 बाइट्स तक नीचे जाता है (और नकारात्मक के लिए सही है)।

— ग्रेगर - मोनिका

1

यह भी ध्यान देने योग्य है कि उस की एक पूरी 7 बाइट्स हैं cat()और \n... कंसोल में सदिश के साथ वेक्टर को प्रिंट करना काफी अच्छा माना जा सकता है (पायथन उत्तरों की तरह * अहम)।

— ग्रेगर - मोनिका

इसके बाद 3. के बाद एक अतिरिक्त कोष्ठक है। यह जेमी के लिए -1 क्लब का भी उत्पादन करता है। Pmax (a, 1) का उपयोग करके इसे ठीक करता है।

— बीएलटी

3

जावास्क्रिप्ट, 59 बाइट्स

सहेजे गए 3 बाइट @ETHproductions के लिए धन्यवाद

2 बाइट्स @Cyoce की बदौलत सहेजे गए

n=>m=>n+` is in the ${m>1?Math.log10(m)/3|0:0}-comma club.`

डेमो

कोड स्निपेट दिखाएं

f=n=>m=>n+` is in the ${m>1?Math.log10(m)/3|0:0}-comma club.`

console.log((f("John")(100000)))
console.log((f("Jamie")(0.05)))
console.log((f("Kylie")(1549001.10)))
console.log((f("Laura")(999999999.99)))
console.log((f("Russ")(986000000)))
console.log((f("Karla")(1)))
console.log((f("Reid")(99.99)))
console.log((f("Mark")(999.99)))
console.log((f("Manson")(1000.01)))
console.log((f("Lonnie")(999999999999.00)))
console.log((f("Nelly")(-123.45)))

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

— ओलिवर
स्रोत

1

के साथ एक बाइट को सहेजें `${}`और आप n=>m=>...(n,m)=>...

— साइरो

2

विम, 72 बाइट्स

:%s;\v +\-=(\d+).*;\=' is in the '.(len(submatch(1))-1)/3.' comma club'

किसी तरह मुझे दिखाना चाहिए कि वहाँ एक वापसी है, लेकिन अनिश्चित कैसे। यह सिर्फ एक मूल regex जवाब है, मुझे यकीन है कि किसी भी regex भाषा द्वारा पीटा जा सकता है। मैंने V का उपयोग किया होगा, लेकिन मुझे लगता है कि विकल्प V विकल्प का उपयोग करते हैं/ डिफ़ॉल्ट रूप से विभाजक के रूप , और मैं यह नहीं समझ सका कि यह कैसे विभाजित के बारे में शिकायत नहीं करता है।

ओपी की तालिका के रूप में इनपुट लेता है, और मानों को तालिका के रूप में लौटाता है, लेकिन "एक्स कमेंट क्लब में" द्वारा प्रतिस्थापित वित्तीय जानकारी के साथ "

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

— nmjcman101
स्रोत

मुझे नहीं लगता कि \-=कुछ भी जोड़ता है। इसके अलावा, यदि आप अपने इनपुट में अतिरिक्त स्थान हटाते हैं, और रेगेक्स को भी बदलते हैं तो \v (\d*).*;आप 4 बाइट्स बचा सकते हैं

— DJMcMayhem

2

05AB1E , 32 बाइट्स

Äï€g3/î<“-comma†Ú“«“€ˆ€†€€ “ì‚ø»

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

व्याख्या

Ä                                 # absolute value of input
 ï                                # convert to int
  €g                              # length of each
    3/                            # divided by 3
      î                           # round up
       <                          # decrement
        “-comma†Ú“«               # append string "-comma club" to each number
                   “€ˆ€†€€ “ì     # prepend string "is in the " to each number
                             ‚    # pair with second input
                              ø   # zip
                               »  # join by spaces and newlines

— Emigna
स्रोत

2

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

हमारे सरणियों को सेट करें:

n = ['John', 'Jamie', 'Kylie', 'Laura', 'Russ', 'Karla', 'Reid', 'Mark', 'Manson', 'Lonnie']
a = [100000, 0.05, 1549001.10, 999999999.99, 1000000000, 1, 99.99, 999.99, 1000.01, 999999999999.00]

और फिर हमारा कार्य हो सकता है:

f=lambda n,a:'%s is in %s comma club'%(n,min(3,(len(str(int(a)))/3)))

हमें देना:

>>> [f(x,y) for x,y in zip(n,a)]
['John is in 2 comma club', 'Jamie is in 0 comma club', 'Kylie is in 2 comma club', 'Laura is in 3 comma club', 'Russ is in 3 comma club', 'Karla is in 0 comma club', 'Reid is in 0 comma club', 'Mark is in 1 comma club', 'Manson is in 1 comma club', 'Lonnie is in 3 comma club']

यदि सरणी को प्रश्न में दिए गए समान होने की आवश्यकता है, तो समाधान की लागत 76 बाइट्स है:

f=lambda n,a:'%s is in %s comma club'%(n,min(3,(len(str(int(float(a))))/3)))

— iwaseatenbyagrue
स्रोत

2

पॉवरशेल, 82 बाइट्स

$args[0]|%{$_[0]+" is in the "+(('{0:N}'-f$_[1]-split',').Count-1)+"-comma club."}

का 2 डी-सरणी इनपुट मानते हुए

cc.ps1 @(@("John",100000),@("Jamie",0.05),@("Kylie",1549001.10),@("Laura",999999999.99),@("Russ",986000000),@("Karla",1),@("Reid",99.99),@("Mark",999.99),@("Manson",1000.01),@("Lonnie",999999999999.00),@("Nelly",-123.45))

आउटपुट है John is in the 1-comma club. Jamie is in the 0-comma club. Kylie is in the 2-comma club. Laura is in the 2-comma club. Russ is in the 2-comma club. Karla is in the 0-comma club. Reid is in the 0-comma club. Mark is in the 0-comma club. Manson is in the 1-comma club. Lonnie is in the 3-comma club. Nelly is in the 0-comma club.

— टो
स्रोत

2

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

n#a=n++" is in the "++(show.truncate.logBase 1e3.abs$a)++"-comma club."

एक ऑपरेटर '#' को परिभाषित करता है जो सही उत्तर प्रदान करता है। उदाहरण के लिए:

*Main> "John"#100000
"John is in the 1-comma club."

दुर्भाग्य से, हास्केल के पास log10कई अन्य भाषाओं की तरह एक कॉम्पैक्ट फ़ंक्शन नहीं है , लेकिन इसका एक उपयोगी logBaseफ़ंक्शन है, जिसका अर्थ है कि हमें अपने उत्तर को 3 से विभाजित करने की आवश्यकता नहीं है। दुर्भाग्य से,logBase 1000 0.05 एक नकारात्मक संख्या है, इसलिए हमें इसका उपयोग करने की आवश्यकता है के truncateबजाय लंबे समय तकfloor यह पूर्णांक बनाना।

परीक्षण मामलों सहित पूरा कार्यक्रम:

(#) :: (RealFrac n, Floating n) => [Char] -> n -> [Char]
n#a=n++" is in the "++(show.truncate.logBase 1e3.abs$a)++"-comma club."

testCases = [
 ("John",      100000),
 ("Jamie",     0.05),
 ("Kylie",     1549001.10),
 ("Laura",     999999999.99),
 ("Russ",      986000000),
 ("Karla",     1),
 ("Reid",      99.99),
 ("Mark",      999.99),
 ("Manson",    1000.01),
 ("Lonnie",    999999999999.00),
 ("Nelly",     -123.45)]

main = putStrLn $ unlines $ map (uncurry (#)) testCases

निम्नलिखित परिणाम देता है:

John is in the 1-comma club.
Jamie is in the 0-comma club.
Kylie is in the 2-comma club.
Laura is in the 2-comma club.
Russ is in the 2-comma club.
Karla is in the 0-comma club.
Reid is in the 0-comma club.
Mark is in the 0-comma club.
Manson is in the 1-comma club.
Lonnie is in the 3-comma club.
Nelly is in the 0-comma club.

— जूल्स
स्रोत

1

के, 66 बाइट्स

    /n is names and a is amounts
    n
    ("John";"Jamie";"Kylie";"Laura";"Russ";"Karla";"Reid";"Mark";"Manson";"Lonnie")
    a
    ("100000";"0.05";"1549001.10";"999999999.99";"1000000000";,"1";"99.99";"999.99";"1000.01";"999999999999.00")
    /the function
    {x," is in the ",($(#.q.cut[3;*"."\:y])-1)," comma club"}./:+(n;a)
    /output
    ("John is in the 1 comma club";"Jamie is in the 0 comma club";"Kylie is in the 2 comma club";"Laura is in the 2 comma club";"Russ is in the 3 comma club";"Karla is in the 0 comma club";"Reid is in the 0 comma club";"Mark is in the 0 comma club";"Manson is in the 1 comma club";"Lonnie is in the 3 comma club")

— Chromozorz
स्रोत

1

पायथन 2.7 , 89 86 84 बाइट्स

for g,b in zip(*input()):print g,'is in the',`(len('%d'%b)+~(b<0))/3`+'-comma club.'

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

पूर्ण कार्यक्रम जो दो सूचियों का एक समूह लेता है - स्ट्रिंग के रूप में नाम, संख्या के रूप में बैंक शेष - और परिणामी तार प्रिंट करता है।

— जोनाथन एलन
स्रोत

1

सी #, 125 बाइट्स

(p,n)=>{for(int x=0;x<p.Length;x++)Console.Write(p[x]+" is in the "+(n[x]<1e3?0:n[x]<1e6?1:n[x]<1e9?2:3)+"-comma club.\n");};

बेनामी फ़ंक्शन जो ओपी के प्रारूप में परिणाम प्रिंट करता है।

परीक्षण मामलों के साथ पूरा कार्यक्रम:

using System;

class CommaClub
{
    static void Main()
    {
        Action<string[], double[]> f =
        (p,n)=>{for(int x=0;x<p.Length;x++)Console.Write(p[x]+" is in the "+(n[x]<1e3?0:n[x]<1e6?1:n[x]<1e9?2:3)+"-comma club.\n");};

        // test cases:
        string[] personArr = new[] {"John", "Jamie", "Kylie", "Laura", "Russ", "Karla", "Reid", "Mark", "Manson", "Lonnie", "Nelly"};
        double[] amountArr = new[] {100000, 0.05, 1549001.10, 999999999.99, 1000000000, 1, 99.99, 999.99, 1000.01, 999999999999.00, -123.45};
        f(personArr, amountArr);
    }
}

— adrianmp
स्रोत

1

पायथन 3 ( 207 159 110 95) 86 बाइट्स, @iwaseatenbyagrue के लिए धन्यवाद)

थोड़ा सा सेटअप:

f = ['John', 'Jamie', 'Kylie', 'Laura', 'Russ', 'Karla', 'Reid', 'Mark', 'Manson', 'Lonnie', 'Nelly']
a = [100000, 0.05, 1549001.10, 999999999.99, 986000000, 1, 99.99, 999.99, 1000.01, 999999999999.00, -123.45]

मेरा प्रयास:

['%s is in the %d-comma club.'%(p,-(-len(str(int(abs(v))))//3)-1) for p,v in zip(f,a)]

परिणाम:

['John is in the 1-comma club.', 'Jamie is in the 0-comma club.', 'Kylie is in the 2-comma club.', 'Laura is in the 2-comma club.', 'Russ is in the 2-comma club.', 'Karla is in the 0-comma club.', 'Reid is in the 0-comma club.', 'Mark is in the 0-comma club.', 'Manson is in the 1-comma club.', 'Lonnie is in the 3-comma club.', 'Nelly is in the 0-comma club.']

संपादित करें: सब कुछ पूर्ण मूल्यों में परिवर्तित करने से मुझे 15 बाइट बचीं।

— blacksite
स्रोत

1

सबसे महत्वपूर्ण बात, यह एक कोड स्निपेट है, आमतौर पर हम केवल कार्यों या पूर्ण कार्यक्रमों की अनुमति देते हैं। गोल्फिंग के लिए, आप कई रिक्त स्थान निकाल सकते हैं। कोशिश करें: ["%s is in the %d-comma club."%(p,v.count(','))for p,v in zip(f,a)]इसके अलावा, आपको एक बाइट गिनती शामिल करनी चाहिए।

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

आप कर सकते हैं print'\n'.join([your array])और वास्तव में आउटपुट प्रिंट कर सकते हैं ।

— एलोनंड

2

साइट पर आपका स्वागत है! नकारात्मक (जैसे -123.45) एक एक करके बंद हो जाते हैं (जब से आप गिनती करते हैं -)। लेकिन नंबरों की सूची क्यों नहीं ली गई और बचा ली गई (क्या मैंने गलत व्याख्या की है?)। आपको आयात स्टेटमेंट जोड़ने की आवश्यकता होगी, और जैसा कि यह खड़ा है कि यह एक स्निपेट नहीं है एक कार्यक्रम या फ़ंक्शन नहीं है (जैसा कि चूक हैं, और उनसे बदलने को तब तक हतोत्साहित किया जाता है जब तक कि कोई अच्छा कारण न हो)।

— जोनाथन एलन

1

धन्यवाद, @JonathanAllan मैं वर्तमान में इसे बेहतर बनाने की कोशिश कर रहा हूं, इसलिए मुझे आयातों की गणना करने की आवश्यकता नहीं है। मुझे पता है कि पायथन के math.ceilकार्य की संभावना मेरे स्कोर में काफी अधिक बढ़ जाती है।

— अश्वेत

2

के (-len(str(abs(v)).split('.')[0])साथ बदलकर आप 9 बाइट्स बचा सकते हैं len(str(int(float(v))))। आपके परीक्षण सेट में, कोई नकारात्मक संख्या नहीं है (उदाहरणों में, एक है)। यदि आप पूर्ण बनना चाहते हैं, तो करने के लिए 5 बाइट्स खर्च करें len(str(abs(int(float(v)))))- जो तब केवल आपको 4 बाइट्स बचाता है।

— इवासेनबीबाग्रे

1

पर्ल 6, 107 95 बाइट्स

for @f {printf "%s is in the %d-comma club.\n",@f[$++],(abs(@a[$++].split(".")[0]).chars-1)/3;}

मेरा सबसे गौरवशाली काम नहीं, मुझे सिर दे दो अगर ive किसी गोल्फिंग तकनीक को भूल गए। EDIT: -12 बाइट्स @ धन्यवाद के लिए धन्यवाद

— हेवार्ड न्यागार्ड
स्रोत

क्यों आसपास है ^@f.elems? btw आप की जरूरत नहीं है कि .elems, for ^@fकाम करता है। इसके बजाय आपको अपने नाम का $xउपयोग करने की आवश्यकता नहीं है $_। और प्रिंटफ का उपयोग न करें, उपयोग करें "{"interpolation"}"।

— वेन

मुझे यह भी समझ में नहीं आता कि आपको इसकी आवश्यकता क्यों है। के लिए क्यों नहीं for @f? आप $++इसे (और सूचकांक में @a) साथ जाने के लिए एक सूचकांक के रूप में उपयोग कर सकते हैं ।

— वेन

बीमार पीसी पर im के रूप में संपादित करें :)

— Håvard Nygård

1

@ $ $ के बारे में सिर के लिए धन्यवाद। मुझे मेरे "वास्तविक" कार्यक्रमों में परेशानी से बचाता है। बस पर्ल 6.

— हेवार्ड न्यागर्ड

क्या आप सुनिश्चित हैं कि प्रक्षेप बाइट्स को नहीं बचाते हैं?

— शुक्र

1

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

for n,a in input():print n+' is in the %dd-comma club.'%'{:20,.2f}'.format(a).count(',')

थोड़ा पुराना (90 बाइट्स):

for n,a in input():print n+' is in the '+`'{:20,.2f}'.format(a).count(',')`+'-comma club.'

टुपल्स (नाम, राशि) की एक सूची के रूप में इनपुट लेता है।

मैं स्कूल में अपने फोन पर ऐसा कर रहा हूं इसलिए बाद में इसका परीक्षण करूंगा।

— डैनियल
स्रोत

1

डीसी, 56 54 बाइट्स

[P[ is in the ]Pd*vdZrX-1-3/n[-comma club.]pstz0<g]sglgx

यह स्टैक से इनपुट लेता है, जिसे स्टैक के शीर्ष पर पहले नाम के साथ प्री-लोड किया जाना चाहिए, पहला नंबर, दूसरा नाम, दूसरा नंबर, आदि।

यहाँ स्टैक को लोड करने और मैक्रो को चलाने का एक उदाहरण है, g:

#!/usr/bin/dc
_123.45         [Nelly]
999999999999.00 [Lonnie]
1000.01         [Manson]
999.99          [Mark]
99.99           [Reid]
1               [Karla]
986000000       [Russ]
999999999.99    [Laura]
1549001.10      [Kylie]
0.05            [Jamie]
100000          [John]
[P[ is in the ]Pd*v1/Z1-3/n[-comma club.]pstz0<g]sglgx

जो सामान्य उत्पादन का उत्पादन करता है,

John is in the 1-comma club.
Jamie is in the 0-comma club.
Kylie is in the 2-comma club.
Laura is in the 2-comma club.
Russ is in the 2-comma club.
Karla is in the 0-comma club.
Reid is in the 0-comma club.
Mark is in the 0-comma club.
Manson is in the 1-comma club.
Lonnie is in the 3-comma club.
Nelly is in the 0-comma club.

यहाँ कोड का एक एक्साइज है:

[P[ is in the ]Pd*v1/Z-1-3/n[-comma club.]pstz0<g]sglgx

[                    # begin macro string
P                    # print and pop person name
[ is in the ]P       # print and pop ' is in the '
# Get absolute value of number by squaring and square root
d*v                  # d=dup, *=multiply, v=root
1/                   # 1/ truncates to integer since scale is 0
Z                    # Z=number length
1-3/n                # n=print and pop (#digits - 1)//3
[-comma club.]p      # print '-comma club.' and newline
st                   # pop '-comma club.' off stack into register t
z0<g                 # Do macro g if 0 is less than z=stack height
]                    # end macro string
sg                   # Save macro g
lgx                  # Load g and do its initial execution

ध्यान दें, संपादित 1 में मैंने प्रतिस्थापित किया dZrX-(डी = डुबकी, जेड = संख्या लंबाई, आर = स्वैप, एक्स = अंश, - = घटाना) 1/Z1 के साथ (विभाजित संख्या, जो डिफ़ॉल्ट पैमाने पर शून्य से पूर्णांक के पूर्णांक के साथ; फिर जेड = संख्या; लंबाई), दो बाइट्स की बचत।

— जेम्स वाल्डबी - jwpat7
स्रोत

1

स्विफ्ट , 166 158 145 बाइट्स

var c="comma club",i=0
f.map{k,v in var a=abs(v);print(k,(1000..<1000000~=a ?1:1000000..<1000000000~=a ?2:1000000000..<1000000000000~=a ?3:0),c)}

और यहाँ शब्दकोश है:

var f = [
    "John": 100000, "Jamie": 0.05, "Kylie" : 1549001.10,
    "Laura": 999999999.99,"Russ":1000000000,"Karla": 1,
    "Reid": 99.99,"Mark": 999.99, "Manson": 1000.01,
    "Lonnie": 999999999999.00, "Nelly": -123.45
]

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

— श्री एक्सकोडर
स्रोत

0

क्लोजर, 108 बाइट्स

(def f ["John", "Jamie", "Kylie", "Laura", "Russ", "Karla", "Reid", "Mark", "Manson", "Lonnie", "Nelly"])
(def a ["100000", "0.05", "1549001.10", "999999999.99", "986000000", "1", "99.99", "999.99", "1000.01", "999999999999.00", "-123.45"])

(map #(str %" is in the "(quot(-(count(nth(partition-by #{\.}(drop-while #{\-}%2))0))1)3)"-comma club.")f a)

सुनिश्चित नहीं है कि अगर फ्लोट्स पर काम किया जा रहा है तो पात्रों के अनुक्रमों की तुलना में छोटा होगा। सुनिश्चित नहीं है कि गैर-फ़ंक्शन उत्तर ठीक है जो उत्तरों का एक क्रम लौटाता है।

— NikoNyrh
स्रोत

0

Rebol, 118 बाइट्स

d: charset"0123456789"forskip s 2[c: 0 parse s/2[opt"-"any[3 d and d(++ c)]]print[s/1"is in the"join c"-comma club."]]

ऐरे घोषणा के साथ अपुष्ट:

s: [
    {John} {100000}
    {Jamie} {0.05}
    {Kylie} {1549001.10}
    {Laura} {999999999.99}
    {Russ} {986000000}
    {Karla} {1}
    {Reid} {99.99}
    {Mark} {999.99}
    {Manson} {1000.01}
    {Lonnie} {999999999999.00}
    {Nelly} {-123.45}
    {Baz} {1.12345678}     ;; added extra Baz test case
]

d: charset "0123456789"
forskip s 2 [
    c: 0
    parse s/2 [
        opt "-"
        any [3 d and d (++ c)]
    ]
    print [s/1 "is in the" join c "-comma club."]
]

आउटपुट:

John is in the 1-comma club.
Jamie is in the 0-comma club.
Kylie is in the 2-comma club.
Laura is in the 2-comma club.
Russ is in the 2-comma club.
Karla is in the 0-comma club.
Reid is in the 0-comma club.
Mark is in the 0-comma club.
Manson is in the 1-comma club.
Lonnie is in the 3-comma club.
Nelly is in the 0-comma club.
Baz is in the 0-comma club.

— draegtun
स्रोत

0

जावा 8 154 141 बाइट्स

m.keySet().stream().map(k->k+" is in the "+(((""+Math.abs(m.get(k).longValue()))).length()-1)/3+"-comma club.").forEach(System.out::println);

Ungolfed

public static void main(String[] args) {
    Map<String, Number> m = new LinkedHashMap<String, Number>(){{
        put("John", 100000);
        put("Jamie", 0.05);
        put("Kylie", 1549001.10);
        put("Laura", 999999999.99);
        put("Russ", 1000000000);
        put("Karla", 1);
        put("Reid", 99.99);
        put("Mark", 999.99);
        put("Manson", 1000.01);
        put("Lonnie", 999999999999.00);
        put("Nelly", -123.45);
    }};
    m.keySet().stream().map(k->k+" is in the "+(((""+Math.abs(m.get(k).longValue()))).length()-1)/3+"-comma club.").forEach(System.out::println);
}

— anacron
स्रोत

1

आप इसके बजाय String.valueOfउपयोग और हटा सकते हैं (((""+Math.abs(m.get(k).longValue())).length()-1)/3)।

— केविन क्रूज़सेन

1

और आप चारों ओर कोष्ठक को भी हटा सकते हैं k->।

— केविन क्रूज़सेन

मेरे दोस्तों को बताएं कि वे किस "कॉमा क्लब" से हैं

परीक्षण के मामले

संपादित करें: कृपया संशोधित परीक्षण मामलों को देखें

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

PostgreSQL, 61 बाइट्स

जेली , 34 32 बाइट्स

कैसे?

PHP, 76 74 बाइट्स

गणितज्ञ (86 बाइट्स)

जाप , 36 बाइट्स

व्याख्या

MATL, 50 48 43 बाइट्स

आर, 68 बाइट्स

जावास्क्रिप्ट, 59 बाइट्स

डेमो

विम, 72 बाइट्स

05AB1E , 32 बाइट्स

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

पॉवरशेल, 82 बाइट्स

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

के, 66 बाइट्स

पायथन 2.7 , 89 86 84 बाइट्स

सी #, 125 बाइट्स

पायथन 3 ( 207 159 110 95) 86 बाइट्स, @iwaseatenbyagrue के लिए धन्यवाद)

पर्ल 6, 107 95 बाइट्स

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

डीसी, 56 54 बाइट्स

स्विफ्ट , 166 158 145 बाइट्स

क्लोजर, 108 बाइट्स

Rebol, 118 बाइट्स

जावा 8 154 141 बाइट्स

Ungolfed