Die Herausforderung

Sie erhalten:

• eine nicht leere, unsortierte Liste h positiver Ganzzahlen (der Heuhaufen)
• eine positive ganze Zahl n (die Nadel)

Ihre Aufgabe ist es, die Liste aller eindeutigen Dezimalverkettungen von Permutationen von h zurückzugeben, deren Binärdarstellung die Binärdarstellung von n enthält .

Beispiele

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

   

   Es gibt nur eine passende Verkettung, die erwartete Ausgabe ist also [321].

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

   Dieses Mal gibt es drei Verkettungen, die das binäre Muster 111 enthalten . Die erwartete Ausgabe ist [123, 231, 312].

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

   Es sind nur zwei Permutationen verfügbar und beide stimmen überein. Die erwartete Ausgabe ist [123, 312].

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

   Die einzige übereinstimmende Verkettung ist 122 ( 1111010 im Binärformat, das 1111 enthält ), die erwartete Ausgabe ist also [122]. Beachten Sie, dass zwei Permutationen tatsächlich zu 122 führen, aber Sie nicht ausgeben dürfen [122, 122].

Erläuterungen und Regeln

• Sie können die Nadel als Ganzzahl ( 65), als Zeichenfolge für einen Dezimalwert ( "65") oder als Zeichenfolge für einen Binärwert ( "1000001") verwenden.
• Sie können den Heuhaufen als natives Array / Objekt / Satz von Ganzzahlen ( [11,12,13]), als natives Array / Objekt / Satz von Zeichenfolgen, die Dezimalwerte ( ["11","12","13"]) darstellen, oder als durch Trennzeichen getrennte Zeichenfolge von Dezimalwerten ( "11 12 13"oder "11,12,13") betrachten. Sie können sich auch für eine Variante mit Arrays von Ziffern (wie [[1,1],[1,2],[1,3]]) entscheiden.
• Die Ausgabe muss einem der oben beschriebenen Formate für den Heuhaufen entsprechen, muss jedoch nicht dasselbe sein.
• Sie dürfen keine Heuschober verarbeiten, deren höchste dezimale Verkettung größer ist als die höchste darstellbare ganze Zahl ohne Vorzeichen in Ihrer Sprache.
• Abgesehen davon sollte Ihr Code theoretisch jede Eingabe unterstützen - vorausgesetzt, er hat genügend Zeit und Speicherplatz.
• Das ist SPARTA! Code-Golf , so gewinnt die kürzeste Antwort in Bytes!

Testfälle

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 Bytes

Nimmt die Nadel als Binärdatei, um 1 Byte zu sparen.

-2 Bytes dank Emigna

œJÙʒbŒIå

Probieren Sie es online!

œ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 Bytes

-3 Bytes dank @ Gábor Fekete

Probieren Sie es online aus

Wird als Eingabearray von Zeichenfolgen verwendet, die Ints aus Heu und Zeichenfolge darstellen und Needle in Binärdarstellung darstellen

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 Bytes

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

Eingabe als List & Binary-String, Ausgabe als Strings in New-Lines.

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

Nimmt den Heuhaufen als Array von Ganzzahlen und die Nadel als Binärzeichenfolge. Gibt ein Array von Ganzzahlzeichenfolgen aus.

á m¬f_°¤øV

• Dank ETHproductions ein Byte gespart

Versuch es

Erläuterung

á 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 Bytes

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

Probieren Sie es online!

Cooles Feature des Tages: Ich wusste nicht, dass ich die Binärdarstellung eines Strings mit einer Zahl ausgeben kann.

Beispiel:

puts "%b"%"123"

-> 1111011

JavaScript (ES6), 140 Byte

Nimmt Nadel als binäre Zeichenfolge.

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

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

Probieren Sie es online!

Erläuterung

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

Mathematica, 170 bis 156 Bytes

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

Eingang

[{12, 34, 56}, 21]

Ausgabe

{125634, 341256, 345612, 563412}

CJam, 23 22 21 19 Bytes

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

Dies ist ein Block, der Eingaben n hauf dem Stapel entgegennimmt und die Ausgabe als Array auf dem Stapel belässt.

Erläuterung:

                   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 Bytes

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

Verwendet eine Reihe von Paketen. pryr::f()Erstellt automatisch eine Funktion, wobei peine Zeichenfolge des zu suchenden Binärmusters und xein Vektor mit der anderen Eingabe als Eingabe verwendet werden. combinat::permnerstellt alle Permutationen von x. R.utils::intToBinist eine nette und wortreiche Version, um eine Zahl (oder Zeichendarstellung einer Zahl) in eine Binärzahl umzuwandeln, die bereits als Zeichen gespeichert ist. Wenden Sie dies also auf alle Permutationen an und geben Sie sie aus, wenn die Binärzeichenfolge pin der Binärversion der Verkettung enthalten ist. Es wird ein expliziter Zeilenumbruch ausgegeben, da sonst die Ausgabe erfolgen würde 12 56 3456 34 1234 56 1234 12 56.

plyr's l_plywird verwendet, um die Ausgabe einer Nullliste neben der regulären Ausgabe zu unterdrücken. Wenn die Ausgabe so erlaubt ist:

3 2 1 
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

[[6]]
NULL

Dann können wir einige Bytes sparen, indem wir lapplystattdessen verwenden:

108 Bytes:

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

Wenn die Ausgabe so erlaubt ist:

[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
[1] 3 2 1

[[5]]
NULL

[[6]]
NULL

Dann können wir es noch kürzer machen:

101 Bytes:

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

Nicht erlaubt.

Perl 6 , 69 Bytes

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