domingo, 22 de febrero de 2026

Prueba 1

 import random

from enum import Enum

from dataclasses import dataclass

from typing import List, Tuple, Optional

import time


class Suit(Enum):

    HEARTS = "♥"

    DIAMONDS = "♦"

    CLUBS = "♣"

    SPADES = "♠"


class Rank(Enum):

    TWO = 2

    THREE = 3

    FOUR = 4

    FIVE = 5

    SIX = 6

    SEVEN = 7

    EIGHT = 8

    NINE = 9

    TEN = 10

    JACK = 11

    QUEEN = 12

    KING = 13

    ACE = 14


@dataclass

class Card:

    suit: Suit

    rank: Rank

    

    def __str__(self):

        rank_str = {11: 'J', 12: 'Q', 13: 'K', 14: 'A'}.get(self.rank.value, str(self.rank.value))

        return f"{rank_str}{self.suit.value}"

    

    def __repr__(self):

        return self.__str__()


class HandRank(Enum):

    HIGH_CARD = 1

    ONE_PAIR = 2

    TWO_PAIR = 3

    THREE_OF_A_KIND = 4

    STRAIGHT = 5

    FLUSH = 6

    FULL_HOUSE = 7

    FOUR_OF_A_KIND = 8

    STRAIGHT_FLUSH = 9

    ROYAL_FLUSH = 10


class Deck:

    def __init__(self):

        self.cards: List[Card] = []

        self.reset()

    

    def reset(self):

        self.cards = [Card(suit, rank) for suit in Suit for rank in Rank]

        random.shuffle(self.cards)

    

    def deal(self, num: int = 1) -> List[Card]:

        dealt = self.cards[:num]

        self.cards = self.cards[num:]

        return dealt


class HandEvaluator:

    @staticmethod

    def evaluate(cards: List[Card]) -> Tuple[HandRank, List[int]]:

        """

        Evalúa una mano de 7 cartas (2 hole + 5 community) y retorna el ranking y valores para desempate

        """

        if len(cards) < 5:

            raise ValueError("Se necesitan al menos 5 cartas")

        

        # Obtener la mejor mano de 5 cartas de las 7 disponibles

        best_rank = HandRank.HIGH_CARD

        best_kickers = [0, 0, 0, 0, 0]

        

        from itertools import combinations

        for combo in combinations(cards, 5):

            rank, kickers = HandEvaluator._evaluate_five_cards(list(combo))

            if rank.value > best_rank.value or (rank.value == best_rank.value and kickers > best_kickers):

                best_rank = rank

                best_kickers = kickers

        

        return best_rank, best_kickers

    

    @staticmethod

    def _evaluate_five_cards(cards: List[Card]) -> Tuple[HandRank, List[int]]:

        ranks = sorted([c.rank.value for c in cards], reverse=True)

        suits = [c.suit for c in cards]

        

        is_flush = len(set(suits)) == 1

        is_straight = HandEvaluator._is_straight(ranks)

        

        # Royal Flush / Straight Flush

        if is_flush and is_straight:

            if ranks[0] == 14:  # Ace high

                return HandRank.ROYAL_FLUSH, [14]

            return HandRank.STRAIGHT_FLUSH, [ranks[0]]

        

        # Four of a Kind

        quads = HandEvaluator._find_groups(ranks, 4)

        if quads:

            kicker = max(r for r in ranks if r != quads[0])

            return HandRank.FOUR_OF_A_KIND, [quads[0], kicker]

        

        # Full House

        trips = HandEvaluator._find_groups(ranks, 3)

        pairs = HandEvaluator._find_groups(ranks, 2)

        if trips and pairs:

            return HandRank.FULL_HOUSE, [trips[0], pairs[0]]

        

        # Flush

        if is_flush:

            return HandRank.FLUSH, ranks

        

        # Straight

        if is_straight:

            return HandRank.STRAIGHT, [ranks[0]]

        

        # Three of a Kind

        if trips:

            kickers = sorted([r for r in ranks if r != trips[0]], reverse=True)[:2]

            return HandRank.THREE_OF_A_KIND, [trips[0]] + kickers

        

        # Two Pair

        if len(pairs) >= 2:

            top_pairs = sorted(pairs, reverse=True)[:2]

            kicker = max(r for r in ranks if r not in top_pairs)

            return HandRank.TWO_PAIR, top_pairs + [kicker]

        

        # One Pair

        if pairs:

            kickers = sorted([r for r in ranks if r != pairs[0]], reverse=True)[:3]

            return HandRank.ONE_PAIR, [pairs[0]] + kickers

        

        # High Card

        return HandRank.HIGH_CARD, ranks

    

    @staticmethod

    def _is_straight(ranks: List[int]) -> bool:

        unique_ranks = sorted(list(set(ranks)), reverse=True)

        if len(unique_ranks) < 5:

            return False

        

        # Straight normal

        for i in range(len(unique_ranks) - 4):

            if unique_ranks[i] - unique_ranks[i+4] == 4:

                return True

        

        # Straight con As bajo (A-2-3-4-5)

        if set([14, 2, 3, 4, 5]).issubset(set(ranks)):

            return True

        

        return False

    

    @staticmethod

    def _find_groups(ranks: List[int], count: int) -> List[int]:

        from collections import Counter

        rank_counts = Counter(ranks)

        return [rank for rank, c in rank_counts.items() if c == count]


