Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[SaintofWar]

Yeah, sure, I guess. But then you might as well just call the EIP an abascus. I dunno, nevermind then. I thought it was a good idea. I guess I'll come back with some interesting code instead.

[Reelya]

What the fuck are you talking about now?

Explicit "Goto" instructions have been removed from high-level languages, but the languages are still entirely structured around using them, it's just that their use has been constrained to specific cases.

If we're talking machine code, we can ask whether gotos exist, or whether for loops, while loops exist. For loops and while loops do not exist in machine code. There's only the "jmp" instruction and registers. Which is identical to how you'd write a goto-based loop in a high level language. Basically none of the high-level theoretical structures of execution flow exist in machine language except the function call/return stack, and one-way gotos.

[SaintofWar]

There's a misunderstanding here. I was answering Miauw62's remark that it was mostly GOTOs. I mistakenly thought that was what you said, hence my remark. What I was trying to say is, assembly is not all about jumps. In fact, there's only a few jumps here and there, especially after compiler optimizations.

If it was all jumps, then indeed, you could just call the EIP some counting or calculation helper 'tool'. Like me in 1st grade when I was tracing with my fingers the numbers I was trying to add together... from a different notebook. It's a bad analogy, I get it. But it's not far off the mark.

In hindsight, I suppose what I should have said, had I immediately realized I was replying to someone else was: Specifically, the pointer would jump forward 4 bytes if it was an int array. Would the same be true for a &pointer? The dereference *pointer is less interesting, that would just increase the value at the address the pointer is pointing to.

[Reelya]

If you did (&pointer)++, then this would most likely do nothing at all. "&pointer" takes the address that holds "pointer", and puts it into a temporary variable. You then increment that temporary variable. but since it's only a literal expression that temp variable is basically out of scope after this instruction ends, losing any changes. It's similar for basic types:

int i;
(&i)++; // <= this won't break i, because &i takes a copy of i's pointer, it doesn't change the address of i itself.

[SaintofWar]

Indeed. But I figured it was awesomer to answer that in actual disassembled code, rather than a straight answer. That was the point, right?

Anyway. I guess it wasn't that special of an idea.

[RoguelikeRazuka]

Hey guys I need to write a program for resolving the travelling salesman problem with the use of the greedy algorithm. The program itself is already written in C (as a concole application), but the teacher says it also needs a visualization to be made, that is a complete weighted undirected graph to be drawn on the screen. I know it's impossible to do it in the console window, and I don't possess any knowledge of win32api or anything. I suspect I could draw the graph by the means of the graph unit from Pascal, but in this case I'll have to rewrite the whole program which could be painfully difficult. What do I do?

[Reelya]

Try learning Opengl. To make things easier you should use a windowing library that builds the OpenGL context for you. GLUT is one I used to use, but I started using SFML recently.

Whatever you do, don't bother with win32api or any of that junk for this. Just use the cross-platform OpenGL stuff and an additional library that handles the windows side of things. Here's the tutorials for SFML. Basically try and hook it up with your compiler of choice, then cut and paste the code from the "open a window" tutorial to get a blank window going. At that point you can look at further SFML stuff, or just do regular OpenGL commands.

http://www.sfml-dev.org/tutorials/2.3/

[jaked122]

SFML is a library that I'm a bit familiar with, but the one thing that surprises me is that some people on stackoverflow recommend it for typical gui programming. I have to wonder if they don't understand the question, or perhaps are advocating fluid uis coded from scratch out of more primitive SFML primitives. Which has ups and downs, but mostly a lot more code than most people would like to implement for themselves.

I hope that's what they're doing, rather than misunderstanding the question.

[miauw62]

If anyone has ever heard of Zybooks then its that. I go toehri for the 'online portion of my class' (In reality the majority) to do sections of chapters. Each section in the end has challenges on the concepts discussed in the chapter. Such as debugging or using a piece of code.


Basically I used the same code but added endl.

 cout << "Press the " << letterToQuit << " key " << numPresses << " times to quit.";

Thinking back it wasn't too hard..except that one bit at the end. Is it normal to 'know' a concept but have some some particle be missing in your code which stops you getting what you want for hours on end? Or am I just bad at being a new programmer?

Perfectly normal, really. Often bugs can be traced back to accidentally typing i++ instead of j++ or using > where you should've used < or =>, stuff like that.

[LoSboccacc]

Perfectly normal, really. Often bugs can be traced back to accidentally typing i++ instead of j++ or using > where you should've used < or =>, stuff like that.

my favorite is

if (something); {


}

[miauw62]

