एक पूर्णांक को देखते हुए , आपको न्यूनतम संख्या में बिट्स को ढूंढना होगा जो इसे वर्ग संख्या में बदलने के लिए में उल्टा होना चाहिए । आपको केवल सबसे महत्वपूर्ण एक के नीचे बिट्स को पलटने की अनुमति है । $N>3$ $N$

उदाहरण

$N=4$ पहले से ही एक वर्ग संख्या ( ) है, इसलिए अपेक्षित आउटपुट । $2^2$ $0$
$N=24$ को 1 बिट: ( ) में बदलकर एक वर्ग संख्या में बदल दिया जा सकता है , इसलिए अपेक्षित आउटपुट । $11000 \rightarrow 1100\color{red}1$ $25=5^2$ $1$
$N=22$ को एक एकल बिट ( $23$ , $20$ , $18$ और होने के संभावित परिणाम) द्वारा एक वर्ग संख्या में नहीं बदला जा सकता है , $30$ लेकिन इसे 2 बिट्स में किया जा सकता है: $10110 \rightarrow 10\color{red}0\color{red}00$ ( $16=4^2$ ), इसलिए अपेक्षित आउटपुट $2$ ।

नियम

यह ठीक है यदि आपका कोड बहुत धीमा है या बड़े परीक्षण-मामलों के लिए कोई त्रुटि देता है, लेकिन इसे कम से कम 1 मिनट में समर्थन करना चाहिए $3 < N < 10000$ ।
यह कोड-गोल्फ है !

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

    Input | Output
----------+--------
        4 | 0
       22 | 2
       24 | 1
       30 | 3
       94 | 4
      831 | 5
      832 | 1
     1055 | 4
     6495 | 6
     9999 | 4
    40063 | 6
   247614 | 7        (smallest N for which the answer is 7)
  1049310 | 7        (clear them all!)
  7361278 | 8        (smallest N for which the answer is 8)
100048606 | 8        (a bigger "8")

या अनुकूल प्रारूप में कॉपी / पेस्ट करें:

[4,22,24,30,94,831,832,1055,6495,9999,40063,247614,1049310,7361278,100048606]

code-golf integer bitwise

— Arnauld
स्रोत

लगभग आधे उत्तर 100048606टीआईओ के लिए निष्पादित नहीं करते हैं , क्या यह एक समस्या है?

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

@MagicOctopusUrn धन्यवाद, मैंने नियमों को अपडेट करके स्पष्ट कर दिया है कि का समर्थन वैकल्पिक है।

N \geq 10000

$N\ge 10000$

— अरनुलद

1

यह एक अच्छा सबसे तेज़-कोड प्रश्न होगा (इनपुट आकार प्रतिबंध के बिना)

— qwr

@qwr हाँ, शायद। या यदि आप कट्टर जाना चाहते हैं: दिया , तो सबसे छोटा ज्ञात करें जैसे कि ।

k

$k$

N

$N$

f (N) = k

$f(N) = k$

— अरनौलड

14

रूबी, 74 बाइट्स

->n{(1..n).map{|x|a=(n^x*x).to_s 2;a.size>Math.log2(n)?n:a.count(?1)}.min}

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

यह बस अनुक्रम उत्पन्न करता है (जो कि पर्याप्त से अधिक है), इसे साथ XORs करता है , और फिर बिट्स की संख्या कम होने पर इसके बाइनरी प्रतिनिधित्व में 1s की संख्या लेता है। , या करने के बराबर या उससे अन्यथा। इसके बाद न्यूनतम संख्या फ़्लिप हो जाती है। बिट्स की संख्या के बजाय वापस लौटना जब उच्चतम बिट फ़्लिप किया गया है से अधिक है, इन मामलों को न्यूनतम, के रूप में चुने जाने से रोकता है $\left[1^2, 2^2, \ldots, n^2\right]$ $n$ $\log_2n$ $n$ $n$ $\log_2n$ $n$ हमेशा बिट्स की संख्या से अधिक होगा।

