एन-आयामी वैक्टर की गणना करना

Question

एक सकारात्मक पूर्णांक k > 1और एक गैर-नकारात्मक पूर्णांक को देखते हुए i, गैर-नकारात्मक पूर्णांकों का एक k-टल (या k-आयामी वेक्टर) उत्पन्न करते हैं। प्रत्येक के लिए k, ℕ से , ^k तक का नक्शा, विशेषण होना चाहिए । यही है, हर इनपुट iको एक अलग ट्यूपल का उत्पादन करना चाहिए, और हर संभव ट्यूपल को कुछ इनपुट द्वारा उत्पादित किया जाना चाहिए i।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं।

आप आउटपुट के लिए किसी भी सुविधाजनक, स्पष्ट, फ्लैट सूची प्रारूप का उपयोग कर सकते हैं।

आपके समाधान पर कोई कृत्रिम सीमा नहीं होनी चाहिए kऔर iआप यह मान सकते हैं कि वे आपकी भाषा के मूल पूर्णांक आकार में फिट हैं। बहुत कम से कम, आपको मूल्यों का समर्थन करना चाहिए 255, हालांकि, यहां तक ​​कि आपके मूल पूर्णांक का आकार इससे छोटा है।

किसी के लिए 1 < k < 32, अपने कोड सेकंड के एक मामले में एक परिणाम का उत्पादन करना चाहिए (बेशक, अगर आपका जवाब का समर्थन नहीं करता पिछले शासन के लिए है कि बड़े कारण, सीमा तदनुसार समायोजित किया जाता है)। यह कोई समस्या नहीं होनी चाहिए: यह इस चुनौती को हल करने के ऐसी है कि वह 2 अप करने के लिए काम करता है संभव है ¹²⁸ कुछ ही सेकंड में है, लेकिन सीमा से बचने के जवाब जो वास्तव में पुनरावृति से करने के लिए नहीं है के लिए परिणाम खोजने के लिए।i < 231i0i

कृपया अपने उत्तर में अपने चुने हुए मानचित्रण का विवरण और क्यों यह विशेषण है के लिए एक औचित्य शामिल करें (यह एक औपचारिक प्रमाण होने की आवश्यकता नहीं है)।

यह कोड गोल्फ है, सबसे छोटा उत्तर (बाइट्स में) जीतता है।

संबंधित चुनौतियाँ

• एक गैर-नकारात्मक से पूर्णांक की एक जोड़ी उत्पन्न करें
• सभी तर्कसंगत संख्याओं की सूची तैयार करें

Answer 1

पायथ, 15 12 बाइट्स

ms+0_%Q>_zdQ

परीक्षण सूट

मेरा परिवर्तन xnor में से एक के समान है, लेकिन आधार १० में। यह इनपुट को k अलग संख्याओं में खोलकर काम करता है:

n = 21003034
k = 3

21003034
 1  3  4    134
2  0  3     203
  0  0        0

संख्याओं को सही अंक की घटती स्थिति में क्रमबद्ध किया जाता है, ताकि संख्याओं के किसी भी समूह के सभी क्रम संभव हो सकें।

जिस तरह से कोड काम करता है हम इनपुट को उल्टा करते हैं, फिर अंतिम 0, 1, ... k-1अंकों को काटते हैं, फिर प्रत्येक kवें अंक को लेते हैं, फिर 0से उलटते हैं, भीख पर एक छड़ी करते हैं, और इंट में परिवर्तित करते हैं।

Answer 2

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

