एक सकारात्मक पूर्णांक n : 500 दिया गया :

खोजें सबसे छोटी सकारात्मक पूर्णांक कश्मीर ऐसी है कि के दशमलव प्रतिनिधित्व सभी अंक n * कश्मीर या तो कर रहे हैं 0 या घ , साथ ≤ घ ≤ 9 1 ।
30 सेकंड से कम समय में प्रिंट या वापसी d ( स्पष्टीकरण और नियम अनुभाग में इसके बारे में अधिक पढ़ें )।

आसान उदाहरण

यहाँ d के पहले 30 मान हैं ।

+----+-------+---------+---+    +----+-------+---------+---+
|  n |     k |   n * k | d |    |  n |     k |   n * k | d |
+----+-------+---------+---+    +----+-------+---------+---+
|  1 |     1 |       1 | 1 |    | 16 |     5 |      80 | 8 |
|  2 |     1 |       2 | 2 |    | 17 |   653 |   11101 | 1 |
|  3 |     1 |       3 | 3 |    | 18 |     5 |      90 | 9 |
|  4 |     1 |       4 | 4 |    | 19 |   579 |   11001 | 1 |
|  5 |     1 |       5 | 5 |    | 20 |     1 |      20 | 2 |
|  6 |     1 |       6 | 6 |    | 21 |    37 |     777 | 7 |
|  7 |     1 |       7 | 7 |    | 22 |     1 |      22 | 2 |
|  8 |     1 |       8 | 8 |    | 23 |  4787 |  110101 | 1 |
|  9 |     1 |       9 | 9 |    | 24 |    25 |     600 | 6 |
| 10 |     1 |      10 | 1 |    | 25 |     2 |      50 | 5 |
| 11 |     1 |      11 | 1 |    | 26 |    77 |    2002 | 2 |
| 12 |     5 |      60 | 6 |    | 27 |    37 |     999 | 9 |
| 13 |    77 |    1001 | 1 |    | 28 |    25 |     700 | 7 |
| 14 |     5 |      70 | 7 |    | 29 | 37969 | 1101101 | 1 |
| 15 |     2 |      30 | 3 |    | 30 |     1 |      30 | 3 |
+----+-------+---------+---+    +----+-------+---------+---+

इतना आसान उदाहरण नहीं

इस चुनौती की एक ख़ासियत यह है कि कुछ मूल्य दूसरों की तुलना में बहुत कठिन हैं - कम से कम विशुद्ध रूप से क्रूर-बल दृष्टिकोण के साथ। नीचे n के कुछ उदाहरण दिए गए हैं जो कि k के उच्च मूल्य को जन्म देते हैं ।

+-----+------------+---------------+---+    +-----+------------+---------------+---+
|   n |          k |         n * k | d |    |   n |          k |         n * k | d |
+-----+------------+---------------+---+    +-----+------------+---------------+---+
|  81 |   12345679 |     999999999 | 9 |    | 324 |   13717421 |    4444444404 | 4 |
| 157 |   64338223 |   10101101011 | 1 |    | 353 |   28615017 |   10101101001 | 1 |
| 162 |   13717421 |    2222222202 | 2 |    | 391 |  281613811 |  110111000101 | 1 |
| 229 |   43668559 |   10000100011 | 1 |    | 405 |   13717421 |    5555555505 | 5 |
| 243 |   13717421 |    3333333303 | 3 |    | 439 |   22781549 |   10001100011 | 1 |
| 283 |   35371417 |   10010111011 | 1 |    | 458 |   43668559 |   20000200022 | 2 |
| 299 |   33478599 |   10010101101 | 1 |    | 471 |   64338223 |   30303303033 | 3 |
| 307 |   32576873 |   10001100011 | 1 |    | 486 |   13717421 |    6666666606 | 6 |
| 314 |   64338223 |   20202202022 | 2 |    | 491 |  203871711 |  100101010101 | 1 |
| 317 | 3154574483 | 1000000111111 | 1 |    | 499 |   22244489 |   11100000011 | 1 |
+-----+------------+---------------+---+    +-----+------------+---------------+---+

स्पष्टीकरण और नियम

n * k में हमेशा कम से कम एक अंक d होगा , लेकिन इसमें कोई शून्य नहीं हो सकता है।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है। हालाँकि, आपका प्रोग्राम या फ़ंक्शन मध्य-श्रेणी के हार्डवेयर पर 30 सेकंड से कम समय में किसी भी 1 ≤ n less 500 के परिणाम को वापस करने में सक्षम होना चाहिए ।
ध्यान रखें कि कुछ मूल्य दूसरों की तुलना में कठिन हैं। एक प्रोग्राम जो k के मान को ब्रूट-फोर्स करने की कोशिश करेगा, वह समय-सीमा की कमी (एक अच्छा परीक्षण मामला n = 317 ) का अनुपालन करने की संभावना नहीं है । डी खोजने के लिए काफी तेज़ तरीके हैं ।

