Actualmente estoy atascado en una tarea, donde pide construir una función y clasificar los trajes en un cierto orden (♢, ♣, ♡, ♠)

Mi código debería terminar devolviendo esto:

['10♢', '10♣', '10♡', '10♠', '2♢', '2♣', '2♡', '2♠', '3♢', '3♣', '3♡', '3♠', '4♢', '4♣', '4♡', '4♠', '5♢', '5♣', '5♡', '5♠', '6♢', '6♣', '6♡', '6♠', '7♢', '7♣', '7♡', '7♠', '8♢', '8♣', '8♡', '8♠', '9♢', '9♣', '9♡', '9♠', 'A♢', 'A♣', 'A♡', 'A♠', 'J♢', 'J♣', 'J♡', 'J♠', 'K♢', 'K♣', 'K♡', 'K♠', 'Q♢', 'Q♣', 'Q♡', 'Q♠']

Aquí está mi código:

def helper_function(cards):
  value = 0
  for string in cards:
    if '♢' in string:
      value = 1
    if '♣' in string:
      value = 2
    if '♡' in string:
      value = 3
    if '♠' in string:
      value = 4

def card_sorter_v1(cards):
  return sorted(cards, key = helper_function)

Sé que necesito usar comparaciones personalizadas, pero no estoy seguro de qué más poner en la función auxiliar para ordenar este mazo. No puedo codificar ningún valor porque el marco de prueba incluirá casos extremos. ¿Algún consejo o consejo?

Aquí está el resultado que estoy recibiendo actualmente:

['A♢', '2♢', '3♢', '4♢', '5♢', '6♢', '7♢', '8♢', '9♢', '10♢', 'J♢', 'Q♢', 'K♢', 'A♣', '2♣', '3♣', '4♣', '5♣', '6♣', '7♣', '8♣', '9♣', '10♣', 'J♣', 'Q♣', 'K♣', 'A♡', '2♡', '3♡', '4♡', '5♡', '6♡', '7♡', '8♡', '9♡', '10♡', 'J♡', 'Q♡', 'K♡', '15♡', 'A♠', '2♠', '3♠', '4♠', '5♠', '6♠', '7♠', '8♠', '9♠', '10♠', 'J♠', 'Q♠', 'K♠']

0
Aspire 8 oct. 2019 a las 01:16

5 respuestas

La mejor respuesta

Este es un enfoque:

cards = ['10♠', '10♡', '10♢', '10♣', '2♠', '2♡', '2♢', '2♣', '3♠', '3♡', '3♢', '3♣', '4♠', '4♡', '4♢', '4♣', '5♠', '5♡', '5♢', '5♣', '6♠', '6♡', '6♢', '6♣', '7♠', '7♡', '7♢', '7♣', '8♠', '8♡', '8♢', '8♣', '9♠', '9♡', '9♢', '9♣', 'A♠', 'A♡', 'A♢', 'A♣', 'J♠', 'J♡', 'J♢', 'J♣', 'K♠', 'K♡', 'K♢', 'K♣', 'Q♠', 'Q♡', 'Q♢', 'Q♣']

SUIT_ORDER = {
    '♢': 0,
    '♣': 1,
    '♡': 2,
    '♠': 3,
}

RANK_ORDER = {str(r):r for r in range(2,11)}
RANK_ORDER.update(
    J = 11,
    Q = 12,
    K = 13,
    A = 14,
)

def helper(card):
    suit = SUIT_ORDER.get(card[-1:], 20)
    rank = RANK_ORDER.get(card[:-1], 20)
    return (suit, rank)

cards.sort(key=helper)
print(cards)

Esto usa diccionarios como mapeos desde el símbolo del palo o el rango (como una cadena) para convertir una cadena de tarjeta en una tupla de 2 ("puntaje del traje", "puntaje de rango").

La función auxiliar devuelve esta tupla y sort usa la función auxiliar como clave de clasificación.

Resultados:

