25

आपको इनपुट के रूप में एक सकारात्मक, पूरी संख्या (जिसमें कभी 0 नहीं होगी) दी जाएगी। आपका काम यह जांचना है कि यह लिंच-बेल नंबर है या नहीं।

एक संख्या एक लिंच-बेल संख्या है यदि इसके सभी अंक अद्वितीय हैं और संख्या अपने प्रत्येक अंक से विभाज्य है।

वास्तव में, वास्तव में केवल 548 लिंच-बेल नंबर हैं, इसलिए हार्ड-कोडिंग एक संभावना है, लेकिन लगभग निश्चित रूप से लंबा होगा।

126 एक लिंच-बेल संख्या है, क्योंकि इसके सभी अंक अद्वितीय हैं, और 126 1, 2 और 6 से विभाज्य है।

आप किसी भी सत्य और मिथ्या मूल्य का उत्पादन कर सकते हैं।

उदाहरण:

7 -> truthy
126 -> truthy
54 -> falsy
55 -> falsy
3915 -> truthy

यह OEIS A115569 है ।

code-golf number decision-problem

— Okx
स्रोत

1

सम्बंधित। (एक निर्णय समस्या प्रस्तुत करने के बजाय सभी नंबरों के लिए पूछता है।)

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

2

क्या मैं एक स्ट्रिंग के रूप में इनपुट ले सकता हूं?

— द लीथलकोडर

2

@ TheLethalCoder बेशक आप कर सकते हैं, यह एक मूर्खतापूर्ण सवाल है।

— ओकेक्स

10

@ ओएक्सएक्स सभी चुनौती वाले पोस्टर उनके अनुमत इनपुट में उतने लचीले नहीं हैं जितने कि आप हमेशा पूछने के लायक हैं।

— द लीथलकोडर

27

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

0!=##&@@d&&##&@@((d=IntegerDigits@#)∣#)&

मुझे लगता 0!=##&@@d&&##&@@है कि गणितज्ञ के लिए पठनीयता में एक नई कमी है ...

व्याख्या

यहाँ इस्तेमाल की जाने वाली कुछ मूल सिन्सेटिक चीनी:

& बहुत ही कम पूर्वता है और इसे अनाम फ़ंक्शन में छोड़ दिया है।
&&बस Andऑपरेटर है।
# अनाम एन्कोडिंग निकटतम फ़ंक्शन का तर्क है।
##फ़ंक्शन के सभी तर्कों का एक क्रम है।
@फ़ंक्शन कॉल के लिए उपसर्ग संकेतन है, अर्थात f@x == f[x]।
@@वह है Apply, जो एक सूची के तत्वों को एक फ़ंक्शन के व्यक्तिगत तर्कों के रूप में पास करता है, अर्थात f@@{a,b,c} == f[a,b,c]।

उस रास्ते से बाहर ...