बाइट बचाने के लिए पिकोको का धन्यवाद ।

— Doorknob
स्रोत

आप (n^x*x).to_s 2;...इसके बजाय बाइट बचा सकते हैं(n^x*x).to_s(2);...

— Piccolo

@Piccolo विश्वास नहीं कर सकता कि मैं चूक गया, धन्यवाद!

— दरवाज़े

6

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

²,BẈEðƇ²^B§Ṃ

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

एक परीक्षण सूट की जाँच करें!

मोनडिक लिंक। गोल्फ होना चाहिए। ~~लेकिन मैं इससे छुटकारा पाने का एक तरीका सोचने के लिए बहुत बेवकूफ हूं ³।~~ यह मेरा पहला उत्तर है जिसमें मैं सफलतापूर्वक एक डेडिक श्रृंखला \ o / के साथ सामान्य रूप से फ़िल्टरिंग / मैपिंग / लूपिंग का उपयोग करता हूं

व्याख्या

Ẉ, B /EðƇ² ^ B§Ṃ - पूर्ण कार्यक्रम / मौद्रिक लिंक। तर्क एन को बुलाओ।
     ic - निम्नलिखित डायैडिक श्रृंखला के साथ फ़िल्टर-रखें [1 ... N]:
Ẉ, B hasE - वर्तमान वस्तु के वर्ग की लंबाई N के समान है।
² - वर्ग।
 , - एन के साथ जोड़ी।
  बी - दोनों को बाइनरी में कनवर्ट करें।
   Ve - उनकी लंबाई को पुनः प्राप्त करें।
    ई - और जाँच करें कि क्या वे समान हैं।
       ² ^ - फ़िल्टर करने के बाद, परिणामों को वर्ग दें और XOR को N के साथ जोड़ें।
         बी - प्रत्येक का द्विआधारी प्रतिनिधित्व।
          Each - प्रत्येक का योग। बाइनरी में 1s की संख्या गिनता है।
           Ṃ - न्यूनतम।

— श्री Xcoder
स्रोत

5

भूसी , 20 बाइट्स

▼mΣfo¬→S↑(Mo¤ż≠↔ḋİ□ḋ

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

व्याख्या

▼mΣf(¬→)S↑(M(¤ż≠↔ḋ)İ□ḋ) -- example input n=4
        S↑(           ) -- take n from n applied to (..)
                     ḋ  -- | convert to binary: [1,0,0]
                   İ□   -- | squares: [1,4,9,16,...]
           M(     )     -- | map with argument ([1,0,0]; example with 1)
                 ḋ      -- | | convert to binary: [1]
             ¤  ↔       -- | | reverse both arguments of: [1] [0,0,1]
              ż≠        -- | | | zip with inequality (absolute difference) keeping longer elements: [1,0,1]
                        -- | : [[1,0,1],[0,0,0],[1,0,1,1],[0,0,1,0,1],[1,0,1,1,1],....
                        -- : [[1,0,1],[0,0,0],[1,0,1,1],[0,0,1,0,1]]
    f(  )               -- filter elements where
       →                -- | last element
      ¬                 -- | is zero
                        -- : [[0,0,0]]
 mΣ                     -- sum each: [0]
▼                       -- minimum: 0

— ბიმო
स्रोत

▼mΣfo¬←ṠMz≠ȯfo£İ□ḋπŀ2Lḋ2 बाइट्स बचाता है। आप सही वर्ग स्कोर RIP।

— श्री Xcoder

@ Mr.Xcoder: स्कोर के बारे में शर्म की बात है .. लेकिन मुझे कुछ और से छुटकारा मिल गया है, अब 16 को लक्षित कर रहा है; पी

— at

5

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

{min map {+$^a.base(2).comb(~1) if sqrt($a+^$_)!~~/\./},^2**.msb}

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

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

— शॉन
स्रोत

4

05AB1E , 20 15 बाइट्स

Lnʒ‚b€gË}^b€SOß

-5 बाइट्स के लिए धन्यवाद @ Mr.Xcoder अपने जेली उत्तर के एक बंदरगाह का उपयोग कर ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें (60 सेकंड के बाद सबसे बड़े तीन परीक्षण मामलों को हटा दिया जाता है, फिर भी अन्य परीक्षण मामलों के साथ लगभग 35-45 सेकंड लगते हैं)।

स्पष्टीकरण:

L            # Create a list in the range [1, input]
             #  i.e. 22 → [0,1,2,...,20,21,22]
 n           # Take the square of each
             #  i.e. [0,1,2,...,20,21,22] → [0,1,4,...,400,441,484]
  ʒ     }    # Filter this list by:
   ,         #  Pair the current value with the input
             #   i.e. 0 and 22 → [0,22]
             #   i.e. 25 and 22 → [25,22]
    b        #  Convert both to binary strings
             #   i.e. [0,22] → ['0','10110']
             #   i.e. [25,22] →  ['10000','11001']
     €g      #  Take the length of both
             #   i.e. ['0','10110'] → [1,5]
             #   ['10000','11001'] → [5,5]
       Ë     #  Check if both are equal
             #   i.e. [1,5] → 0 (falsey)
             #   i.e. [5,5] → 1 (truthy)