class Player:

    def __init__(self, name: str, chips: int = 1000):

        self.name = name

        self.chips = chips

        self.hole_cards: List[Card] = []

        self.current_bet = 0

        self.folded = False

        self.all_in = False

    

    def reset(self):

        self.hole_cards = []

        self.current_bet = 0

        self.folded = False

        self.all_in = False

    

    def bet(self, amount: int) -> int:

        amount = min(amount, self.chips)

        self.chips -= amount

        self.current_bet += amount

        if self.chips == 0:

            self.all_in = True

        return amount

    

    def __str__(self):

        return f"{self.name} (${self.chips})"


class TexasHoldem:

    def __init__(self):

        self.deck = Deck()

        self.players: List[Player] = []

        self.community_cards: List[Card] = []

        self.pot = 0

        self.current_bet = 0

        self.dealer_index = 0

    

    def add_player(self, name: str, chips: int = 1000):

        self.players.append(Player(name, chips))

    

    def play_round(self):

        print("\n" + "="*50)

        print("NUEVA MANO DE TEXAS HOLD'EM")

        print("="*50)

        

        # Reset

        self.deck.reset()

        self.community_cards = []

        self.pot = 0

        self.current_bet = 0

        

        for player in self.players:

            player.reset()

        

        # Ciegas

        small_blind_idx = (self.dealer_index + 1) % len(self.players)

        big_blind_idx = (self.dealer_index + 2) % len(self.players)

        

        sb_amount = 10

        bb_amount = 20

        

        sb_player = self.players[small_blind_idx]

        bb_player = self.players[big_blind_idx]

        

        self.pot += sb_player.bet(sb_amount)

        self.pot += bb_player.bet(bb_amount)

        self.current_bet = bb_amount

        

        print(f"\nCiegas: {sb_player.name} paga {sb_amount}, {bb_player.name} paga {bb_amount}")

        

        # Repartir cartas

        for player in self.players:

            player.hole_cards = self.deck.deal(2)

        

        # Mostrar cartas del jugador humano

        human = self.players[0]

        print(f"\nTus cartas: {' '.join(str(c) for c in human.hole_cards)}")

        

        # Pre-flop

        print("\n--- PRE-FLOP ---")

        self._betting_round(big_blind_idx)

        

        if self._count_active_players() > 1:

            # Flop

            print("\n--- FLOP ---")

            self.community_cards.extend(self.deck.deal(3))

            self._show_community()

            self.current_bet = 0

            for p in self.players:

                p.current_bet = 0

            self._betting_round(self.dealer_index)

        

        if self._count_active_players() > 1:

            # Turn

            print("\n--- TURN ---")

            self.community_cards.extend(self.deck.deal(1))

            self._show_community()

            self.current_bet = 0

            for p in self.players:

                p.current_bet = 0

            self._betting_round(self.dealer_index)

        

        if self._count_active_players() > 1:

            # River

            print("\n--- RIVER ---")

            self.community_cards.extend(self.deck.deal(1))

            self._show_community()

            self.current_bet = 0

            for p in self.players:

                p.current_bet = 0

            self._betting_round(self.dealer_index)

        

        # Showdown

        self._showdown()

        

        # Rotar dealer

        self.dealer_index = (self.dealer_index + 1) % len(self.players)

    

    def _show_community(self):

        print(f"Cartas comunitarias: {' '.join(str(c) for c in self.community_cards)}")

    

    def _betting_round(self, start_index: int):

        active_players = [p for p in self.players if not p.folded and not p.all_in]

        if len(active_players) <= 1:

            return

        

        current_idx = (start_index + 1) % len(self.players)

        last_raiser = None

        

        while True:

            player = self.players[current_idx]

            

            if not player.folded and not player.all_in and player.chips > 0:

                if player.name == "Jugador":

                    action = self._get_player_action(player)

                else:

                    action = self._get_ai_action(player)

                

                if action == "fold":

                    player.folded = True

                    print(f"{player.name} se retira")

                elif action == "call":

                    call_amount = self.current_bet - player.current_bet

                    actual_call = player.bet(call_amount)

                    self.pot += actual_call

                    print(f"{player.name} iguala (${actual_call})")

                elif action.startswith("raise"):

                    raise_amount = int(action.split()[1])

                    total_bet = self.current_bet + raise_amount - player.current_bet

                    actual_raise = player.bet(total_bet)

                    self.pot += actual_raise

                    self.current_bet += raise_amount

                    last_raiser = current_idx

                    print(f"{player.name} sube a ${self.current_bet}")

                elif action == "check":

                    print(f"{player.name} pasa")

            

            # Verificar si la ronda de apuestas termina

            next_idx = (current_idx + 1) % len(self.players)

            

            # Condiciones de fin: todos han igualado o se retiraron

            all_matched = all(

                p.folded or p.all_in or p.current_bet == self.current_bet or p.chips == 0

                for p in self.players

            )

            

            if all_matched and (last_raiser is None or next_idx == (last_raiser + 1) % len(self.players)):

                break

            

            current_idx = next_idx

            

            # Evitar bucle infinito si solo queda un jugador activo

            if self._count_active_players() <= 1:

                break

    

    def _get_player_action(self, player: Player) -> str:

        to_call = self.current_bet - player.current_bet

        

        while True:

            print(f"\nTu turno. Fichas: ${player.chips}")

            print(f"Apuesta actual: ${self.current_bet}, Bote: ${self.pot}")

            

            if to_call > 0:

                print(f"Necesitas ${to_call} para igualar")

                action = input("¿Qué haces? (fold/call/raise [cantidad]): ").lower().strip()

            else:

                action = input("¿Qué haces? (fold/check/raise [cantidad]): ").lower().strip()

            

            if action == "fold":

                return "fold"

            elif action == "call" and to_call > 0:

                if player.chips >= to_call:

                    return "call"

                else:

                    print("No tienes suficientes fichas")

            elif action == "check" and to_call == 0:

                return "check"

            elif action.startswith("raise"):

                try:

                    parts = action.split()

                    if len(parts) == 2:

                        amount = int(parts[1])

                        if amount >= 20 and player.chips >= to_call + amount:

                            return f"raise {amount}"

                        else:

                            print("Subida inválida (mínimo 20 o fichas insuficientes)")

                    else:

                        print("Formato: raise [cantidad]")

                except ValueError:

                    print("Cantidad inválida")

            else:

                print("Acción no válida")

    

    def _get_ai_action(self, player: Player) -> str:

        to_call = self.current_bet - player.current_bet

        

        # IA simple basada en fuerza de mano pre-flop o aleatorio post-flop

        if len(self.community_cards) == 0:

            # Evaluar mano inicial simple

            ranks = [c.rank.value for c in player.hole_cards]

            suited = player.hole_cards[0].suit == player.hole_cards[1].suit

            pair = ranks[0] == ranks[1]

            

            strength = max(ranks) + (10 if pair else 0) + (5 if suited else 0)

        else:

            # Evaluar mano completa

            all_cards = player.hole_cards + self.community_cards

            hand_rank, _ = HandEvaluator.evaluate(all_cards)

            strength = hand_rank.value * 10

        

        time.sleep(1)  # Simular pensamiento

        

        if to_call == 0:

            if strength > 25:

                return "raise 40"

            return "check"

        else:

            if strength < 15 and to_call > 20:

                return "fold"

            elif strength > 30 and player.chips > to_call + 40:

                return "raise 40"

            elif player.chips >= to_call:

                return "call"

            else:

                return "fold"

    

    def _count_active_players(self) -> int:

        return sum(1 for p in self.players if not p.folded)

    

    def _showdown(self):

        print("\n" + "="*50)

        print("SHOWDOWN")

        print("="*50)

        

        active_players = [p for p in self.players if not p.folded]

        

        if len(active_players) == 1:

            winner = active_players[0]

            winner.chips += self.pot

            print(f"{winner.name} gana ${self.pot} (todos los demás se retiraron)")

            return

        

        # Evaluar manos

        best_hand = None

        best_rank = None

        best_kickers = None

        winners = []

        

        for player in active_players:

            all_cards = player.hole_cards + self.community_cards

            rank, kickers = HandEvaluator.evaluate(all_cards)

            

            print(f"\n{player.name}: {' '.join(str(c) for c in player.hole_cards)}")

            print(f"  Mejor mano: {rank.name}")

            

            if best_rank is None or rank.value > best_rank.value or (rank.value == best_rank.value and kickers > best_kickers):

                best_rank = rank

                best_kickers = kickers

                winners = [player]

            elif rank.value == best_rank.value and kickers == best_kickers:

                winners.append(player)

        

        # Repartir bote

        win_amount = self.pot // len(winners)

        remainder = self.pot % len(winners)

        

        for i, winner in enumerate(winners):

            amount = win_amount + (1 if i < remainder else 0)

            winner.chips += amount

            print(f"\n>>> {winner.name} gana ${amount} con {best_rank.name} <<<")

        

        # Mostrar estado final

        print("\nEstado de jugadores:")

        for p in self.players:

            print(f"  {p.name}: ${p.chips}")


