आलसी मूल्यों को उत्पन्न करें

Question

संबंधित: मेरे माइक्रोवेव ओवन कार्यक्रम । जेनरेट आलसी माइक्रोवेव इनपुट से प्रेरित ।

पूर्णांक गैर नकारात्मक की आलसी मूल्य एन पूर्णांकों कि के सबसे करीब हैं सबसे छोटी है एन जबकि उनके सभी अंक समान हैं।

रिटर्न (किसी भी माध्यम से) दिए गए (किसी भी तरह से) का आलसी मूल्य एन ।

एन ≤ सबसे बड़ा पूर्णांक है कि अपनी भाषा गैर प्रतिपादक डिफ़ॉल्ट रूप से रूप में प्रतिनिधित्व करता है। 1000000 (बहुत अधिक आवश्यकता के कारण कई दिलचस्प समाधान खो जाते हैं।)

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

   0 →    0
   8 →    8
   9 →    9
  10 →    9
  16 →   11
  17 →   22
  27 →   22
  28 →   33
 100 →   99
 105 →   99
 106 →  111
 610 →  555
 611 →  666
7221 → 6666
7222 → 7777 

---

प्रश्न में सहयोगी ने साबित किया कि कोई संबंध नहीं होगा: 9/11, 99/111, आदि को छोड़कर, जिसके लिए एक दूसरे से छोटा है, दो लगातार मान्य उत्तर हमेशा एक विषम दूरी के होते हैं, इसलिए कोई पूर्णांक नहीं हो सकता है उनसे बराबर।

Answer 1

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

n=>~-(n*9+4).toPrecision(1)/9|0

सीधे प्रत्येक के लिए आलसी मूल्य की गणना करता है n।

संपादित करें: केवल जावास्क्रिप्ट के पूर्णांक प्रकार की सीमाओं के कारण 277777778 तक काम करता है। वैकल्पिक संस्करण:

n=>((n*9+4).toPrecision(1)-1)/9>>>0

35 बाइट्स, 16666666667 तक काम करती है।

n=>((n=(n*9+4).toPrecision(1))-n[0])/9

38 बाइट्स, 944444444444443 तक काम करता है। लेकिन अभी भी 2 ⁵³ की कमी है जो 9007199254740992 है।

Comments

@ user81655 मैंने अपनी संख्यात्मक सीमाओं के साथ कुछ वैकल्पिक संस्करण जोड़े हैं।

— नील

मुझे यह एल्गोरिथम काम करने के लिए नहीं मिला Number.MAX_SAFE_INTEGERक्योंकि या तो 8e16 - 1इसे व्यक्त किया गया है 8e16। अफसोस की बात है कि ऐसा लगता है कि अधिकतम परिणाम के लिए एकमात्र तरीका हार्ड-कोडिंग होगा। फिर भी नॉन।

— user81655

@ user81655 मैंने समाधान की अनुमति देने के लिए ऊपरी सीमा को कम कर दिया।

— अड्म

आपको 10k @Neil मिला, गोल्फ से प्यार करें!

— नीक न्यूमैन

@NiCkNewman Woohoo! धन्यवाद!

— नील

Answer 2

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

ḤRµDIASµÐḟµạ³ỤḢị

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

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

ḤRµDIASµÐḟµạ³ỤḢị  Main link. Input: n

Ḥ                 Compute 2n.
 R                Yield [1, ..., 2n] or [0].
  µ               Begin a new, monadic chain. Argument: R (range)
   D              Convert to base 10.
    I             Compute all differences of consecutive decimal digits.
     A            Take the absolute values of the differences.
      S           Sum the absolute values.
       µÐḟ        Filter-false by the chain to the left.
          µ       Begin a new, monadic chain. Argument: L (lazy integers)
           ạ³     Take the absolute difference of each lazy integer and n (input).
             Ụ    Grade up; sort the indices of L by the absolute differences.
                  This is stable, so ties are broken by earlier occurrence and,
                  therefore, lower value.
              Ḣ   Head; retrieve the first index, corresponding to the lowest
                  absolute difference.
               ị  Retrieve the item of L at that index.

Answer 3

ओरेकल SQL 11.2, 200 बाइट्स

WITH v(i)AS(SELECT 0 FROM DUAL UNION ALL SELECT DECODE(SIGN(i),0,-1,-1,-i,-i-1)FROM v WHERE LENGTH(REGEXP_REPLACE(:1+i,'([0-9])\1+','\1'))>1)SELECT:1+MIN(i)KEEP(DENSE_RANK LAST ORDER BY rownum)FROM v;

संयुक्त राष्ट्र के golfed

WITH v(i) AS
(
  SELECT 0 FROM DUAL      -- Starts with 0
  UNION ALL
  SELECT DECODE(SIGN(i),0,-1,-1,-i,-i-1) -- Increments i, alternating between negatives and positives
  FROM   v 
  WHERE  LENGTH(REGEXP_REPLACE(:1+i,'([0-9])\1+','\1'))>1  -- Stop when the numbers is composed of only one digit
)
SELECT :1+MIN(i)KEEP(DENSE_RANK LAST ORDER BY rownum) FROM v;

Answer 4

पायथ - 26 बाइट्स

यह उत्तर हमेशा एक टाई में सबसे छोटे मूल्य को वापस नहीं करता है, लेकिन यह चश्मा में नहीं है, इसलिए 3 बाइट्स के लिए निर्धारित स्पष्टीकरण का इंतजार है ।

