La sfida

Ti viene dato:

• un elenco non vuoto, non ordinato h di numeri interi positivi (il pagliaio)
• un numero intero positivo n (l'ago)

Il tuo compito è di restituire l'elenco di tutte le concatenazioni decimali uniche di permutazioni di h la cui rappresentazione binaria contiene la rappresentazione binaria di n .

Esempi

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

   

   C'è solo una concatenazione corrispondente, quindi l'output previsto è [321].

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

   Questa volta, ci sono tre concatenazioni che contengono il modello binario 111 . L'output previsto è [123, 231, 312].

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

   Sono disponibili solo due permutazioni ed entrambe corrispondono. L'output previsto è [123, 312].

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

   L'unica concatenazione corrispondente è 122 ( 1111010 in binario, che contiene 1111 ), quindi l'output previsto è [122]. Nota che due permutazioni effettivamente portare a 122 ma siete senza possibile eseguire l'output [122, 122].

Chiarimenti e regole

• Puoi prendere l'ago come un numero intero ( 65), una stringa che rappresenta un valore decimale ("65" ) o una stringa che rappresenta un valore binario ( "1000001").
• Puoi prendere il pagliaio come un array / oggetto / set nativi di numeri interi ( [11,12,13]), un array / oggetto / set di stringhe nativi che rappresentano valori decimali ( ["11","12","13"]) o una stringa delimitata di valori decimali ( "11 12 13"o"11,12,13" ). Puoi anche optare per una variante usando matrici di cifre (come [[1,1],[1,2],[1,3]]).
• L'output deve seguire uno dei formati sopra descritti per il pagliaio, ma non necessariamente lo stesso.
• Non dovresti gestire covoni di fieno la cui concatenazione decimale più alta è maggiore dell'intero senza segno più alto rappresentabile nella tua lingua.
• A parte questo, il tuo codice dovrebbe teoricamente supportare qualsiasi input, supponendo che abbia abbastanza tempo e memoria.
• Questo è SPARTA! code-golf , quindi vince la risposta più breve in byte!

Casi test

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

Prende l'ago in binario per salvare 1 byte.

-2 byte grazie a Emigna

œJÙʒbŒIå

Provalo 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 byte

-3 byte grazie a @ Gábor Fekete

Provalo online

Prende come matrice di input di stringhe, che rappresentano ints da fieno e stringa, che rappresenta l'ago in binario

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

Input come Elenco e stringa binaria, output come String su new-line.

Spiegazione:

Provalo qui.

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

Prende il pagliaio come una matrice di numeri interi e l'ago come una stringa binaria. Emette un array di stringhe intere.

á m¬f_°¤øV

• Salvataggio di un byte grazie a ETHproductions

Provalo

Spiegazione

á 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

Rubino , 61 59 byte

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

Provalo online!

Fantastica funzionalità del giorno: non sapevo di poter generare la rappresentazione binaria di una stringa contenente un numero.

Esempio:

puts "%b"%"123"

-> 1111011

JavaScript (ES6), 140 byte

Prende l'ago come una stringa binaria.

(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?∧}ᵘ

Provalo online!

Spiegazione

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

ingresso

[{12, 34, 56}, 21]

produzione

{125634, 341256, 345612, 563412}

CJam, 23 22 21 19 byte

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

Questo è un blocco che accetta input n h nello stack e lascia l'output come array nello stack.

Spiegazione:

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

Utilizza un sacco di pacchetti. pryr::f()crea automaticamente una funzione, prendendo p, una stringa del modello binario da cercare e xun vettore con l'altro input come input. combinat::permncrea tutte le permutazioni di x. R.utils::intToBinè una versione piacevole e prolissa per convertire un numero (o rappresentazione di carattere di un numero) in un numero binario, già convenientemente memorizzato come carattere. Quindi applicando questo su tutte le permutazioni e emettendole se la stringa binaria pè contenuta nella versione binaria della concatenazione. Viene stampato un newline esplicito, perché altrimenti sarebbe l'output 12 56 3456 34 1234 56 1234 12 56.

plyr's l_plyè usato per sopprimere l'output di un elenco null, oltre al normale output. Se l'output in questo modo è consentito:

3 2 1 
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

[[6]]
NULL

Quindi possiamo salvare pochi byte usando lapplyinvece:

108 byte:

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

Se l'output in questo modo è consentito:

[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
[1] 3 2 1

[[5]]
NULL

[[6]]
NULL

Quindi possiamo farlo ancora più breve:

101 byte:

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

Non autorizzato.

Perl 6 , 69 byte

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