^            # After we've filtered, Bitwise-XOR each with the input
             #  i.e. [16,25] and 22 → [6,15]
 b           # Convert each to a binary string again
             #  i.e. [6,15] → ['110','1111']
  €S         # Change the binary strings to a list of digits
             #  i.e. ['110','1111'] → [['1','1','0'],['1','1','1','1']]
    O        # Take the sum of each
             #  i.e. [['1','1','0'],['1','1','1','1']] → [2,4]
ß            # And then take the lowest value in the list
             #  i.e. [2,4] → 2

— केविन क्रूज़सेन
स्रोत

1

ठीक है फिर, एक मान्य 15-बटर Lnʒ‚b€gË}^b€SOß:। यह दुर्भाग्य से आपके टेस्ट सूट को तोड़ देता है, हालांकि

— श्री एक्सकोडर

1

@ Mr.Xcoder धन्यवाद! और मेरा टेस्ट सूट लगभग हमेशा मैं गोल्फ के बाद टूट जाता है .. XD लेकिन यह अब भी तय हो गया है।

— केविन क्रूज़सेन

मुझे लगता है कि मैं 05AB1E su \ _ (not) _ / su में टेस्ट सूट लिखने में अच्छा नहीं हूं, यह अच्छा है कि आपने इसे ठीक कर लिया है :)

— श्री एक्सकोडर

3

जावा (JDK 10) , 110 बाइट्स

n->{int i=1,s=1,b,m=99,h=n.highestOneBit(n);for(;s<h*2;s=++i*i)m=(s^n)<h&&(b=n.bitCount(s^n))<m?b:m;return m;}

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

— ओलिवियर ग्रेजायर
स्रोत

1

आप बिटवाइस का उपयोग करके 1 बाइट बचा सकते हैं और &तार्किक के बजाय&&

— kirbyquerby

3

गैया , 18 बाइट्स

मेरे जेली उत्तर के पास-पोर्ट ।

s¦⟪,b¦l¦y⟫⁇⟪^bΣ⟫¦⌋

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

टूट - फूट