(d=IntegerDigits@#)

यह काफी आत्म-व्याख्यात्मक होना चाहिए: यह हमें इनपुट के दशमलव अंकों की एक सूची देता है और परिणाम को संग्रहीत करता है d।

(...∣#)

यह अपने प्रत्येक अंक (क्योंकि विभाज्यता ऑपरेटर है Listable) द्वारा विभाज्यता के लिए इनपुट का परीक्षण करता है । यह हमें Trues और Falses की सूची देता है ।

...&@@...

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

...&@@d

हम दूसरे फ़ंक्शन को लागू करते हैं d, ताकि अलग-अलग अंकों को अलग-अलग तर्क दिए जाएं। कार्य है 0!=##&, अर्थात । यह जाँचता है कि सभी अंक अलग-अलग हैं (और वे अलग-अलग हैं, लेकिन यह चुनौती से दिया गया है, और यदि ऐसा नहीं होता, तो यह वैसे भी विभाजक नहीं होगा)। वास्तव में केवल 1-बाइट सेवर का उपयोग करने पर ही होता है, और यह काम करता है क्योंकि 1-बाइट तत्व ( ) है जो हम जानते हैं कि मौजूद नहीं है। तो यह पहली चीज जांचती है कि अंक अद्वितीय हैं। चलो इस परिणाम को कहते हैंUnequal[0, d₁, d₂, ...]00!=##&Unequal0U

...&&##

फिर, यह वास्तव में सिर्फ आशुलिपि के लिए है And[U, ##]। ##एक अनुक्रम होने के साथ , प्रारंभिक विभाज्यता जांच से अलग-अलग बूलियन में विस्तार किया जाता है And, इसलिए हमें यह पता चलता है कि दोनों अंक अद्वितीय हैं और प्रत्येक अंक इनपुट को विभाजित करता है।And[U, d₁∣n, d₂∣n, ...]

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

6

##&@@d&&##&@@? वह भी क्या करता है?

— ओकेक्स

@ ओएक्सएक्स ने एक स्पष्टीकरण जोड़ा।

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

आप 0!=द्वारा प्रतिस्थापित किया जा सकता है 0<?

— सर्गियोल जूल

@sergiol मुझे ऐसा करने के लिए अंकों को क्रमबद्ध करना होगा।

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

वास्तव में पठनीयता में नया कम, आम तौर पर मैथेमेटिका कुछ फ़ंक्शन नामों के आसपास सिंटेक्स-चीनी का एक गुच्छा जैसा दिखता है, जिसे मैं समझ सकता हूं, मैं अनजान था कि आप पूरी तरह से चीनी से बाहर एक कार्यक्रम बना सकते हैं: पी (निश्चित रूप से, आपका उत्कृष्ट स्पष्टीकरण मुझे देखते हैं। बेशक यह सभी चीनी नहीं है, लेकिन फिर भी, बहुत प्रभावशाली! "

— mbrig

11

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

lambda n:any(int(n)%int(x)for x in n)or len(n)>len({*n})

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

आउटपुट Falseअगर यह एक लिंच-बेल नंबर है, Trueअन्यथा।

— छड़ी
स्रोत

1

क्या यह इनपुट स्ट्रिंग के रूप में है?

— कैलक्यूलेटरफ्लेन

2

यह दो समस्याएं हैं: 1) यह निर्दिष्ट के रूप में सत्य / गलत जवाब नहीं देता (यह सिर्फ 4 बाइट्स है!)। 2) यह "10" इनपुट पर एक अपवाद फेंकता है। अन्यथा, बहुत अच्छा और संक्षिप्त!

— सीआर ड्रॉस्ट

@ कैलाकुलरफलाइन हाँ।

— सीआर ड्रॉस्ट

@CRDrost 1) अच्छी तरह से परिभाषित किया गया है, इसलिए कोई समस्या नहीं है (आमतौर पर 2) 0इनपुट में कभी नहीं होगा

— रॉड

1

1) मेरा मतलब है, एक समस्या है, जो यह है कि उन्होंने एक्स के लिए कहा और आपने नहीं दिया। 2) आह, तुम पूरी तरह से सही हो, मैं पूरी तरह से याद किया।

— सीआर ड्रॉस्ट

8

ब्रेकीलॉग , 10 बाइट्स

≠g;?z%ᵐ=h0

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

व्याख्या

≠             All digits are different
 g;?z         Zip the input with each of its digits
     %ᵐ       Map mod
       =      All results are equal
        h0    The first one is 0

— Fatalize
स्रोत

6

सी #, 87 83 बाइट्स

using System.Linq;s=>s.Distinct().Count()==s.Length&s.All(c=>int.Parse(s)%(c-48)<1)

^{मैंने इसे विजुअल स्टूडियो में परीक्षण से पहले नोटपैड में लिखा था, जहां यह ठीक काम करता था, इसलिए मुझे एहसास हुआ कि मैं अब बेवकूफ हूं ...}