संदर्भ तालिका

1 ≤ n of 500 के लिए d के सभी मूल्य नीचे सूचीबद्ध हैं।

n       | d
--------+--------------------------------------------------
001-025 | 1 2 3 4 5 6 7 8 9 1 1 6 1 7 3 8 1 9 1 2 7 2 1 6 5
026-050 | 2 9 7 1 3 1 8 3 2 7 9 1 2 3 4 1 6 1 4 9 2 1 6 7 5
051-075 | 3 4 1 9 5 7 1 2 1 6 1 2 9 8 5 6 1 4 3 7 1 9 1 2 3
076-100 | 4 7 6 1 8 9 2 1 4 5 2 3 8 1 9 1 4 3 2 5 6 1 7 9 1
101-125 | 1 6 1 8 7 2 1 9 1 1 1 7 1 2 5 4 9 2 7 6 1 2 3 4 5
126-150 | 6 1 8 3 1 1 6 7 2 9 8 1 6 1 7 1 2 1 9 5 2 7 4 1 3
151-175 | 1 8 9 7 5 4 1 2 1 8 7 2 1 4 3 2 1 8 1 1 3 4 1 6 7
176-200 | 8 3 2 1 9 1 2 1 8 5 6 1 4 9 1 1 6 1 2 3 7 1 9 1 2
201-225 | 3 2 7 4 5 2 9 8 1 7 1 4 1 2 5 9 7 2 3 2 1 2 1 7 9
226-250 | 2 1 4 1 1 3 8 1 6 5 4 3 7 1 6 1 2 3 4 7 6 1 8 3 5
251-275 | 1 6 1 2 3 8 1 6 7 2 9 2 1 6 5 7 3 4 1 9 1 8 3 2 5
276-300 | 6 1 2 9 7 1 2 1 4 5 2 7 9 1 1 3 4 1 7 5 8 9 2 1 3
301-325 | 7 2 3 8 5 6 1 4 3 1 1 8 1 2 9 4 1 2 1 8 1 7 1 4 5
326-350 | 2 1 8 7 3 1 4 3 2 5 8 1 2 3 2 1 6 1 8 3 2 1 4 1 7
351-375 | 9 8 1 6 5 4 7 2 1 9 1 2 3 4 5 2 1 8 9 1 7 6 1 2 3
376-400 | 8 1 9 1 2 3 2 1 6 7 2 9 4 1 3 1 7 1 2 5 9 1 2 7 4
401-425 | 1 6 1 4 5 2 1 8 1 1 3 4 7 9 5 8 1 2 1 6 1 2 3 8 5
426-450 | 2 7 4 3 1 1 9 1 7 3 4 1 6 1 4 3 2 1 4 5 2 3 7 1 9
451-475 | 1 4 3 2 5 8 1 2 9 2 1 6 1 8 3 2 1 6 7 1 3 8 1 6 5
476-500 | 7 3 2 1 6 1 2 3 4 5 6 1 8 3 7 1 6 1 2 9 8 7 6 1 5

code-golf arithmetic

— Arnauld
स्रोत

1

हाल की चुनौती से पूरी तरह से प्रेरित (लेकिन इससे काफी अलग) ।

— अर्नुलद

n = 6669666 -> d = 9

— J42161217

उस तालिका में दिलचस्प विकर्ण।

— जेम्स

@ नाम की जानकारी। MOD 24 को स्वरूपित करने से पैटर्न थोड़ा और स्पष्ट दिखाई देगा। MOD 25 के साथ, हमें इसके बजाय कुछ विकर्ण मिलते हैं। :-)

— अरनुलद

3

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

²B€Ḍ9×þF%Þ¹ḢQS

द्विघात रनटाइम (TIO पर 25 सेकंड से कम)।

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

वैकल्पिक संस्करण, 15 बाइट्स

2ȷB€Ḍ9×þF%Þ¹ḢQS

लगातार क्रम (लगभग 1 TIO पर दूसरा)।

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

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

²B€Ḍ9×þF%Þ¹ḢQS  Main link. Argument: n

²               Take the square of n.
                This bound is high enough for all integers up to 500. 
                In fact, The highest value we need is 1387 for input 471, so
                2000 (2ȷ) is also enough (and a lot faster).

 B€             Binary; convert 1, ..., 4159 to base 2.
   Ḍ            Undecimal; convert each digit array from base 10 to integer.
                This generates the array A of all positive integers up to n²
                whose decimal representations consist entirely of 1's and 0's.
    9×þ         9 multiply table; for each x in A, yield [x, 2x, ..., 8x, 9x].
       F        Flatten; concatenate the resulting arrays, yielding the vector
                V. Note that V contains all numbers that match the regex ^d[0d]*$
                in base 10, in ascending order.
          ¹     Identity; yield n.
        %Þ      Sort the entries for V by their remainders modulo n. This places
                multiples of n at the beginning. The sorting algorithm in stable,
                so the first element of sorted V is the smallest multiple of n.
           Ḣ    Head; extract the first element.
            Q   Unique; deduplicate its digits in base 10. This yields [d, 0].
             S  Take the sum, yielding d.

