Igualdade de oscilação


15

Temos objetos que oscilam entre dois pontos inteiros [l, r], na velocidade de uma unidade por unidade de tempo, iniciando lem t=0. Você pode assumir l < r. Por exemplo, se um objeto oscila [3, 6], então temos:

t=0 -> 3
t=1 -> 4
t=2 -> 5
t=3 -> 6
t=4 -> 5
t=6 -> 4
t=7 -> 3
t=8 -> 4

Etc. Mas os objetos oscilam continuamente, então também temos t=0.5 -> 3.5e t=3.7 -> 5.3.

Dado dois objetos oscilando entre [l1, r1], [l2, r2], determinar se há sempre um tempo ttal que os dois objetos compartilham a mesma posição. Você faz o take l1, r1, l2, r2em qualquer formato conveniente e gera quaisquer valores de verdade / falsidade.


Entradas de verdade:

[[3, 6], [3, 6]]
[[3, 6], [4, 8]]
[[0, 2], [2, 3]]
[[0, 3], [2, 4]]
[[7, 9], [8, 9]]

Entradas falsas:

[[0, 3], [3, 5]] 
[[0, 2], [2, 4]]
[[5, 8], [9, 10]]
[[6, 9], [1, 2]]
[[1, 3], [2, 6]]
code-golf  array-manipulation  decision-problem  code-golf  math  number-theory  palindrome  integer-partitions  code-golf  math  decision-problem  geometry  code-golf  string  random  code-golf  ascii-art  code-golf  kolmogorov-complexity  primes  code-golf  kolmogorov-complexity  code-golf  graphical-output  code-golf  number-theory  primes  integer  factoring  code-golf  sequence  array-manipulation  integer  code-golf  array-manipulation  matrix  code-golf  sequence  binary  code-golf  game  cellular-automata  game-of-life  binary-matrix  code-golf  string  ascii-art  code-golf  random  generation  logic  code-golf  string  code-golf  code-golf  sequence  array-manipulation  random  apl  code-golf  code-golf  sequence  primes  code-golf  math  sequence  integer  code-golf  number  arithmetic  array-manipulation  decision-problem  code-golf  ascii-art  number  code-golf  restricted-source  quine  code-golf  chess  board-game  code-golf  math  sequence  code-golf  number  sequence  kolmogorov-complexity  code-golf  number  sequence  arithmetic  code-golf  math  number  alphabet  code-golf  ascii-art  classification  statistics  apl  code-golf  array-manipulation  matrix  code-golf  string  kolmogorov-complexity  code-golf  sequence  binary  base-conversion  binary-matrix  code-golf  string  classification  code-golf  tips  python  code-golf  combinatorics  binary  subsequence  restricted-time  code-golf  number  number-theory  code-golf  math  number  complex-numbers  code-golf  string  code-golf  string  code-golf  string  random  game  king-of-the-hill  python  code-golf  number  sequence  code-golf  number  sequence  code-golf  code-golf  math  number  array-manipulation  code-golf  array-manipulation  decision-problem  code-golf  string  code-golf  sequence  integer 

então é uma onda pontuda e não sinusóide, certo?
HyperNeutrino

Para referência deste desafio, consulte este jogo , onde você deve detectar se é possível pular de um bloco para o outro.
user202729

@HyperNeutrino Correct.
orlp

O valor falso pode ser 0e realmente qualquer número inteiro positivo ou deve ser consistente. Ainda mais, pode ser falsamente a lista vazia e realmente qualquer lista não vazia?
Sr. Xcoder,

3
Um bom teste de falsidade é [[1,3],[2,6]]: isso falsifica a heurística "os intervalos se sobrepõem e não têm o mesmo comprimento".
Misha Lavrov #

Respostas:



6

Casca , 13 bytes

VEΣUẊeTmȯ…¢mD

Recebe entrada no formato [[l,r],[L,R]]. Retorna 0para instâncias falsas e um número inteiro positivo para instâncias verdadeiras. Experimente online!

Explicação

As principais idéias são

  1. Uma colisão só pode acontecer em uma coordenada de número inteiro ou meio inteiro.
  2. É suficiente simular o sistema até que uma repetição de dois estados consecutivos seja encontrada.

Aqui está o código anotado.

