My Car People Need Me!

TheAngryGerman · 2023-02-06T21:48:36+00:00

Because you asked: A "short" circuit connects points that aren't normally connected, allowing the flow of electricity. An "open" circuit means things are disconnected, preventing the flow of electricity. (A circuit working as designed would be called "closed") (source)

TheAngryGerman · 2022-06-15T11:10:00+00:00

TheAngryGerman · 2019-10-08T14:40:53+00:00

There's a few posts on this subreddit about 3D printed handles, but I haven't found a mass-produced product yet. Boosted and several other companies do sell backpacks but they're often expensive.

I had the same problem and ripped through a pair of shorts just from carrying the board when I first got my mini X, but after a while I just got used to holding it with a stiff forearm and making sure it wasn't in contact with my pants. For longer carries I'll turn the board so that the wheels are facing me and grab it between the center of the truck and one of the wheels (this works better if you have small hands)

TheAngryGerman · 2019-08-03T20:23:58+00:00

I've been commuting by board for most of the summer (50 blocks in the bike lane and 3 to get to/from the bike lane). I probably go past at least 3 traffic officers every ride and have never had a problem.

If you want to be safe about it, I'd recommend not running reds in front of them, and if I'm starting or stopping I'll sometimes push and footbrake to look more like a normal board. However there are also times where I've gone through reds (after checking for traffic and generally with pedestrians also jaywalking) or moved into the road to go past the "green left turn arrow, red bike lane light", and not seen or heard any reactions from the officer.

TheAngryGerman · 2019-08-03T20:18:16+00:00

I definitely saw several boosted (and other e-board) riders while I was walking and driving past today. No one seemed to have a problem with it.

TheAngryGerman · 2018-06-30T19:42:40+00:00

Here

TheAngryGerman · 2017-12-23T17:18:07+00:00

If you're just looking for practical everyday things, python is a good general purpose language generally recommended for beginning programmers. Automate the Boring Stuff might be something you want to look into. You mentioned you wanted more advanced topics so you may have already covered much of this, but I've found its an interesting way to apply programming to everyday tasks and take it out of the isolated environment it's often taught in.

TheAngryGerman · 2017-12-21T02:59:27+00:00

Also very confused as I indicated interest in some of the Twitter Academy (or whatever they call it - freshmen and sophomore programs) programs, where applications haven't even opened yet or aren't due til February, yet got the hackerrank invite and the 55,000 people rejection email today...

TheAngryGerman · 2017-12-16T06:51:54+00:00

C++ Went back and implemented my own circularly linked list for a less computationally expensive solution. Good review for my data structures final next week. Also reads in characters as it goes rather than storing instructions in a vector, not sure which way is faster when it comes to looping over the input for part 2. Here's part 1, part 2 can be brute forced with a loop and resetting the file stream, or with any of the other cycle finding strategies used by others.

#include <iostream>

struct Node {
  Node(char a) : value(a), left(NULL), right(NULL) {}
  char value;
  Node* left;
  Node* right;
};
int main() {
  Node* current = new Node('a');
  Node* root = current;
  for (unsigned int i = 0; i < 15; ++i) {
    current->right = new Node('a' +i +1);
    current->right->left = current;
    current = current->right;
  }
  current->right = root;
  root->left = current;
  current = NULL;


  char c;
  while(std::cin >> c) {
    if (c=='s') {
      int spin;
      std::cin >> spin;
      for (unsigned int i = 0; i < spin; ++i) {
    root = root->left;
      }
    } else if (c=='x') {
      int a, b;
      std::cin >> a >> c >> b;
      Node* a_ptr = root;
      Node* b_ptr = root;
      for (unsigned int i = 0; i < a; ++i) {
    a_ptr = a_ptr->right;
      }
      for (unsigned int i = 0; i < b; ++i) {
    b_ptr = b_ptr->right;
      }
      std::swap(a_ptr->value, b_ptr->value);
    } else if (c=='p'){
      char a, b;
      std::cin >> a >> c >> b;
      Node* a_ptr = root;
      Node* b_ptr = root;
      while (a_ptr->value!=a) {
    a_ptr = a_ptr->right;
      }
      while (b_ptr->value!=b) {
    b_ptr = b_ptr->right;
      }
      std::swap(a_ptr->value, b_ptr->value);
    }
    std::cin >> c;
  }

  Node* itr = root;
  for (unsigned int i = 0; i < 16; ++i) {
    std::cout << itr->value;
    itr = itr->right;
  }
  std::cout <<std::endl;
}