पूर्ण / स्वरूपित संस्करण:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<string, bool> f = s => s.Distinct().Count() == s.Length
                                  & s.All(c => int.Parse(s) % (c - 48) < 1);

        Console.WriteLine(f("7"));
        Console.WriteLine(f("126"));
        Console.WriteLine(f("54"));
        Console.WriteLine(f("55"));
        Console.WriteLine(f("3915"));

        Console.ReadLine();
    }
}

— TheLethalCoder
स्रोत

5

— आज्ञाकारी

6

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

s=>![...s].some((e,i)=>s%e|s.search(e)<i)

इनपुट को एक स्ट्रिंग के रूप में लेता है और रिटर्न trueया falseउपयुक्त के रूप में। संपादित करें: @RickHitchcock के लिए 1 बाइट धन्यवाद सहेजा गया। अन्य संस्करण:

एक स्ट्रिंग के रूप में इनपुट लेता है और 40 बाइट्स के लिए रिटर्न ( 0या 1तार्किक उलटा) देता है:

s=>/(.).*\1/.test(s)|[...s].some(e=>s%e)

इनपुट को एक संख्या के रूप में लेता है और 43 बाइट्स के लिए 0या रिटर्न करता है 1:

n=>/(.).*\1/.test(n)|[...''+n].some(e=>n%e)

इनपुट को एक संख्या के रूप में लेता है और 45 बाइट्स के लिए 1या रिटर्न करता है 0:

n=>!/(.).*\1/.test(n)&![...''+n].some(e=>n%e)

— नील
स्रोत

मैं बैक-संदर्भित के लिए \ n विकल्प से अपरिचित था। +1। आप बाइट को बचाने के लिए टेस्ट लॉजिक को किसी विधि में ले जा सकते हैं:s=>![...s].some((e,i)=>s%e|s.search(e)<i)

— रिक हिचकॉक

जब मैंने उपयोग किया तो [...new Array(9999999)].map((_,n)=>n+1+"").filter(s=>![...s].some((e,i)=>s%e|s.search(e)<i)).lengthमुझे 5081उम्मीद के बजाय मिला 548, इसलिए यह लिखित रूप में सही नहीं है। वास्तव में तंग कोड, हालांकि।

— सीआर ड्रॉस्ट

क्षमा करें, मैं इस बारे में अपनी टिप्पणी को सही नहीं मान रहा हूं। मेरा परीक्षण कोड सही नहीं है क्योंकि मूल पोस्टर को उम्मीद है कि शून्य को पहले ही फ़िल्टर किया जा चुका है। एक अतिरिक्त के साथ .filter(x => x.indexOf('0')===-1)यह 548 रिटर्न के रूप में वादा किया गया है।

— CR Drost

6

जेली , 6 4 बाइट्स

Dg⁼Q

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

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

Dg⁼Q  Main link. Argument: n

D     Decimal; convert n to base 10.
 g    Take the GCD of each decimal digit k and n.
      For each k, this yields k if and only if k divides n evenly.
   Q  Unique; yield n's decimal digits, deduplicated.
  ⁼   Test the results to both sides for equality.

— डेनिस
स्रोत

3

gQV=यदि आप ASCII- केवल समाधान पसंद करते हैं, तो भी है ।

— डेनिस

5

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

रिटर्न Falseएक नंबर एक लिंच बेल संख्या है जब। इनपुट के रूप में तार लेता है। मेरे साथ आया, लेकिन रॉड के समान है। मैंने उनकी पोस्ट के नीचे टिप्पणी की होगी, लेकिन अभी तक मेरी कोई प्रतिष्ठा नहीं है।

lambda s:len({*s})<len(s)+any(int(s)%int(c)for c in s)

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

— C मैकवायो
स्रोत

2

PPCG में आपका स्वागत है!

— स्टीफन

स्वागत हे! रॉड की तरह, आपका फ़ंक्शन इनपुट "10" पर एक अपवाद फेंकता है।

— सीआर ड्रॉस्ट