VEΣUẊeTmȯ…¢mD  Implicit input, say [[0,2],[2,3]]
       mȯ      For both pairs do:
           mD   Double each: [[0,4],[4,6]]
          ¢     Cycle: [[0,4,0,4..],[4,6,4,6..]]
         …      Rangify: [[0,1,2,3,4,3,2,1,0,1,2..],[4,5,6,5,4,5,6..]]
      T        Transpose: [[0,4],[1,5],[2,6],[3,5],[4,4],[3,5],[2,6]..
    Ẋe         Adjacent pairs: [[[0,4],[1,5]],[[1,5],[2,6]],[[2,6],[3,5]],[[3,5],[4,4]]..
   U           Prefix of unique elements: [[[0,4],[1,5]],[[1,5],[2,6]],[[2,6],[3,5]],[[3,5],[4,4]]..[[1,5],[0,4]]]
  Σ            Concatenate: [[0,4],[1,5],[1,5],[2,6],[2,6],[3,5],[3,5],[4,4]..[1,5],[0,4]]
VE             Index of first pair whose elements are equal (or 0 if not found): 8

Resposta esperta. Por que você precisa dobrar cada um? Isso é para transformar a declaração "colisões só podem acontecer em números inteiros ou meios inteiros" em "colisões só podem acontecer em números inteiros"?
Jonah

@ Jonah Sim, exatamente.
Zgarb 24/10

2

JavaScript (ES6), 104 100 bytes

Uma implementação ingênua que apenas executa a simulação. Toma (a, b, c, d) como 4 variáveis ​​distintas.

(a,b,c,d)=>(g=(X,Y)=>x==y|x+X==y&(y+=Y)==x||(x+=X)-a|y-c&&g(x>a&x<b?X:-X,y>c&y<d?Y:-Y))(1,1,x=a,y=c)

Casos de teste


2

Wolfram Language (Mathematica) , 77 69 61 bytes

If[#>#3,#0[##3,#,#2],(z=GCD[x=#-#2,#3-#4])Mod[x/z,2]<=#2-#3]&

Uma função pura, tendo os quatro argumentos l1, r1, l2, r2como entrada: por exemplo, [0,3,2,4]quando os intervalos são [0,3]e [2,4].

Experimente online!

Como funciona

Para chegar [a,b]perto de um ponto [c,d], supondo a<c<b<dque queremos um múltiplo ímpar de b-adentro b-cde um múltiplo par de d-c. Se b-ahouver mais fatores 2que d-c, podemos fazer com que isso aconteça exatamente: haverá um momento em que o primeiro ponto está em be o segundo ponto está em c, e então estamos em boa forma. Caso contrário, o melhor que podemos fazer é o MDC de b-ae d-c.


1

JavaScript (ES6), 89 bytes

(a,b,c,d)=>[...Array((b-=a)*(d-=c)*4)].some((g=e=>i/e&2?e-i/2%e:i/2%e,i)=>a+g(b)==c+g(d))

Toma l1,r1,l2,r2como argumentos separados. Explicação: É garantido que a simulação se repita após as (r1-l1)*(r2-l2)*2unidades de tempo (ou um fator disso); gcalcula o deslocamento do objeto apropriado após as i/2unidades de tempo e, portanto, iprecisa variar até (r1-l1)*(r2-l2)*4.


1

05AB1E , 12 10 14 bytes

+4 bytes para lidar com intervalos negativos

Retorne 0 se falso, ou um número inteiro positivo caso contrário

Use a ideia de duplicar valores da Zgarb para facilitar a detecção da mesma posição

Obrigado a @ Zacharý por apontar meus erros

ÄZU\·εXиŸ}øüQO

Experimente online!

Explicações:

ÄZU\·εXиŸ}øüQO 
ÄZU\            Store in X the largest absolute number in the lists
    ·           Double lists ([3,6],[4,8] => [6,12],[8,16])
     ε   }      For each...
      X             Push X
       и            List-repeat that much times ([6,12]*12 => [6,12,6,12,6,...])
        Ÿ           Rangify ([6,12,6,...] => [6,7,8,9,10,11,12,11,...])
          ø     Zip lists ([6,7,8,...],[8,9,10,...] => [6,8],[7,9],[8,10],...)
           üQ   1 if both elements of a pair are equal, 0 otherwise
             O  Sum result list (=0 if the same position is never shared)
                Implicit output

Eu não acho que isso funcione para grandes intervalos de lista, porque 100 parece bastante arbitrário.
`` Zacharý

@ Zacharý Obrigado! Corrigi-o de uma maneira muito ineficaz, pois agora as listas são repetidas muitas vezes. :-)
scottinet 26/10

Na verdade, isso pode não funcionar ainda (não vou me incomodar em descobrir como, porque levaria muito tempo e, honestamente, as listas teriam que ser um intervalo minúsculo e ENORME do que eu acho que não funcionará. )
Zacharý 26/10

@ Zacharý Deveria funcionar para números inteiros positivos grandes arbitrários, uma vez que o pior caso seria [[0,n],[n-1, n]]e, mesmo nesse caso, a segunda lista seria repetida várias vezes (e mais) para que a primeira atingisse seu limite superior. Mas eu esqueci de levar em consideração os números negativos: [[-100, 1], [0, 1]]não funciona. Corrigindo-o a um custo de 4 bytes :-(
scottinet

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.