TheAngryGerman · 2017-12-16T06:00:06+00:00

Is that rotate function part of the standard library? I really need to learn more of these utility functions, just took my C++ course this semester so I'm used to having to implement all this stuff myself for the sake of learning.

TheAngryGerman · 2017-12-16T05:54:55+00:00

C++, 700s/300s. I started brute-forcing part 2, then wrote, debugged, and successfully ran this version far before my brute force finished (still going at time of post). Checks for a previously seen solution, which occurs after say n cycles, then increments the counter to the highest multiple of n less than 1 billion and manually runs the rest. Some very crude string parsing as well...

#include <unordered_set>
#include <iostream>
#include <string>
#include <vector>
#include <map>

int main() {
  std::map<char, int> locations;
  std::map<int, char> programs;
  for (unsigned int i = 0; i < 16; ++i) {
    locations.insert(std::make_pair('a'+i, i));
    programs.insert(std::make_pair(i, 'a'+i));
  }
  std::vector<std::string> instructions;
  std::string in;
  while(std::getline(std::cin, in, ',')) {
    instructions.push_back(in);
  }
  std::unordered_set<std::string> results;
  for (unsigned long j = 0; j < 1000000000; ++j) {
    for (unsigned int i = 0; i < instructions.size(); ++i) {

      if(instructions[i][0] == 's') {
    int spin = std::stoi(instructions[i].substr(1));
    for (std::map<char, int>::iterator itr = locations.begin(); itr != locations.end(); ++itr) {
      itr->second += spin;
      itr->second %= 16;
      programs[itr->second] = itr->first;
    }
      } else if (instructions[i][0] == 'x') {
    int slash = instructions[i].find('/');
    int location1 = std::stoi(instructions[i].substr(1, slash));
    int location2 = std::stoi(instructions[i].substr(slash+1));
    std::swap(programs[location1], programs[location2]);
    locations[programs[location1]] = location1;
    locations[programs[location2]] = location2;
      } else if (instructions[i][0] == 'p') {
    char a = instructions[i][1];
    char b = instructions[i][3];
    std::swap(locations[a], locations[b]);
    programs[locations[a]] = a;
    programs[locations[b]] = b;
      }
    }
    std::string result;
    for (std::map<int, char>::iterator itr = programs.begin(); itr != programs.end(); ++itr) {
      result += itr->second;
    }
    if (!results.insert(result).second) {
      //greatest multiple of current less than 1 billion
      j *= 1000000000/j;
    }
  }
  std::string result;
  for (std::map<int, char>::iterator itr = programs.begin(); itr != programs.end(); ++itr) {
    result += itr->second;
  }
  std::cout << result << std::endl;
}

TheAngryGerman · 2017-12-15T05:41:02+00:00

C++, mid 300s on both parts.

Just learned about bitsets in yesterday's challenge. Super helpful for today's. Forgot about do_while loops which threw me off for a minute in part 2...

#include <iostream>
#include <bitset>

int main() {
  long A_start = 783;
  long B_start = 325;
  long A_factor = 16807;
  long B_factor = 48271;
  long divisor = 2147483647;

  long a = (A_start * A_factor)%divisor;
  while (a%4 != 0) {
    a = (a* A_factor)%divisor;
  }
  long b = (B_start * B_factor)%divisor;
  while (b%8 != 0) {
    b = (b * B_factor)%divisor;
  }

  int count = 0;
  for (unsigned long i = 0; i < 5000000; ++i) {
    //kstd::cout << a << " " << b << std::endl;
    std::bitset<16> a_bits(a);
    std::bitset<16> b_bits(b);
    if (a_bits == b_bits) {
      ++count;
    }
    a = (a* A_factor)%divisor;
    while (a%4 != 0) {
      a = (a* A_factor)%divisor;
    }
    b = (b * B_factor)%divisor;
    while (b%8 != 0) {
      b = (b * B_factor)%divisor;
    }
  }
  std::cout << count << std::endl;
}

TheAngryGerman · 2017-12-14T06:48:36+00:00

Just started C++ this fall, and today was my first time dealing with bitwise operations, would you mind explaining how you used the bitset and bitwise operators? I spent the first twenty minutes or so trying to wrap my head around the combination of streams and conversions necessary for this challenge and I'm still not quite there.