q~({4b2fmd2/z2fb~p}*

मानचित्रण इस उत्तर के - 1 बार से मानचित्रण लागू करने के बाद से विशेषण है ।

कार्यक्रम इनपुट के रूप में पढ़ता है i k। CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

हम एक विशेषण मानचित्रण f का निर्माण कर सकते हैं : n → N ² को परिभाषित करके f (i) निम्नानुसार है:

• मुझे इसके बाइनरी अंकों की सरणी में परिवर्तित करें ।

• यदि अंकों की विषम संख्या है, तो इस सरणी में 0 को प्रीपेंड करें ।

• परिणामी सरणी को Deinterleave करें, प्रक्रिया में नए लोगों के लिए।

• उन सरणियों को आधार 2 से पूर्णांक में बदलें। परिणामों के रूप में f ₁ (i) और f ₂ (i) को परिभाषित करें ।

एक विशेषण मानचित्रण जी प्राप्त करने के लिए : एन → एन ³ , हम जी (एन): = (एफ ₁ (आई), एफ ₁ (एफ ₂ (आई)), एफ ₂ (एफ ₂ (आई))) को परिभाषित कर सकते हैं ।

एक विशेषण मानचित्रण h प्राप्त करने के लिए : N → N ⁴ , हम h (i) को परिभाषित कर सकते हैं : = (g ₁ (i), g ₂ (i), f ₁ (g ₃ (i)), f ₂ (g ₃ ( i)) ।

उपरोक्त प्रक्रिया को जारी रखते हुए, हम अंततः एक जीवनी मानचित्र N → N ^k पर पहुंचते हैं ।

कोड

q~      e# Read and evaluate all input. This pushes i and k.
({      e# Do k-1 times:
  4b    e#   Convert the integer on the stack (initially i) to base 4.
  2fmd  e#   Replace each base-4 digit d by d/2 and d%2.
  2/    e#   Split into the chunks [d/2 d%2].
  z     e#   Transpose. This collects all quotients in one array and all
        e#   residues in another one.
  2fb   e#   Convert each array from base 2 to integer.
  ~     e#   Dump both integers on the stack.
  p     e#   Print the topmost one.
}*      e#

Comments

xnor का विचार 20 बाइट्स भी देता है (या इससे कम यदि आप इसे गोल्फ से बेहतर करते हैं तो मैंने किया है): q~2bW%1$Te]/zWf%2fbp(विपरीत इनपुट ऑर्डर)

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

Answer 3

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

q~({)2bW%_1#p))b}*

यह अधिक बेवकूफ सूत्र का उपयोग करता है।

इसे यहाँ आज़माएँ ।

व्याख्या

q~          e# Read input.
({          e# Repeat k-1 times:
    )       e# Increment the current integer (initially i), to make it positive.
    2b      e# Convert to binary.
    W%      e# Reverse the binary.
            e# The result can be any non-empty binary string without trailing 0s.
    _1#     e# Find the position of the first 1, or the number of initial 0s.
    p       e# Print.
    )       e# Extract the final bit, which is always 1.
            e# An array that can be any binary string is left in the stack.
    )       e# Increment the 1 to make it 2.
    b       e# Convert the binary string to a number using base 2.
            e# Only the number of initial 0s doesn't affect the result,
            e# which is exactly what is printed before.
}*          e# The final integer is printed automatically when the program ends.

सारांश में, यह एक सकारात्मक पूर्णांक को मैप करता है:

1. अनुगामी शून्य की संख्या।
2. अनुगामी शून्य के साथ मूल पूर्णांक हटा दिया गया, उलट गया, और अनुगामी (मूल रूप से प्रारंभिक) 1 हटा दिया गया।

Answer 4

अजगर 2, 62

lambda z,k:[int('0'+bin(z)[~i:1:-k][::-1],2)for i in range(k)]

यह कोड बदसूरत और गोल्फ है, लेकिन विचार बहुत सरल है।

kप्रत्येक kऑफसेट को अलग-अलग ऑफसेट के साथ पढ़कर एक में बाइनरी विस्तार पैक करें । उदाहरण के लिए, k=3इनपुट 357नक्शे के साथ (3,0,7):

101100101 <- 357
  1  0  1 -> 5
 0  0  0  -> 0
1  1  1   -> 7

संख्याओं को एक साथ वापस जोड़ने से इसका उलटा होता है, इसलिए यह एक आपत्ति है। ऐसा करने में, द्विआधारी विस्तार के बारे में सोचें, क्योंकि अनंत संख्या में अग्रणी शून्य हैं।

Answer 5

जे, 38 28 27 बाइट्स

(({.,g^:_1@}.)g=:_ q:>:)~<:

यह एक टैसिट, डियाडिक क्रिया है जो बाएं और दाएं तर्कों के रूप में i और k लेता है। इसे Jjs के साथ ऑनलाइन आज़माएं ।

विचार

हम एक नक्शा f: N → N ^k को f (i): = (α ₁ ,… α _k-1 , p ₁ ^{α _k} … p ₂ ^{α _{k + 1}} … - 1) से परिभाषित करते हैं , जहां ⟩p _n the है अभाज्य संख्याओं का क्रम और I + 1 = p ₁ ^{α ₁} p ₂ ^{α ₂} … ।

मौलिक अंकगणित प्रमेय, नक्शे तक छ: लागू नहीं → एन ^ω द्वारा परिभाषित जी (i): = (α ₁ , α ₂ , ...) (के प्रधानमंत्री गुणन की एक्स्पोनेंट्स i + 1 द्विभाजित है)।

चूँकि f (i) = (g ₁ (i),… g _k-1 (i), g ^-1 (g _k (i), g _{k + 1} (i),…) , मानचित्र f जैसा विशेषण है कुंआ।

कोड

                            Left argument: i -- Right argument: k
                         <: Decerement k.
(                      )~   Reverse the order of the arguments and apply the
                            dyadic verb inside the parentheses to k-1 and i.
              g=:            Define a monadic helper verb g:
                     >:       Increment its right argument.
                 _ q:         Calculate the exponents of the prime factorization.
                             (implicit) Apply g to i.
(            )               Apply the dyadic verb inside the parentheses to k-1
                             and (g i).
           }.                 Drop the first k-1 elements of (g i)...
          @                   and...
     g^:_1                    apply the inverse of g to the result.
  {.                          Take the first k-1 elements of (g i).
    ,                         Append the rightmost result to the leftmost one.

Comments

आपका फ़ंक्शन विशेषण क्यों है?

— xnor

@xnor कम से कम मेरे स्पष्टीकरण में से एक नहीं था, क्योंकि मैंने गलती से कुछ सूचकांकों की अदला-बदली कर ली थी। मैंने एक प्रूफ स्केच जोड़ा है।

— डेनिस

Answer 6

अजगर 2, 72

q=lambda z:z and z%2+2*q(z/4)
g=lambda z,k:1/k*[z]or[q(z)]+g(q(z/2),k-1)

फ़ंक्शन qबाइनरी नंबरों पर कार्य करता है जो अंत से शुरू होने वाला हर दूसरा बिट लेता है। नतीजतन q(z), q(z>>1), दो नंबर देता है जिनके बाइनरी अंक देने के लिए प्रतिच्छेदन होता है z। उदाहरण के लिए, 594 12 और 17 में विभाजित होता है।

1001010010   <- 594
 0 1 1 0 0   ->  12
1 0 0 0 1    ->  17

यह एक आपत्ति है क्योंकि हम मूल संख्या को पुनर्प्राप्त करने के लिए संख्याओं को एक साथ वापस कर सकते हैं।

फ़ंक्शन gइस आक्षेप k-1समय को लागू करता है , एक तत्व से एक जोड़ी से एक ट्रिपल ... k-tuple तक विस्तारित होता है। हर बार, अंतिम तत्व को दो तत्वों तक विस्तारित किया जाता है। यह बायर्स के माध्यम से एक जोड़ी के इनपुट को मैप करके, आउटपुट के पहले एंट्री के लिए पेयर के पहले एलिमेंट को ले कर और k-1बाकी एंट्रीज़ को प्रोड्यूस करने के लिए दूसरे एलिमेंट के साथ फंक्शन को दोबारा अप्लाई करके किया जाता है।

Comments

मुझे एहसास हुआ कि मैं इस तरह से बहुत जटिल बना रहा हूँ ...

— xnor