मेरे दोस्त और मैं हमारे एपी कंप्यूटर विज्ञान वर्ग में एक प्रयोगशाला में काम कर रहे थे और हमने एक के बाद एक गोल्फ को कोड करने का फैसला किया क्योंकि हमारे पास समाप्त होने के बाद भी हम आधे वर्ग मुक्त थे। यहाँ सवाल है:

संख्या n को देखते हुए, क्या प्रत्येक अंक द्वारा विभाज्य है?

उदाहरण के लिए, 128 इस परीक्षा को पास करेगा- यह 1,2 से विभाज्य है, और 8. शून्य के साथ कोई भी संख्या स्वचालित रूप से संख्या को अयोग्य बनाती है। जब आप अन्य भाषाओं का उपयोग कर सकते हैं और यदि आप चाहें तो उनके साथ समाधान पोस्ट कर सकते हैं, हम यह देखने में सबसे अधिक रुचि रखते हैं कि कैसे लोग जावा में प्रोग्राम बना सकते हैं, क्योंकि यही वह भाषा है जिसका हम कक्षा में उपयोग करते हैं। अब तक, हम दोनों के पास 51 हैं। यहां मेरा वर्तमान कोड है:

public boolean dividesSelf(int n){for(int p=n;n%10>0;)n/=p%(n%10)>0?.1:10;return n<1;}
// 51 characters

// Breakdown:
// for(int p=n;         Saves one semicolon to put declaration into for loop
// n%10>0;)             Basic check-for-zero
// n/=                  Pretty simple, discarding one number off of n at a time
// p%(n%10)>0?          If p (the given value) is not divisible by n%10 (the current digit)...
// .1:10;               Divide by .1 (multiply by 10) so it fails the check next iteration. If it is divisible, divide by 10 to truncate the last digit
// return n<1           If the number was fully divisible, every digit would be truncated, and n would be 0. Else, there would still be non-zero digits.

आवश्यकताएँ

विधि हस्ताक्षर आप जो चाहें कर सकते हैं। बस फ़ंक्शन बॉडी की गिनती करें। हालांकि, सुनिश्चित करें कि यह विधि एक बूलियन मान लौटाती है और केवल एक संख्यात्मक पैरामीटर (स्ट्रिंग नहीं) में गुजरती है ।