hSh.g.a-kQsmsM*RdjkUTtBl`Q

टेस्ट सूट ।

Answer 5

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

haDQsM*M*`MTSl`Q

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

haDQsM*M*`MTSl`Q   implicit: Q = input number
              `Q   convert Q to a string
             l     take the length
            S      create the list [1, 2, ..., len(str(Q))]
         `MT       create the list ["0", "1", "2", "3", ..., "9"]
        *          create every combination of these two lists:
                   [[1, "0"], [1, "1"], [1, "2"], ..., [len(str(Q)), "9"]]
      *M           repeat the second char of each pair according to the number:
                   ["0", "1", "2", ..., "9...9"]
    sM             convert each string to a number [0, 1, 2, ..., 9...9]
  D                order these numbers by:
 a Q                  their absolute difference with Q
h                  print the first one

Answer 6

MATL , 25 बाइट्स

2*:"@Vt!=?@]]N$vtG-|4#X<)

जानवर बल का उपयोग करता है, इसलिए बड़ी संख्या के लिए कुछ समय लग सकता है।

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

2*:       % range [1,2,...,2*N], where is input
"         % for each number in that range
  @V      %   push that number, convert to string
  t!=     %   test all pair-wise combinations of digits for equality
  ?       %   if they are all equal
    @     %     push number: it's a valid candidate
  ]       %   end if
]         % end for each
N$v       % column array of all stack contents, that is, all candidate numbers
t         % duplicate
G-|       % absolute difference of each candidate with respect to input
4#X<      % arg min
)         % index into candidate array to obtain the minimizer. Implicitly display

Answer 7

पर्ल, 32

नील द्वारा सुंदर जावास्क्रिप्ट समाधान के आधार पर।

$_=0|1/9*~-sprintf"%.e",$_*9+4.1

पर असफल होने लगता है 5e15

Answer 8

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

f@x_:=Last@Sort[Flatten@Table[y*z,{y,1,9},{z,{FromDigits@Table[1,10~Log~x+1-Log[10,1055555]~Mod~1]}}],Abs[x-#]>Abs[x-#2]&]

X नाम का कार्य।

Answer 9

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

n=>eval(`for(i=a=0;i<=n;a=i%10?a:++i)p=i,i+=a;n-p>i-n?i:p`)

पुनरावर्ती समाधान (56 बाइट्स)

यह थोड़ा कम है, लेकिन इसके लिए काम नहीं करता है n > 1111111110क्योंकि अधिकतम कॉल स्टैक का आकार पार हो गया है, इसलिए यह तकनीकी रूप से अमान्य है।

f=(n,p,a,i=0)=>n<i?n-p>i-n?i:p:f(n,i,(i-=~a)%10?a:i++,i)

व्याख्या

प्रत्येक आलसी संख्या के माध्यम से Iterates जब तक कि यह पहले से अधिक नहीं हो जाता है n, तब nपरिणाम निर्धारित करने के लिए इस और पिछली संख्या की तुलना करता है।

var solution =

n=>
  eval(`           // eval enables for loop without {} or return
    for(
      i=a=0;       // initialise i and a to 0
      i<=n;        // loop until i > n, '<=' saves having to declare p above
      a=i%10?a:++i // a = amount to increment i each iteration, if i % 10 == 0 (eg.
    )              //     99 + 11 = 110), increment i and set a to i (both become 111)
      p=i,         // set p before incrementing i
      i+=a;        // add the increment amount to i
    n-p>i-n?i:p    // return the closer value of i or p
  `)

N = <input type="number" oninput="R.textContent=solution(+this.value)"><pre id="R"></pre>

Comments

मैंने आपके समाधान की अनुमति देने के लिए ऊपरी सीमा को नीचे कर दिया।

— अड्म

Answer 10

जाप , 18 बाइट्स

9*U+4 rApUs l¹/9|0

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

_{नील की तकनीक पर आधारित}

गैर-प्रतिस्पर्धात्मक समाधान :

*9+4 h /9|0

Comments

और अब आप कर सकते हैं *9+4 h /9|0:-)

— ETHproductions

@ETHproductions धन्यवाद! मुझे जाप के साथ बहुत मज़ा आ रहा है :)

— ओलिवर

Answer 11

05AB1E , 20 बाइट्स

9Ývy7L×})˜ïD¹-ÄWQÏ{¬

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

9Ý                   # Push 0..9
  vy7L×})˜           # For each digit, 0-9, push 1-7 copies of that number.
          ïD         # Convert to integers, dupe the list.
            ¹        # Push original input (n).
             -Ä      # Push absolute differences.
               WQ    # Get min, push 1 for min indices.
                 Ï{¬ # Push indices from original array that are the min, sort, take first.

Comments

99 निश्चित रूप से 111 से अधिक आलसी है, क्योंकि इसमें केवल दो बटन प्रेस की आवश्यकता है।

— 16

@ पर्याप्त मेला, प्रमुख कमान जोड़ा।

— मैजिक ऑक्टोपस Urn

Answer 12

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

Min@Nearest[##&@@@Table[d(10^n-1)/9,{n,0,6},{d,0,9}],#]&

पहले तर्क के साथ शुद्ध कार्य #, आदानों के लिए काम करता है 10^6।

एक nonnegative पूर्णांक nऔर एक अंक के लिए d, 10^n-1 = 99...9( 9बार- nबार), इसलिए d(10^n-1)/9 = dd...d( dबार- nबार)। के Tableलिए मानों का निर्माण करता है 0 <= n <= 6और 0 <= d <= 9फिर तालिका को समतल करता है, तत्वों की सूची पाता Nearestहै #और ले जाता है Min।

मुझे विश्वास है कि यह संस्करण मनमाने ढंग से बड़े पूर्णांकों के लिए काम करेगा:

Min@Nearest[##&@@@Table[d(10^n-1)/9,{n,0,IntegerLength@#},{d,0,9}],#]&