Encontre uma agulha binária em um palheiro decimal


41

O desafio

Você é dado:

  • uma lista h vazia e não classificada de números inteiros positivos (o palheiro)
  • um número inteiro positivo n (a agulha)

Sua tarefa é retornar a lista de todas as concatenações decimais exclusivas de permutações de h cuja representação binária contém a representação binária de n .

Exemplos

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

    exemplo

    Há apenas uma concatenação correspondente, portanto a saída esperada é [321].

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

    Desta vez, existem três concatenações que contêm o padrão binário 111 . A saída esperada é [123, 231, 312].

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

    Apenas duas permutações estão disponíveis e ambas são correspondentes. A saída esperada é [123, 312].

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

    A única concatenação correspondente é 122 ( 1111010 em binário, que contém 1111 ), portanto a saída esperada é [122]. Observe que duas permutações realmente levam a 122, mas você não tem permissão para produzir [122, 122].

Esclarecimentos e regras

  • Você pode usar a agulha como um número inteiro ( 65), uma string representando um valor decimal ( "65") ou uma string representando um valor binário ( "1000001").
  • Você pode usar o palheiro como uma matriz nativa / objeto / conjunto de números inteiros ( [11,12,13]), uma matriz nativa / objeto / conjunto de seqüências representando valores decimais ( ["11","12","13"]) ou uma sequência delimitada de valores decimais ( "11 12 13"ou "11,12,13"). Você também pode optar por uma variante usando matrizes de dígitos (como [[1,1],[1,2],[1,3]]).
  • A saída deve seguir um dos formatos descritos acima para o palheiro, mas não necessariamente o mesmo.
  • Você não deve lidar com palheiros cuja concatenação decimal mais alta é maior que o número inteiro não assinado mais representável no seu idioma.
  • Além disso, seu código deve teoricamente oferecer suporte a qualquer entrada - desde que seja concedido tempo e memória suficientes.
  • Isso é SPARTA! , então a resposta mais curta em bytes ganha!

Casos de teste

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 ]

11
A saída da minha solução é como set([(1, 2, 2)]). É válido ou devo me livrar set?
Gambá morto

@DeadPossum Sim, é válido.
Arnauld 29/05

A entrada do palheiro pode ser uma única sequência ("123")? Em algumas linguagens de uma string é o mesmo que uma matriz de caracteres, então eu acho que seria faz sentido
Luis Mendo

Não @LuisMendo Ele pode, porque ["12","3"]e ["1","23"]são dois palheiros distintas.
Arnauld

@ Arnauld Ah, eu pensei que eles eram dígitos. Obrigado
Luis Mendo

Respostas:


17

05AB1E , 10 8 bytes

Leva a agulha em binário para economizar 1 byte.

-2 bytes graças a Emigna

œJÙʒbŒIå

Experimente 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

11
“J'bʒIå deve funcionar também.
Emigna

@Emigna Graças, que salva 2 bytes :)
kalsowerus

11

Python 2, 90 bytes

-3 bytes graças a @ Gábor Fekete

Experimente online

Toma como matriz de entrada de strings, representando entradas de feno e string, representando agulha em binário

from itertools import*
lambda H,N:{i for i in permutations(H)if N in bin(int(''.join(i)))}

4
Escrever em {...}vez de set(...)salvar 3 bytes.
Gábor Fekete

11
@ GáborFekete Eu sempre esqueço que {} está definido: D Thanks
Dead Possum

Eu acredito que isso falha H=['1'], N='0'.
User2357112 suporta Monica

Oh, espere, é necessário que a entrada seja positiva.
User2357112 suporta Monica

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

Entrada como Lista e String binária, saída como Strings em novas linhas.

Explicação:

Experimente aqui.

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