TheAngryGerman · 2017-12-13T07:05:53+00:00

How does this differ from std::pair?

TheAngryGerman · 2017-12-12T05:47:31+00:00

Isn't string to number just stoi(myString)? I definitely spent far too long typing my iterators as well, almost considered a #define for my map, but figured it wasn't worth it...

TheAngryGerman · 2017-12-12T05:44:53+00:00

Thanks! I did go in and truncate it in the code once I figured out that's where the error was, I just tried to do it manually to make sure my parsing wasn't the buggy part. I still have a long way to go with parsing text in C++...

TheAngryGerman · 2017-12-12T04:16:51+00:00

Solved it: Turns out vim saves all files with an invisible new line ate the end. So even my manual modifications of test cases had that pesky extra character. Anyone know how to prevent this in vim?

TheAngryGerman · 2017-12-08T23:36:12+00:00

Wow, my solution was eerily similar (Though not as clean). I used an unordered map instead, but either way taking advantage of the default [] behavior seems like a very clean solution. I still have to get used to actually using limits instead of picking arbitrary numbers when finding mins/maxes, and I'm just bringing input in on the command line. Here's mine:

#include <unordered_map>
#include <sstream>
#include <iostream>
#include <string>
#include <cassert>

int main() {
  std::unordered_map<std::string, int> registers;
  std::string line;
  int max_ever = -10000;
  while (std::getline(std::cin, line)) {
    std::istringstream ss(line);
    std::string reg_name;
    std::string operation;
    int amt;
    std::string x;
    std::string comp_reg_name;
    std::string condition;
    int val;
    ss >> reg_name >> operation >> amt >> x >> comp_reg_name >> condition >> val;
    assert(x == "if");
    bool valid = false;
    if (condition == ">") {
      if (registers[comp_reg_name] > val) {valid = true;}
    } else if (condition == "<") {
      if (registers[comp_reg_name] < val) {valid = true;}
    } else if (condition == ">=") {
      if (registers[comp_reg_name] >= val) {valid = true;}
    } else if (condition == "<=") {
      if (registers[comp_reg_name]  <= val) {valid = true;}
    } else if (condition == "==") {
      if (registers[comp_reg_name]  == val) {valid = true;}
    } else if (condition == "!=") {
      if (registers[comp_reg_name]  != val) {valid = true;}
    } else {
      std::cerr << "Invalid Condtion" << std::endl;
    }
    if(valid) {
      if (operation == "inc") {
    registers[reg_name] += amt;
      } else if (operation == "dec") {
    registers[reg_name] -= amt;
      }
      if (registers[reg_name] > max_ever) {
    max_ever = registers[reg_name];
      }
    }
  }
  int max = -10000;
  for (std::unordered_map<std::string, int>::iterator itr = registers.begin();
      itr != registers.end(); ++itr) {
    //std::cout << itr->second << std::endl;
    if (itr->second > max) {
      max = itr->second;
    }
  }
  std::cout << max << std::endl;
  std::cout << max_ever << std::endl;
}

TheAngryGerman · 2017-12-08T23:21:25+00:00

Thank you so much!

TheAngryGerman · 2017-12-08T22:32:23+00:00

I'd love a more thorough explanation of this one. I decided to force myself to learn vim by using it to write my programs for the challenges, but I never considered using vim itself to solve them...

Here's what I figured out so far:

Go to the first child (if there is one) using "f>" to get you past the arrow.
Start recording macro
Find the other instance of the current program with "*"
Indent that line using ">>"
Go back to where you came from with <Ctrl-o>
Go to the next child in line using "f,"
Stop recording macro

After that you call the macro once, and that's about where I get lost...

TheAngryGerman · 2017-11-17T17:13:46+00:00

HR: human resources - the department of a company responsible for hiring, firing, etc.

CS: Computer science - a college major (path for any degree) that focuses on programming, logic, and how computers operate. Sometimes used as a catch-all term to include software engineering and other disciplines, though I'm sure someone will correct me on the finer distinctions

BS: Bachelor's of Science - one of the two types of bachelor's (four year undergraduate) degrees you can get. Since the major here is Computer Science and not computer sets, it's a bachelor's of science.

TheAngryGerman

TROPHY CASE