Uguaglianza di oscillazione


15

Abbiamo oggetti che oscillano tra due punti interi [l, r], alla velocità di un'unità per unità di tempo, a partire da lon t=0. Puoi presumere l < r. Ad esempio, se un oggetto oscilla su [3, 6], allora abbiamo:

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

Ecc. Ma gli oggetti oscillano continuamente, quindi abbiamo anche t=0.5 -> 3.5e t=3.7 -> 5.3.

Dati due oggetti oscillanti tra [l1, r1], [l2, r2], determinare se v'è mai un tempo ttale che i due oggetti condividono la stessa posizione. Prendi take l1, r1, l2, r2in qualsiasi formato conveniente e produci valori di verità / falsità.


Ingressi sinceri:

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

Ingressi falsi:

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

quindi è un'onda appuntita non una sinusoide, giusto?
HyperNeutrino,

Per riferimento a questa sfida , fai riferimento a questo gioco , in cui devi rilevare se è possibile saltare da un blocco all'altro.
user202729,

@HyperNeutrino Correct.
orlp,

Il valore di falsità può essere 0e in verità qualsiasi numero intero positivo o devono essere coerenti. Ancora di più, la falsa può essere la lista vuota e la verità può essere una lista non vuota?
Mr. Xcoder,

3
Un buon test di falsa è [[1,3],[2,6]]: questo falsifica l'euristico "gli intervalli si sovrappongono e non hanno la stessa lunghezza".
Misha Lavrov,

Risposte:



6

Buccia , 13 byte

VEΣUẊeTmȯ…¢mD

Accetta input nel formato [[l,r],[L,R]]. Restituisce 0per istanze false e un numero intero positivo per istanze true. Provalo online!

Spiegazione

Le idee principali sono

  1. Una collisione può avvenire solo su una coordinata intera o mezza intera.
  2. È sufficiente simulare il sistema fino a quando si verifica una ripetizione di due stati consecutivi.

Ecco il codice annotato.

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

Risposta semplice. Perché è necessario raddoppiare ciascuno? È per trasformare la frase "le collisioni possono avvenire solo a numeri interi o mezze intere" in "le collisioni possono avvenire solo a numeri interi"?
Giona,

@Giona Sì, esattamente.
Zgarb,

2

JavaScript (ES6), 104 100 byte

Un'implementazione ingenua che esegue solo la simulazione. Prende (a, b, c, d) come 4 variabili distinte.

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

Casi test


2

Wolfram Language (Mathematica) , 77 69 61 byte

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

Una funzione pura che prende l1, r1, l2, r2come input quattro argomenti : ad esempio, [0,3,2,4]quando gli intervalli sono [0,3]e [2,4].

Provalo online!

Come funziona

Per ottenere un punto [a,b]vicino a un punto [c,d], supponendo a<c<b<d, vogliamo un multiplo dispari b-aall'interno b-cdi un multiplo pari di d-c. Se b-aha più fattori di 2rispetto d-c, siamo in grado di fare questo accadere esattamente: ci sarà un momento in cui il primo punto è in be il secondo punto è c, e quindi siamo in buona forma. In caso contrario, il meglio che possiamo fare è il GCD di b-ae d-c.


1

JavaScript (ES6), 89 byte

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

Prende l1,r1,l2,r2come argomenti separati. Spiegazione: La simulazione si ripete dopo le (r1-l1)*(r2-l2)*2unità di tempo (o un suo fattore); gcalcola l'offset dell'oggetto appropriato dopo le i/2unità di tempo, quindi ideve variare fino a (r1-l1)*(r2-l2)*4.


1

05AB1E , 12 10 14 byte

+4 byte per gestire intervalli negativi

Restituisce 0 se falso, o un numero intero positivo altrimenti

Usa l'idea di Zgarb di raddoppiare i valori per facilitare lo stesso rilevamento della posizione

Grazie a @ Zacharý per aver segnalato i miei errori

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

Provalo online!

spiegazioni:

Ä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

Non penso che funzionerà per grandi intervalli di elenchi, perché 100 sembra piuttosto arbitrario.
Zacharý,

@ Zacharý Grazie! L'ho risolto in modo molto inefficace, poiché ora gli elenchi vengono ripetuti troppe volte. :-)
scottinet,

In realtà, questo potrebbe non funzionare ancora (non mi preoccuperò di capire come, perché ci vorrebbe troppo tempo e, onestamente, le liste dovrebbero essere una gamma minuscola e una gamma ENORME da ciò che penso non funzionerà )
Zacharý,

@ Zacharý Dovrebbe funzionare per interi positivi grandi arbitrari, poiché il caso peggiore sarebbe [[0,n],[n-1, n]]e anche in quel caso, il secondo elenco verrebbe ripetuto abbastanza volte (e altro) affinché il primo raggiungesse il limite superiore. Ma ho dimenticato di prendere in considerazione i numeri negativi: [[-100, 1], [0, 1]]non funziona. Risolto il problema al costo di 4 byte :-(
scottinet,

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.