1

@CRDrost "आपको इनपुट के रूप में एक सकारात्मक, पूरी संख्या (जिसमें कभी 0 नहीं होगी) दी जाएगी।"

— सी मैकएवॉय

ठीक है, मैंने हर जगह टिप्पणियां पोस्ट की हैं, मैंने इस बारे में शिकायत की है, लेकिन मैं स्पष्ट रूप से इस एक को याद करता हूं। क्षमा करें, पीछे हटा!

— CR Drost

@CRDrost कोई चिंता नहीं!

— C मैकआवॉय

2

जेली , 8 बाइट्स

D⁼QaDḍ$Ạ

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

— आउटगोल्फर को एरिक करें
स्रोत

2

PHP, 62 48 बाइट्स

while($i=$argn[$k++])$r|=$argn%$i|$$i++;echo!$r;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया उसका परीक्षण करें । झूठा के लिए खाली उत्पादन, सच्चाई के 1लिए।

टूट - फूट

while($i=$argn[$k++])   # loop through digits
    $r|=                    # set $r to true if
        $argn%$i            # 1. number is not divisible by $i
        |$$i++;             # 2. or digit has been used before
echo!$r;                # print negated $r

— टाइटस
स्रोत

2

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

(#)=<<show
(d:r)#n=notElem d r&&mod n(read[d])<1&&r#n
_#_=0<3

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

एक अनाम फ़ंक्शन को परिभाषित करता है (#)=<<show, जो एक नंबर, रिटर्न Trueया देता है False।

— Laikoni
स्रोत

यह फ़ंक्शन इनपुट पर विफल रहता है।

— CR Drost

क्षमा करें, मैं इसके बारे में गलत हूं - मैंने याद किया कि आपको उन इनपुट के लिए कोई उत्तर देने की आवश्यकता नहीं है जिनके पास 0s हैं।

— CR Drost

2

05AB1E , 4 बाइट्स

ÑÃÙQ

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

संबंधित प्रश्न के उत्तर के रूप में समान एल्गोरिथ्म ।

— ग्रिमी
स्रोत

1

05AB1E , 8 बाइट्स

SÖP¹DÙQ*

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

1

मैथेमेटिका, 57 बाइट्स

Tr@Boole[IntegerQ/@Union[s=#/IntegerDigits@#]]==Length@s&

— J42161217
स्रोत

1

यदि आप IsLynchBellNumber

— बिलिन का

1

आप मार्टिन को एक ही प्रस्ताव क्यों नहीं देते?

— 1542 पर J42161217

@ ओकेएक्स लेकिन यह उस तरह से कम मजेदार है।

— QBrute

@Qrute क्या आप एक चुटकुला ले सकते हैं?

— ओकेक्स

1

@ ओएक्सएक्स यह अधिक विश्वसनीय होगा LynchBellNumberQ। ;)

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

1

अजगर २ , 66 बाइट्स

यह पायथन 2 में एक समाधान है, जिसका पूरा उद्देश्य Trueसत्य के लिए और झूठे के लिए उत्पादन करना है False:

lambda n:len(set(n))==len(n)and not any((int(n)%int(x)for x in n))

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

— श्री Xcoder
स्रोत

1

हास्केल, २६० २४१ 201 162 बाइट्स

f([x])=1<2
f(x:xs)=not(x`elem`xs)&&(f xs)
r n i= n`mod`(read[(show n!!i)]::Int)==0
q n 0=r n 0 
q n i=r n i&&q n(i-1)
p n=length(show n)-1
s n=q n(p n)&&f(show n)

व्याख्या

f ([x]) = True                                           f function checks for                                                       
f (x:xs) = not(x `elem` xs) && (f xs)                    repeated digits              
r n i = n `mod` (read [(show n !! i)] :: Int) == 0       checks whether num is 
                                                         divisible by i digit
q n 0 = r n 0                                            checks wether n divisible
q n i = r n i && q n (i-1)                               by all of its digits                             
p n = length (show n) -                                  gets length of number                             
s n = (q n (p n)) && (f (show n))                        sums it all up!!!

लाईकोनी के लिए काफी छोटा है

— सर्गी मार्टीनेंको जूनियर
स्रोत

1

विशेष रूप से PPCG और हास्केल गोल्फ में आपका स्वागत है! इस उत्तर को बहुत कम रिक्त स्थान को हटाकर काफी छोटा किया जा सकता है, जैसे कि समान संकेतों के आसपास या कोष्ठक के बगल वाले।

— लकोनी

1

आप हास्केल में गोल्फिंग के लिए टिप्स और हास्केल में गाइडिंग टू गोल्फिंग रूल्स के बारे में भी जान सकते हैं ।

— लकोनी

आपकी सलाह के लिए @ लिकोनी थैंक्स! मैं इसे देख रहा हूँ

— सर्गी मार्टीनेंको जूनियर

1

जाप , 15 14 11 10 9 बाइट्स

ì®yUÃ¥Uìâ

कोशिश करो

— झबरा
स्रोत

©!-> «1 बाइट के लिए

— जस्टिन मैरिनर

धन्यवाद, @JustinMariner; पता नहीं कैसे देखा जा रहा है बिना इतना लंबा चला गया! मुझे एक छोटा समाधान मिला, हालाँकि।

— झबरा

0

नीम , 9 बाइट्स

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

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

-2 ओक्स के लिए धन्यवाद ।

हम्म, एक अच्छा समरूपता है ... oO.O.O.Oo

— आउटगोल्फर को एरिक करें
स्रोत

आप गोल्फ कर सकते हैं 𝐂D𝐮𝔼करने के लिए 𝐮ℚ(uniquify, समानता अनदेखी प्रकार के लिए चेक)

— Okx

अभी भी वहाँ गोल्फ के लिए कमरा;)

— ओक्स

@ ओक्स हम्म ... मुझे वहां कुछ खास दिलचस्प नहीं लगता।

— आउटगॉल्फ जूल

0

पर्ल 6 , 27 बाइट्स

{$_%%.comb.all&&[!=] .comb}

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

.combएक विधि है, जब कोई तर्क नहीं दिया जाता है, अपने व्यक्तिगत वर्णों में एक स्ट्रिंग को विभाजित करता है। एक संख्या को स्पष्ट रूप से एक स्ट्रिंग में परिवर्तित किया जाता है, और इसी तरह.comb इसके अंक वापस आ जाते हैं।
.comb.all सभी अंकों का एक-जंक्शन है।
$_ %% .comb.all$_इसके सभी अंको द्वारा इनपुट तर्क की विभाज्यता का जंक्शन है । उदाहरण के लिए, यदि $_है 123, तो जंक्शन है all(True, False, True), जो Falseएक सत्य संदर्भ में ढह जाता है।
[!=] .comb!=ऑपरेटर के साथ इनपुट तर्क के अंकों को कम करता है , जो मूल्यांकन करता है Trueकि क्या अंक सभी भिन्न हैं।

— शॉन
स्रोत

0

रेटिना , 37 बाइट्स

(.).*\1
0
.
<$&$*1>$_$*
<(1+)>\1+

^$

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

— नील
स्रोत

0

रूबी 2.4, 42 बाइट्स

->x{(r=x.digits)|[]==r&&r.none?{|f|x%f>0}}

(कोई TIO अभी तक, क्षमा करें)

— जीबी
स्रोत

0

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

CJam गोल्फ भाषाओं का जावा है। यह जावा में भी व्याख्या की गई है!

{_Ab__L|=@@f%:+>}

स्पष्टीकरण:

{   e# Stack:              3915
_   e# Duplicate:          3915 3915
Ab  e# Digits in base 10:  3915 [3 9 1 5]
__  e# Duplicate twice:    3915 [3 9 1 5] [3 9 1 5] [3 9 1 5]
L|  e# Remove duplicates:  3915 [3 9 1 5] [3 9 1 5] [3 9 1 5]
=   e# Test equality:      3915 [3 9 1 5] 1
@@  e# Rotate twice:       1 3915 [3 9 1 5]
f%  e# Modulo each:        1 [0 0 0 0]
:+  e# Sum:                1 0
>   e# Greater than:       1
}   e# Output:             1 (truthy)

— फल तोड़ना
स्रोत

0

वीबीएसस्क्रिप्ट, 177 बाइट्स

हे सब, यह मेरी पहली सीजी पोस्ट है, और पहला प्रयास है, इसलिए आशा है कि मैंने सभी नियमों का पालन किया है ...

Function L(s)
dim i,j,k,m,n
j = Len(s)
redim a(j)
n = 0
for i = 0 to j-1
   A(i) = Mid(s,i+1,1)   
   m = m + s Mod A(i)   
   if j = 1 then         
   else                             
        for k = 0 to i - 1        
            if A(i)  = A(k) then n = n + 1   
        next
   end if
next
if m + n = 0 then L = "y" else L = "n"
End Function

इसे नोटपैड से अंत में एक लाइन जोड़कर चलाया जा सकता है

Msgbox L(InputBox(""))

और फिर इसे .vbs के रूप में सहेजना, फिर डबल क्लिक करें।

स्पष्टीकरण:

Function L(s)                  'creates the function "L" taking test number as input
dim i,j,k,t,m,n                'variables
j = Len(s)                     '"j" gets length of test number
redim a(j)                     'creates array "a", size is length of test number 
n = 0                          'sets repeat character counter "n" to zero
for i = 0 to j-1               'for length of string
   A(i) = Mid(s,i+1,1)         'each array slot gets one test number character
   m = m + s Mod A(i)          '"m" accumulates moduli as we test divisibility of each digit
   if j = 1 then               'if test number is of length 1, it passes (do nothing)
   else                        'otherwise, gotta test for repeats     
        for k = 0 to i - 1     'for each digit already in array, test against current digit   
            if A(i)  = A(k) then n = n + 1  
                               'repeat char counter "n" stores no of repeats  
        next                   'proceed through array looking for repeat  
   end if
next                           'test next digit for divisibility and repeats
if m + n = 0 then L = "y" else L = "n"      
                               'check for any repeats and moduli,
                               'then return yes or no for LynchBelledness
End Function

VBScript गोल्फिंग के लिए एक कुंद साधन है, लेकिन हे, मैंने रूबी को अभी तक नहीं सीखा है ...

— आआआआ आआआआ
स्रोत

क्या आप 'एल = "वाई" जैसे कुछ

— व्हाट्सएप को

तकनीकी रूप से, हाँ! मुझे यह करना चाहिए कि ... btw, मैं कोडगॉल्फ भाषाओं को देख रहा हूं, जो सीखने के लिए शांत हो सकती हैं, लेकिन अधिकांश के लिए, प्रलेखन गैर-मौजूद होने के लिए न्यूनतम है ... क्या कोई अच्छी भाषा की सिफारिश कर सकता है जो अच्छी तरह से प्रलेखित है? कोशिश कर रहा था "वास्तव में / गंभीरता से" लेकिन डॉक्टर की कमी के कारण कुछ बाधाओं को मारा ....

— Aaaaa Aaaa

0

पीएचपी , 51 बाइट्स

सत्य के लिए शून्य और झूठ के लिए शून्य

for(;$c=$argn[$i++];$$c=1)$t|=$$c||$argn%$c;echo$t;

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

PHP , 62 बाइट्स

सत्य के लिए शून्य और झूठ के लिए शून्य

for($a=$argn;$c=$a[$i];)$t|=strpos($a,$c)<+$i++||$a%$c;echo$t;

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

— जार्ग हुल्सरमन
स्रोत

0

अजगर , 10 बाइट्स

qiRQKjQT{K

सभी परीक्षण मामलों की जाँच करें।

कैसे?

qiRQKjQT {K ~ पूर्ण कार्यक्रम।

     jQT ~ इनपुट के दशमलव अंकों की सूची।
    K ~ एक चर K को असाइन करें।
 iRQ ~ प्रत्येक दशमलव अंक के लिए ...
 i Q ~ ... इनपुट के साथ ही सबसे बड़ा सामान्य भाजक प्राप्त करें।
        {K ~ K डुप्लिकेट तत्वों को हटा दिया गया।
q ~ बराबर है? आउटपुट निहित है।

अजगर , 11 बाइट्स

&!f%sQsTQ{I

सभी परीक्षण मामलों की जाँच करें।

कैसे?

और! f% sQsTQ {I ~ पूर्ण कार्यक्रम, निहित इनपुट के साथ।

  f Q ~ इनपुट स्ट्रिंग पर फ़िल्टर करें।
   % sQsT ~ इनपुट एक पूर्णांक में परिवर्तित होकर वर्तमान अंक को मापता है।
             ~ इसे रखता है यदि यह 0 से अधिक है, और इसे अन्यथा छोड़ देता है।
 ! ~ नकार। यदि सूची खाली है, तो सही है, अन्यथा गलत है।
& {I ~ और डिडुप्लिकेटिंग के तहत इनपुट अनियंत्रित है? आउटपुट निहित है।

— श्री Xcoder
स्रोत

0

पर्ल 5 , 34 बाइट्स

-pध्वज के लिए कोड + 1 के 33 बाइट्स

$n=$_;$\|=$n%$_|$k{$_}++for/./g}{

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

सत्य के 0लिए आउटपुट , मिथ्या के लिए कोई अन्य संख्या

— Xcali
स्रोत

0

कोटलिन 1.1, 98 66 59 बाइट्स

{i->i.none{i.toInt()%(it-'0')>0}&&i.length==i.toSet().size}

सजा हुआ

{i ->
    // None of the digits are not factors
    i.none { i.toInt() % (it-'0') > 0 }
    // AND
    &&
    // None of the digits are repeated
    i.length == i.toSet().size
}

परीक्षा

var L:(String)-> Boolean =
{i->i.none{i.toInt()%(it-'0')>0}&&i.length==i.toSet().size}
data class TestData(val input: String, val output: Boolean)

fun main(args: Array<String>) {
    var inputs = listOf(
        TestData("7", true),
        TestData("126", true),
        TestData("54", false),
        TestData("55", false),
        TestData("3915", true)
    )

    for (test in inputs) {
        if (L(test.input) != test.output) {
            throw AssertionError(test.toString())
        }
    }
    println("Test Passed")
}

— jrtapsell
स्रोत

0

एपीएल (डायलॉग यूनिकोड) , 24 बाइट्स

{((,⍵)≡∪⍵)×∧/0=(⍎¨⍵)|⍎⍵}

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

सरल Dfn, शायद थोड़ा अधिक गोल्फ हो सकता है। सत्य के लिए यील्ड मानक एपीएल बूलियन 1, मिथ्या के लिए 0।

यह उल्लेख के लायक है कि यह फ़ंक्शन तर्कों के बजाय तर्कों के रूप में तर्क लेता है।

किस तरह:

{((,⍵)≡∪⍵)×∧/0=(⍎¨⍵)|⍎⍵} ⍝ Dfn, argument ⍵.
                      ⍎⍵  ⍝ Convert ⍵ to integer
                     |    ⍝ Modulus
                (⍎¨⍵)     ⍝ Each digit in ⍵
              0=          ⍝ Equals 0? Returns a vector of booleans
            ∧/            ⍝ Logical AND reduction
           ×              ⍝ multiplied by (the result of)
  (     ∪⍵)               ⍝ unique elements of ⍵
       ≡                  ⍝ Match
   (,⍵)                   ⍝ ⍵ as a vector; the Match function then returns 1 iff all digits in ⍵ are unique

— जे। सल्ल
स्रोत

0

जूलिया 1.0 , 39 बाइट्स

f(x,d=digits(x))=rem.(x,d)==0*unique(d)

rem.(x,d)एक वेक्टर है जिसमें प्रत्येक अंक द्वारा x को विभाजित करने के बाद अवशेष होते हैं x। 0*unique(d)सभी शून्य मानों के साथ अद्वितीय अंकों की संख्या के बराबर लंबाई वाला एक वेक्टर है। जाँच करें कि क्या वे समान हैं।

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

— gggg
स्रोत

0

माणिक-एन , 40 बाइट्स

p gsub(/./){$'[$&]||$_.to_i%$&.hex}<?0*8

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

एक स्ट्रिंग के रूप में संख्या में पढ़ें। प्रत्येक वर्ण (अंक) को उस वर्ण की बाद की घटना के साथ प्रतिस्थापित करें, यदि मौजूद है, या उस अंक की पूरी संख्या modulo है। यह केवल 0अगर और यह एक लिंच-बेल संख्या है, तो केवल एस की एक स्ट्रिंग में परिणाम होगा । क्यूं कर? यदि कोई दोहराया गया अंक है, तो अंतिम का प्रत्येक उदाहरण समान रहता है, और चूंकि इनपुट में शून्य नहीं है अर्थात गैर-शून्य अंक है। अन्यथा, हम अभी जाँच रहे हैं कि क्या प्रत्येक अंक समान रूप से संख्या को विभाजित करता है।

चूँकि कोई 8 या अधिक अंक लिंच-बेल संख्याएँ नहीं हैं (औपचारिक प्रमाण: OEIS ऐसा कहता है), यह जाँचना कि क्या परिणामी स्ट्रिंग लेक्सिकोग्राफ़िक रूप से पहले की तुलना में स्ट्रिंग '00000000'की जाँच करने के बराबर है कि क्या यह सभी शून्य है।

— histocrat
स्रोत

0

आर , 86 बाइट्स

x=scan(,'');a=as.double;all(table(utf8ToInt(x))==1)&&all(!a(x)%%a(el(strsplit(x,""))))

एक स्ट्रिंग के रूप में इनपुट लेता है। मुझे निश्चित रूप से ऐसा लग रहा है कि यह गोल्फ का खेल है।

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

— Sumner18
स्रोत

क्या यह लिंच-बेल नंबर है?

उदाहरण:

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

व्याख्या

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

ब्रेकीलॉग , 10 बाइट्स

व्याख्या

सी #, 87 83 बाइट्स

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

जेली , 6 4 बाइट्स

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

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

जेली , 8 बाइट्स

PHP, 62 48 बाइट्स

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

05AB1E , 4 बाइट्स

05AB1E , 8 बाइट्स

मैथेमेटिका, 57 बाइट्स

अजगर २ , 66 बाइट्स

हास्केल, २६० २४१ 201 162 बाइट्स

जाप , 15 14 11 10 9 बाइट्स

नीम , 9 बाइट्स

पर्ल 6 , 27 बाइट्स

रेटिना , 37 बाइट्स

रूबी 2.4, 42 बाइट्स

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

स्पष्टीकरण:

वीबीएसस्क्रिप्ट, 177 बाइट्स

पीएचपी , 51 बाइट्स

PHP , 62 बाइट्स

अजगर , 10 बाइट्स

कैसे?

अजगर , 11 बाइट्स

कैसे?

पर्ल 5 , 34 बाइट्स

कोटलिन 1.1, 98 66 59 बाइट्स

सजा हुआ

परीक्षा

एपीएल (डायलॉग यूनिकोड) , 24 बाइट्स

किस तरह:

जूलिया 1.0 , 39 बाइट्स

माणिक-एन , 40 बाइट्स

आर , 86 बाइट्स