कोड इन सभी मामलों को पारित करने में सक्षम होना चाहिए (मूल प्रश्न के निर्देशों के अनुसार सही रहने के लिए, केवल बूलियन सही और गलत मानों की गणना करता है यदि भाषा बूलियंस का समर्थन करती है। यदि और केवल यदि आपकी भाषा आपके पास बूलियन चर नहीं है। किसी भी गैर-पूर्णांक पूर्णांक के साथ 0 और सही के साथ गलत का प्रतिनिधित्व कर सकता है (अधिमानतः 1 या -1):

128 -> true
 12 -> true
120 -> false
122 -> true
 13 -> false
 32 -> false
 22 -> true
 42 -> false
212 -> true
213 -> false
162 -> true
204 -> false

इसके अलावा, हम व्हॉट्सएप की गिनती नहीं करते हैं, इसलिए ऐसा करने के लिए स्वतंत्र महसूस करें, जब तक कि प्रोग्राम के कामकाज के लिए व्हॉट्सएप आवश्यक नहीं है (इसलिए जावा में नए लिंक की गिनती नहीं होती है, लेकिन गिनती intऔर x=1गणना के बीच एक ही स्थान है ।) !

code-golf

— मैथ्यू किर्शबाउम
स्रोत

18

PPCG में आपका स्वागत है! कुछ सुझाव: 1. कार्यात्मक व्हाट्सएप की गिनती नहीं करना एक बुरा विचार है। व्हॉट्सएप में लिखा गया कोई भी जवाब अपने आप जीत जाएगा। 2. क्या हमारा सबमिशन प्रिंट / रिटर्न चाहिए trueऔर falseया सत्य / झूठे मूल्य ठीक हैं? 3. javaटैग वास्तव में यहां लागू नहीं होता है, क्योंकि चुनौती स्वयं जावा से असंबंधित है।

— डेनिस

ठीक है। मुद्दों के लिए खेद है। बस इसे साफ करने के लिए, क्या आप 'int p = n' में स्थान को कार्यात्मक मानेंगे, क्योंकि मैंने पहले नहीं किया था। आपके द्वारा बताए गए अन्य मुद्दों को मैं ठीक करूंगा।

— मैथ्यू किर्शबाउम

5

कार्य करने के लिए कोड के लिए आवश्यक सभी व्हाट्सएप कार्यात्मक है।

— FryAmTheEggman

ठीक है, प्रतिक्रिया के लिए धन्यवाद!

— मैथ्यू किर्शबाउम

1

@RickyDemer: चूंकि 0 उस मामले में एक असाधारण इनपुट होगा (यह 0अंकों के साथ एकमात्र संख्या है, जो उनमें से प्रत्येक का एक से अधिक है), मुझे लगता है कि अधिकांश उत्तर बस एक निर्बाध तरीके से इसके लिए एक चेक शामिल करने में अधिक समय लेंगे। इसलिए मुझे यह समस्या अच्छी लगती है क्योंकि शीर्षक बेहतर है (इसके अंकों से विभाज्य है, बजाय इसके कई अंकों का, जो 0 को छोड़कर)।

— जीरोन मोस्टर्ट

23

पर्ल 6, 13

sub golf($_) {
   $_%%.comb.all
}

निहित चर का उपयोग करता है $_- $_ %% .comb.allके बराबर है $_ %% all($_.comb)। %%"विभाज्य" ऑपरेटर है, और combकोई अतिरिक्त तर्क के साथ एक स्ट्रिंग में वर्णों की सूची नहीं देता है। एक उदाहरण के रूप में, यदि तर्क 123 है, तो फ़ंक्शन मूल्यांकन करता है

123 %% all(123.comb)

जो है

123 %% all(1, 2, 3)

जंक्शन ऑटोथ्रेडिंग इसे बनाता है

all(123 %% 1, 123 %% 2, 123 %% 3)

जो है

all(True, False, True)

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

Boolफ़ंक्शन सिग्नेचर कर कॉल करने वालों से जंक्शन-नेस को छिपाने और छिपाने के लिए रिटर्न वैल्यू को ज़बर्दस्ती करना संभव हो सकता है sub golf($_ --> Bool()), लेकिन रकुडो में अभी तक फंक्शन सिग्नेचर में काम नहीं करते हैं। वापसी का मूल्य अभी भी सही या गलत है, यह सिर्फ Trueया नहीं है False।

— हॉब्स
स्रोत

यदि आप इसे वापस करना चाहते हैं तो कोड के सामने Boolजोड़ soदें so$_%%.comb.all।

— ब्रैड गिल्बर्ट b2gills

21

सी # और सिस्टम.लिंक - 26/40

नियमों के अनुसार, विधि घोषणा को स्वयं नहीं गिना जाता है।

bool dividesSelf(int i) { 
    return(i+"").All(d=>i%(d-48d)<1);
}

यह दिखाते हुए कि एक बार फिर, C # सबसे अच्छा विकल्प है जब Java विचाराधीन है ... I kid, I kid!

दुर्भाग्य से, यह फ़ंक्शन (और अन्य उत्तरों में कई) नकारात्मक इनपुट के लिए सही परिणाम नहीं देगा। हम इसे ठीक कर सकते हैं, लेकिन समाधान अपने आकर्षण का एक बहुत कुछ खो देता है (और लंबाई में 46 वर्ण तक बढ़ता है):

return(i+"").All(d=>d>48&&i%(d-48)==0||d==45);

संपादित करें : टिम के सुझाव के साथ एक चरित्र का मुंडन।

संपादित करें : C # 6 में अभिव्यक्ति-शारीरिक सदस्यों की शुरूआत के साथ, हम इसे नीचे काट कर आगे बढ़ा सकते हैं return:

bool dividesSelf(int i) =>
    (i+"").All(d=>i%(d-48d)<1);

कुल 26 वर्णों के लिए (मेरी राय में, =>ब्रेसिज़ से अधिक किसी को शामिल नहीं किया जाना चाहिए)। नकारात्मक संख्याओं को संभालने वाले संस्करण को इसी तरह छोटा किया जा सकता है।

— जीरो मोस्टर्ट
स्रोत

क्यों .0? पूर्णांक मापांक के अलावा किसी और चीज की कोई आवश्यकता नहीं है।

— पीटर टेलर

3

@PeterTaylor: यदि आप सबसे छोटा प्रोग्राम चाहते हैं तो - पूर्णांक के i % 0साथ ia DivideByZeroException।

— जीरोन मोस्टर्ट

2

और एक डबल के साथ यह NaN देता है! अच्छा!

— पीटर टेलर

2

48dके रूप में ही है 48.0, लेकिन एक कम चरित्र (डबल के लिए)।

— टिम एस।

1

@ स्टुअर्टएलसी: लंबोदा विधियाँ नहीं हैं; उनका दायरा अलग है, इसलिए मुझे लगता है कि यह नियम बहुत दूर है। लेकिन चूंकि C # 6 (जो यह उत्तर पूर्व निर्धारित करता है), हमारे पास अभिव्यक्ति-ग्रस्त सदस्य हैं, जो हमें परिभाषा को छोटा करने की अनुमति देते हैं। नकारात्मक मामले के लिए, हम उपयोग नहीं कर सकते &, ठीक है क्योंकि &शॉर्ट-सर्किट नहीं है - आपको शून्य अपवाद द्वारा एक विभाजन मिलेगा %। हम इसे एक डबल (साथ d) बनाकर ठीक कर सकते हैं , लेकिन फिर हमने एक चरित्र खो दिया है।

— जीरो मोस्टर्ट

18

एपीएल ( 13 11)

(स्पष्ट रूप से कोष्ठक की गिनती नहीं है)

{0∧.=⍵|⍨⍎¨⍕⍵}

स्पष्टीकरण:

⍎¨⍕⍵: स्ट्रिंग के प्रतिनिधित्व में प्रत्येक चरित्र का मूल्यांकन करें ⍵
⍵|⍨: उनमें से प्रत्येक के लिए, इसके मॉड्यूल को ढूंढें और ⍵
0∧.=: देखें कि क्या वे सभी समान हैं 0

परीक्षण के मामलों:

      N,[.5] {0∧.=⍵|⍨⍎¨⍕⍵} ¨ N←128 12 120 122 13 32 22 42 212 213 162 204
128 12 120 122 13 32 22 42 212 213 162 204
  1  1   0   1  0  0  1  0   1   0   1   0

— मारीनस
स्रोत

एपीएल कर सकते हैं X%0? बिना फेंके?

— ऑप्टिमाइज़र

@Optimizer: हाँ। 0|Xदेता है X।

— मैरिनस

मिठाई। साथ ही आपका उत्तर 11 बाइट्स है, 13 नहीं

— ऑप्टिमाइज़र

9

केवल एपीएल 0 से मॉडुलो पर एक त्रुटि नहीं देगा, और एक नॉन-बूल का मूल्यांकन करने पर दुर्घटना एक बूल के रूप में होगी;)

— फ्रैमएग्जमैन

3

Dfn के बजाय ट्रेन से छोटा एक पात्र:(0∧.=⍎¨∘⍕|⊢)

— ngn

14

पायथन 2: 43 वर्ण

f=lambda n:any(n%(int(d)or.3)for d in`n`)<1

जाँचता है कि क्या संख्या में कोई भी गैर-अक्षरा बनी हुई है, अपने अंकों को मापता है, और उसी के नकार को आउटपुट करता है। शून्य अंकों को अजीब तरीके से संभाला जाता है: चूंकि कंप्यूटिंग %0में त्रुटि होती है, अंकों 0को प्रतिस्थापित किया जाता है .3, जो हमेशा अस्थायी बिंदु अशुद्धियों के कारण नॉनज़रो परिणाम देता है।

फ़ंक्शन बॉडी 32 वर्ण है।

— XNOR
स्रोत

14

पर्ल - 27 बाइट्स

sub dividesSelf{
    $_=pop;s/./!$&||$_%$&/ger<1
}