s, b⟪l¦y⟫⁇ Σ⟫¦⌋ ^ b Full - पूर्ण कार्यक्रम। चलो इनपुट एन।
s - श्रेणी में प्रत्येक पूर्णांक को वर्ग [1 ... N]।
  ⁇ Certain ⟪- उन लोगों का चयन करें जो एक निश्चित स्थिति को पूरा करते हैं, जब वे भाग जाते हैं
                     एक डाईडिक ब्लॉक। एक dyadic ब्लॉक का उपयोग कर एक बाइट बचाता है क्योंकि
                     इनपुट, एन, को अन्य तर्क के रूप में इस्तेमाल किया जाता है।
   , - एक सूची में वर्तमान तत्व और एन जोड़ी।
    b - उन्हें बाइनरी में बदलें।
      l - उनकी लंबाई प्राप्त करें।
        y - फिर जांचें कि क्या वे समान हैं।
           ⟪Run - सभी मान्य पूर्णांकों को एक डेडिक ब्लॉक के माध्यम से चलाएं।
            ^ - XOR प्रत्येक N के साथ।
             b - बाइनरी और सम में कनवर्ट करें (बाइनरी में 1s गिनें)
                 ⌋ - न्यूनतम।

— श्री Xcoder
स्रोत

2

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

यह किसी भी लंबाई के रिकॉर्ड को तोड़ने वाला नहीं है, लेकिन मैंने सोचा कि इसे वैसे भी पोस्ट करूंगा

⟨⟨{⟦^₂ᵐḃᵐ}{h∋Q.l~t?∧}ᶠ{ḃl}⟩zḃᶠ⟩{z{∋≠}ᶜ}ᵐ⌋

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

— Kroppeb
स्रोत

बस एहसास हुआ कि ज़िपिंग एक चीज़ है। डिनर से वापस आने के बाद मैं इसे छोटा

— करूंगा

1

@Arnauld हाँ, मुख्य समस्या यह थी कि प्रत्येक i के लिए श्रेणी (0, n + 1) में मैंने श्रेणी को पुनर्गठित किया, इसे चुकता किया और बाइनरी किया। इसे बाहर रखकर कुछ और बाइट्स की भर्ती की गई, लेकिन अब यह तेजी से आगे बढ़ रही है

— Kroppeb

2

x86-64 विधानसभा, 37 बाइट्स

बाईटकोड:

53 89 fb 89 f9 0f bd f7 89 c8 f7 e0 70 12 0f bd
d0 39 f2 75 0b 31 f8 f3 0f b8 c0 39 d8 0f 42 d8
e2 e6 93 5b c3

अच्छी तरह से, यह एक सेकंड से भी कम समय में उच्चतम उदाहरण की गणना करता है।

एल्गोरिथ्म का दिल हमेशा की तरह xor / popcount है।

    push %rbx
    /* we use ebx as our global accumulator, to see what the lowest bit
     * difference is */
    /* it needs to be initialized to something big enough, fortunately the
     * answer will always be less than the initial argument */
    mov %edi,%ebx
    mov %edi,%ecx
    bsr %edi,%esi
.L1:
    mov %ecx,%eax
    mul %eax
    jo cont     /* this square doesn't even fit into eax */
    bsr %eax,%edx
    cmp %esi,%edx
    jnz cont    /* can't invert bits higher than esi */
    xor %edi,%eax
    popcnt %eax,%eax
    cmp %ebx,%eax   /* if eax < ebx */
    cmovb %eax,%ebx
cont:
    loop .L1
    xchg %ebx,%eax
    pop %rbx
    retq

— ObsequiousNewt
स्रोत

अपने कम से कम एक जगह का सुझाव movएक साथxchg

— ceilingcat

जहां तक मैं बता सकता हूं कि केवल एक ही बाइट बचाएगी ( mov %ecx,%eax) और मैं वहां% ecx को मरने नहीं दे सकता।

— नया

1

वोल्फ्राम भाषा (गणितज्ञ) , 67 बाइट्स