def main():

    print("¡Bienvenido al Poker Texas Hold'em!")

    print("Comandos: fold (retirarse), call (igualar), check (pasar), raise [cantidad] (subir)")

    

    game = TexasHoldem()

    game.add_player("Jugador", 1000)

    game.add_player("CPU 1", 1000)

    game.add_player("CPU 2", 1000)

    

    while True:

        # Verificar si el jugador humano sigue en juego

        human = game.players[0]

        if human.chips <= 0:

            print("\n¡Te has quedado sin fichas! Game Over.")

            break

        

        # Verificar si hay suficientes jugadores con fichas

        active_count = sum(1 for p in game.players if p.chips > 0)

        if active_count < 2:

            print("\nNo hay suficientes jugadores para continuar.")

            break

        

        game.play_round()

        

        print("\n" + "-"*50)

        cont = input("¿Jugar otra mano? (s/n): ").lower().strip()

        if cont != 's':

            break

    

    print("\n¡Gracias por jugar!")

    print("Resultados finales:")

    for p in game.players:

        print(f"  {p.name}: ${p.chips}")


if __name__ == "__main__":

    main()


viernes, 25 de julio de 2014

EXTANT

La serie es un thriller furista que mostrarán las vivencias de Molly Wattsdesde el momento de su partida a la galaxia estarán relacionadas con una serie de sucesos que tendrán consecuencias con el cambio de dirección de la historia de la humanidad. Ya tienes disponible el episodio 1 de la serie Extant, disfruta en su idioma original, subtitulado en español, te invitamos que compartas con tus amigos