That causes me physical pain.

[Orange Wizard]

* Orange Wizard gags violently.

[TheBiggerFish]

Error in process rational_thought: uncaught HasGoneStarkRavingMad exception.

[Bauglir]

Okay, so I wasted about 4 hours of my time on one of Google's foo.bar puzzles today, in the spoiler below. I have given up because I have now become convinced that the solution I arrived at within the first hour is correct, but it keeps failing all tests but one. At this point, I'd just like to know why the code doesn't do what I think it should do. I looked up the solution, and while I take a different approach to implementing it, as far as I can tell they should result in equivalent outcomes, so an illustration of the difference would work for me.

Thanks.

Spoiler: The Problem (click to show/hide)

Rusty calculator
================

Lab minion Rusty works for Professor Boolean, a mad scientist. He’s been stuck in this dead-end job crunching numbers all day since 1969. And it’s not even the cool type of number-crunching – all he does is addition and multiplication. To make matters worse, under strict orders from Professor Boolean, the only kind of calculator minions are allowed to touch is the Unix dc utility, which uses reverse Polish notation.

Recall that reverse Polish calculators such as dc push numbers from the input onto a stack. When a binary operator (like “+” or “*”) is encountered, they pop the top two numbers, and then push the result of applying the operator to them.

For example:
2 3 * => 6
4 9 + 2 * 3 + => 13 2 * 3 + => 26 3 + => 29

Each day, Professor Boolean sends the minions some strings representing equations, which take the form of single digits separated by “+” or “*”, without parentheses. To make Rusty’s work easier, write function called answer(str) that takes such a string and returns the lexicographically largest string representing the same equation but in reverse Polish notation.

All numbers in the output must appear in the same order as they did in the input. So, even though “32+” is lexicographically larger than “23+”, the expected answer for “2+3″ is “23+”.

Note that all numbers are single-digit, so no spaces are required in the answer. Further, only the characters [0-9+*] are permitted in the input and output.

The number of digits in the input to answer will not exceed 100.

Test cases
==========

Inputs:
(string) str = “2+3*2″
Output:
(string) “232*+”

Inputs:
(string) str = “2*4*3+9*3+5″
Output:
(string) “243**93*5++”

Spoiler: My Code (click to show/hide)

def answer(string):
    """Returns a string containing the reverse Polish notation
    equivalent of the supplied infix, parentheses-free string
    equation."""

    # @ is used as a dummy character. If later versions require
    # using that character as an operator or value, replace it.

    # One extra slot allocated to prevent out_str.index() from
    # raising an error if 100 '@'s are consumed. Assumes that
    # the time spent on out_str.index() and the extra allocated
    # space is a lesser cost than the time to reallocate the
    # list every time a value needs to be appended.

    out_stack = ['@'] * 201
    out_count = 0
    mult_count = 0
    add_count = 0

    for char in string:
        if char.isdigit():
            # Push numbers onto a stack. They must retain order, so this works.
            # I suppose that since nothing is ever popped from this, but it's
            # read out FIFO, it's a queue.
            out_stack[out_count] = char
            out_count += 1

        elif char is '*':
            # Commutative property means that sequential multiplications will
            # create "blobs" of uninterrupted numbers up until an addition
            # would take place, so don't put the '*' in until necessary.
            mult_count += 1
        elif char is '+':
            # Because multiplication and addition are the only operators,
            # addition can be held until all local multiplications are done.
            # However, at each addition, all multiplications so far should
            # be dumped to apply them to the correct values.
            while mult_count > 0:
                out_stack[out_count] = '*'
                mult_count -= 1
                out_count += 1
            add_count += 1
    out_str = "".join(out_stack[0:out_count])
    op_str = '*'*mult_count+'+'*add_count

    output = out_str + op_str
    return output

Spoiler: My Code, Uncommented (click to show/hide)

def answer(string):

    out_stack = ['@'] * 201
    out_count = 0
    mult_count = 0
    add_count = 0

    for char in string:
        if char.isdigit():
            out_stack[out_count] = char
            out_count += 1

        elif char is '*':
            mult_count += 1

        elif char is '+':
            while mult_count > 0:
                out_stack[out_count] = '*'
                mult_count -= 1
                out_count += 1
            add_count += 1
    out_str = "".join(out_stack[0:out_count])
    op_str = '*'*mult_count+'+'*add_count

    output = out_str + op_str
    return output

EDIT: Had pasted a slightly older, less clean version by mistake. Should be logically identical.

[TheBiggerFish]

...Grr why did i look at this thread now I want to solve this problemmmmmmm....