Min@DigitCount[l=BitLength;#~BitXor~Pick[s=Range@#^2,l@s,l@#],2,1]&

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

$\{1, 2, \ldots, n\}$ BitLengthPickBitXorMinDigitCount1

— जंगहवान मिन
स्रोत

1

चारकोल , 31 बाइट्स

ＮθＩ⌊ＥΦＥθ↨×ιι²⁼ＬιＬ↨θ²ΣＥ↨θ²¬⁼λ§ιμ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ                              Input N
       θ                        N
      Ｅ                         Map over implicit range
          ιι                    Current value (twice)
         ×                      Multiply
        ↨   ²                   Convert to base 2
     Φ                          Filter over result
               ι                Current value
                  θ             N
                 ↨ ²            Convert to base 2
              Ｌ Ｌ               Length
             ⁼                  Equals
    Ｅ                           Map over result
                       θ        N
                      ↨ ²       Convert to base 2
                     Ｅ          Map over digits
                           λ    Current base 2 digit of N
                             ι  Current base 2 value
                              μ Inner index
                            §   Get digit of value
                          ⁼     Equals
                         ¬      Not (i.e. XOR)
                    Σ           Take the sum
   ⌊                            Take the minimum
  Ｉ                             Cast to string
                                Implicitly print

— नील
स्रोत

1

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

BL’Ø.ṗŻ€©Ḅ^⁸Æ²a§ɼ¹ƇṂ

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

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

1

पायथन 2 , 82 बाइट्स

lambda n:min(bin(i*i^n).count('1')for i in range(n)if len(bin(i*i^n))<len(bin(n)))

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

— TFeld
स्रोत

1

जाप `-g` , 20 बाइट्स

यह नीचे गोल्फ हो सकता है।

op f_¤Ê¥¢lÃ®^U ¤¬xÃn

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत

1

सी (जीसीसी) , 93 91 बाइट्स

g(n){n=n?n%2+g(n/2):0;}m;i;d;f(n){m=99;for(i=0;++i*i<2*n;m=g(d=i*i^n)<m&d<n/2?g(d):m);n=m;}

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

संपादित करें: मुझे लगता है कि मेरा मूल समाधान ( इसे ऑनलाइन आज़माएं! ) मान्य नहीं है, क्योंकि चर में mसे एक, प्रकार को निर्दिष्ट न करके कुछ बाइट्स को बचाने के लिए वैश्विक, के बाहर इनिशियलाइज़ किया गया था f(n)और इसलिए कॉल के बीच पुनर्निमाण किया जाना था

असमतल और टिप्पणी कोड:

g(n){n=n?n%2+g(n/2):0;} // returns the number of bits equal to 1 in n
m; //miminum hamming distance between n and a square
i; //counter to browse squares
d; //bitwise difference between n and a square
f(n){m=99; //initialize m to 99 > size of int (in bits)
    for(
        i=0;
        ++i*i<2*n; //get the next square number, stop if it's greater than 2*n
        g(d=i*i^n)<m&&d<n/2&&(m=g(d)) //calculate d and hamming distance
//      ^~~~~~~~~~~^ if the hamming distance is less than the minimum
//                    ^~~~^ and the most significant bit of n did not change (the most significant bit contains at least half the value)
//                           ^~~~~~~^ then update m
       );
    n=m;} // output m

संपादन:

सेविंग के लिए 2 बाइट्स धन्यवाद

— Annyo
स्रोत

कुछ बिट्स टॉगल करें और एक वर्ग प्राप्त करें

उदाहरण

नियम

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

रूबी, 74 बाइट्स

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

व्याख्या

भूसी , 20 बाइट्स

व्याख्या

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

05AB1E , 20 15 बाइट्स

जावा (JDK 10) , 110 बाइट्स

गैया , 18 बाइट्स

टूट - फूट

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

x86-64 विधानसभा, 37 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 67 बाइट्स

चारकोल , 31 बाइट्स

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

पायथन 2 , 82 बाइट्स

जाप -g , 20 बाइट्स

सी (जीसीसी) , 93 91 बाइट्स

असमतल और टिप्पणी कोड:

संपादन:

जाप `-g` , 20 बाइट्स