Le défi

Vous êtes donné:

• une liste non vide et non triée h d'entiers positifs (la botte de foin)
• un entier positif n (l'aiguille)

Votre tâche consiste à renvoyer la liste de toutes les concaténations décimales uniques des permutations de h dont la représentation binaire contient la représentation binaire de n .

Exemples

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

   

   Il n'y a qu'une concaténation correspondante, donc le résultat attendu est [321].

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

   Cette fois-ci, trois concaténations contiennent le motif binaire 111 . La sortie attendue est [123, 231, 312].

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

   Seules deux permutations sont disponibles et les deux correspondent. La sortie attendue est [123, 312].

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

   La seule concaténation correspondante est 122 ( 1111010 en binaire, qui contient 1111 ), donc le résultat attendu est [122]. Notez que deux permutations conduisent à 122 mais que vous n'êtes pas autorisé à sortir [122, 122].

Clarifications et règles

• Vous pouvez prendre l’aiguille comme un entier ( 65), une chaîne représentant une valeur décimale ( "65") ou une chaîne représentant une valeur binaire ( "1000001").
• Vous pouvez prendre la pile de foin comme un tableau / objet / ensemble d'entiers [11,12,13]natif ( ), un tableau / objet / un ensemble de chaînes représentant des valeurs décimales ( ["11","12","13"]) ou une chaîne délimitée de valeurs décimales ( "11 12 13"ou "11,12,13"). Vous pouvez également opter pour une variante utilisant des tableaux de chiffres (comme [[1,1],[1,2],[1,3]]).
• La sortie doit suivre l’un des formats décrits ci-dessus pour la meule de foin, mais pas nécessairement le même.
• Vous n'êtes pas censé gérer des meules de foin dont la concaténation décimale la plus élevée est supérieure au nombre entier non signé représentable le plus élevé dans votre langue.
• En dehors de cela, votre code devrait théoriquement prendre en charge toute entrée, en supposant qu'il dispose de suffisamment de temps et de mémoire.
• C'est SPARTA! code-golf , donc la réponse la plus courte en octets est gagnante!

Cas de 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 octets

Prend l'aiguille en binaire pour enregistrer 1 octet.

-2 octets grâce à Emigna

œJÙʒbŒIå

Essayez-le en ligne!

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

-3 octets grâce à @ Gábor Fekete

Essayez-le en ligne

Prend en tant que tableau d'entrée de chaînes, représentant les entrées de foin et de chaînes, représentant l'aiguille en binaire

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 octets

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

Entrée en tant que liste et chaîne binaire, sortie en tant que chaînes sur les nouvelles lignes.

Explication:

Essayez ici.

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 octets

Prend la botte de foin comme un tableau d’entiers et l’aiguille comme une chaîne binaire. Sort un tableau de chaînes entières.

á m¬f_°¤øV

• Enregistrement d'un octet grâce à ETHproductions

L'essayer

Explication

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

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

Essayez-le en ligne!

Fonctionnalité intéressante du jour: je ne savais pas que je pouvais sortir la représentation binaire d'une chaîne contenant un nombre.

Exemple:

puts "%b"%"123"

-> 1111011

JavaScript (ES6), 140 octets

Prend l'aiguille comme une chaîne binaire.

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

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

Essayez-le en ligne!

Explication

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

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

contribution

[{12, 34, 56}, 21]

sortie

{125634, 341256, 345612, 563412}

CJam, 23 22 21 19 octets

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

C'est un bloc qui prend des entrées n hsur la pile et laisse la sortie sous forme de tableau sur la pile.

Explication:

                   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 octets

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

Utilise un tas de paquets. pryr::f()crée automatiquement une fonction, en prenant p, une chaîne du motif binaire à rechercher, et xun vecteur avec l'autre entrée en entrée. combinat::permncrée toutes les permutations de x. R.utils::intToBinest une version agréable et verbeuse permettant de convertir une représentation numérique (ou la représentation d’un caractère numérique) en un nombre binaire, déjà stocké de manière pratique sous forme de caractère. Donc, appliquez ceci sur toutes les permutations et affichez-les si la chaîne binaire pest contenue dans la version binaire de la concaténation. Une nouvelle ligne explicite est imprimée, sinon le résultat serait 12 56 3456 34 1234 56 1234 12 56.

plyr's l_plyest utilisé pour surpresser la sortie d'une liste null, en plus de la sortie normale. Si une sortie comme celle-ci est autorisée:

3 2 1 
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

[[6]]
NULL

Ensuite, nous pouvons économiser quelques octets en utilisant lapply place:

108 octets:

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

Si une sortie comme celle-ci est autorisée:

[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
[1] 3 2 1

[[5]]
NULL

[[6]]
NULL

Ensuite, nous pouvons le faire encore plus court:

101 octets:

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

Interdit.

Perl 6 , 69 octets

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