— डेनिस
स्रोत

5

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

n=>{for(p=1;;p=k)for(d=0;d++<9;)for(k=p;k<p+p;k++)if(k.toString(2)*d%n<1)return d;}

अब लौटता 6है n=252! मैंने एक पुनरावर्ती दृष्टिकोण की कोशिश की, लेकिन यह 83 बाइट्स भी है और कठिन संख्याओं के लिए मेरे लिए दुर्घटनाग्रस्त हो गया है:

f=(n,p=1,d=1,k=p)=>k<p+p?k.toString(2)*d%n<1?d:f(n,p,d,k+1):d>8?f(n,p+p):f(n,p,d+1)

— नील
स्रोत

4

गणितज्ञ, १०३ १०० ९। बाइट्स

#&@@IntegerDigits[Sort[Join@@Table[Cases[FromDigits/@{0,i}~Tuples~13/#,_Integer],{i,9}]][[10]]#]&

0.39 सेकंड में 317 पाता है

कोड को ऑनलाइन कॉपी / पेस्ट करने की कोशिश करें , अंत में [317] जोड़ें और चलाने के लिए शिफ्ट + एंटर करें

-3 बाइट्स @ जुंगहवन मिन
-3 बाइट्स @ कीय गन से

— J42161217
स्रोत

आप से छुटकारा प्राप्त कर सकते हैं *में *#, और Tuples[{0,i},13]है{0,i}~Tuples~13

— JungHwan मिन

हाँ, बिल्कुल।

— J42161217

ओह, और एक और: [[1]]अंत #&@@में शुरू में डाल के रूप में ही है

— जंगवान मिन

... और हमने इसे 100 पर बना दिया! -3 बाइट्स के लिए धन्यवाद

— J42161217

आप Join@@इसके बजायFlatten@

— Keyu Gan

2

पायथन 2/3, 129 128 127 बाइट्स

from itertools import*
lambda n:next(d for p in count()for d in range(1,10)for k in range(2**p,2*2**p)if d*int(bin(k)[2:])%n<1)

-1 बाइट: count(0)→ count()
-1 बाइट: ==0→ <1चूंकि यह नकारात्मक नहीं हो सकता

— Score_Under
स्रोत

2

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

9Rṭ€0ṗ€⁴ẎḌḍ@Ðf⁸ṢDFḟ0Ḣ

संख्या को लौटाने वाली एक विवादास्पद कड़ी या इसे मुद्रित करने वाला एक पूरा कार्यक्रम।

एक सीमित-सीमा वाली जानवर-चिकित्सा जो किसी भी 1 ≤ n ( 500 के लिए 20 सेकंड से कम समय लेती है (1 बाइट कोड लागत के लिए 3 सेकंड से कम - ⁴साथ बदलें 13)।

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

कैसे?

9Rṭ€0ṗ€⁴ẎḌḍ@Ðf⁸ṢDFḟ0Ḣ - Link: number, n
9R                    - range of 9 = [1,2,3,4,5,6,7,8,9]
  ṭ€0                 - tack €ach to 0 -> [[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9]]
       ⁴              - literal 16
     ṗ€               - Cartesian product for €ach
        Ẏ             - tighten (flatten by 1 level)
         Ḍ            - covert from decimal list to number (vectorises)
              ⁸       - chain's left argument (n)
            Ðf        - filter keep items for which this yields a truthy value:
          ḍ@          -   divisible? with swapped @rguments
               Ṣ      - sort
                D     - convert to decimal list (vectorises)
                 F    - flatten into a single list
                  ḟ0  - filter out zeros
                    Ḣ - head (get the first value)

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

2

PHP , 87 बाइट्स

for(;++$i<5e3;)for($n=10;$d=--$n*decbin($i);)($y&&$d>$y)|$d%$argn?:$x=$n.!$y=$d;echo$x;

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

PHP , 89 बाइट्स

for(;++$i<5e3;)for($n=10;$d=--$n*decbin($i);)$d%$argn?:$r[$d]=$n;krsort($r);echo end($r);

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

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

n * k = dd0d00d जहां d =…?

आसान उदाहरण

इतना आसान उदाहरण नहीं

स्पष्टीकरण और नियम

संदर्भ तालिका

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

वैकल्पिक संस्करण, 15 बाइट्स

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

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

गणितज्ञ, १०३ १०० ९। बाइट्स

पायथन 2/3, 129 128 127 बाइट्स

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

कैसे?

PHP , 87 बाइट्स

PHP , 89 बाइट्स