कितने लिंच-बेल नंबर हैं?

19

चुनौती

एक पूर्णांक को देखते हुए n, इनपुट के रूप में, जहां 36 >= n >= 2आधार में कितने लिंच-बेल संख्या आउटपुट हैं n।

आउटपुट बेस 10 में होना चाहिए।

लिंच-बेल नंबर

एक संख्या एक लिंच-बेल संख्या है यदि:

  • इसके सभी अंक अद्वितीय हैं (अंकों की पुनरावृत्ति नहीं)
  • संख्या अपने प्रत्येक अंक से विभाज्य है
  • इसके अंकों में से एक के रूप में शून्य नहीं है

चूंकि, सभी अंकों का विशिष्ट होना आवश्यक है, और आपके पास प्रत्येक आधार में एकल अंकों की संख्याओं का एक निश्चित सेट है, लिंच-बेल संख्याओं की एक परिमित संख्या है।

उदाहरण के लिए, आधार 2 में केवल एक लिंच-बेल नंबर है 1, क्योंकि अन्य सभी संख्याएं या तो अंकों को दोहराती हैं या 0 होती हैं।

उदाहरण

Input > Output
2 > 1
3 > 2
4 > 6
5 > 10
6 > 10
7 > 75
8 > 144
9 > 487
10 > 548

Mathematica Online आधार से ऊपर की मेमोरी से बाहर चला गया। आप अपना खुद का जेनरेट करने के लिए निम्न कोड का उपयोग कर सकते हैं:

