कई आधार लेकिन एक ही अंक के दो बार नहीं

Question

इनपुट

सकारात्मक पूर्णांक का एक गैर-खाली सरणी।

कार्य

प्रत्येक पूर्णांक को बाइनरी, ऑक्टल, दशमलव या हेक्साडेसिमल में इस तरह से कनवर्ट करें कि प्रत्येक अंक ( 0 से एफ ) का उपयोग सबसे अधिक बार किया जाए।

उत्पादन

उन ठिकानों की सूची जिनका उपयोग पहेली को हल करने के लिए किया गया था।

विस्तृत उदाहरण

के लिए उम्मीद उत्पादन [16, 17] है [अष्टाधारी, दशमलव] ।

यहाँ क्यों है:

• हम केवल दोनों संख्याओं के लिए दशमलव का उपयोग नहीं कर सकते हैं, क्योंकि वे दोनों में 1 शामिल है ।
• 16 को बाइनरी में नहीं बदला जा सकता है, क्योंकि इस बेस ( 10000 ) में इसके प्रतिनिधित्व में कई 0 हैं ।
• 17 को बाइनरी में परिवर्तित नहीं किया जा सकता है, क्योंकि इस बेस ( 10001 ) में इसके प्रतिनिधित्व में कई 0 और कई 1 हैं ।
• 17 को हेक्साडेसिमल में नहीं बदला जा सकता है, क्योंकि इस बेस ( 11 ) में इसके प्रतिनिधित्व में दो 1 's हैं।

• आइए शेष सभी संभावनाओं पर विचार करें:

                 +---------+---------+--------+
                 | oct(16) | dec(16) | hex(16)|
                 | = 20    | = 16    | = 10   |
  +--------------+---------+---------+--------+
  | oct(17) = 21 | 20,21   | 16,21   | 10,21  |
  | dec(17) = 17 | 20,17   | 16,17   | 10,17  |
  +--------------+---------+---------+--------+
  

  एकमात्र संभव समाधान 16 को अष्टक ( 20 ) में बदलना और 17 को दशमलव ( 17 ) में रखना है । इस तरह, अंक 0 , 1 , 2 और 7 का उपयोग एक बार किया जाता है।

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

• इनपुट को एक अद्वितीय समाधान की ओर ले जाने की गारंटी है। आपका कोड उन सरणियों का समर्थन करने वाला नहीं है जो कई समाधान देते हैं या कोई समाधान नहीं देते हैं।
• आप किसी भी उचित प्रारूप में आधारों का उत्पादन कर सकते हैं, जैसे ["बिन" , "ओक्ट" , "डिक ", "हेक्स"] , ['बी', 'ओ', 'डी', 'एच'] , '' बीओडीएच '' " , [२,,,१०,१६] , [०,१,२,३]] लेकिन यह आपके उत्तर में स्पष्ट रूप से बताया जाना चाहिए।
• आउटपुट में आधारों का क्रम इनपुट पूर्णांकों के क्रम से मेल खाना चाहिए।
• यदि वह मदद करता है, तो आप मान सकते हैं कि इनपुट सबसे कम से उच्चतम तक, या उच्चतम से सबसे कम क्रमबद्ध है।
• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

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

आपको नीचे सूचीबद्ध रूपांतरण परिणामों को आउटपुट करने की आवश्यकता नहीं है। वे विशुद्ध रूप से सूचनात्मक हैं।

Input                                  | Output          | Conversion result
---------------------------------------+-----------------+------------------------
[ 119 ]                                | O               | 167
[ 170 ]                                | D               | 170
[ 64222 ]                              | H               | FADE
[ 16, 17 ]                             | O/D             | 20/17
[ 14, 64, 96 ]                         | H/H/D           | E/40/96
[ 34, 37, 94 ]                         | O/D/H           | 42/37/5E
[ 2, 68, 82 ]                          | B/D/H           | 10/68/52
[ 22, 43, 96 ]                         | O/O/O           | 26/53/140
[ 3639, 19086, 57162 ]                 | H/D/H           | E37/19086/DF4A
[ 190, 229, 771 ]                      | O/H/O           | 276/E5/1403
[ 2, 44, 69, 99 ]                      | B/H/H/H         | 10/2C/45/63
[ 75, 207, 218, 357, 385 ]             | H/H/H/D/O       | 4B/CF/DA/357/601
[ 12, 28, 46, 78, 154, 188, 222, 240 ] | D/O/O/D/H/H/H/H | 12/34/56/78/9A/BC/DE/F0

कच्चे इनपुट सूची यहाँ उपलब्ध है ।

Comments

क्या हमें दक्षता के कुछ पहलू की परवाह करनी चाहिए? (जैसे अगर सरणी की लंबाई 1000 या उससे कुछ अधिक है)

— डैनियलइंडी

