도전

당신은 주어진 :

• 비어 있지 않은 분류되지 않은 양의 정수 h 목록 (건초 더미)
• 양의 정수 n (바늘)

이진 표현에 이진 표현 n이 포함 된 h 의 순열에 대한 모든 고유 한 10 진수 연결 목록을 반환해야합니다 .

예

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

   

   일치하는 연결이 하나뿐이므로 예상 출력은 [321]입니다.

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

   이번에는 이진 패턴 ( 111) 을 포함하는 3 개의 연결이있다 . 예상 출력은 [123, 231, 312]입니다.

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

   두 개의 순열 만 사용할 수 있으며 둘 다 일치합니다. 예상 출력은 [123, 312]입니다.

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

   일치하는 유일한 연결은 122 ( 2 진의 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]].
• 출력은 건초 더미에 대해 위에서 설명한 형식 중 하나를 따라야하지만 반드시 같은 것은 아닙니다.
• 귀하의 언어에서 가장 높은 십진 연결이 부호없는 정수보다 큰 건초 더미를 처리해서는 안됩니다.
• 그 외에도 코드는 충분한 시간과 메모리가 있다고 가정하면 이론적으로 모든 입력을 지원해야합니다.
• 이다 스파르타! code-golf 이므로 바이트 단위의 최단 답변이 승리합니다!

테스트 사례

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 바이트

1 바이트를 절약하기 위해 바늘을 이진수로 가져옵니다.

Emigna 덕분에 -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

파이썬 2, 90 바이트

@ Gábor Fekete 덕분에 -3 바이트

온라인으로 사용해보십시오

건초와 문자열의 정수를 나타내는 이진수로 바늘을 나타내는 문자열의 입력 배열로 사용합니다.

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

자바 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

Japt , 15 14 13 12 10 바이트

건초 더미를 정수 배열로, 바늘을 2 진 문자열로 사용합니다. 정수 문자열의 배열을 출력합니다.

á m¬f_°¤øV

• ETHproduction 덕분에 바이트 절약

시도 해봐

설명

á 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

루비 , 61 59 바이트

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

온라인으로 사용해보십시오!

오늘의 멋진 기능 : 숫자가 포함 된 문자열의 이진 표현을 출력 할 수 있다는 것을 몰랐습니다.

예:

puts "%b"%"123"

-> 1111011

자바 스크립트 (ES6), 140 바이트

needle을 이진 문자열로 사용합니다.

(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 바이트

{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

매쓰, 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)&

입력

[{12, 34, 56}, 21]

산출

{125634, 341256, 345612, 563412}

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]

R, 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()받는 함수 와 다른 입력을 입력으로하는 벡터를 자동으로 생성합니다 . 의 모든 순열을 만듭니다 . 숫자 (또는 숫자의 문자 표현)를 이미 문자로 편리하게 저장된 이진수로 변환하는 멋지고 장황한 버전입니다. 따라서 모든 순열에 이것을 적용하고 이진 문자열 이 연결의 이진 버전에 포함되어 있으면 출력합니다 . 그렇지 않으면 출력은이므로 명시적인 줄 바꿈이 인쇄 됩니다.pxcombinat::permnxR.utils::intToBinp12 56 3456 34 1234 56 1234 12 56

plyr집은 l_ply일정한 출력 외에, 널리스트를 출력 surpress에 사용된다. 이와 같은 출력이 허용되는 경우 :

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

허용되지 않습니다.

펄 6 , 69 바이트

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