चुनौती

आपको दिया गया है:

धनात्मक पूर्णांक की एक गैर-खाली, अनसोल्ड सूची h (हैस्टैक)
एक धनात्मक पूर्णांक n (सुई)

आपका कार्य h के क्रमपरिवर्तन के सभी अनूठे दशमलव समाकलन की सूची को वापस करना है जिसके बाइनरी प्रतिनिधित्व में n का बाइनरी प्रतिनिधित्व है ।

उदाहरण

h = [१, २, ३]
n = ६५

केवल एक मिलान मिलान है, इसलिए अपेक्षित आउटपुट है [321]।
h = [१, २, ३]
n = 2

इस बार, तीन संयोजन हैं जिनमें बाइनरी पैटर्न 111 शामिल हैं । अपेक्षित आउटपुट है [123, 231, 312]।
h = [१२, ३]
n = 3

केवल दो क्रमपरिवर्तन उपलब्ध हैं और दोनों मिलान कर रहे हैं। अपेक्षित आउटपुट है [123, 312]।
h = [१, २, २]
n = १५

एकमात्र मिलान मिलान 122 ( बाइनरी में 1111010 , जिसमें 1111 शामिल हैं ) है, इसलिए अपेक्षित आउटपुट है [122]। ध्यान दें कि दो क्रमपरिवर्तन वास्तव में 122 तक ले जाते हैं लेकिन आपको आउटपुट की अनुमति नहीं है[122, 122] ।

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

आप सुई को पूर्णांक ( 65), दशमलव मान का प्रतिनिधित्व करने वाली स्ट्रिंग ( "65") या बाइनरी मान का प्रतिनिधित्व करने वाले स्ट्रिंग ( "1000001") के रूप में ले सकते हैं।
आप मूल सारणी / वस्तु / पूर्णांक के सेट ( [11,12,13]), एक मूल सरणी / वस्तु / सेट को दशमलव मानों ( ["11","12","13"]), या दशमलव मानों ( "11 12 13"या "11,12,13") के सीमांकित स्ट्रिंग के रूप में सेट कर सकते हैं । आप अंकों के सरणियों (जैसे [[1,1],[1,2],[1,3]]) का उपयोग कर एक प्रकार का विकल्प भी चुन सकते हैं ।
आउटपुट को हाईस्टैक के लिए ऊपर वर्णित स्वरूपों में से एक का पालन करना चाहिए, लेकिन जरूरी नहीं कि वही हो।
आप ऐसी हाइस्टैक को संभालने वाले नहीं हैं जिसका उच्चतम दशमलव संयोजन आपकी भाषा में उच्चतम प्रतिनिधित्व योग्य अहस्ताक्षरित पूर्णांक से अधिक है।
इसके अलावा, आपके कोड को सैद्धांतिक रूप से किसी भी इनपुट का समर्थन करना चाहिए - यह मानते हुए कि उसे पर्याप्त समय और मेमोरी दी गई है।
यह ~~सपार्टा है!~~ कोड-गोल्फ , तो बाइट्स में सबसे छोटा जवाब जीत!

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

Haystack             | Needle   | Output
---------------------+----------+-----------------------------------
[ 1, 2, 3 ]          | 65       | [ 321 ]
[ 1, 2, 3 ]          | 7        | [ 123, 231, 312 ]
[ 12, 3 ]            | 7        | [ 123, 312 ]
[ 1, 2, 2 ]          | 15       | [ 122 ]
[ 1, 2 ]             | 7        | []
[ 12, 34, 56 ]       | 21       | [ 125634, 341256, 345612, 563412 ]
[ 1, 2, 3, 4, 5 ]    | 511      | [ 53241 ]
[ 1, 3, 5, 7, 9 ]    | 593      | [ 37519, 51793, 75913, 75931 ]
[ 11, 12, 13, 14 ]   | 12141311 | [ 12141311 ]
[ 1, 2, 1, 2, 1, 2 ] | 1015     | [ 221112 ]