निर्देश के अनुसार, हस्ताक्षर पर हस्ताक्षर नहीं करना।

नमूना उपयोग:

use Data::Dump qw(dump);
for $i (128, 12, 120, 122, 13, 32, 22, 42, 212, 213, 162, 204) {
  printf "%3d -> %s\n", $i, dump(dividesSelf $i);
}

नमूना आउटपुट:

128 -> 1
 12 -> 1
120 -> ""
122 -> 1
 13 -> ""
 32 -> ""
 22 -> 1
 42 -> ""
212 -> 1
213 -> ""
162 -> 1
204 -> ""

समस्या विनिर्देशन को संबोधित करते हुए: "केवल बूलियन सच्चे और झूठे मूल्यों की गिनती होती है। सत्य / गलत मूल्यों की गिनती नहीं होती है।"

use Data::Dump qw(dump);
dump(1 == 1);
dump(0 == 1);

आउटपुट:

1
""

'यह सच है' और 'गलत' के रूप में परिभाषित कर रहे हैं 1और ""।

इरेटम:
जैसा कि ब्रैड गिल्बर्ट सही बताते हैं , पर्ल एक स्केलर के रूप में सही परिभाषित करता है जो एक साथ पूर्णांक 1और स्ट्रिंग दोनों है "1", और एक स्केलर के रूप में गलत है जो पूर्णांक 0और स्ट्रिंग दोनों ""एक साथ है।

— Primo
स्रोत

इस का उपयोग नहीं कर से छोटा किया जा सकता $_: pop=~s///ger<1। मुझे नहीं पता कि ओपी इससे सहमत होगा या नहीं 1और ""वैध परिणाम हैं। यदि नहीं, तो इसे दो और बाइट्स के साथ तय किया जा सकता है: बस जोड़ें |0।

— HVD

perl -pe'$_=s/./!$&||$_%$&/ger<1|0'26 ध्वज |0और -pध्वज सहित बाइट्स है । आपको किसी फ़ंक्शन का उपयोग करने की आवश्यकता नहीं है।

— hmatt1

1

वास्तव में यह सच है और झूठी मान अधिक की तरह हैं dualvar(1,'1')और dualvar(0,'')।

— ब्रैड गिल्बर्ट ने

1

@ ब्रैडगिलबर्ट दिलचस्प है। मैं उचित रूप से perlguts से परिचित हूं, लेकिन मुझे पता नहीं था कि सच्चे और झूठे विशेष आवरण थे। वे वास्तव में 'ट्रिपल स्केलर्स' हैं, SVIV(इंट), SVNV(डबल), और SVPV(स्ट्रिंग) के रूप में चिह्नित ।

— प्राइमो

1

असल में जब आप पहली बार स्ट्रिंग या नंबर के रूप में एक स्ट्रिंग का उपयोग करते हैं, तो वैरिएबल उस अतिरिक्त डेटा को होल्ड करने के लिए संशोधित हो जाता है। यही कारण है कि आपको केवल एक चेतावनी मिलती है जब आप पहली बार 'abc'एक नंबर के रूप में उपयोग करते हैं (यह मानते हुए कि आप use warnings;सक्षम हैं।)

— ब्रैड गिल्बर्ट b2gills

13

सीजेएम, 11 10 बाइट्स

{
    _Ab:df%:+!
}:F;

यह नामित फ़ंक्शन को परिभाषित करता है Fऔर स्टैक से ब्लॉक को हटा देता है।

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

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

$ cjam <(echo '{_Ab:df%:+!}:F;[128 12 120 122 13 32 22 42 212 213 162 204]{F}%p')
[1 1 0 1 0 0 1 0 1 0 1 0]

यह काम किस प्रकार करता है

_      " Copy the integer on the stack.                                          ";
Ab     " Push the array of its digits in base 10.                                ";
:d     " Cast each digit to Double.                                              ";
f%     " Take the integer on the stack modulus each of its digits.               ";
:+     " Add the results.                                                        ";
!      " Push the logical NOT of the sum.                                        ";

— डेनिस
स्रोत

क्या प्रश्न लिखने के बाद CJam में 10-बाइट समाधान के लिए आपके द्वारा उपयोग की जाने वाली विशेषताएं थीं?

— lirtosiast

@ThomasKwa: हाँ, यह किया है। मैंने संस्करण 0.6.2 में कोड का परीक्षण किया है, जो जुलाई 2014 में जारी किया गया था।

— डेनिस

12

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

v=>[...""+v].every(x=>v%x<1)

सुझाव के (""+v).split("")साथ बदलने के लिए core1024 का धन्यवाद [...""+v], और फ़ंक्शन के उपयोग का सुझाव देने के लिए ओपनकोरक्लोज़ every।

वर्तमान में मेरे कोड में से एक बिट शामिल नहीं है: ओ

पिछला समाधान

v=>[...""+v].filter(x=>v%x|!+x)==""

==""[""]==""रिटर्न के बाद से कोई सरणी खाली है या नहीं, यह जांचने का एक वैध तरीका नहीं है true, लेकिन सरणी में गैर-रिक्त स्ट्रिंग शामिल करने की गारंटी है, इसलिए यह यहां काम करता है।

बाकी जावास्क्रिप्ट में काफी मानक शॉर्टहैंड प्रकार रूपांतरण हैं।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत

1

आप की जगह कुछ characteras बचा सकता है (""+v).split("")के साथ [...""+v]।

— core1024

1

everyविधि का उपयोग क्यों नहीं करते ? v=>[...""+v].every(x=>v%x<1);

— ओपन

@openorclose: धन्यवाद। जेएस में इसका उपयोग करने का कभी मौका नहीं मिला, इसलिए मैंने कभी इस तरह के समारोह की खोज करने के बारे में नहीं सोचा।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

v=>![...""+v].some(x=>v%x)

— l4m2

@ l4m2 चूंकि v%0रिटर्न करता है NaNऔर NaN == falseइसलिए, आपके मामले में नंबर जिसमें 0 है, जैसे कि 10, वापस आ सकता है true।

— शायरु असकोतो

9

जावा 8, 46 बाइट्स (विधि निकाय)

