Meydan okuma

Size verildi:

• Boş olmayan, sıralanmamış liste h pozitif tamsayılar (samanlık)
• pozitif bir tamsayı n (iğne)

Göreviniz , ikili gösterimi n'nin ikili gösterimini içeren, h nin permütasyonlarının tüm benzersiz ondalık birleştirmelerinin listesini döndürmektir .

Örnekler

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

   

   Yalnızca bir eşleşen birleştirme var, bu nedenle beklenen çıktı [321].

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

   Bu sefer, 111 ikili desenini içeren üç birleştirme vardır . Beklenen çıktı [123, 231, 312].

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

   Sadece iki permütasyon mevcuttur ve her ikisi de eşleşmektedir. Beklenen çıktı [123, 312].

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

   Yalnızca eşleşen birleşimidir 122 ( 1111010 içeren ikili, içinde 1111 beklenen çıkışı bu yüzden,) [122]. İki permütasyon aslında yol açtığını Not 122 ama edilmektedir değil çıkışına izin [122, 122].

Açıklamalar ve kurallar

• İğneyi bir tamsayı ( 65), ondalık bir değeri ( "65") temsil eden bir dize veya ikili değeri ( "1000001") temsil eden bir dize olarak alabilirsiniz .
• Samanlık, yerel bir dizi / nesne / tamsayılar kümesi ( [11,12,13]), ondalık değerleri ( ["11","12","13"]) temsil eden bir yerel dizi / nesne / dizi dizisi veya sınırlandırılmış ondalık değer dizisi ( "11 12 13"veya "11,12,13") olarak alabilirsiniz. Rakam dizilerini (benzeri [[1,1],[1,2],[1,3]]) kullanarak bir değişkeni de seçebilirsiniz .
• Çıktı, samanlık için yukarıda açıklanan formatlardan birini izlemelidir, ancak mutlaka aynı değildir.
• Onda en yüksek ondalık birleştirme, kendi dilinizde temsil edilebilecek en yüksek işaretsiz tamsayıdan büyük olan haystacks ile işlem yapmamanız gerekir.
• Bunun dışında, kodunuz yeterli zaman ve hafıza verildiği varsayılarak herhangi bir girişi teorik olarak desteklemelidir.
• Bu SPARTA! kod-golf , bu yüzden bayt cinsinden en kısa cevap kazanır!

Test durumları

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 bayt

İğneyi 1 bayttan tasarruf etmek için ikili olarak alır.

Emigna sayesinde -2 bayt

œJÙʒbŒIå

Çevrimiçi deneyin!

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

@ Gábor Fekete sayesinde -3 bayt

Çevrimiçi deneyin

İğne'yi ikili olarak temsil eden, samandan ve dizeden gelen girişleri temsil eden girdi dizileri olarak alır

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 bayt

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

Liste ve ikili-Dize olarak giriş yapın, yeni satırlarda Dize olarak çıkış yapın.

Açıklama:

Burada dene.

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 bayt

Samanlıkta bir tamsayı dizisi, iğneyi de ikili bir dizge olarak alır. Bir tamsayı dizesi dizisi çıkarır.

á m¬f_°¤øV

• ETHproductions sayesinde bir bayt kaydedildi

Dene

açıklama

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

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

Çevrimiçi deneyin!

Günün harika özelliği: Sayı içeren bir dizgenin ikili gösterimini çıktılayabileceğimi bilmiyordum.

Örnek:

puts "%b"%"123"

-> 1111011

JavaScript (ES6), 140 bayt

İğneyi ikili dize olarak alır.

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

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

Çevrimiçi deneyin!

açıklama

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

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

giriş

[{12, 34, 56}, 21]

çıktı

{125634, 341256, 345612, 563412)

CJam, 23 22 21 19 bayt

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

Bu, n hyığında girişleri alan ve çıktıyı yığında bir dizi olarak bırakan bir bloktur .

Açıklama:

                   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 bayt

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

Bir sürü paket kullanır. pryr::f()otomatik olarak aranacak pikili düzende bir dize alarak bir işlev oluşturur ve xgirdi olarak diğer girişe sahip bir vektör. combinat::permntüm permütasyonlarını yaratır x. R.utils::intToBinbir nümerik (veya nümerik bir karakter temsilini) bir karakter sayısının halihazırda bir karakter olarak saklanan bir ikili sayıya dönüştürmesi için güzel ve küçük bir versiyondur. Bu nedenle, tüm permütasyonlar üzerine bunu uygulamak ve ikili dizge pbirleşmenin ikili versiyonunda yer alıyorsa bunları çıkarmak. Aksi halde çıktı alınacağı için açık bir yeni satır yazdırılır 12 56 3456 34 1234 56 1234 12 56.

plyr's l_ply, normal çıkışın yanı sıra boş bir listenin çıktısını bastırmak için kullanılır. Bunun gibi bir çıktıya izin verilirse:

3 2 1 
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

[[6]]
NULL

Sonra lapplybunun yerine birkaç byte'ı kaydedebiliriz :

108 bayt:

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

Bunun gibi bir çıktıya izin verilirse:

[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
[1] 3 2 1

[[5]]
NULL

[[6]]
NULL

O zaman daha da kısa yapabiliriz:

101 bayt:

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

İzin verilmedi.

Perl 6 , 69 bayt

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