Các thách thức

Bạn đã cho:

• một danh sách không trống, chưa sắp xếp h của các số nguyên dương (haystack)
• một số nguyên dương n (kim)

Nhiệm vụ của bạn là trả về danh sách tất cả các phép nối thập phân duy nhất của hoán vị của h có biểu diễn nhị phân chứa biểu diễn nhị phân của n .

Ví dụ

1. h = [1, 2, 3]
   n = 65

   

   Chỉ có một cách ghép phù hợp, do đó, đầu ra dự kiến ​​là [321].

2. h = [1, 2, 3]
   n = 7

   Lần này, có ba cách ghép có chứa mẫu nhị phân 111 . Sản lượng dự kiến ​​là [123, 231, 312].

3. h = [12, 3]
   n = 7

   Chỉ có hai hoán vị có sẵn và cả hai đều phù hợp. Sản lượng dự kiến ​​là [123, 312].

4. h = [1, 2, 2]
   n = 15

   Phép nối phù hợp duy nhất là 122 ( 1111010 ở dạng nhị phân, chứa 1111 ), do đó, đầu ra dự kiến ​​là [122]. Lưu ý rằng hai hoán vị thực sự dẫn đến 122 nhưng bạn không được phép xuất [122, 122].

Làm rõ và quy tắc

• Bạn có thể lấy kim làm số nguyên ( 65), chuỗi đại diện cho giá trị thập phân ( "65") hoặc chuỗi đại diện cho giá trị nhị phân ( "1000001").
• Bạn có thể lấy haystack làm mảng / đối tượng / bộ số nguyên ( [11,12,13]), mảng / đối tượng / bộ chuỗi gốc biểu thị các giá trị thập phân ( ["11","12","13"]) hoặc một chuỗi các giá trị thập phân ( "11 12 13"hoặc "11,12,13") được phân tách . Bạn cũng có thể chọn một biến thể bằng cách sử dụng các mảng chữ số (như [[1,1],[1,2],[1,3]]).
• Đầu ra phải tuân theo một trong các định dạng được mô tả ở trên cho haystack, nhưng không nhất thiết phải giống nhau.
• Bạn không được phép xử lý các đống cỏ khô có độ nối thập phân cao nhất lớn hơn số nguyên không dấu có thể biểu thị cao nhất trong ngôn ngữ của bạn.
• Ngoài ra, về mặt lý thuyết, mã của bạn sẽ hỗ trợ bất kỳ đầu vào nào - giả sử nó được cung cấp đủ thời gian và bộ nhớ.
• Đây là SPARTA! code-golf , vì vậy câu trả lời ngắn nhất trong byte thắng!

Các trường hợp thử nghiệm

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 ]

05AB1E , 10 8 byte

Lấy kim trong nhị phân để tiết kiệm 1 byte.

-2 byte nhờ Emigna

œJÙʒbŒIå

Hãy thử trực tuyến!

œ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

Python 2, 90 byte

-3 byte nhờ @ Gábor Fekete

Dùng thử trực tuyến

Lấy làm mảng đầu vào của chuỗi, đại diện cho int từ hay và chuỗi, đại diện cho kim trong nhị phân

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

Java 10, 320 312 305 297 292 byte

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",""));}

Nhập dưới dạng Danh sách & Chuỗi nhị phân, xuất dưới dạng Chuỗi trên dòng mới.

Giải trình:

Hãy thử nó ở đây.

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

Japt , 15 14 13 12 10 byte

Lấy haystack như một mảng các số nguyên và kim là một chuỗi nhị phân. Xuất ra một mảng các chuỗi số nguyên.

á m¬f_°¤øV

• Đã lưu một byte nhờ vào ETHproductions

Thử nó

Giải trình

á 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

Ruby , 61 59 byte

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

Hãy thử trực tuyến!

Tính năng thú vị trong ngày: Tôi không biết mình có thể xuất biểu diễn nhị phân của một chuỗi chứa một số.

Thí dụ:

puts "%b"%"123"

-> 1111011

JavaScript (ES6), 140 byte

Lấy kim như một chuỗi nhị phân.

(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)) )

Brachylog , 15 byte

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

Hãy thử trực tuyến!

Giải trình

{            }ᵘ    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

Toán học, 170 156 byte

(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)&

đầu vào

[{12, 34, 56}, 21]

đầu ra

{125634, 341256, 345612, 563412}

CJam, 23 22 21 19 byte

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

Đây là một khối lấy đầu vào n htrên ngăn xếp và để lại đầu ra dưới dạng một mảng trên ngăn xếp.

Giải trình:

                   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]

R, 114 byte

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

Sử dụng một loạt các gói. pryr::f()tự động tạo một hàm, lấy p, một chuỗi của mẫu nhị phân cần tìm và xmột vectơ với đầu vào khác làm đầu vào. combinat::permntạo ra tất cả các hoán vị của x. R.utils::intToBinlà một phiên bản đẹp và dài để chuyển đổi một số (hoặc ký tự đại diện của một số) thành một số nhị phân, được lưu trữ thuận tiện dưới dạng một ký tự. Vì vậy, áp dụng điều này trên tất cả các hoán vị và xuất chúng nếu chuỗi nhị phân pđược chứa trong phiên bản nhị phân của phép nối. Một dòng mới rõ ràng được in, bởi vì nếu không thì đầu ra sẽ là 12 56 3456 34 1234 56 1234 12 56.

plyrCủa l_plyđược sử dụng để thay thế một danh sách null, bên cạnh đầu ra thông thường. Nếu đầu ra như thế này được cho phép:

3 2 1 
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

[[6]]
NULL

Sau đó, chúng ta có thể lưu vài byte bằng cách sử dụng lapplythay thế:

108 byte:

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

Nếu đầu ra như thế này được cho phép:

[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
[1] 3 2 1

[[5]]
NULL

[[6]]
NULL

Sau đó, chúng ta có thể làm điều đó thậm chí còn ngắn hơn:

101 byte:

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

Không cho phép.

Perl 6 , 69 byte

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