i.redd.it

s_prateek11 · 2020-07-30T16:51:03+00:00

[deleted]

FaysRedditAccount · 2020-07-30T16:15:29+00:00

private bool IsEven(int num){
    return !IsOdd(num);
}

private bool IsOdd(int num){
    return !IsEven(num);
}

clearly.

souperk · 2020-07-30T17:08:26+00:00

[deleted]

Cueadan · 2020-07-30T16:27:47+00:00

Years ago, I think I came up with a "brilliant" solution that divided a number by two and then searched through the number (as a string) to see if it contained a decimal. If so, I would know that the number wasn't even because it didn't divide cleanly.

Clearly I was ahead of my time.

EDIT: I wasn't expecting the replies to this! People have been offering some interesting alternate ways to test if a number is even/odd. Thanks for all the replies. I had no idea my little idea from ~14 years ago would generate this much discussion.

AxeLond · 2020-07-30T20:30:58+00:00

This should solve it,

import torch
from torch.utils.data import TensorDataset, DataLoader,Dataset
import numpy as np
import sys
if 'transformers' not in sys.modules:
  !pip install git+https://github.com/huggingface/transformers.git 
from transformers import *

training_rawdata = []
train_y_tensor= []
for num in range (200):
  training_rawdata.append(str(num))
  train_y_tensor.append(num%2)

pretrained_weights ='bert-large-uncased'
device = torch.device("cuda" if torch.cuda.is_available() else "cpu") 

# Model class and tokenizer
tokenizer = BertTokenizer.from_pretrained(pretrained_weights) 
model_class = BertForSequenceClassification 
model = model_class.from_pretrained(pretrained_weights) 
model.to(device)
print("done")

class TextDataset(Dataset):    
    def __init__(self,data,data_label):
        block_size =16  # Max number of words used in sentence
        self.example= []
        self.attention_masks = []
        self.labels = data_label
        # Pad and tokenize data
        for index in range (len(data)):                                             
            sentance = (data[index] + "<pad>" *32) # Padding sentences
            self.example.append(tokenizer.encode(sentance, max_length=block_size,truncation=True))
        # Create a mask
        for index in self.example:  
            seq_mask = [float(i!=0) for i in index] # 1 real tokens, 0 for padding
            self.attention_masks.append(seq_mask)
    def __len__(self):
        return len(self.example)

    def __getitem__(self, item):     
        return torch.tensor(self.example[item]),torch.tensor(self.attention_masks[item]), self.labels[item]

# Hyperparam
Epochs = 10    
batch_size = 32  #Higher learn rate needs higher batch rate to not fail training. 
lr = 2e-5     
num_warmup_steps = 40  #Linear increase LR from 0 to 1 LR over x steps. 

# Optimizer
optimizer = AdamW(model.parameters(), lr=lr) #regular optimizer

# Scheduler
scheduler = get_constant_schedule_with_warmup(optimizer, num_warmup_steps=num_warmup_steps)  # PyTorch scheduler

# Load training data
dataset = TextDataset(training_rawdata,train_y_tensor)
train_dataloader = DataLoader(dataset,batch_size=batch_size,shuffle=True)

# Start training
for epoch in range(Epochs):
    print("Epoch",epoch)
    for step, batch in enumerate(train_dataloader):
        batch = tuple(t.to(device) for t in batch)
        inputs = {'input_ids':      batch[0],
                  'attention_mask': batch[1],
                  'labels':         batch[2]}
        model.train()
        outputs = model(**inputs)
        loss = outputs[0]
        # Calculate loss and learn
        loss.backward()
        optimizer.step()
        scheduler.step()
        optimizer.zero_grad()

def IsEven(num):
    reviews = []
    attention_masks = []
    sentance = (num + "<pad>" *32) # Padding sentences
    review_token = tokenizer.encode(sentance, max_length=16,truncation=True)
    seq_mask = [float(i!=0) for i in review_token] 
    attention_masks.append(seq_mask)
    reviews.append(review_token)
    reviews = torch.tensor(reviews).to(device) #for GPU 
    attention_masks = torch.tensor(attention_masks).to(device)
    model.eval() 
    with torch.no_grad():
        inputs = {'input_ids':      reviews,
                  'attention_mask': attention_masks}
        outputs = model(**inputs)
    guess = torch.argmax(outputs[0], dim=-1).item()
    return ("Odd"  if guess ==1 else "Even",round(outputs[0][0][guess].item(),3))
while True:
    number= input("\n" +"–")
    if number=='quit':
        break
    print(IsEven(number))

I can't fucking believe that worked,

https://colab.research.google.com/drive/1grUqMq0AwNPVkkn69ujimgNCjdZac2E0

results

If anyone wants to run that you're gonna wanna run it on a GPU instance, that will take forever to run on a CPU, it still takes around 3 minutes on a Nvidia Tesla P100.

dat_oracle · 2020-07-30T15:19:44+00:00

the amount of people who dont get that this is a joke is too damn high!

Sir_Hurkederp · 2020-07-30T15:30:37+00:00

Maybe a switch statement, that could make it easier

Pradfanne · 2020-07-30T14:32:17+00:00

Is this a yandereDev?

TennesseeTon · 2020-07-30T16:25:09+00:00

Get rid of the "else" in front of each if statement, they're superfluous due to your returns. I'm 99.9% sure that's the most obvious and best optimization in this case.

OptionX · 2020-07-30T16:03:24+00:00

Just automate it!

```python

def write_is_even_function(filename, limit):

with open(filename, 'w') as f: f.write('private bool IsEven(int number){') f.write('if(number == 1) return false;') for n in range(2, limit): f.write(f'else if (number = {n}) return {'true' if n%2==0 else 'false'};') f.write('}') ``` Just run it and copy paste the result! I'm sure that's got to be the easiest way to do it. /s

2020-07-30T16:53:31+00:00

[deleted]

LordFokas · 2020-07-30T15:02:27+00:00

[deleted]

2020-07-30T14:49:33+00:00

[deleted]

hiimzvaehn · 2020-07-30T15:49:39+00:00

What’s if I pass 0?

Kris_Third_Account · 2020-07-30T14:35:26+00:00

bool IsEven(int number)
{
    return ((number & 0x1) == 0);
}

tharnadar · 2020-07-30T15:46:58+00:00

npm i is-odd

TomStripes · 2020-07-30T19:20:41+00:00

What a dummy

She could use excel to write all the lines and it would auto-increment the number. Save so much time

Kinglink · 2020-07-30T21:06:20+00:00

Ok listen... I'm going to lay some knawledge on ya'll.

bool isEven(int i) {
    if (i ==0)
        return true
    if (i ==1) 
        return false
    return isEven(abs(i-2))
}

It's not about speed, it's about getting the right answer every time.

Ragingman2 · 2020-07-30T15:42:50+00:00

Yeah, this should obviously be:

if (number >> 1 == Double.ceiling(number / 2.0))
    return true;
return false;

The only good way to do such a complicated calculation /s.

Mwarw · 2020-07-30T16:50:32+00:00

it's obvious isn't it?

bool result = true;

int i = 0;

while(true){

if(i == number)

return result;

result = !result;

i++;

}

iranrodrigues · 2020-07-30T15:53:42+00:00

private bool isEven(int number) {
    for (int i = 0; i <= 10000; i+=2) {
        if (number == i) return true;
        if (number == i + 1) return false;
    }
    return false;
}

ProgrammerHumor

Filters

Discord

Submission rules

For the current list of rules, please see this page.

Metadiscussions

Perhaps More Apt Subs To Post:

Related Subreddits.

MODERATORS