@DanielIndie नहीं, आपको नहीं करना है। इसके अलावा, 1000 प्रविष्टियों की एक पहेली में बहुत सारे डुप्लिकेट अंक शामिल होंगे, कोई फर्क नहीं पड़ता कि आधार का उपयोग किया जाता है, इसलिए यह संभवतः एक वैध नहीं हो सकता है। (यह पहले नियम के अनुसार नहीं होने की गारंटी है।)

— अर्नुलद

हाँ, आप सही हैं ... मुझे बेवकूफ

— बनाइए

वास्तव में एक जाप समाधान की प्रतीक्षा कर रहा हूं, क्योंकि मैंने इसे आजमाया और एक अच्छा नहीं मिला।

— नाइट

@ सरकोबल नहीं। :) अच्छा प्रयास!

— अरनौलड

Answer 1

जावास्क्रिप्ट (Node.js) , 192,155,154,152,151,145,136,113,99,92 90 बाइट

• मुझे याद दिलाने के लिए @Arnauld का धन्यवाद कि मैं [0,1,2,3] -> जो कि [2,8,10,16] है, 8 बाइट्स बचाता है, और शानदार विचार के लिए (जो 23+ से कम करने में मदद करता है बाइट्स)
• 1 बाइट्स कम करने के लिए @ केविन क्रूज़सेन को धन्यवाद

f=([c,...a],t="")=>c?[1,4,5,8].find(b=>T=!/(.).*\1/.test(n=t+c.toString(b*2))&&f(a,n))+T:a

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

स्पष्टीकरण:

[c,...a]- @ एक समय में एक आइटम लेने के लिए ट्रंक c?***:" "-> अगर सी अपरिभाषित है तो हम अंतिम परिणाम प्राप्त करने में कामयाब रहे- [] - अगर मैं "" को ढूंढने की तुलना में वैध नहीं मानूंगा । ([] + ५ = "५" जेएस एफटीडब्ल्यू) [1,4,5,8].findहर बार जब हम सही आधार पाते हैं (आउटपुट इस सरणी (१,४,५, ()) का होगा -> (२,,,१०,१६) इसकी वैधता। अब यह कैसे काम करता है -> यदि यह कुछ पाता है तो यह तत्व (1-8) और आंतरिक समाधान के परिणाम को जोड़ देता है। यदि यह नहीं दिखता है तो यह अपरिभाषित हो जाता है + T अब गलत है -> NaN जो माता-पिता की कॉल को गलत माना जाएगा

!/(.).*\1/.test(n=t+b) निर्धारित करें कि क्या स्ट्रिंग में डुप्लिकेट है, यदि ऐसा है:

f(a,n)) बस अगले नंबर पर जाएँ (एक अब array.slice (1)) नई स्ट्रिंग के साथ (n)

हम परिणाम के टी (अस्थायी) के लिए परिणाम प्रदान करते हैं क्योंकि ढूंढने पर स्टॉप मिल जाता है और इसलिए हम जानते हैं कि अंतिम परिणाम f () होगा जो परिणाम B है

Comments

t="",B=""करने के लिए t="",B=tएक बाइट की बचत होगी।

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