Pessoalmente, eu colocaria l->n->{...depois, void p(...pois o lambda é a resposta para o prompt e a função é necessária para que o lambda funcione. O consenso sobre "expressões de função" é algo como "a última 'expressão' de sua submissão pode ser uma 'expressão de função' se, quando armazenada em uma variável, atende aos requisitos de uma resposta de função" IIRC. Mas isso é apenas uma questão de formatação, e uma questão subjetiva.
CAD97

@ CAD97 Eu não fazia ideia de que o pedido importava. A última vez que publiquei uma resposta do Java 8 com dois métodos que usei voidporque era menor que um segundo lambda e o múltiplo .apply. Não marquei esta resposta (por exemplo, void p(List l,int k)& 2x p(l,0)versus (l,k)->& 2x p.apply(l,0)). Hmm .. o segundo parece ser 1 byte mais curto neste caso. Mas você diz que as regras afirmam que você só pode ter um método lambda? Ainda um pouco confuso por que tem que ser o último. Pessoalmente, eu sempre postar minhas respostas na seguinte ordem: imports; class-fields; main-method/lambda; other methods.
Kevin Cruijssen

novamente, é principalmente opinião, eu gostaria que alguém mais experiente gritasse antes de realmente dizer de um jeito ou de outro. No entanto, sei que isso é verdade: se você precisar chamar um método (por exemplo, recursivo ou como auxiliar), ele precisará ter um nome. Mas, quanto ao pedido, isso realmente não importa, pois não altera a contagem de bytes. Mas eu encomendo comoimports;helper methods;lambda
CAD97

@ CAD97 Ah, é claro, então seria void p(List l,int k)& 2x f(l,0);versus f=(l,p)->& 2x p.apply(l,0);(o que significa que a versão atual é 1 byte mais curta). Quanto ao pedido, vou continuar com isso, já que o fiz com todas as minhas respostas, e também faz sentido para mim começar pessoalmente com o método principal da explicação e, em seguida, o (s) método (s) auxiliar (es), se existe algum.
Kevin Cruijssen

e, infelizmente, você não pode simplesmente fazer f=(lambda)em Java, éjava.util.function.BiConsumer<List,Integer>f=(l,p)->{...}
CAD97

9

Japt , 15 14 13 12 10 bytes

Toma o palheiro como uma matriz de números inteiros e a agulha como uma sequência binária. Produz uma matriz de cadeias inteiras.

á m¬f_°¤øV

Tente


Explicação

á 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

Muito bom, sobre o que eu teria feito. ®¬nÃsalva um byte no mapeamento. (Eu também mover âpara o meio do programa para se livrar do segundo Ã; não salva nenhum bytes, mas é um pouco mais eficiente e parece um pouco melhor)
ETHproductions

Ah, obrigada, @ETHproductions - eu estava tão concentrado em ver se conseguia raspar alguns bytes emitindo cada número como uma matriz que perdi aquela simples alteração no mapeamento. O âfoi uma solução rápida pregado no final, quando Arnauld apontou que eu tinha esquecido para remover as duplicatas da matriz final, mas, você está certo, removendo as duplicatas antes de executar o filtro seria mais eficiente.
Shaggy

4

Ruby , 61 59 bytes

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

Experimente online!

Recurso interessante do dia: eu não sabia que poderia gerar a representação binária de uma string contendo um número.

Exemplo:

puts "%b"%"123"

-> 1111011

3

JavaScript (ES6), 140 bytes

Leva a agulha como uma corda binária.

(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

Braquilog , 15 bytes

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

Experimente online!

Explicação

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


entrada

[{12, 34, 56}, 21]

saída

{125634, 341256, 345612, 563412}


Há um espaço em branco em v[#2, 2].
Yytsi 30/05

1

CJam, 23 22 21 19 bytes

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

Este é um bloco que recebe entradas n hna pilha e deixa a saída como uma matriz na pilha.

Explicação:

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

Usa vários pacotes. pryr::f()cria automaticamente uma função, obtendo p, uma sequência do padrão binário a ser procurada e xum vetor com a outra entrada como entrada. combinat::permncria todas as permutações de x. R.utils::intToBiné uma versão agradável e cheia de palavras para converter um numérico (ou representação de um numérico) em um número binário, já convenientemente armazenado como um caractere. Portanto, aplique isso em todas as permutações e produza-as se a cadeia binária pestiver contida na versão binária da concatenação. Uma nova linha explícita é impressa, porque, caso contrário, a saída seria 12 56 3456 34 1234 56 1234 12 56.

plyr's l_plyé usado para suprimir a saída de uma lista nula, além da saída regular. Se uma saída como essa for permitida:

3 2 1 
[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
NULL

[[5]]
NULL

[[6]]
NULL

Em seguida, podemos salvar alguns bytes usando lapply:

108 bytes:

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

Se uma saída como essa for permitida:

[[1]]
NULL

[[2]]
NULL

[[3]]
NULL

[[4]]
[1] 3 2 1

[[5]]
NULL

[[6]]
NULL

Então podemos fazê-lo ainda mais curto:

101 bytes:

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

Não permitido.


0

Perl 6 , 69 bytes

{set @^a.permutations».join.grep(*.fmt('%b').contains($^b.base(2)))}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.