Suchen Sie eine Binärnadel in einem dezimalen Heuhaufen


41

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

    Beispiel

    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! , 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 ]

1
Die Ausgabe meiner Lösung ist wie set([(1, 2, 2)]). Ist es gültig oder soll ich es loswerden set?
Dead Possum

@DeadPossum Ja, es ist gültig.
Arnauld

Kann die Heuhaufen-Eingabe eine einzelne Zeichenfolge sein ("123")? In einigen Sprachen ist eine Zeichenfolge dasselbe wie eine Reihe von Zeichen, daher halte ich es für sinnvoll
Luis Mendo,

@ LuisMendo Es kann nicht weil ["12","3"]und ["1","23"]sind zwei verschiedene Heuhaufen.
Arnauld

@Arnauld Ah, ich dachte, das sind Ziffern. Danke
Luis Mendo

Antworten:


17

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

1
„JÙʒbÙʒIå sollte auch funktionieren.
Emigna

@Emigna Danke, das spart 2 Bytes :)
kalsowerus

11

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

4
Schreiben {...}statt set(...)3 Bytes sparen.
Gábor Fekete

1
@ GáborFekete Ich vergesse immer, dass {} gesetzt ist: D Danke
Dead Possum

Ich glaube das scheitert H=['1'], N='0'.
user2357112

Oh, warte, der Eingang muss positiv sein.
user2357112

10

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

Persönlich würde ich setze l->n->{...nach void p(...wie das Lambda ist die Antwort auf die Eingabeaufforderung und die Funktion erforderlich ist , Setup für die Lambda - Arbeit. Konsens über "Funktionsausdrücke" ist so etwas wie "Der letzte" Ausdruck "Ihrer Übermittlung kann ein" Funktionsausdruck "sein, wenn er beim Speichern in einer Variablen die Anforderungen einer Funktionsantwort" IIRC "erfüllt. Aber das ist nur ein Formatierungsproblem, und zwar ein subjektives.
CAD97

@ CAD97 Ich hatte keine Ahnung, dass die Bestellung von Bedeutung ist. Das letzte Mal habe ich eine Java 8-Antwort mit zwei Methoden gepostet, die ich verwendet habe, voidweil sie kürzer als ein zweites Lambda und das Vielfache war .apply. Ich habe es nicht auf diese Antwort überprüft (dh void p(List l,int k)& 2x p(l,0)versus (l,k)->& 2x p.apply(l,0)). Hmm .. zweite scheint in diesem Fall 1 Byte kürzer zu sein. Aber Sie sagen, Regeln besagen, dass Sie nur eine Lambda-Methode haben dürfen? Immer noch ein bisschen verwirrt, warum es das letzte sein muss. Persönlich schreibe ich immer meine Antworten in dieser Reihenfolge: imports; class-fields; main-method/lambda; other methods.
Kevin Cruijssen

wieder ist es meistens die Meinung, ich möchte, dass jemand erfahrener ist, bevor er wirklich so oder so sagt. Ich weiß jedoch, dass dies zutrifft: Wenn Sie eine Methode aufrufen müssen (z. B. rekursiv oder als Helfer), muss sie einen Namen haben. Aber wie für die Bestellung, ist es nicht wirklich wichtig , da es nicht die Byte - Zählung nicht ändert. Aber ich bestelle alsimports;helper methods;lambda
CAD97

@ CAD97 Ah, natürlich wäre es stattdessen void p(List l,int k)& 2x f(l,0);versus f=(l,p)->& 2x p.apply(l,0);(was bedeutet, dass die aktuelle Version 1 Byte kürzer ist). Bei der Bestellung bleibe ich einfach dabei, da ich dies bei all meinen Antworten getan habe, und es ist auch für mich persönlich sinnvoll, mit der Hauptmethode in der Erklärung und dann mit der (den) Hilfsmethode (n) zu beginnen, wenn es gibt welche
Kevin Cruijssen

und leider kann man das nicht einfach f=(lambda)in Java machen, es istjava.util.function.BiConsumer<List,Integer>f=(l,p)->{...}
CAD97

9

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

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

Sehr schön darüber, was ich getan hätte. ®¬nÃSpeichert ein Byte im Mapping. (Ich würde auch âin die Mitte des Programms gehen, um die Sekunde loszuwerden. ÃSpeichert keine Bytes, aber es ist ein bisschen effizienter und sieht etwas besser aus.)
ETHproductions

Aha, danke, @ETHproductions - ich habe mich so sehr darauf konzentriert, zu sehen, ob ich durch die Ausgabe jeder Zahl als Array alle Bytes entfernen kann. Ich habe diese einfache Änderung an der Zuordnung verpasst. Das âwar eine schnelle Lösung, als Arnauld darauf hinwies, dass ich vergessen hatte, die Duplikate aus dem endgültigen Array zu entfernen, aber Sie haben Recht, das Entfernen der Duplikate vor dem Ausführen des Filters wäre effizienter.
Shaggy

4

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

3

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


3

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

2

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}


Es gibt ein Leerzeichen bei v[#2, 2].
Yytsi

1

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]

1

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.


0

Perl 6 , 69 Bytes

{set @^a.permutations».join.grep(*.fmt('%b').contains($^b.base(2)))}
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.