[
 '2♢', '3♢', '4♢', '5♢', '6♢', '7♢', '8♢', '9♢', '10♢', 'J♢', 'Q♢', 'K♢', 'A♢',
 '2♣', '3♣', '4♣', '5♣', '6♣', '7♣', '8♣', '9♣', '10♣', 'J♣', 'Q♣', 'K♣', 'A♣',
 '2♡', '3♡', '4♡', '5♡', '6♡', '7♡', '8♡', '9♡', '10♡', 'J♡', 'Q♡', 'K♡', 'A♡', 
 '2♠', '3♠', '4♠', '5♠', '6♠', '7♠', '8♠', '9♠', '10♠', 'J♠', 'Q♠', 'K♠', 'A♠'
]

Editar:

Cambié el valor predeterminado de las llamadas get a 20, un número más alto que cualquier tarjeta válida. No necesita hacer esto (y podría simplemente usar RANK_ORDER[card[-1:]]) pero de esta manera su programa seguirá funcionando con trajes o rangos inválidos, y el tipo los colocará al final.

(El uso de la indexación [] daría como resultado un KeyError para tarjetas no válidas y .get() con el valor predeterminado predeterminado de None daría como resultado un TypeError al ordenar .)

Editar 2:

Mi código debería terminar devolviendo esto: ['10 ♢ ', '10 ♣', '10 ♡ ', '10 ♠', '2 ♢', '2 ♣', '2 ♡', '2 ♠', ' 3 ♢ ',' 3 ♣ ',' 3 ♡ ',' 3 ♠ ',' 4 ♢ ',' 4 ♣ ',' 4 ♡ ',' 4 ♠ ',' 5 ♢ ',' 5 ♣ ',' 5 ♡ ',' 5 ♠ ',' 6 ♢ ',' 6 ♣ ',' 6 ♡ ',' 6 ♠ ',' 7 ♢ ',' 7 ♣ ',' 7 ♡ ',' 7 ♠ ',' 8 ♢ ',' 8 ♣ ',' 8 ♡ ',' 8 ♠ ',' 9 ♢ ',' 9 ♣ ',' 9 ♡ ',' 9 ♠ ',' A ♢ ',' A ♣ ',' A ♡ ',' A ♠ ',' J ♢ ',' J ♣ ',' J ♡ ',' J ♠ ',' K ♢ ',' K ♣ ',' K ♡ ',' K ♠ ',' Q ♢ ',' Q ♣ ',' Q ♡ ',' Q ♠ ']

Si eso es lo que realmente desea, su función clave puede ser mucho más simple:

def helper(card):
    suit = SUIT_ORDER.get(card[-1:], 20)
    rank = card[:-1]
    return (rank, suit)
1
jedwards 7 oct. 2019 a las 22:46

No sé por qué funciona esto, pero aquí:

List = ['10♠', '10♡', '10♢', '10♣', '2♠', '2♡', '2♢',
        '2♣', '3♠', '3♡', '3♢', '3♣', '4♠', '4♡', '4♢',
        '4♣', '5♠', '5♡', '5♢', '5♣', '6♠', '6♡', '6♢',
        '6♣', '7♠', '7♡', '7♢', '7♣', '8♠', '8♡', '8♢',
        '8♣', '9♠', '9♡', '9♢', '9♣', 'A♠', 'A♡', 'A♢',
        'A♣', 'J♠', 'J♡', 'J♢', 'J♣', 'K♠', 'K♡', 'K♢',
        'K♣', 'Q♠', 'Q♡', 'Q♢', 'Q♣']


def val(ele):

    color = ele[-1]
    value = ele.replace(color,'')

    ord_color = ['♠','♡','♣','♢']
    ord_value = ['Q','K','J','A','9','8','7','6','5','4','3','2','10']

    rank = ord_color.index(color) + (ord_value.index(value)*len(ord_color))

    return rank


List.sort(key=val,reverse=True)

print(List)
0
J.Doe 7 oct. 2019 a las 22:51

No utilicé una forma pitónica para resolverlo, simplemente convertí el rango de cada carta en un número entre 1 y 4, luego escribí un tipo de burbuja para ordenar la lista:

def convert_card_to_number(card):
  if '♢' in card:
    return card[:-1]+'1'
  if '♣' in card:
    return card[:-1]+'2'
  if '♡' in card:
    return card[:-1]+'3'
  if '♠' in card:
    return card[:-1]+'4'

