TR Forums

#include <stdio.h>
int main(int a, int b, int range) {
printf("%i",0.5*a*((range-1)/a)*(((range-1)/a)+1)+0.5*b*((range-1)/b)*(((range-1)/b)+1)-0.5*a*b*((range-1)/(a*b))*(((range-1)/(a*b))+1)); 
return 0;
}

#!/usr/bin/python2

# Randomly draw cards from a deck for two players and print out 
# the randomly drawn hands. Implemented in a Pythonesque manner

import random, copy

# Global Defines:
CARDFACES = ("Ace", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King")
CARDSUITS = ("Hearts", "Diamonds", "Clubs", "Spades")

# Our main card deck that can deal randomized cards.
# Note: It might make sense to make the individual card hands be subclasses of the deck object, or
# make an abstract parent class for both CardDeck and PlayerHand to reduce code duplication.
class CardDeck:

   # Setup our card deck 
   def __init__ (self, cardSuitsParam = CARDSUITS, cardFacesParam = CARDFACES, startShuffled = True):
     
     self.cardSuits = copy.copy (CARDSUITS) # internal copy of all the card suites
     self.cardFaces = copy.copy (cardFacesParam) # internal copy of all the card faces, used for printouts.

     # Generate our card deck as a list of tuples. Each list entry includes a tuple (Suit, Face) 
     # that identifies a card (e.g. [("Hearts", "Three"), ("Clubs", "Two"), ("Spades", "Queen") . . . ])
     self.cardList = []
     for nextSuit in self.cardSuits:
       for nextFace in self.cardFaces:
         self.cardList.append ((nextSuit, nextFace)) 

     # Now shuffle the deck if the startShuffled parameter is true (see shuffle method below):
     if startShuffled: 
       self.shuffle ()
 
   # This shuffles the deck using a randomized card swap process.
   # Note: A full deck or a non-full deck can be reshuffled.
   def shuffle (self):
     
     random.shuffle (self.cardList)  # easy... just use random.shuffle!
          
   # prints out contents of deck. Optionally adjust suit & face order of output using the suitOrder & 
   # faceOrder parameters.
   def showCards (self, suitOrder = CARDSUITS, faceOrder = CARDFACES):
      cardSet = set (self.cardList) # sets have more efficient search functions
      for nextSuit in suitOrder:
        for nextCardFace in faceOrder:
          # only print if a card is actually present in the deck:
          if (nextSuit, nextCardFace) in cardSet:
            print "%s of %s in deck." % (nextCardFace, nextSuit) 


   # Deals a number of cards (default to 5) at random that are removed from the deck.
   # Returns: A list of (suit, face) tuples (e.g. [("Hearts, "Two"), ("Clubs", "Eight") . . . ]):.
   def dealCards (self, numCards = 5):
     
     # sanity check: If numCards is greater than the total number of cards left in the whole deck, fire an exception.
     if (numCards < 1) or (numCards > len (self.cardList)):
       raise ValueError ("Insufficient cards remaining in deck or invalid draw request!")

     # Now pull the cards. We pop numCard cards from self.cardList and place the popped entries in outputCardList
     outputCardList = [self.cardList.pop () for II in xrange (0, numCards)] 
     
     return (outputCardList) 
 
   # Dummy function right now, but this adds cards back into the deck:
   def addCards (self, cardList):
     return (None)

# A hand given to a player:
class PlayerHand:

   def __init__ (self, initialCards = [], cardSuitsParam = CARDSUITS, cardFacesParam = CARDFACES):
     # setup a hand including an optional set of initialCards. Similar to the deck initialization, but we start out
     # with no cards present in the hand.
     # Each card in initialCards is added as a tuple of (suit, face) (e.g. ("Spades", "Ace"))
     
     self.cardSuits = copy.copy (CARDSUITS) # internal copy of all the card suites
     self.cardFaces = copy.copy (cardFacesParam) # internal copy of all the card faces, used for printouts.
     self.cardList = []
    
     if len (initialCards) > 0:
       self.addCards (initialCards)
     
   
   # Almost the same as showCards in CardDeck class (could be refactored for common code??)
   def showCards (self, suitOrder = CARDSUITS, faceOrder = CARDFACES):
      cardSet = set (self.cardList)
      
      for nextSuit in suitOrder:
        for nextCardFace in faceOrder:
          # only print if a card is actually present in the hand:
          if (nextSuit, nextCardFace) in cardSet:
            print "%s of %s in hand." % (nextCardFace, nextSuit) 
  

   # This function receives a list of cards cardList as (Suit, Face) tuples (e.g. ("Hearts", "Jack") and adds them
   # to the hand.
   def addCards (self, addedCards):
   
       # error checking:
       for nextSuit, nextFace in addedCards: 
         if (nextSuit not in self.cardSuits) or (nextFace not in self.cardFaces):
           raise ValueError ("Invalid card suit or face name %s, %s" % (nextSuit, nextFace))

       self.cardList.extend (addedCards)
        
    
   # Dummy function right now, but this discards cards from the hand:
   def discardCards (self, discardedCards):
     return (None)

if __name__ == "__main__":
  
  # start by generating our deck and hands
  pokerDeck = CardDeck ()
  myHand = PlayerHand ()
  computerHand = PlayerHand ()

  # Show deck prior to dealing
  print "Cards in Original Deck: "
  pokerDeck.showCards ()

  # Now deal out two hands. Note: To be even more realistic, deal out 1 card at a time to each player in a loop.
  myHand.addCards (pokerDeck.dealCards ())
  computerHand.addCards (pokerDeck.dealCards ())

  # print out our player & computer hands, then print out the deck again:
  print "\nPlayer's Hand:"
  myHand.showCards ()

  print "\nComputer's Hand:"
  computerHand.showCards ()
  
  print "\nRemaining Cards in Deck:"
  pokerDeck.showCards ()

long int summit(int n) {
  long int sum=0;
  do {
    if((n % 3)==0 || (n %5 )==0) {
      sum+=n;
    }
  } while(n--);
  return sum;
}

  ;n is passed in EAX
  push EBX  ;save EBX and ECX as they will hold the sum while we run
  push ECX
  xor EBX,EBX  ;zero out ECX:EBX
  xor ECX,ECX
loop:
  xor EDX,EDX  ;zero the high bits for the division
  push EAX       ;save out current count
  mov ESI, 3   ;divide by three 
  div ESI
  pop EAX    ;restore our count.  We don't care about the quotient
  test EDX   ;if the remainder is zero, then we add to our running sum
  jnz div5   ;otherwise we skip to check for divide by 5
  add EBX, EAX  ;add the low chunk first
  adc ECX, 0      ;and propagate the carry into the high chunk
  jmp decr_n
div5:          ;same logic as the divide by 3
  xor EDX, EDX
  push EAX
  mov ESI, 5
  div ESI
  pop EAX
  test EDX
  jnz decr_n
  add EBX, EAX
  adc ECX, 0
decr_n:     ;decrement our count and loop until we hit 0
  dec EAX
  jnz loop
  mov EDX, ECX   ;we are going to return our count in EDX:EAX
  mov EAX, EBX
  pop ECX  ;restore the values of the temp registers prior to function return
  pop EBX
  ret  ;sum is returned in EDX:EAX

if (condition1) {
  <stuff>
  label1:
  <stuff>
  if (condition2) goto label2;
  <stuff>
} else {
  <stuff>
  if (condition3) goto label1;
  <stuff>
  label2:
  <stuff>
}