Do[Print[i," > ",Count[Join@@Permutations/@Rest@Subsets@Range[#-1],x_/;And@@(x\[Divides]FromDigits[x,#])]&[i]],{i,10,36,1}]

जीतना

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf  number  base-conversion 
— बीटा डिके
स्रोत
1
@MagicOctopusUrn हमें एक शब्दकोश की आवश्यकता क्यों है? हमें उस बेस में आउटपुट की आवश्यकता नहीं है।
— user202729
2
क्या आप एक उदाहरण जोड़ सकते हैं >10?
— रॉड
1
@JonathanAllan मैं देख रहा हूं, मैंने अब साफ़ कर दिया है कि
— बीटा
3
यदि केवल [2-36] का समर्थन किया जाए तो हम उन सभी को सूचीबद्ध कर सकते हैं।
— जोनाथन एलन
3
पता चलता है कि कोई भी गणना करने में कामयाब नहीं हुआ है f(36)। इसके आधार पर सबसे तेज़-चुनौती बनाना संभवत: दिलचस्प होगा।
— user202729

जवाबों:

8

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

Q⁼g
*`Ṗ©bç"®S

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

एक और ओ (एन एन ) समाधान।

व्याख्या

Q⁼g  Helper link. Input: digits (LHS), integer (RHS)
Q    Unique (digits)
 ⁼   Match
  g  GCD between each digit and the integer

*`Ṗ©bç"®S  Main link. Input: integer n
*`         Compute n^n
  Ṗ        Pop, forms the range [1, n^n-1]
   ©       Store previous result in register
    b      Convert each integer to base n
     ç"    Call the helper link, vectorized, with
       ®   The register's value
        S  Sum
— मील की दूरी पर
स्रोत
16 बाइट्स ṖŒPḊŒ!€Ẏ⁼g¥"ḅ¥³Sऔर तेज़
— मीलों
5

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

*ḃ€’Q€Qḍḅ¥€⁸Ạ€S

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

जटिलता ।O(nn)

— लीक नन
स्रोत
5
केवल कोड-गोल्फ में एक O(N^N)समाधान न केवल स्वीकार्य है, बल्कि अच्छा है।
— DJMcMayhem
5
@DJMcMayhem Meh, मुझे लगता है कि हम उन नंबरों को पंप कर सकते हैं और प्राप्त कर सकते हैंO(N↑↑N)
— Beta Decay
क्या ऐसा O(N^(N+1))इसलिए होना चाहिए क्योंकि प्रत्येक उत्पन्न संख्या की वैधता की जाँच करें O(N)? (हालांकि मैं जेली को नहीं समझता)
— user202729
@ user202729 N + 1 बिग-ओ नोटेशन में सिर्फ N है।
— मलबिग
1
बेशक @mbrig मुझे समझ में बड़ा-ओ अंकन, कि ( N+1में है O(N)) का तात्पर्य यह नहीं है N^(N+1)में है O(N^N)।
— user202729
3

जावा, 222 212 190 बाइट्स

-10 बाइट्स हरमन को धन्यवाद

-22 बाइट्स केविन की बदौलत

import java.util.*;a->{int c=0,i=1;A:for(;i<Math.pow(a,a);i++){Set g=new HashSet();for(char b:a.toString(i).toCharArray())if(!g.add(b)|b<49||i%a.parseInt(b+"",a)>0)continue A;c++;}return c;}

Ungolfed:

a -> {
    int count = 0;
    OUTER:
    for (int i = 1; i < Math.pow(a, a); i++) {
        Set<Character> found = new HashSet<>();
        for (char b : Integer.toString(i, a).toCharArray()) {
            if (!found.add(b) || b == 48 || i % Integer.parseInt(b + "", a) != 0) {
                continue OUTER;
            }
        }
        count++;
    }
    return count;
}

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

बड़ी संख्या के लिए बहुत धीमा हो जाता है।

— Okx
स्रोत
-10 बाइट्स:a->{int c=0,i=1;A:for(;i<Math.pow(a,a);i++){java.util.Set<Character>g=new java.util.HashSet<>();for(char b:Long.toString(i,a).toCharArray())if(!g.add(b)|b<49||i%Long.parseLong(b+"",a)>0)continue A;c++;}return c;}
— हरमन एल
पहली बार मैंने एक कोडगॉल्फ उत्तर में प्रयुक्त एक लेबल देखा है
— जस्टिन
A:और continue A;१३ बाइट्स हैं जबकि {--c;break;}१२ है। क्या मैं कुछ बग को नहीं देख पाऊंगा?
— जॉलीजोकर
यह एक अलग उत्तर के लायक हो सकता है, लेकिन आप प्रत्येक अंक i%aऔर i/=aप्रत्येक लूप द्वारा आधार n में अंकों के माध्यम से लूप कर सकते हैं । आप सेट का उपयोग करके int[]और जाँच कर सकते हैं किx[b]++<2
— जॉलीजोकर
java.util.Set<Character>‌​g=new java.util.HashSet<>();हो सकता है import java.util.*;+ Set g=new HashSet();; Long.toStringहो सकता है a.toString; और Long.parseLongहो सकता है a.parseInt।
— केविन क्रूज़सेन
3

पर्ल 6 , 86 84 77 बाइट्स

-2 बाइट्स रामलीज की बदौलत

->\n{n-1+grep {.Set==$_&&.reduce(* *n+*)%%.all},map {|[X] (1..^n)xx$_},2..^n}

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

TIO पर n = 8 के लिए काम करता है।

— nwellnhof
स्रोत
1
मुझे लगता है कि आप .allइसके बजाय 2 बाइट्स बचा सकते हैं all $_।
— रामलीज
2

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

;╗DR⌠╜DR╨i⌡M⌠;╜@¿♀%ΣY⌡MΣ

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

व्याख्या

इस कार्यक्रम में दो मुख्य भाग होते हैं: क्रमपरिवर्तन पीढ़ी, और लिंच-बेल परीक्षण। इसलिए, यह स्पष्टीकरण प्रत्येक भाग को अलग से, अधिक स्पष्टता के लिए देखेगा।

क्रमपरिवर्तन उत्पन्न करना

इनपुट: n(पूर्णांक में [2, 36])

आउटपुट: सभी आंशिक और कुल क्रमपरिवर्तन [1, n-1]( [1, n-1]बिना दोहराव के जिनकी लंबाई वाले मानों से युक्त अनुक्रम [1, n-1])

;╗DR⌠╜DR╨i⌡M
;╗            store a copy of n in register 0
  DR          range(1, n)
    ⌠╜DR╨i⌡M  do the following for each element k in range:
     ╜DR        range(1, n)
        ╨       k-permutations of [1, n-1]
         i      flatten

लिंच-बेल टेस्ट

इनपुट: आधार- nपूर्णांक की एक सूची , जो आधार- nअंकों की सूची के रूप में दर्शायी जाती है

आउटपुट: आधार में लिंच-बेल की संख्या n

⌠;╜@¿♀%ΣY⌡MΣ
⌠;╜@¿♀%ΣY⌡M   for each base-n digit list a:
 ;╜             duplicate a, push n
   @¿           convert a from base-n to decimal
     ♀%         modulo a with each of its base-n digits
       Σ        sum
        Y       boolean negation (1 if all modulo results are 0, else 0)
           Σ  sum (count the 1s in the resultant list)
— मै जाऊं
स्रोत
2

मैथेमेटिका, 82 79 76 बाइट्स

Count[Join@@Permutations/@Subsets@Range[#-1],x_/;x==x~FromDigits~#~GCD~x]-1&
— user202729
स्रोत
आप इसमें एक नंबर कैसे पास करते हैं? (क्षमा करें, गणितज्ञ मेरे लिए नया है)
— बीटा
फ़ंक्शन को पेस्ट करें (जैसे, वुल्फराम सैंडबॉक्स को), और उसके [<parameter>]बाद डाल दिया । parameterएक नंबर होने के साथ ।
— user202729
क्या आप एक TIO, या समकक्ष जोड़ सकते हैं?
— Shaggy
1
— बीटा डिके
1
क्या f (5) और f (6) दोनों वास्तव में 10 हैं? यह अजीब है ...
— मैजिक ऑक्टोपस Urn
1

05AB1E , 22 बाइट्स

mLIBε0KÙ}ÙvyIöySIö%O_O

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

O_O जब यह अंत में काम किया मेरा चेहरा भी था।

<ÝIBJ0Kæ¦Ù€œ˜ जिस तरह से मैं वास्तविक उत्तर में संख्याओं को उत्पन्न करने के लिए उपयोग करता हूं उससे अधिक तेज है, लेकिन 7 से अधिक (स्पष्ट कारण के लिए) यादृच्छिक रूप से काम करना बंद कर देता है?

व्याख्या

mLIBε0KÙ}ÙvyIöySIö%O_O # (input = i)
m                      # Push i^i
 L                     # ...and get a range from one to this value
  IB                   # Map every element to their base i representation
    ε   }              # Map every element to ...
     0K                 # Itself without 0s
       Ù                # ...and only unique digits
         Ù             # Uniquify the resulting list
          v            # For each element...
           yIö          # Push it converted to base 10
              ySIö      # Push every digit of it converted to base 10 in a list
                  %     # Calculate the modulo for each digit
                   O    # Sum all results together
                    _   # Negate: Returns 0 for every positive number and 1 for 0
                     O  # Sum with the rest of the stack (Basically counting all Lynch-Bell-Numbers)
                       # Implicit print
— Datboi
स्रोत
मुझे पूरा यकीन है कि एक अलग दृष्टिकोण अधिक बाइट्स को बचा सकता है, लेकिन आपके वर्तमान समाधान में एक बाइट को बचाने के लिए ε0KÙ}हो सकता 0м€Ùहै।
— केविन क्रूज़सेन
1

पर्ल 5, 80 76 बाइट्स (75 + -p)

$\+=!grep$_?$;%$_|$|{0,$_}++:1,@@until($@[$}++]+=1)%=$_ and++$;,$}=$}==$_}{

$;मज़े और लाभ के लिए गाली देना । इनपुट्स> 8 पर टाइम्स आउट करें।

संपादित करें: दो छोरों को मर्ज करके -4 बाइट्स।

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

रूबी , 80 65 बाइट्स

->n{(1..n**n).count{|i|(d=i.digits n)-[0]==d|d&&d.sum{|j|i%j}<1}}

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

-15 बाइट्स के लिए GB का धन्यवाद।

— किरिल एल।
स्रोत
यह n> 10 ("j.to_i" के कारण) के लिए काम नहीं करेगा
— GB
अच्छा कैच, इससे पहले भी कई बार खराब। :)
— किरिल एल।
वैसे भी: आप आधार को तर्क के रूप में पास करने वाले "अंकों" को कह सकते हैं और बहुत बचा सकते हैं: `-> n {(1.. ** ** n) .count {| i | (d = i.digits n) - [0] == d | d && d.sum! {| j | i% j} <0}} `
— GB
वास्तव में मैं पूरी तरह से चूक गया था कि अंकों में यह पैरामीटर है। लेकिन मुझे लगता है कि आपने इसे एक अलग उत्तर के रूप में पोस्ट किया था और फिर हटा दिया गया था। मैं कहूंगा, आगे बढ़ो, तुम मुझे इसके लिए हराओ :)
— किरिल एल।
मुझे लगता है कि मेरा उत्तर भी समान है, यह कुछ शॉर्टकट के साथ एक ही दृष्टिकोण है, ज्यादातर चोरी कोड।
— जीबी
1

जाप -x , 25 19 बाइट्स

-6 बाइट्स शैगी को धन्यवाद

pU õìU ËeDâ f myDìU

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

— ASCII-केवल
स्रोत
— झबरा
या झंडे के साथ 19 बाइट्स-x ।
— झबरा
वाह O_o मैं स्पष्ट रूप से भयानक गोल्फिंग जप्पर में हूँ
— केवल
आप अब तक अच्छा कर रहे हैं :) एक नई भाषा के साथ पकड़ में आने में समय लगता है, इसकी सभी विशेषताओं, ट्रिक्स और क्विर्क का पता लगाएं।
— झबरा
@Shaggy लेकिन आप जितनी बार मैं इसे उम्मीद की जानी चाहिए कि मैं 25% एक्सडी तरह से इष्टतम के करीब हो जाएगा कर एक नई भाषा का उपयोग करते हैं
— ASCII-केवल
0

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

lambda x,r=range,i=chain:sum(0**any(int(''.join(map(str,y)),x)%z for z in y)for y in i(*map(permutations,i(*[combinations(r(1,x),e)for e in r(x)]))))-1
from itertools import*

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

श्रेणी (1, n) (कोई शून्य, अद्वितीय) की शक्तियां के प्रत्येक तत्व के प्रत्येक क्रमपरिवर्तन के लिए, संख्यात्मक स्ट्रिंग को बेस n में परिवर्तित करें। प्रत्येक अंक द्वारा विभाज्य होने वाले योग, खाली सेट बनाने वाली शक्तियां के कारण 1 घटाएं।

@30s के लिए -30 बाइट्स धन्यवाद!

— कॉनर जॉनसन
स्रोत
— 19
— 19
0

पर्ल 5 , 108 + 1 ( -p) = 109 बाइट्स

while(@a<$_){$r=%k=@a=();for($t=++$i;$t;$t=int$t/$_){push@a,$t%$_}$r||=!$_||$i%$_||$k{$_}++for@a;$r||$\++}}{

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

यह एक सुअर है। निश्चित नहीं है कि यह बिना टाइम आउट के TIO पर बेस 8 से ज्यादा करेगा।

— Xcali
स्रोत
0

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 144 बाइट्स

n=>{int j,i,p;for(j=i=0;i++<~0UL;){p=i;var a=new List<int>();for(;p>0;p/=n)a.Add(p%n);j+=a.All(c=>c>0&&i%c<1&a.Count(x=>x==c)<2)?1:0;}return j;}

0 से सभी नंबरों के माध्यम से जाता है ulong.MaxValue, और उन का चयन करता है जो निर्दिष्ट आधार में लिंच-बेल नंबर हैं। हमेशा के लिए चलाने के लिए ले जाता है, यहां तक ​​कि 2 के लिए, हालांकि यदि आप ~0ULलूप के लिए कुछ छोटे हिस्से में सेट करते हैं, तो आप TIO पर एक मिनट के भीतर 7 तक इनपुट के लिए आउटपुट प्राप्त कर सकते हैं।

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

— अज्ञान का अवतार
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.