@KevinCruijssen ने समाधान अपडेट किया, धन्यवाद :) (और आप

— अरनुलड को

@Arnauld मैंने आपका शानदार विचार लिया और कुछ अनुकरण किया। अब समाधान देखें

— डैनियलइंडी

@ अर्नुलड शुद्ध अस्वस्थता

— डैनियलइंडी

ठंडा! चलो 2 और बाइट्स को शेव करें (और trim()अब कोई ज़रूरत नहीं है)।

— अरनौलड

Answer 2

पर्ल 5 -alp , 55 बाइट्स

%xहेक्स के लिए, %dदशमलव के लिए, %oअष्टक के लिए और %bबाइनरी के लिए उपयोग करता है

#!/usr/bin/perl -alp
($_)=grep{sprintf($_,@F)!~/(.).*\1/}glob"%{d,o,b,x}"x@F

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

Answer 3

रूबी, 72 71 बाइट्स

->a{a.map{%w[b o d x]}.inject(&:product).find{|c|/(.).*\1/!~[p,c]*?%%a}}

आउटपुट स्वरूप कुछ प्रकार की रिवर्स एस-एक्सप्रेशन मोनरोस्ट्रिटी है:

f[[12, 28, 46, 78, 154, 188, 222, 240]]
=> [[[[[[["d", "o"], "o"], "d"], "x"], "x"], "x"], "x"]

इसके बजाय इसे अलग करने से 3 और बाइट्स (एपेंडिंग *?/) खर्च होंगे ।

यह प्रारूप लूप संरचना से आता है, अधिक मुहावरेदार की तुलना में थोड़ा छोटा है repeated_combination(a.size), जो वर्णों के सरणियों की एक सरणी उत्पन्न करता है और फिर इसे क्रॉस-उत्पाद फ़ंक्शन पर कम कर देता है।

संपादित करें: लिन के लिए 1 बाइट धन्यवाद सहेजा गया।

Answer 4

पायथ, 21 20 बाइट्स

f{Is.bjYNTQ^[8T2y8)l

आधारों की सभी संभावित सूचियों की सूची देता है (जिनकी हमेशा लंबाई 1 होती है)।
इसे यहाँ आज़माएँ

व्याख्या

f{Is.bjYNTQ^[8T2y8)l
           ^[8T2y8)lQ  Get the tuples of bases of the same length as the input.
f                      Filter to get those...
    .bjYNTQ            ... where converting bases elementwise...
   s                   ... and joining together...
 {I                    ... has no repeats.

Answer 5

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 71 बाइट्स

Cases[2{1,4,5,8}~Tuples~Tr[1^#],b_/;UnsameQ@@Join@@IntegerDigits[#,b]]&

आधारों की सूची लौटाएं।

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

Answer 6

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

⁴⁽%ʠḃṗL³bF⁼Q$ƲÐf

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

आधारों की सूची लौटाएं।

 == स्पष्टीकरण ==
⁴⁽% ⁴⁽L³bF⁼Q $ linkf मुख्य लिंक।
 ʠ% ʠ एक संख्या।
    ḃ इसे विशेषण आधार में बदलें ...
⁴ 16. परिणाम [2,8,10,16] है।
     । एल कार्टेसियन शक्ति इनपुट लंबाई द्वारा।
             ƲÐf फ़िल्टर करें, उन्हें संतुष्ट रखें ...
       ³ इनपुट
        b उस आधार में परिवर्तित करें
         F समतल होने पर (सभी अंकों को मिलाएं)
                      विभिन्न संख्याएँ एक साथ)
          IfiedQ $ खुद के बराबर है।

Answer 7

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

from itertools import*
a=input()
for b in product(*['bdxo']*len(a)):
 s=''.join(map(format,a,b))
 if len(s)==len(set(s)):print b

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

Answer 8

05AB1E , 17 बाइट्स

2žv8T)sgãʒIsв˜DÙQ

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

Comments

मुझे 05AB1E नहीं पता है, इसलिए शायद मुझे तब तक इंतजार करना चाहिए जब तक कि आप इससे पहले कि मैं यह पूछने से पहले स्पष्टीकरण न जोड़ दूं, लेकिन 8चरित्र के लिए परिणाम क्यों है '8', और अन्य तीन पूर्णांक हैं? +1 हालांकि, अधिक अंतिम परीक्षण मामलों सहित, ठीक काम करने के लिए लगता है।

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

@ केविनक्रूजसेन "2žv8T" से आ रहा है। स्रोत कोड में संख्याओं को 05AB1E में वर्णों के रूप में धकेल दिया जाता है, जबकि žv (16) और T (10) बिल्ट-इन होते हैं जो स्टैक पर अपनी संबंधित संख्या को धक्का देते हैं। यह आमतौर पर किसी का ध्यान नहीं जाता है क्योंकि स्टैक में अंतिम तत्व का 05AB1E का अंतर्निहित प्रदर्शन संख्याओं में परिवर्तित हो जाता है, लेकिन चूंकि इस मामले में प्रदर्शित परिणाम तत्वों की एक सरणी है, इसलिए उन तत्वों को अछूता छोड़ दिया जाता है, इसलिए उद्धरण। कमांड command उदाहरण के लिए इस्तेमाल किया जा सकता है) के बाद दो चार तत्वों को सम्मिलित करने के लिए।

— कलडो

@KevinCruijssen मेरे स्पष्टीकरण का उदाहरण: tio.run/##MzBNTDJM/f/fyPbQDtv//wE कोड: 2 पुश, प्रिंट करें, एक सरणी में प्रिंट करें, प्रिंट करें।

— कलडो

Answer 9

अजगर २ , 121 117 113 111 बाइट्स

def f(a,d='',s=''):
 if a:
	for c in'bodx':t=format(a[0],c)+s;len(t)-len(set(t))or f(a[1:],d+c,t)
 else:print d

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

टोपी की टिप लिन के लिएformat , जिसे मैं भूल गया था!

Answer 10

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

fȯS=UΣz`B¹πmDd1458L

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

आधारों की सूची लौटाता है

व्याख्या

fȯS=UΣz`B¹πmDd1458L  Implicit input
                  L  Length of input
          π          Cartesian power of
             d1458     The digits of 1458  [1,4,5,8]
           mD          Double the digits   [2,8,10,16]
fȯ                   Filter by
      z`B¹             Zip with input by converting to its base
     Σ                 Concatenate
  S=U                  Equal to itself with unique elements