code-golf binary permutations

— Arnauld
स्रोत

1

मेरे समाधान के उत्पादन की तरह है set([(1, 2, 2)])। क्या यह वैध है या मुझे इससे छुटकारा चाहिए set?

— मृत पोसुम

@DeadPossum हाँ, यह मान्य है।

— अरनौलद

क्या हिस्टैक इनपुट एकल स्ट्रिंग ("123") हो सकता है? कुछ भाषाओं में एक तार वर्णों की एक सरणी के समान है, इसलिए मुझे लगता है कि यह समझ में आता है

— लुइस मेंडू

@LuisMendo यह नहीं हो सकता है ["12","3"]और ["1","23"]दो अलग-अलग haystacks हैं।

— अरनौल

@ अर्नुलद आह, मुझे लगा कि वे अंक हैं। धन्यवाद

— लुइस मेंडू

17

05AB1E , 10 8 बाइट्स

बाइट में सुई को 1 बाइट बचाने के लिए लेता है।

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

œJÙʒbŒIå

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

œJÙʒbŒIå   Arguments: a, n
œJÙ        Get all unique permutations of a
   ʒ       Filter: Keep if following code returns true
    b      Convert to binary
     Œ     Get all substrings
      Iå   Check if substrings contain n
           Implicit output of filtered list

— kalsowerus
स्रोत

1

œJ .bœIå के रूप में अच्छी तरह से काम करना चाहिए।

— एमिगा

@Eigna धन्यवाद, कि 2 बाइट बचाता है :)

— kalsowerus

11

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

-3 बाइट्स @ गेबर फेकेट की बदौलत

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

तार के इनपुट सरणी के रूप में ले जाता है, घास और स्ट्रिंग से स्याही का प्रतिनिधित्व करता है, बाइनरी में सुई का प्रतिनिधित्व करता है

from itertools import*
lambda H,N:{i for i in permutations(H)if N in bin(int(''.join(i)))}

— मृत पोसुम
स्रोत

4

लिखने के {...}बजाय set(...)3 बाइट्स बचाता है।

— गैबोर फेकेट

1

@ GáborFekete मैं हमेशा भूल जाता हूं, कि {} सेट है: D धन्यवाद

— डेड पॉसम

मेरा मानना है कि यह विफल रहता है H=['1'], N='0'।

— user2357112

ओह, रुको, सकारात्मक होने के लिए इनपुट आवश्यक है।

— user2357112

10

जावा 10, 320 312 305 297 292 बाइट्स

import java.util.*;Set s=new HashSet();l->n->{Long q=0;p(l,0);for(var x:s)if(q.toString(q.decode(x+""),2).contains(n))System.out.println(x);}void p(List l,int k){int i=k,x=l.size();for(Collections C=null;i<x;p(l,k+1),C.swap(l,k,i++))C.swap(l,i,k);if(k>x-2)s.add((l+"").replaceAll("\\D",""));}

इनपुट के रूप में सूची और बाइनरी-स्ट्रिंग, नई लाइनों पर स्ट्रिंग्स के रूप में आउटपुट।

स्पष्टीकरण:

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

import java.util.*;           // Required import for Set, HashSet, List, and Collections

Set s=new HashSet();          // Class-level Set

l->n->{                       // Method (1) with List and String parameters and no return-type
  Long q=0;                   //  Number-object is required for two static method-calls below
  p(l,0);                     //  Determine all permutations of given list and put it in the Set
  for(var x:s)                //  Loop over these permutations
    if(q.toString(q.decode(x+""),2)
                              //   If the binary String of the current permutation
        .contains(n))         //   contains the binary String of the input integer
      System.out.println(x);} //    Print this permutation

