Skip to main content
Code Golf

Return to Answer

reduced deviation, maybe it'll work better??? the whole span was a rather large choice
Source Link
M Virts
M Virts
  • 1.1k
  • 4
  • 9

Guesser, BinaryReset


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess deterministically."""
    ub=255
    lb=0
    while True:
        g=(ub-lb)//2+lb
        r=liar(g)
        if r==-1:
            lb=g
        elif r==1:
            ub=g
        if lb>=ub:
            ub=255
            lb=0

Untested, for now ill just hope it works.

Guesser, BinaryResetGaussian


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess less deterministically."""
    ub=255
    lb=0
    while True:
        g=max(0,min(255,int(rng.gauss((ub+lb)//2,(ub-lb)/6))))
        r=liar(g)
        if r==-1:
            lb=g+1
        elif r==1:
            ub=g-1
        if lb>=ub:
            ub=255
            lb=0

Instead of fixing my binary search, why not just add randomness?

Guesser, BinaryReset


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess deterministically."""
    ub=255
    lb=0
    while True:
        g=(ub-lb)//2+lb
        r=liar(g)
        if r==-1:
            lb=g
        elif r==1:
            ub=g
        if lb>=ub:
            ub=255
            lb=0

Untested, for now ill just hope it works.

Guesser, BinaryResetGaussian


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess less deterministically."""
    ub=255
    lb=0
    while True:
        g=max(0,min(255,int(rng.gauss((ub+lb)//2,ub-lb))))
        r=liar(g)
        if r==-1:
            lb=g+1
        elif r==1:
            ub=g-1
        if lb>=ub:
            ub=255
            lb=0

Instead of fixing my binary search, why not just add randomness?

Guesser, BinaryReset


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess deterministically."""
    ub=255
    lb=0
    while True:
        g=(ub-lb)//2+lb
        r=liar(g)
        if r==-1:
            lb=g
        elif r==1:
            ub=g
        if lb>=ub:
            ub=255
            lb=0

Untested, for now ill just hope it works.

Guesser, BinaryResetGaussian


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess less deterministically."""
    ub=255
    lb=0
    while True:
        g=max(0,min(255,int(rng.gauss((ub+lb)//2,(ub-lb)/6))))
        r=liar(g)
        if r==-1:
            lb=g+1
        elif r==1:
            ub=g-1
        if lb>=ub:
            ub=255
            lb=0

Instead of fixing my binary search, why not just add randomness?

Fixed bug u => ub
Source Link
M Virts
M Virts
  • 1.1k
  • 4
  • 9

Guesser, BinaryReset


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess deterministically."""
    ub=255
    lb=0
    while True:
        g=(ub-lb)//2+lb
        r=liar(g)
        if r==-1:
            lb=g
        elif r==1:
            ub=g
        if lb>=ub:
            ub=255
            lb=0

Untested, for now ill just hope it works.

Guesser, BinaryResetGaussian


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess less deterministically."""
    ub=255
    lb=0
    while True:
        g=max(0,min(255,int(rng.gauss((ub+lb)//2,ub-lb))))
        r=liar(g)
        if r==-1:
            lb=g+1
        elif r==1:
            ub=g-1
        if lb>=ulb>=ub:
            ub=255
            lb=0

Instead of fixing my binary search, why not just add randomness?

Guesser, BinaryReset


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess deterministically."""
    ub=255
    lb=0
    while True:
        g=(ub-lb)//2+lb
        r=liar(g)
        if r==-1:
            lb=g
        elif r==1:
            ub=g
        if lb>=ub:
            ub=255
            lb=0

Untested, for now ill just hope it works.

Guesser, BinaryResetGaussian


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess less deterministically."""
    ub=255
    lb=0
    while True:
        g=max(0,min(255,int(rng.gauss((ub+lb)//2,ub-lb))))
        r=liar(g)
        if r==-1:
            lb=g+1
        elif r==1:
            ub=g-1
        if lb>=u:
            ub=255
            lb=0

Instead of fixing my binary search, why not just add randomness?

Guesser, BinaryReset


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess deterministically."""
    ub=255
    lb=0
    while True:
        g=(ub-lb)//2+lb
        r=liar(g)
        if r==-1:
            lb=g
        elif r==1:
            ub=g
        if lb>=ub:
            ub=255
            lb=0

Untested, for now ill just hope it works.

Guesser, BinaryResetGaussian


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess less deterministically."""
    ub=255
    lb=0
    while True:
        g=max(0,min(255,int(rng.gauss((ub+lb)//2,ub-lb))))
        r=liar(g)
        if r==-1:
            lb=g+1
        elif r==1:
            ub=g-1
        if lb>=ub:
            ub=255
            lb=0

Instead of fixing my binary search, why not just add randomness?

deleted 3 characters in body
Source Link
M Virts
M Virts
  • 1.1k
  • 4
  • 9

Guesser, BinaryReset


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess deterministically."""
    ub=255
    lb=0
    while True:
        g=(ub-lb)//2+lb
        r=liar(g)
        if r==-1:
            lb=g
        elif r==1:
            ub=g
        if lb>=ub:
            ub=255
            lb=0

Untested, for now ill just hope it works.

Guesser, BinaryResetGaussian


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess less deterministically."""
    ub=255
    lb=0
    while True:
        g=max(0,min(255,int(randomrng.gauss((ub+lb)//2,ub-lb))))
        r=liar(g)
        if r==-1:
            lb=g+1
        elif r==1:
            ub=g-1
        if lb>=u:
            ub=255
            lb=0

Instead of fixing my binary search, why not just add randomness?

Guesser, BinaryReset


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess deterministically."""
    ub=255
    lb=0
    while True:
        g=(ub-lb)//2+lb
        r=liar(g)
        if r==-1:
            lb=g
        elif r==1:
            ub=g
        if lb>=ub:
            ub=255
            lb=0

Untested, for now ill just hope it works.

Guesser, BinaryResetGaussian


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess less deterministically."""
    ub=255
    lb=0
    while True:
        g=max(0,min(255,int(random.gauss((ub+lb)//2,ub-lb))))
        r=liar(g)
        if r==-1:
            lb=g+1
        elif r==1:
            ub=g-1
        if lb>=u:
            ub=255
            lb=0

Instead of fixing my binary search, why not just add randomness?

Guesser, BinaryReset


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess deterministically."""
    ub=255
    lb=0
    while True:
        g=(ub-lb)//2+lb
        r=liar(g)
        if r==-1:
            lb=g
        elif r==1:
            ub=g
        if lb>=ub:
            ub=255
            lb=0

Untested, for now ill just hope it works.

Guesser, BinaryResetGaussian


import random
from typing import Callable

def Main(rng: random.Random, liar: Callable[[int], int]):
    """Guess less deterministically."""
    ub=255
    lb=0
    while True:
        g=max(0,min(255,int(rng.gauss((ub+lb)//2,ub-lb))))
        r=liar(g)
        if r==-1:
            lb=g+1
        elif r==1:
            ub=g-1
        if lb>=u:
            ub=255
            lb=0

Instead of fixing my binary search, why not just add randomness?

added second answer
Source Link
M Virts
M Virts
  • 1.1k
  • 4
  • 9
added 48 characters in body
Source Link
M Virts
M Virts
  • 1.1k
  • 4
  • 9
Fixed a bug: didn't indent conditionals
Source Link
M Virts
M Virts
  • 1.1k
  • 4
  • 9
Source Link
M Virts
M Virts
  • 1.1k
  • 4
  • 9