cards = ['10♠', '10♡', '10♢', '10♣', '2♠', '2♡', '2♢', '2♣', '3♠', '3♡', '3♢', '3♣', '4♠', '4♡', '4♢', '4♣', '5♠', '5♡', '5♢', '5♣', '6♠', '6♡', '6♢', '6♣', '7♠', '7♡', '7♢', '7♣', '8♠', '8♡', '8♢', '8♣', '9♠', '9♡', '9♢', '9♣', 'A♠', 'A♡', 'A♢', 'A♣', 'J♠', 'J♡', 'J♢', 'J♣', 'K♠', 'K♡', 'K♢', 'K♣', 'Q♠', 'Q♡', 'Q♢', 'Q♣']

for i in range(len(cards)):
   for j in range(i+1,len(cards)):
      if convert_card_to_number(cards[i])>convert_card_to_number(cards[j]):
         temp = cards[i]
         cards[i] = cards[j]
         cards[j] = temp

print(cards)

La salida sería:

['10♢', '10♣', '10♡', '10♠', '2♢', '2♣', '2♡', '2♠', '3♢', '3♣', '3♡', '3♠', '4♢', 
'4♣', '4♡', '4♠', '5♢', '5♣', '5♡', '5♠', '6♢', '6♣', '6♡', '6♠', '7♢', '7♣', '7♡', 
'7♠', '8♢', '8♣', '8♡', '8♠', '9♢', '9♣', '9♡', '9♠', 'A♢', 'A♣', 'A♡', 'A♠', 'J♢', 
'J♣', 'J♡', 'J♠', 'K♢', 'K♣', 'K♡', 'K♠', 'Q♢', 'Q♣', 'Q♡', 'Q♠']
0
Mohsen_Fatemi 7 oct. 2019 a las 22:46

Aquí utilicé dos funciones, una para ordenar el mazo por números y otra para ordenarlo por símbolos:


cards = ['10♠', '10♡', '10♢', '10♣', '2♠', '2♡', '2♢', '2♣', '3♠', '3♡', '3♢', '3♣', '4♠', '4♡', '4♢', '4♣', '5♠', '5♡', '5♢', '5♣', '6♠', '6♡', '6♢', '6♣', '7♠', '7♡', '7♢', '7♣', '8♠', '8♡', '8♢', '8♣', '9♠', '9♡', '9♢', '9♣', 'A♠', 'A♡', 'A♢', 'A♣', 'J♠', 'J♡', 'J♢', 'J♣', 'K♠', 'K♡', 'K♢', 'K♣', 'Q♠', 'Q♡', 'Q♢', 'Q♣']


# sorts deck by number
def sort_by_number(cards):
    sort = ["10", "2", "3", "4", "5", "6", "7", "8", "9", "A", "J", "K", "Q"]
    sorted_deck = []
    for i in sort:
        for card in cards:
            if card[:-1] == i:
                sorted_deck.append(card)
    return sorted_deck


# sorts deck by symbol:
def sort_by_symbol(cards):
    cards = sort_by_number(cards)
    for i in range(0, len(cards)):
        current_num = cards[i][:-1]
        _0, _1, _2, _3 = 0, 0, 0, 0       
        for card in cards:
            if card[:-1] == current_num:
                if card[-1] == "♢":
                    _0 = card
                if card[-1] == "♣":
                    _1 = card
                if card[-1] == "♡":
                    _2 = card
                if card[-1] == "♠":
                    _3 = card
        cards[i:i+4] = [_0, _1, _2, _3]
    return cards 

0
Issac Newton 7 oct. 2019 a las 22:49

Puede usar el corte de cuerdas para romper la tarjeta y el palo:

for card in cards:
    (card[:-1], card[-1])

El primer elemento de la tupla es la carta; El segundo elemento es el traje. Recomiendo hacer funciones de ayuda para ambos. Veo que ya está haciendo eso por el traje, pero también lo necesitará para que la tarjeta maneje las tarjetas con imágenes.

Luego, consulte esta respuesta para ver cómo ordenar una lista de tuplas: ¿Cómo funciona operator.itemgetter y sort () en Python?

0
wgb22 7 oct. 2019 a las 22:33
58277822