Jeroen Mostert के दोहरे चाल में बदलने का उपयोग करना ।

public static boolean dividesSelf(int n) {
    return(""+n).chars().allMatch(x->n%(x-48d)<1);
}

— CPU1
स्रोत

8

पायथ, 12 बाइट्स

!f|!vT%vzvTz

यह स्ट्रिंग में वर्णों को शून्य ( !vT) या इनपुट ( %vzvT) को विभाजित नहीं करने के लिए फ़िल्टर करता है , फिर परिणामी सूची के तार्किक नहीं लेता है।

इसे यहाँ आज़माएँ।

— isaacg
स्रोत

नहीं, यदि कोई फ़ंक्शन उपयोग नहीं किया जाता है, तो मैं ठीक हूं। मैं बस किसी ऐसे व्यक्ति को इंगित करना चाहता था जो फ़ंक्शन का उपयोग कर रहा था कि उन्हें घोषणा की गणना करने की आवश्यकता नहीं है, और केवल अंदर कोड।

— मैथ्यू किर्शबाउम

8

रूबी, 44 बाइट्स (फ़ंक्शन बॉडी: 37)

संभवतः आगे गोल्फ होने की क्षमता है।

f=->n{n.to_s.chars.all?{|x|x>?0&&n%x.hex<1}}

इनपुट फ़ंक्शन के माध्यम से लिया जाता है f। उदाहरण का उपयोग:

f[128] # => true
f[12]  # => true
f[120] # => false
...

— अगस्त
स्रोत

1

आप बदल सकते हैं .to_iकरने के लिए .hex, के बाद से ही अंकों की संख्या के आधार 16 में ही कर रहे हैं, और बदल सकते हैं ==0करने के लिए <1।

— 16

8

पायथन - 59 50 49 47 बाइट्स

f=lambda n:all(c>'0'and 0==n%int(c)for c in`n`)

मुझे यकीन है कि वहाँ एक तेज़ तरीका है ... ओह ठीक है।

संपादित करें - गोल्फ युक्तियाँ के लिए FryAmTheEggman के लिए धन्यवाद।

2 संपादित करें - FryAmTheEggman ने इस बिंदु पर यह लिखा है, उफ़

3 संपादित करें - अगर आपको पता भी नहीं चला तो जीनक्सप्स एक चीज थी। ...सिर्फ मैं?

— Kasran
स्रोत

बहुत बहुत शुक्रिया! मैं उन सब बातों को भूलता रहता हूं। (मुझे इस बात का भी

— अंदाजा

ओह, तर्क को पलटते हुए यह थोड़ा छोटा भी लगता है f=lambda n:all([c>'0'and 0==n%int(c)for c in`n`]):। और कोई समस्या नहीं है :)

— FryAmTheEggman

ओह, मुझे एहसास नहीं था कि एक allविधि भी थी ।

— कासरन

चाहेंगे 1>n%int(c)काम करते हैं?

— Sp3000

3

सूची-बोध क्यों? एक जीनएक्सपी का उपयोग करना: all(c>'0'and 0==n%int(c)for c in`n`)बिल्कुल वैसा ही करता है, जैसे 2 चार कम और यहां तक कि सूची के आवंटन की बचत भी।

— बाकूरी

8

अजगर ११