lista de capitulos

extant capitulo 1x01
extant capitulo 1x02
extant capitulo 1x03

si algun enlace ya no se ve el video haganmelo saber publicando un comentario
yo no subo los videos solo proporciono enlaces a otras paginas para que puedan disfrutar de las series


ROOTEAR XPERIA P

facil y rapido de rootear simplemente
decomprime el archivo zip que les dejare abajo
le das click a runme
luego conectas tu xperia p en modo flash al ordenador y listo
facil y rapido

root xperia p zip


viernes, 18 de julio de 2014

The Strain

The strain, aqui doy inicio a este post acerca de esta nueva serie, que se estreno el domingo 13 de julio,  del 2014 la primera temporada de la espectacular serie ‘The Strain‘ La serie se basa en la trilogía de las novelas de terror de vampiros de mismo nombre, de Guillermo del Toro y Chuck Hogan y que son ahora los responsables de la serie junto a Carlton Cuse.

La trama comienza cuando un avión Boeing 777 llega al aeropuerto internacional neoyorquino JFK, procedente de Berlin y, tras tomar tierra, para en seco en mitad de la pista de aterrizaje. No hay luces y los canales decomunicación no funcionan, es como si no hubiese vida dentro del avión. Al principio todo parece que es a causa de un virus mortal, pero pronto se descubre que es por algo mucho más aterrador.
Todos los pasajeros afectados están sedientos y lo único que quieren consumir es sangre. El contagio avanza de forma vertiginosa y en pocos días todo Manhattan está infectado. Los antiguos vampiros han vuelto con un amenazador propósito, quieren hacerse con el control del mundo.

La serie se centra en el Dr. Ephraim Goodweather (Corey Stoll), que trabaja para el CDC (centro de control de enfermedades) que investiga el misterioso ataque viral y que se relaciona con una cepa antigua del vampirismo. A medida que la enfermedad se desarrolle, Eph, su equipo y compañeros en Nueva York deberán librar una lucha para combatir el destino de la humanidad. 

lista de capitulos