Trouver une aiguille binaire dans une botte de foin décimale


41

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

    Exemple

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

1
Le résultat de ma solution est comme set([(1, 2, 2)]). Est-ce valide ou devrais-je m'en débarrasser set?
Dead Possum

@DeadPossum Oui, c'est valide.
Arnauld

L'entrée haystack peut-elle être une chaîne unique ("123")? Dans certaines langues, une chaîne est identique à un tableau de caractères, alors je pense que cela aurait un sens
Luis Mendo

@ LuisMendo Il ne peut pas, car ["12","3"]il ["1","23"]y a deux meules de foin distinctes.
Arnauld

@Arnauld Ah, je pensais qu'ils étaient des chiffres. Merci
Luis Mendo

Réponses:


17

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

1
œJÙʒbŒIå devrait également fonctionner.
Emigna

@ Emigna Merci, cela économise 2 octets :)
kalsowerus

11

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

4
Ecrire {...}au lieu de set(...)sauver 3 octets.
Gábor Fekete

1
@ GáborFekete J'oublie toujours que {} est réglé: D Merci
Dead Possum

Je crois que cela échoue H=['1'], N='0'.
user2357112 prend en charge Monica

Oh, attendez, l'entrée est nécessaire pour être positif.
user2357112 prend en charge Monica

10

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

Personnellement, je mettrais l->n->{...après void p(...car le lambda est la réponse à l'invite et la fonction est requise pour que le lambda fonctionne. Un consensus sur les "expressions de fonction" est quelque chose comme "la dernière" expression "de votre soumission peut être une" expression de fonction "si, lorsqu'elle est stockée dans une variable, elle répond aux exigences d'une réponse de fonction" IIRC. Mais ce n’est qu’un problème de formatage, et subjectif en plus.
CAD97

@ CAD97 Je ne savais pas que l'ordre importait. La dernière fois que j'ai posté une réponse Java 8 avec deux méthodes que j'ai utilisées, voidc'était plus court qu'un deuxième lambda et le multiple .apply. Je n'ai pas vérifié pour cette réponse (c'est-à-dire void p(List l,int k)& 2x p(l,0)contre (l,k)->& 2x p.apply(l,0)). Hmm .. le second semble être plus court d'un octet dans ce cas. Mais vous dites que les règles stipulent que vous n'êtes autorisé à avoir qu'une méthode lambda? Encore un peu confus pourquoi cela doit être le dernier. Personnellement , je posterai toujours mes réponses dans cet ordre: imports; class-fields; main-method/lambda; other methods.
Kevin Cruijssen

encore une fois, c’est surtout l’opinion, je voudrais que quelqu'un plus expérimenté intervienne avant de vraiment dire d’une manière ou d’une autre. Cependant, je sais que cela est vrai: si vous devez appeler une méthode (par exemple, récursive ou comme aide), elle doit avoir un nom. Mais en ce qui concerne la commande, cela n'a pas vraiment d' importance car cela ne change pas le nombre d'octets. Mais je commande en tant queimports;helper methods;lambda
CAD97

@ CAD97 Ah bien sûr, ce serait donc void p(List l,int k)& 2x f(l,0);contre f=(l,p)->& 2x à la p.apply(l,0);place (ce qui signifie que la version actuelle est plus courte de 1 octet). En ce qui concerne la commande, je m'en tiendrai à cela puisque je l'ai fait avec toutes mes réponses, et il est également logique pour moi personnellement de commencer par la méthode principale de l'explication, puis la (les) méthode (s) d'aide si il y en a.
Kevin Cruijssen

et malheureusement, vous ne pouvez pas tout faire f=(lambda)à Java, c'estjava.util.function.BiConsumer<List,Integer>f=(l,p)->{...}
CAD97

9

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

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

Très bien, à propos de ce que j'aurais fait. ®¬nÃenregistre un octet sur le mappage. (Je passerais également âau milieu du programme pour me débarrasser du deuxième Ã; ne garde aucun octet, mais il est un peu plus efficace et semble un peu mieux)
ETHproductions

Aha, merci, @ETHproductions - J'étais tellement concentré sur le fait de voir si je pouvais supprimer tous les octets en affichant chaque nombre sous forme de tableau, j'ai raté ce simple changement du mappage. Le âétait une solution rapide clouée sur la fin quand Arnauld a que j'avais oublié de supprimer les doublons du tableau final , mais, vous avez raison, en supprimant les doublons avant d' exécuter le filtre serait plus efficace.
Shaggy

4

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

3

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


3

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

2

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}


Il y a un espace blanc à v[#2, 2].
Yytsi

1

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]

1

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.


0

Perl 6 , 69 octets

{set @^a.permutations».join.grep(*.fmt('%b').contains($^b.base(2)))}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.