!f%Q|vT.3`Q

यह @ isaacg's और @ xnor के उत्तरों को जोड़ती है। यह इनपुट से अंकों को छानता है, जिसके मान की जाँच करता है input % (eval(current_digit) or .3)। फिर यह जांचता है कि परिणामी स्ट्रिंग खाली है या नहीं।

एक और जोड़ी के समान लंबाई वाले संस्करण आए:

!f%Q|T.3jQT
!f|!T%QTjQT

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

— फ्राइअमईएग्गमैन को दर्शाता है
स्रोत

5

बैश + कोरुटिल्स, 44 बाइट्स

पूर्ण कार्य की परिभाषा है:

f()((`tr 0-9 \10<<<$1``sed "s/./||$1%&/g"<<<$1`))

मुझे यकीन नहीं है कि यह कैसे स्कोर किया जाए क्योंकि आम तौर पर शेल फ़ंक्शन एक एकल सेट का उपयोग करते हैं {}या ()फ़ंक्शन बॉडी को शामिल करने के लिए। मैंने पाया कि मैं (())फ़ंक्शन का उपयोग करने के लिए डबल का भी उपयोग कर सकता हूं जो एक अंकगणितीय विस्तार का कारण बनता है जो कि मुझे यहां चाहिए। इसलिए अब मैं उन कोष्ठकों में से केवल एक जोड़ी को गिन रहा हूं - इस पर आगे चर्चा स्वागतयोग्य है।

आउटपुट:

$ for i in 128 12 120 122 13 32 22 42 212 213 162 204; do f $i; printf "%d " $?; done
1 1 0 1 0 0 1 0 1 0 1 0 $
$

— डिजिटल आघात
स्रोत

उह - यह मेरे लिए स्पष्ट नहीं है कि क्या 1s और 0s स्वीकार्य हैं या यदि मुझे प्रिंट करना है true/ false?

— डिजिटल ट्रॉमा

4

जे - 14 चार

फ़ंक्शन बॉडी के बाद का भाग है =:। अगर हम पूरे फंक्शन के लिए कैरेक्टर काउंट को कम से कम करना चाहते हैं, तो यह 15 वर्ण है */@(0=,.&.":|])।

f=:0*/@:=,.&.":|]

,.&.":J का सबसे छोटा तरीका है कि अपने दशमलव अंकों की सूची में संख्या का विस्तार करें: स्ट्रिंग में कनवर्ट करें, अंकों को अलग करें, और प्रत्येक अंक को वापस संख्या में परिवर्तित करें। उन अंकों ,.&.":|]का इनपुट नंबर ( ]) मोडुलो ( |) लेता है । 0*/@:=यदि सभी परिणाम 0 थे, तो सच है, अन्यथा एक झूठी देता है।

   f 162
1
   f every 204 212 213
0 1 0

— algorithmshark
स्रोत

3

जावा - 121 102 97 79 78 बाइट्स

मुझे सिर्फ इतना पता है कि यह बाद में बंद हो जाएगा। ओह अच्छा।

boolean b(int a){int m=10,j,t=1;for(;m<a*10;m*=10){j=10*(a%m)/m;if(j==0||a%j>0)t=0;}return t>0;}

मैं वापस आऊंगा।

— खिंचाव पागल
स्रोत

1

अब आप जो चाहें अपने फंक्शन को नाम दे सकते हैं। मैंने नियमों को बदल दिया है ताकि आप केवल वास्तविक फ़ंक्शन के अंदर गणना की गणना कर सकें, लेकिन फ़ंक्शन को एक बूलियन प्रकार वापस करना होगा । तो यह वर्तमान में 86 वर्णों पर है।

— मैथ्यू किर्शबाउम

3

हास्केल - 100 54 38

f x=all(\y->y>'0'&&x`mod`read[y]<1)$show x

अभी भी सीखने, आलोचकों की सराहना की

— globby
स्रोत

मैंने यहां एक टिप्पणी की थी, लेकिन मैंने गलती से इसे किसी भी तरह से हटा दिया ... वैसे भी, कुछ सुझाव: 1) एस ड्रॉप करें length, वे अनावश्यक हैं। 2) tइसकी परिभाषा से बदलें । 3) elem y sअनावश्यक है। 4) के /='0'स्थान पर बाएं फ़िल्टर में ले जाया जा सकता है elem y s। 5) इस मामले में, /='0'के बराबर है >'0', क्योंकि हर अक्षर एक अंक है। 6) modबैकटिक्स में डालें , तो यह इन्फिक्स बन जाता है। 7) सब कुछ एक लाइन पर रखो।

— ज़र्गब

1 और 3 तब से थे जब मैं इसे एक अलग तरीके से करने की कोशिश कर रहा था और कोड को बचाया। सुझावों के लिए धन्यवाद।

— ग्लोबबी

1

मेरे सुझाव: उपयोग करने के बजाय s==filter(...)sआपको उपयोग करना चाहिए all(...)s। अब, क्योंकि sकेवल एक बार अभिव्यक्ति में प्रकट होता है, आप इसे परिभाषा और ड्रॉप के साथ बदल सकते हैं where। इसके अलावा, ==0आप के बजाय उपयोग कर सकते हैं <1।

— गर्व हैस्केलर

पहले संस्करण से बहुत सुधार!

— गर्व हैकेलर

मुझे लगता है कि आप अभी भी एक बाइट खो सकते हैं यदि आप all(\y->...)$show xद्वारा प्रतिस्थापित करते हैं and[...|y<-show x]।

— ज़गरब

2

सीजेएम, 15 बाइट्स

{_Abf{_g{%}*}:|!}

यह एक ब्लॉक है, जो सीजेएम में एक समारोह के लिए निकटतम चीज है। मैं केवल शरीर की गिनती कर रहा हूं (यानी ब्रेसिज़ को छोड़ना)। आप इसका उपयोग इस प्रकार कर सकते हैं:

128{_Abf{_g{%}*}:|!}~

या यदि आप इनपुट की एक श्रृंखला का परीक्षण करना चाहते हैं, तो आप कर सकते हैं

[128 12 120 122 13 32 22 42 212 213 162 204]{{_Abf{_g{%}*}:|!}~}%

परिणाम को इंगित करने के लिए स्टैक पर ब्लॉक पत्ते 0(झूठा) या 1(सच्चाई)। (CJam में बूलियन प्रकार नहीं है।)

इसका परीक्षण यहां करें।

स्पष्टीकरण:

_               "Duplicate input.";
 Ab             "Get base-10 digits.";
   f{      }    "This maps the block onto the list of digits, supplying the input each time.";
     _g         "Duplicate digit, get signum S (0 or 1).";
       { }*     "Repeat this block S times.";
        %       "Take input modulo digit.";
                "This leaves an array of zeroes for divisible digits, non-zeroes
                 for non-divisible digits, and non-zero junk for zeroes.";
            :|  "Fold OR onto this list. One could also sum the list with :+";
              ! "Logical NOT. Turns 0 into 1, and non-zero values into 0.";

वैकल्पिक, 15 बाइट्स भी

{:XAb{X\_X)?%},!}

व्याख्या

:X              "Store input in X.";
  Ab            "Get base-10 digits.";
    {       },  "Filter this list by the result of the block.";
     X\         "Push another copy of X, swap with digit.";
       _        "Duplicate digit.";
        X)      "Push X+1.";
          ?     "Select digit itself or X+1, depending on whether digit is 0 or not.";
           %    "Take modulo. X%(X+1) will always be nonzero for positive integers.";
              ! "Logical NOT. Turns an empty list into 1 and a non-empty list into 0.";

— मार्टिन एंडर
स्रोत

2

सीजेएम, 15 बाइट्स

{_Abf{_{%}1?}1b!}

{}CJam में एक फ़ंक्शन के लिए निकटतम चीज़ है। मैं सिर्फ फंक्शन की बॉडी गिन रहा हूं

इसे इस तरह उपयोग करें:

128{_Abf{_{%}1?}1b!}~

या तो पाने के लिए 1(यदि संख्या विभाज्य है) या 0(यदि संख्या उसके अंकों से विभाज्य नहीं है)।

इसे यहाँ ऑनलाइन आज़माएँ

व्याख्या

_Ab                "Copy the number and split it to its digits";
   f{      }       "For each digit, run this code block on the number";
     _{%}1?        "If the digit is 0, put 1, otherwise perform number modulus digit";
            1b     "We now have an array of modulus corresponding to each digit. Sum it up";
              !    "Negate the sum. If all digits were divisible, sum of modules will be"
                   "0, thus answer should be 1 and vice versa";

— अनुकूलक
स्रोत

मुझे कुछ याद आ रहा है, लेकिन सीजेएम पर जल्दी से पढ़ने के बाद, कुछ चीजें समझ में नहीं आती हैं: Abअंकों का विभाजन कैसे होता है ? ऐसा लगता है कि इसे केवल आधार 10 में परिवर्तित किया जा सकता है। इसके अलावा,% को संख्या से मॉड करने के लिए कैसे जाना जाता है, और न केवल अगले अंक को, क्योंकि ऐसा लगता है कि अगला अंक स्टैक पर अगला होगा?

— मैथ्यू किर्शबाउम

आपके सभी सवालों का जवाब देना मुश्किल हो जाएगा। कोड में प्रत्येक वर्ण के बाद एड लगाकर सीखना आसान होगा। दौड़ने का प्रयास करें128{ed_edAedbedf{ed_ed{ed%ed}1ed?ed}ed1edbed!ed}~

— ऑप्टिमाइज़र

1

विशेष प्रश्नों के उत्तर: आधार 10 करने से आधार 10 परिवर्तित संख्याओं की एक सरणी मिलती है, जो इस मामले में स्वयं अंक हैं। %बस अंतिम दो संख्याएँ (इस मामले में) लें और मॉड की गणना करें। यहाँ अंतिम दो संख्याएँ वास्तविक संख्या और अंक (हमेशा) हैं

— ऑप्टिमाइज़र

ठीक है, सलाह के लिए धन्यवाद!

— मैथ्यू किर्शबाउम

2

C89, 43 बाइट्स

unsigned char d(int n, int c) {
        int a=n%10;return!n||a&&!(c%a)&&d(n/10,c);
}

C89 में बूलियन प्रकार नहीं है। आशा है कि काम करता है। इसके अलावा, मैंने स्टैक के माध्यम से मूल संख्या की एक प्रति पारित करने के लिए एक दूसरे पैरामीटर का उपयोग किया, लेकिन परिभाषा कुछ भी हो सकती है। सही परिणाम प्राप्त करने के लिए आपको फ़ंक्शन को दोनों मापदंडों ( d(128, 128)) के लिए समान मूल्य के साथ कॉल करना होगा ।

संपादित करें: एक अनाम उपयोगकर्ता द्वारा एप्लाइड सुझाए गए संपादन

— MarcDefiant
स्रोत

Codegolf.stackexchange.com/review/suggested-edits/17160 पर एक नज़र डालें , किसी ने आपको कुछ गोल्फ सुझाव दिए

— जस्टिन

विशेष रूप से नियमों के खिलाफ। एक पैरामीटर।

— edc65

हाँ, यह पोस्ट वास्तव में क्यों मैंने उस नियम को बनाने का फैसला किया, क्योंकि यह सही नहीं लगता था कि उपयोगकर्ता को कार्यक्रम के बजाय दोहराव करना चाहिए।

— मैथ्यू किर्शबाउम

मुझे लगता है कि मुझे एक आवरण समारोह जोड़ना होगा। क्या उस फ़ंक्शन की घोषणा बाइट की गिनती में शामिल होती है?

— मार्कडेफिएंट

2

C11 - 44 फ़ंक्शन बॉडी में बाइट्स

एक और सी संस्करण, गैर पुनरावर्ती और एक अस्थायी बिंदु अपवाद के बिना।

bool digit_multiple(int i)
{
    for(int n=i;i%10&&n%(i%10)<1;i/=10);return!i;
}

यह C ++, Java और अन्य सी-लाइक भाषाओं में भी काम करेगा।

प्राइमो की टिप्पणी के सुधार को शामिल करने के लिए संपादित।

— स्टेट बैंक ऑफ इंडिया
स्रोत

1

जावा में संकलित एक संस्करण (1.7.0_45-b18):, int n=i;for(;i%10>0&&n%(i%10)<1;i/=10);return i<1;ओपी कोड की तुलना में एक बाइट कम है।

— प्रिमो

2

जूलिया 32 25 23

अंकों का उपयोग करके सुधार किया गया

साथ ही नकारात्मक संख्याओं के साथ समस्या को ठीक करता है

selfDivides(x)=sum(x%digits(x).^1.)==0

पुरानी विधि

यदि सभी अवशेषों का योग 0. है तो सभी अंक विभाजित होते हैं। दूसरों की तरह, नकारात्मक संख्याओं के साथ समस्या है।

selfDivides(x)=sum(x.%(Float64["$x"...]-48))==0

उत्पादन

[selfDivides(x) for x in [128,12,120,122,13,32,22,42,212,213,162,204]]
12-element Array{Any,1}:
  true
  true
 false
  true
 false
 false
  true
 false
  true
 false
  true
 false

बेहतर तरीका भी BigInt संभालता है

selfDivides(BigInt(11111111111111111111111111111111111111112))
true

हालाँकि

selfDivides(BigInt(11111111111111111111111111111111111111113))
false

चूंकि

BigInt(11111111111111111111111111111111111111113) %3
1

— waTeim
स्रोत

2

C / C ++, 58 बाइट्स (शरीर में 44)

अपरिभाषित व्यवहार को आमंत्रित करता है (टिप्पणियां देखें)

int d(int i){int j=i;while(i&&!(j%(i%10)))i/=10;return!i;}

trueऔर false कर रहे हैं 1 और 0, लेकिन हस्ताक्षर करने के लिए एक चरित्र जोड़ने के लिए एक वापसी के लिए स्वतंत्र महसूस bool।

और मज़े के लिए, एक पुनरावर्ती संस्करण जो छोटा है यदि आप फॉर्म की कॉल की अनुमति देते हैं r(128,128)

संपादित करें : अब नियमों द्वारा अस्वीकृत:

सी / सी ++, 53 बाइट्स (शरीर में 33)

int r(int i,int j){return!i||!(j%(i%10))&&r(i/10,j);}

— etheranger
स्रोत

2

# 1 0 के साथ संख्याओं के लिए एक अस्थायी बिंदु अपवाद के साथ मर जाता है क्योंकि j% (i% 10) i% 10 = 0. के लिए अवैध होगा

— SBI

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

— ईथर

"संकलक-निर्भर यूबी" क्या है? या तो यह यूबी है या यह (और शून्य से विभाजन नहीं है, या बल्कि मोडुलो शून्य है, वास्तव में यूबी है)। UB की अनुमति नहीं दी जानी चाहिए क्योंकि शाब्दिक रूप से कुछ भी हो सकता है। हम मान सकते हैं कि आपका कार्यक्रम एक मशीन पर चलेगा, जो शून्य से एक विभाजन होने पर सभी को उड़ा देगा और उसके चारों ओर मार देगा। अब, मुझे यकीन है कि आप चाहते हैं कि हम सभी जीवित रहें ... सी में कार्यान्वयन-परिभाषित व्यवहार की अवधारणा है, लेकिन शून्य से विभाजित करना इसके अंतर्गत नहीं आता है।

— जीरोन मोस्टर्ट 11

2

@ कैटलेंजर: 0 द्वारा डिवीजन को ऐतिहासिक कारण के लिए फ्लोटिंग पॉइंट अपवाद कहा जाता है: stackoverflow.com/questions/16928942/…

— n

2

@JeroenMostert: मैं इस साइट पर सभी C उत्तरों का 90% से अधिक UB बोलूंगा। जब तक यह साथ काम करता है कुछ पर संकलक कुछ मशीन, जवाब वैध माना जाता है।

— डेनिस

2

आर: 72 67 65

कार्यक्रम

f<-function(a)!(anyNA(a%%(d=as.double(strsplit(paste0(a),"")[[1]])))|sum(a%%d))

बचत के लिए @AlexA और @plannapus को धन्यवाद

परीक्षण चालन

i=c(128,12,120,122,13,32,22,42,212,213,162,204)
for(a in i){print(f(a))}
[1] TRUE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE
[1] FALSE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE

— MickyT
स्रोत

मैं वर्तमान में 72 नहीं, आपके फ़ंक्शन बॉडी में 70 बाइट्स गिनता हूं। लेकिन आप इसे 67 का उपयोग करके प्राप्त कर सकते हैं d=as.double(strsplit(toString(a),"")[[1]]);!(anyNA(a%%d)|sum(a%%d))। :)

— एलेक्स ए।

@AlexA। धन्यवाद। मेरी पहली कोशिशों में से एक wih R। निश्चित रूप से फिर से

— आएगी

@MickyT paste(a)के बजाय toString(a)एक ही परिणाम देता है।

— प्लेनैपस जूल

@plannapus धन्यवाद, स्वच्छ छोटी चाल। यह याद रखना चाहिए कि

— मिकट

1

GNU Awk: 53 वर्ण

गिना भाग:

for(;++i<=split($1,a,//);)r=r||!a[i]||v%a[i];return!r

संपूर्ण कार्य:

function self_divisible(v, i, r)
{
    for (; ++i <= split($1, a, //); )
        r = r || ! a[i] || v % a[i]

    return ! r
}

जैसा कि अक्क के पास कोई बूलियन मूल्य नहीं है, 1 टोर सच और 0 झूठे के लिए देता है।

— आदमी काम पर है
स्रोत

1

जावास्क्रिप्ट (ईएस 6) 30

एक संख्यात्मक पैरामीटर के साथ फ़ंक्शन। % और घटाव का उपयोग करते हुए, विशेष मामले '0' की आवश्यकता नहीं है क्योंकि 0% 0 जावास्क्रिप्ट में NaN है।

सहेजे गए 1 char thx DocMax को संपादित करें

F=n=>[for(d of t=n+'')t-=n%d]&&t==n

सिर्फ मनोरंजन के लिए, नियम हस्ताक्षर का दुरुपयोग करते हुए, हस्ताक्षर हस्ताक्षर नहीं करने के बारे में, 4

Check=(n,t=n+'',q=[for(d of t)n-=t%d])=>t==n

फायरफॉक्स / फायरबग कंसोल में टेस्ट

console.log([128, 12, 120, 122, 13, 32, 22, 42, 212, 213, 162, 204]
.map(x=>+x + ' -> ' + F(x)).join('\n'))

उत्पादन

128 -> true
12 -> true
120 -> false
122 -> true
13 -> false
32 -> false
22 -> true
42 -> false
212 -> true
213 -> false
162 -> true
204 -> false

— edc65
स्रोत

मैं एक स्ट्रिंग इनपुट करने के लिए नहीं कहने जा रहा हूँ।

— मैथ्यू किर्शबाउम

1

फ़ायरफ़ॉक्स कंसोल of(t=n+'')केवल of t=n+''1 को बचाने के लिए के प्रतिस्थापन से खुश है ।

— DocMax

1

PHP: 85 बाइट्स (शरीर पर 64 बाइट्स)

इस फ़ंक्शन को काम करने के लिए, बस एक स्ट्रिंग या एक संख्या पास करें।

0 सही ढंग से झूठे लौटेंगे।

कोड:

function f($n,$i=0){for($n.='';$n[$i]&&$t=!($n%$n[$i++]););return$t&&$i==strlen($n);}

कृपया, 2ND पैरामीटर सेट न करें!

जावास्क्रिप्ट: 76 बाइट्स (शरीर पर 61 बाइट्स)

यह पिछले फ़ंक्शन का पुनर्लेखन है।

दोनों संस्करणों के बीच ज्यादा बदलाव नहीं हुआ।

यहाँ कोड है:

function f(n){for(i=0,n+='';n[i]/1&&(t=!(n%n[i++])););return t&&i==n.length}

पॉलीग्लॉट: जावास्क्रिप्ट + पीएचपी १।। 217 बाइट्स (76 बॉयलरप्लेट के बिना 84 बाइट्स):

मैंने इसे क्यों बनाया?

कारण के कारण और शायद इसलिए कि मैं कर सकता हूँ!

~~बस PHP पर त्रुटि को अनदेखा करें: यह वैसे भी काम करता है!~~
अब आवश्यकता नहीं है, यह 3 बाइट्स को हटाकर ठीक किया गया था।

यहाँ कृति है:

if('\0'=="\0"){function strlen($s){return $s['length'];}}
function toString(){return'';}
function f($n){for($i=0,$n=$n.toString();$n[$i]/1&&($t=!($n%$n[$i++])););return $t&&$i==strlen($n);}

आप अपने सांत्वना और एक PHP दुभाषिया पर इस कोड को चला सकते हैं!

पुराना संस्करण:

if('\0'=="\0"){function strlen($s){return $s['length'];}}
function s($s){return('\0'=="\0")?$s+'':str_replace('','',$s);}
function f($n,$i){for($i=0,$n=s($n);$n[$i]/1&&($t=!($n%$n[$i++])););return $t&&$i==strlen($n);}

— इस्माइल मिगुएल
स्रोत

"और केवल एक संख्यात्मक पैरामीटर में गुजरता है"। इसके बिना आप eval ($ x) कर सकते हैं और पूरे कोड $ x

— abc667

@ abc667 क्षमा करें, लेकिन मुझे नहीं मिला।

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

1

ऑक्टेव, 33 (फ़ंक्शन सेटअप सहित 39)

संख्यात्मक-से-मैट्रिक्स रूपांतरण का उपयोग करना:

f=@(a)sum(mod(a./(num2str(a)-48),1))==0

मैट्रिक्स एक्स द्वारा संख्या तत्व को विभाजित करें, जहां एक्स को स्ट्रिंग में संख्या में परिवर्तित करके और एएससीआईआई मानों से फिर से संख्याओं पर जाने के लिए 48 घटाकर बनाया गया है। प्रत्येक डिवीजन के दशमलव भाग को प्राप्त करने के लिए modulo 1 लें, यह पुष्टि करें कि ये सभी शून्य हैं (यदि कोई 0 / के कारण NaN हैं, तो योग NaN होगा और इसलिए शून्य नहीं है)।

नमूना इनपुट का उपयोग कर www.octave-online.net:

f=@(a)sum(mod(a./(num2str(a)-48),1))==0
for j=[128,12,120,122,13,32,22,42,212,213,162,204]
f(j)
end

आउटपुट:

ans =  1
ans =  1
ans = 0
ans =  1
ans = 0
ans = 0
ans =  1
ans = 0
ans =  1
ans = 0
ans =  1
ans = 0

— Jørgen
स्रोत

हम इसका परीक्षण कैसे कर सकते हैं?

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

octave-online.net - ऊपर से कोड परिभाषा दर्ज करें और फिर (उदाहरण के लिए) f (128)। आउटपुट जोड़ देगा

— जोर्जेन

मुझे कंपाइलर मिल गया था और पूछने से पहले उसने कोशिश की थी। लेकिन यह ठीक काम करता है (को छोड़कर f(123), जो 1, 2 और 3 से विभाज्य है)। लेकिन यह प्रदान किए गए परीक्षण-मामलों के लिए काम करता है।

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

1

MATLAB - 39 वर्ण

function [b] = dividesSelf(i)
b=all(~mod(i,sscanf(num2str(i),'%1d')))
end

— Bastian35022
स्रोत

1

BASH - 117 वर्ण

f(){ [[ $1 =~ 0 ]]&& return 0 || r=;n=$1;for((i=0;i<${#n};i++));do r=$(($r+${n}%${n:$i:1}));done;return $(($r==0));}

परीक्षण

for N in 128 12 120 122 13 32 22 42 212 213 162 204; do
  f $N
  echo "${N} ->  $?"
done

128 ->  1
12 ->  1
120 ->  0
122 ->  1
13 ->  0
32 ->  0
22 ->  1
42 ->  0
212 ->  1
213 ->  0
162 ->  1
204 ->  0

— ब्रायन
स्रोत

1

PHP - 74 71 64 वर्ण

golfed:

function t($n){while($n>1){if(!($b=$n%10)||($n%$b)){return 0;}$n/=10;}return 1;}

कम गोल्फ वाला:

function t($n){
    while($n>1){
        if( !($b=$n%10) || ($n%$b) )
            { return 0; }
        $n/=10;
    }
    return 1;
}

परीक्षण के परिणाम:

(कोड)

$ans = array(128,12,120,122,13,32,22,42,212,213,162,204);
foreach($ans as $a)
{ echo "$a -> ".(t($a)?"True":"False").PHP_EOL; }

(आउटपुट)

128 -> True
12 -> True
120 -> False
122 -> True
13 -> False
32 -> True
22 -> True
42 -> True
212 -> True
213 -> True
162 -> False
204 -> False

— जेपीएमसी
स्रोत

क्या इसके प्रत्येक अंक से एक संख्या विभाज्य है?

आवश्यकताएँ

पर्ल 6, 13

सी # और सिस्टम.लिंक - 26/40

एपीएल ( 13 11)

पायथन 2: 43 वर्ण

पर्ल - 27 बाइट्स

सीजेएम, 11 10 बाइट्स

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

यह काम किस प्रकार करता है

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

पिछला समाधान

जावा 8, 46 बाइट्स (विधि निकाय)

पायथ, 12 बाइट्स

रूबी, 44 बाइट्स (फ़ंक्शन बॉडी: 37)

पायथन - 59 50 49 47 बाइट्स

अजगर ११

बैश + कोरुटिल्स, 44 बाइट्स

आउटपुट:

जे - 14 चार

जावा - 121 102 97 79 78 बाइट्स

हास्केल - 100 54 38

सीजेएम, 15 बाइट्स

वैकल्पिक, 15 बाइट्स भी

सीजेएम, 15 बाइट्स

C89, 43 बाइट्स

C11 - 44 फ़ंक्शन बॉडी में बाइट्स

जूलिया 32 25 23

अंकों का उपयोग करके सुधार किया गया

पुरानी विधि

उत्पादन

बेहतर तरीका भी BigInt संभालता है

C / C ++, 58 बाइट्स (शरीर में 44)

सी / सी ++, 53 बाइट्स (शरीर में 33)

आर: 72 67 65

GNU Awk: 53 वर्ण

जावास्क्रिप्ट (ईएस 6) 30

PHP: 85 बाइट्स (शरीर पर 64 बाइट्स)

जावास्क्रिप्ट: 76 बाइट्स (शरीर पर 61 बाइट्स)

पॉलीग्लॉट: जावास्क्रिप्ट + पीएचपी १।। 217 बाइट्स (76 बॉयलरप्लेट के बिना 84 बाइट्स):

ऑक्टेव, 33 (फ़ंक्शन सेटअप सहित 39)

MATLAB - 39 वर्ण

PHP - 74 71 64 वर्ण