void p(List l,int k){         // Method (2) with List and integer parameters and no return-type
  int i=k,x=l.size();         //  Two temp integers
  for(Collections C;          //  Collections-object is required for two static method-calls below
      i<x                     //  Loop `i` in the range [`k`, list-size)
      ;                       //    After every iteration:
       p(l,k+1),              //     Do a recursive-call to this method with `k+1`
       Collections.swap(l,k,i++))
                              //     And swap the items at indices `k` and `i` back
    Collections.swap(l,i,k);  //   Swap the items at indices `i` and `k`
  if(k>x-2)                   //  If `k` is now equal to the size of the list - 1
    s.add((l+"").replaceAll("\\D",""));}
                              //   Add this permutation to the Set

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

व्यक्तिगत रूप से मैं l->n->{...बाद void p(...में डालूंगा क्योंकि लंबोदर प्रॉम्प्ट का उत्तर है और कार्य करने के लिए लंबोदर के लिए फ़ंक्शन की आवश्यकता है। "फंक्शन एक्सप्रेशंस" पर सहमति कुछ इस तरह है "यदि आपके वेरिएशन को स्टोर किया जाए तो" सबमिशन का आखिरी 'एक्सप्रेशन' फंक्शन एक्सप्रेशन 'हो सकता है। लेकिन यह सिर्फ एक प्रारूपण मुद्दा है, और उस पर एक व्यक्तिपरक है।

— सीएडी 97

@ CAD97 मुझे नहीं पता था कि आदेश का मामला है। पिछली बार मैंने जावा 8 के उत्तर को दो विधियों के साथ पोस्ट किया voidथा, जिनका मैंने उपयोग किया था क्योंकि यह एक दूसरे लैम्बडा और मल्टीपल से कम था .apply। इस उत्तर के लिए इसकी जाँच नहीं की गई (अर्थात void p(List l,int k)& 2x p(l,0)बनाम (l,k)->2x p.apply(l,0))। हम्म .. दूसरा इस मामले में 1 बाइट छोटा लगता है। लेकिन आप कहते हैं कि नियम आपको केवल एक लंबोदर विधि की अनुमति देते हैं? अभी भी थोड़ा उलझन में है कि यह आखिरी क्यों है। व्यक्तिगत रूप से मैं हमेशा इस क्रम में अपने उत्तर पोस्ट करता हूं imports; class-fields; main-method/lambda; other methods:।

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

फिर से, यह ज्यादातर राय है, मैं चाहता हूं कि किसी और को वास्तव में एक तरह से कहने से पहले झंकार का अनुभव किया जाए। हालाँकि, मुझे यह पता है कि यह सच है: यदि आपको किसी विधि (जैसे पुनरावर्ती या सहायक के रूप में) को कॉल करने की आवश्यकता है, तो उसे एक नाम रखना होगा। लेकिन आदेश देने के लिए, यह वास्तव में कोई फर्क नहीं पड़ता क्योंकि यह बाइट गिनती नहीं बदलता है। लेकिन मैं के रूप में आदेशimports;helper methods;lambda

— CAD97

@ CAD97 आह, तो यह होगा और इसके बजाय void p(List l,int k)2x f(l,0);बनाम f=(l,p)->2x p.apply(l,0);होगा (जिसका अर्थ है कि वर्तमान संस्करण 1 बाइट छोटा है)। आदेश के लिए, मैं बस इसी के साथ रहूंगा क्योंकि मैंने अपने सभी उत्तरों के साथ ऐसा किया है, और यह मुझे व्यक्तिगत रूप से स्पष्टीकरण में मुख्य विधि के साथ शुरू करने के लिए भी समझ में आता है, और फिर सहायक विधि (ओं) कोई हैं।

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

और दुर्भाग्य से आप सिर्फ f=(lambda)जावा में नहीं कर सकते , यह हैjava.util.function.BiConsumer<List,Integer>f=(l,p)->{...}

— CAD97

9

जाप , 15 14 13 12 10 बाइट्स

पूर्णांक के एक सरणी के रूप में और एक बाइनरी स्ट्रिंग के रूप में सुई को संभालता है। पूर्णांक तार की एक सरणी आउटपुट।

á m¬f_°¤øV

ETHproductions के लिए एक बाइट धन्यवाद सहेजा गया

कोशिश करो

व्याख्या

á m¬â f_°¤øV
              :Implicit input of array U=haystack and string V=needle
á             :Unique permutations of U
  m           :Map
   ¬          :  Join to a string
    f_        :Filter
      °       :  Postfix increment current element to cast it to an integer
       ¤      :  Convert to base-2 string
        øV    :  Does that contain V?
              :Implicit output of resulting array

— झबरा
स्रोत

बहुत अच्छा है, जो मैंने किया होगा। ®¬nÃमैपिंग पर एक बाइट बचाता है। (मैं âदूसरे से छुटकारा पाने के लिए कार्यक्रम के मध्य में Ã

— जाऊँगा

अहा, धन्यवाद, @ETHproductions - मैं यह देखने पर ध्यान केंद्रित कर रहा था कि क्या मैं प्रत्येक संख्या को आउटपुट करके बाइट को शेव कर सकता हूं क्योंकि एक सरणी के रूप में मैं चूक गया कि मैपिंग में सरल परिवर्तन। âएक त्वरित अंत पर हमला बोला जब Arnauld कहा कि मैं अंतिम सरणी से डुप्लिकेट को निकालने के भूल थी ठीक था, लेकिन, तुम सही हो, फिल्टर चल अधिक कुशल हो रहा था जब डुप्लिकेट हटाने।

— शैगी

4

रूबी , 61 59 बाइट्स

->a,n{a.permutation.select{|s|"%b"%s.join=~/#{"%b"%n}/}|[]}

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

दिन की शांत सुविधा: मुझे नहीं पता था कि मैं एक संख्या वाले स्ट्रिंग के द्विआधारी प्रतिनिधित्व को आउटपुट कर सकता हूं।

उदाहरण:

puts "%b"%"123"

-> 1111011

— जीबी
स्रोत

3

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

बाइनरी स्ट्रिंग के रूप में सुई लेता है।

(h,n,S=new Set,p=(a,m='')=>a.length?a.map((_,i)=>p(A=[...a],m+A.splice(i,1))):S.add(+m),_=p(h))=>[...S].filter(d=>~d.toString(2).indexOf(n))

कोड स्निपेट दिखाएं

f=
(h,n,S=new Set,p=(a,m='')=>a.length?a.map((_,i)=>p(A=[...a],m+A.splice(i,1))):S.add(+m),_=p(h))=>[...S].filter(d=>~d.toString(2).indexOf(n))

console.log( f([1, 2, 3], (65).toString(2)) )
console.log( f([12, 34, 56], (21).toString(2)) )

स्निपेट का विस्तार करें

— darrylyeo
स्रोत

3

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

{hpc.ḃs~ḃ~t?∧}ᵘ

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

व्याख्या

{            }ᵘ    Find all unique outputs, given [h, n], of:
 hpc.                The Output is the concatenation of a permutation of h
    .ḃs              Take a substring of the binary representation of the Output
       ~ḃ            Convert it back to a decimal number
         ~t?∧        This decimal number must me n

— Fatalize
स्रोत

2

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

(t={};l=Length;v=IntegerDigits;j=v[#2, 2];s=FromDigits/@Flatten/@v@Permutations@#1;Table[If[l@SequenceCases[v[s[[i]],2],j]>0,t~AppendTo~s[[i]]],{i,l@s}];t)&

इनपुट

[{१२, ३४, ५६}, २१]

उत्पादन

{125634, 341256, 345612, 563412}

— J42161217
स्रोत

वहाँ एक व्हाट्सएप है v[#2, 2]।

— यति

1

CJam, 23 22 21 19 बाइट्स

{e!{si2b1$2b#)},\;}

यह एक ब्लॉक है जो n hस्टैक पर इनपुट लेता है और स्टैक पर एक सरणी के रूप में आउटपुट छोड़ देता है।

स्पष्टीकरण:

                   e# Stack:                      | 65 [1 2 3]
e!                 e# Unique Permutations:        | 65 [[1 2 3] [1 3 2] [2 1 3] [2 3 1] [3 1 2] [3 2 1]]
  {                e# Filter where block is true: | 65 [3 2 1]
   s               e#   Convert to string:        | 65 "321"
    i              e#   Convert to int:           | 65 321
     2b            e#   Convert to binary:        | 65 [1 0 1 0 0 0 0 0 1]
       1$          e#   Copy behind:              | 65 [1 0 1 0 0 0 0 0 1] 65
         2b        e#   Convert to binary:        | 65 [1 0 1 0 0 0 0 0 1] [1 0 0 0 0 0 1]
           #       e#   Find array in another:    | 65 2
            )      e#   Increment:                | 65 3
             },    e# End filter                  | 65 [321]
               \;  e# Delete back:                | [321]

— फल तोड़ना
स्रोत

1

आर, 114 बाइट्स

pryr::f(plyr::l_ply(combinat::permn(x),function(y)if(grepl(p,R.utils::intToBin(paste(y,collapse=""))))cat(y,"\n")))

संकुल का एक गुच्छा का उपयोग करता है। pryr::f()स्वचालित रूप से एक फ़ंक्शन बनाता है, लेने के लिए p, बाइनरी पैटर्न की एक स्ट्रिंग, और xइनपुट के रूप में अन्य इनपुट के साथ एक वेक्टर। combinat::permnके सभी क्रमपरिवर्तन बनाता है x। R.utils::intToBinएक संख्यात्मक (या एक संख्यात्मक के चरित्र का प्रतिनिधित्व) एक द्विआधारी संख्या में परिवर्तित करने के लिए एक अच्छा और चिंताजनक संस्करण है, जो पहले से ही आसानी से एक चरित्र के रूप में संग्रहीत है। तो यह सभी क्रमपरिवर्तन पर लागू होता है और बाइनरी स्ट्रिंग pसमवर्ती के बाइनरी संस्करण में समाहित होने पर उन्हें आउटपुट करता है । एक स्पष्ट न्यूलाइन छपी है, क्योंकि अन्यथा आउटपुट होगा 12 56 3456 34 1234 56 1234 12 56।

plyrके l_plyलिए नियमित रूप से उत्पादन के अलावा एक अशक्त सूची outputting को दबाने के लिए प्रयोग किया जाता है,। यदि इस तरह आउटपुट की अनुमति है:

3 2 1 
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

[[6]]
NULL

तो हम lapplyइसके बजाय का उपयोग करके कुछ बाइट्स बचा सकते हैं :

108 बाइट्स:

pryr::f(lapply(combinat::permn(x),function(y)if(grepl(p,R.utils::intToBin(paste(y,collapse=""))))cat(y,"\n")))

~~यदि इस तरह आउटपुट की अनुमति है:~~

~~[[1]] NULL [[2]] NULL [[3]] NULL [[4]] [1] 3 2 1 [[5]] NULL [[6]] NULL~~

फिर हम इसे और भी छोटा कर सकते हैं:

101 बाइट्स:

pryr::f(lapply(combinat::permn(x),function(y)if(grepl(p,R.utils::intToBin(paste0(y,collapse=""))))y))

अनुमति नहीं हैं।

— JAD
स्रोत

0

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

{set @^a.permutations».join.grep(*.fmt('%b').contains($^b.base(2)))}

— शॉन
स्रोत

एक दशमलव हिस्टैक में एक बाइनरी सुई का पता लगाएं

चुनौती

उदाहरण

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

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

05AB1E , 10 8 बाइट्स

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

जावा 10, 320 312 305 297 292 बाइट्स

जाप , 15 14 13 12 10 बाइट्स

व्याख्या

रूबी , 61 59 बाइट्स

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

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

व्याख्या

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

CJam, 23 22 21 19 बाइट्स

आर, 114 बाइट्स

108 बाइट्स:

101 बाइट्स:

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