■ En Jamaïque, le but est de créer la somme des dés noirs en appliquant quatre règles (addition, soustraction, multiplication et division) en utilisant une fois chaque nombre de dés blancs.

■ Les nombres sur les dés blancs peuvent être calculés dans n'importe quel ordre.

Exemple)Dés blancs: 2, 2, 3, 3,4 dés noirs: 40,Dans le cas de 5

　　[1]Dés blancs une fois → 2*2*3*4 - 3 = 48 - 3 = 45
　　[2]Somme des dés noirs → 40+ 5 = 45

Puisqu'il peut être calculé comme, cet ensemble de quatre règles est une solution.

Task.004 "Préparation de quatre fonctions arithmétiques de règles basées sur les règles de la Jamaïque"

■ Les résultats de calcul qui ne peuvent pas être soustraits ou divisés ne doivent pas continuer après cela. Exemple) Dés blancs: 2, 2, 4, 5, 6 Dés noirs: 40, 5 Soustraction: 2-6 = -4 Division: 6/4 = 3/2 Ne peut pas être utilisé dans les calculs intermédiaires. ** * Il existe une règle qui autorise les minutes contractuelles. ** **

■ À partir de ce qui précède, créez la fonction d'opération à quatre règles suivante.

Une fonction qui calcule la somme de deux nombres:　add()
Une fonction qui calcule la différence entre deux nombres:　substract()* Le résultat de la soustraction du plus grand du plus petit est nan.
Une fonction qui calcule le produit de deux nombres:　multiply()
Une fonction qui calcule le quotient de deux nombres:　divide()* Si le résultat n'est pas un entier, vous avez besoin d'une option pour décider de l'accepter ou non.

** ＿＿＿＿＿ [Article de référence] ＿＿＿＿＿ ** [^ ref003] Task004 ｜ [Qu'est-ce que NAN? ] Signification et utilisation ➡︎ J'ai réalisé qu'il serait bon d'utiliser np.nan pour indiquer que la sortie n'est pas possible. (J'espère qu'il n'y aura pas de valeurs aberrantes involontaires lors de la détermination des résultats ultérieurement.)

task004_calcfunctions

def add(var1, var2):
  return var1 + var2

def substract(var1, var2):
  if var1 >= var2: #Si le premier argument est supérieur ou égal au deuxième argument, effectuez une soustraction
    return var1 - var2
  else: #Si le premier argument est plus petit que le deuxième argument, sortez nan pour que le calcul ne continue pas.
    return np.nan

def multiply(var1, var2):
  return var1 * var2

def divide(var1, var2, fracOption): #Le troisième argument, fracOption, est une option qui autorise les fractions irréductibles uniquement lorsque True.
  if var2 == 0: #En divisant par 0, sortez nan pour que le calcul ne se poursuive plus.
    return np.nan
  elif isinstance(var1, int) and isinstance(var1, int): #Lorsque les deux nombres sont des entiers
    if not fracOption == True: #Si vous n'autorisez pas les fractions
      if var1 >= var2 and var1 % var2 ==0: #De plus, si le premier nombre est le deuxième ou plus et est divisible, le quotient est affiché.
        return var1 // var2
      else: #Si le premier nombre est inférieur au second ou n'est pas divisible, sortez nan pour que le calcul ne se poursuive plus.
        return np.nan
    else: #Si vous souhaitez autoriser les fractions, effectuez simplement la division
      return var1 / var2
  else: #2 Lorsque l'un des nombres n'est pas un entier
    if not fracOption ==True: #Si vous n'autorisez pas les fractions, indiquez nan pour que le calcul ne se poursuive plus
      return np.nan
    else: #Si vous souhaitez autoriser les fractions, effectuez simplement la division
      return var1 / var2

task004_calcdisplay

### function trial START ###

#Faut-il sortir le résultat du calcul de soustrait avec nan?
print('___Vérifier la soustraction___')
for num in range(8):
  print('6-',num,' = ',substract(6,num))

#Le résultat du calcul de la division est fracOption=Vérifier avec True
print('___Vérifier la division 1: fracOption=True & varA is int___')
for num in range(8):
  print('6/',num,' = ',divide(6,num,fracOption=True))
#Le résultat du calcul de la division est fracOption=Vérifier avec faux
print('___Vérifier la division 2: fracOption=False & varA is int___')
for num in range(8):
  print('6/',num,' = ',divide(6,num,fracOption=False))
#Le résultat du calcul de la division est fracOption=True &Vérifiez le nombre à diviser avec le flotteur
print('___Vérifier la division 3: fracOption=True & varA is float___')
for num in range(8):
  print('6.5/',num,' = ',divide(6.5,num,fracOption=True))
#Le résultat du calcul de la division est fracOption=False &Vérifiez le nombre à diviser avec le flotteur
print('___Vérifier la division 4: fracOption=False & varA is float___')
for num in range(8):
  print('6.5/',num,' = ',divide(6.5,num,fracOption=False))

### function trial END ###

___Vérifier la soustraction___
6- 0  =  6
6- 1  =  5
6- 2  =  4
6- 3  =  3
6- 4  =  2
6- 5  =  1
6- 6  =  0
6- 7  =  nan
___Vérifier la division 1: fracOption=True___
6/ 0  =  nan
6/ 1  =  6.0
6/ 2  =  3.0
6/ 3  =  2.0
6/ 4  =  1.5
6/ 5  =  1.2
6/ 6  =  1.0
6/ 7  =  0.8571428571428571
___Vérifier la division 2: fracOption=False___
6/ 0  =  nan
6/ 1  =  6
6/ 2  =  3
6/ 3  =  2
6/ 4  =  nan
6/ 5  =  nan
6/ 6  =  1
6/ 7  =  nan
___Vérifier la division 3: fracOption=True & varA is float___
6.5/ 0  =  nan
6.5/ 1  =  6.5
6.5/ 2  =  3.25
6.5/ 3  =  2.1666666666666665
6.5/ 4  =  1.625
6.5/ 5  =  1.3
6.5/ 6  =  1.0833333333333333
6.5/ 7  =  0.9285714285714286
___Vérifier la division 4: fracOption=False & varA is float___
6.5/ 0  =  nan
6.5/ 1  =  nan
6.5/ 2  =  nan
6.5/ 3  =  nan
6.5/ 4  =  nan
6.5/ 5  =  nan
6.5/ 6  =  nan
6.5/ 7  =  nan

Task.005 "Envisager une fonction pour rechercher une solution en Jamaïque"

■ Les idées suivantes peuvent être considérées comme une fonction qui utilise des dés blancs pour faire avancer des calculs candidats à des solutions en Jamaïque.

[étape 1]5 lancers de dés blancs, soit 5 valeurs entières(1 ou plus et 6 ou moins)Sélectionnez deux d'entre eux et organisez-les (5P2)=20 combinaisons) et 4 règles (4 types d'addition, de soustraction, de multiplication et de division) sont exécutées.
[Étape 2]ce qui précède[1]1 nombre généré dans et les 3 valeurs entières restantes(1 ou plus et 6 ou moins)Sélectionnez-en deux et organisez-les(4P2=12 combinaisons), Effectue quatre règles (4 types d'addition, de soustraction, de multiplication et de division).
[Étape 3]ce qui précède[1][2]Continuez jusqu'à ce qu'un nombre soit émis dans le même flux que.

■ La fonction ci-dessus devra changer la sortie selon les conditions d'entrée suivantes.

(1)Ensemble de rouleaux d'entrée et de résultats de calcul (np.format de tableau)
(2) (1)Nombre de valeurs d'inclusion de(=Longueur du tableau)Si c'est 1, arrêtez le calcul et faites un jugement de match.
(3)Autoriser les fractions(fracOption == True or False)

■ De plus, puisqu'il est nécessaire de sortir un enregistrement dont le numéro et l'ordre des quatre opérations de règles ont été appliquées, la sortie suivante devra également être laissée.

(4)À propos des quatre règles de calcul qui ont calculé deux nombres(_varA_ _Symbole d'opération_ _varB_)Enregistrer
Exemple) 2 *Dans le cas de 5, "(2 * 5)Enregistrer

■ Compte tenu de ce qui précède, définissez d'abord la fonction suivante.

■ Sort calcDice, qui stocke les éléments calculés sous forme de nombres calculables, et calcDNames, qui est une chaîne d'entre eux.

[Fonction 1]  transForClac()
＿＿＿Input: Un tableau contenant les résultats de 7 dés jmcDice
_____ Sortie: Un tableau calcDice qui stocke la somme de 5 dés blancs et 2 dés noirs.

[Fonction 2] makeCalcName()
＿＿＿Input: Un tableau calcDice qui stocke la somme de 5 dés blancs et 2 dés noirs
_____ Sortie: Nombres convertis en chaînes de caractères(Un type qui peut être mis à jour en une chaîne de n'importe quelle longueur)Array calcDNames

task005_calcfunctions_1&2

# [Fonction 1]  transForClac()
#＿＿＿Input: Un tableau contenant les résultats de 7 dés jmcDice
#_____ Sortie: Un tableau calcDice qui stocke la somme de 5 dés blancs et 2 dés noirs.
###################################################

def transForCalc(jmcDice, printOption):
  calcDice = jmcDice.astype(np.float64) #Lors de la mise à jour ultérieure de l'élément de calcul, np.nan(format float64)Créez un calcDice redéfini avec un tableau float64 depuis le début afin qu'il puisse être écrasé par.
  calcDice[5] = calcDice[5] + calcDice[6] #Calculer la somme des valeurs des dés noirs et de l'indice=5(C'est le sixième)Mettre à jour la valeur des dés
  calcDice = np.delete(calcDice, 6) #Plus besoin, index=Supprimez la valeur des 6e (c'est-à-dire 7e) dés
  if printOption == True:
    print('Liste des éléments calculés: ', calcDice)
  return calcDice

# [Fonction 2] makeCalcName()
#＿＿＿Input: Un tableau calcDice qui stocke la somme de 5 dés blancs et 2 dés noirs
#_____ Sortie: Nombres convertis en chaînes de caractères(Un type qui peut être mis à jour en une chaîne de n'importe quelle longueur)Array calcDNames
###################################################

def makeCalcName(calcDice, printOption):
  calcDNames = np.empty(calcDice.shape[0],dtype=object) #Format d'objet np pour que des chaînes de différentes longueurs puissent être stockées.Définissez un tableau (la longueur est la même que la longueur du tableau calcDice)
  for i in range(calcDNames.shape[0]):
    calcDNames[i] = str(int(calcDice[i])) #Stockez chaque élément de calcDice dans l'ordre
  if printOption == True:
    print('Liste des tableaux caractérisés: ', calcDNames)
  return calcDNames

### fanction trial START ###
jmcDice = jmc_diceroll(printOption=True)
calcDice = transForCalc(jmcDice, printOption=True)
calcDNames = makeCalcName(calcDice, printOption=True)
### fanction trial END ###

>Résultats jamaïcains de Die Roll:[ 2  3  1  4  4 50  5]
>Liste des éléments calculés:  [ 2.  3.  1.  4.  4. 55.]
>Liste des tableaux caractérisés:  ['2' '3' '1' '4' '4' '55']

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

■ J'ai pu créer un tableau contenant uniquement des éléments calculés, calcDice et calcDNames, qui est une chaîne d'entre eux.

■ Cette fois, vous devrez sélectionner vos deux numéros préférés et pratiquer l'une des quatre règles.

■ Par conséquent, nous allons définir la fonction suivante qui exécute les quatre règles des deux nombres sélectionnés en saisissant arithOpeNo, qui spécifie les quatre règles à exécuter.

[Fonction 3] arithOperator()
_____ Entrée 1: Le premier des deux nombres que vous voulez calculer var1
_____ Entrée 2: Le deuxième des deux nombres que vous voulez calculer var2
＿＿＿Input 3: Le nombre pour spécifier laquelle des quatre opérations de règles utiliser arithOpeNo
＿＿＿ Entrée 4: option de sélection d'autoriser ou non les fractions fracOption
_____ Sortie: résultat de l'opération à quatre règles de deux nombres
 
[Fonction 4] arithMarker()
＿＿＿Input: Number pour spécifier laquelle des quatre règles utiliser arithOpeNo
_____ Sortie: Marque utilisée pour l'enregistrement de calcul du calcul de 2 nombres

task005_calcfunctions_3&4

# [Fonction 3] arithOperator()
#_____ Entrée 1: Le premier des deux nombres que vous voulez calculer var1
#_____ Entrée 2: Le deuxième des deux nombres que vous voulez calculer var2
#＿＿＿Input 3: Le nombre pour spécifier laquelle des quatre opérations de règles utiliser arithOpeNo
#＿＿＿ Entrée 4: option de sélection d'autoriser ou non les fractions fracOption
#_____ Sortie: résultat de l'opération à quatre règles de deux nombres
###################################################

def arithOperator(var1, var2, arithOpeNo, fracOption):
  if arithOpeNo == 0: #Ajouter lorsque 0 est spécifié dans arithOpeNo
    return add(var1, var2)
  elif arithOpeNo == 1: #Soustraire lorsque 1 est spécifié pour arithOpeNo
    return substract(var1, var2)
  elif arithOpeNo == 2: #Multiplier en spécifiant 2 dans arithOpeNo
    return multiply(var1, var2)
  elif arithOpeNo == 3: #Divisez en spécifiant 3 pour arithOpeNo
    return divide(var1, var2, fracOption)
  else: #arithOpeNo vaut 0,1,2,Si ce n'est pas 3, np pour que le résultat du calcul ne soit pas sorti après cela..Sortie nan
    return np.nan

# [Fonction 4] arithMarker()
#＿＿＿Input: Number pour spécifier laquelle des quatre règles utiliser arithOpeNo
#_____ Sortie: Marque utilisée pour l'enregistrement de calcul du calcul de 2 nombres
###################################################

def arithMarker(arithOpeNo):
  if arithOpeNo == 0: #Ajouter lorsque 0 est spécifié dans arithOpeNo
    return ' + '
  elif arithOpeNo == 1: #Soustraire lorsque 1 est spécifié pour arithOpeNo
    return ' - '
  elif arithOpeNo == 2: #Multiplier en spécifiant 2 dans arithOpeNo
    return ' * '
  elif arithOpeNo == 3: #Divisez en spécifiant 3 pour arithOpeNo
    return ' / '
  else: #arithOpeNo vaut 0,1,2,S'il n'est pas 3, alors il ne peut pas être calculé|???|Afficher
    return ' |???| '

### fanction trial START ###
var1 = 19
var2 = 4
print('___Résultat de quatre règles___ for ', var1, ' & ', var2)
for i in range(6):
  print(arithOperator(var1, var2, arithOpeNo=i, fracOption=True))

print('___Marque de quatre règles___')
for i in range(6):
  print(arithMarker(arithOpeNo=i))
### fanction trial END ###

___Résultat de quatre règles___ for  19  &  4
23
15
76
4.75
nan
nan
___Marque de quatre règles___
 + 
 - 
 * 
 / 
 |???| 
 |???| 

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

■ Il est maintenant possible de calculer vos 2 nombres préférés en utilisant la touche d'opération à 4 règles spécifiée comme entrée et en sortie quel type d'opérations de 4 règles ont été effectuées.

■ Ensuite, spécifiez les 2 nombres souhaités du tableau calcDice avec index et définissez la fonction renewDice () qui génère le tableau qui stocke le résultat du calcul des 2 nombres selon la clé arithOpeNo de l'opération à quatre règles favorite. Je vais.

■ En même temps que ci-dessus, une fonction qui spécifie un favori 2 nombres dans le tableau calcDNames avec index et génère un tableau qui stocke un enregistrement de la façon dont les 2 nombres ont été calculés selon la clé arithOpeNo de l'opération favorite à quatre règles. Nous définirons renewDNames ().

** ＿＿＿＿＿ [Article de référence] ＿＿＿＿＿ ** [^ ref004] Task005 ｜ Comment écrire une branche conditionnelle par instruction if en Python ➡︎ Parmi la façon d'écrire des instructions if, j'ai surtout fait référence aux sauts de ligne dans les expressions conditionnelles.

task005_calcfunctions_5&6

# [Fonction 5] renewDice()
#＿＿＿Input 1: Un tableau qui enregistre le résultat du jet de dés en tant qu'élément de calcul calcDices
#_____ Entrée 2: Le premier des deux index que vous voulez calculer ind1
#_____ Entrée 3: Le deuxième des deux index que vous voulez calculer ind2
#＿＿＿Input 4: Le nombre pour spécifier laquelle des quatre règles opérations à utiliser arithOpeNo
#_____ Entrée 5: Option pour choisir d'autoriser ou non les fractions fracOption
#_____ Sortie: un tableau qui stocke nouvellement le résultat du calcul de deux nombres
###################################################

def renewDice(calcDice, ind1, ind2, arithOpeNo, fracOption):
  newDice = np.copy(calcDice) #Obtenez une copie de calcDice sans écraser le tableau
  if newDice.shape[0] -1 > ind1 \
    and newDice.shape[0] -1 > ind2 \
    and ind1 != ind2:
    #ind1,Plage où ind2 indique des dés blancs(0 ou plus de nouvelle longueur de dés-2 ou moins)Quand ind1 et ind2 sont différents
      newDice[ind1] = arithOperator(newDice[ind1], newDice[ind2], arithOpeNo, fracOption)
      #Exécute les quatre règles spécifiées par arithOpeNo à la valeur de l'index spécifié
  else:
    for i in range(newDice.shape[0] - 1):
      newDice[i] = np.nan #Np tous les éléments de calcul.Remplacer par nan
  newDice = np.delete(newDice, ind2)
  #En commun, supprimez la valeur de ind2 et modifiez la longueur du tableau d'éléments de calcul des dés.-1
  return newDice

# [Fonction 6] renewDNames()
#＿＿＿ Entrée 1: un tableau de caractères de résultats de jet de dés calcDNames
#_____ Entrée 2: Le premier des deux index que vous voulez calculer ind1
#_____ Entrée 3: Le deuxième des deux index que vous voulez calculer ind2
#＿＿＿Input 4: Le nombre pour spécifier laquelle des quatre règles opérations à utiliser arithOpeNo
#_____ Entrée 5: Option pour choisir d'autoriser ou non les fractions fracOption
#_____ Sortie: un tableau qui enregistre le calcul de deux nombres
###################################################

def renewDNames(calcDNames, ind1, ind2, arithOpeNo, fracOption):
  newDNames = np.copy(calcDNames) #Obtenez une copie de calcDNames sans écraser le tableau
  if newDNames.shape[0] - 1 > ind1 \
    and newDNames.shape[0] -1 > ind2 \
    and ind1 != ind2:
    #ind1,Plage où ind2 indique des dés blancs(0 ou plus de nouvelle longueur de dés-2 ou moins)Quand ind1 et ind2 sont différents
      newDNames[ind1] = '(' + newDNames[ind1] + arithMarker(arithOpeNo) + newDNames[ind2] + ')'
      #Gardez une trace des quatre règles spécifiées par arithOpeNo
  else:
    for i in range(newDNames.shape[0] - 1):
      newDNames[i] = '|???|' #Un enregistrement de tous les éléments de calcul|???|Remplacer par
  newDNames = np.delete(newDNames, ind2)
  #En commun, supprimez la valeur de ind2 et modifiez la longueur du tableau d'éléments de calcul des dés.-1
  return newDNames

### fanction trial START ###
calcDice = transForCalc(jmcDice, printOption=True)
calcDNames = makeCalcName(calcDice, printOption=True)
print('\n___index=1,Liste des éléments calculés mise à jour en multipliant le 4e___\n', renewDice(calcDice, 1, 4, arithOpeNo=2, fracOption=False))
print('___index=1,Liste des tableaux caractérisés mis à jour en multipliant le 4e___\n', renewDNames(calcDNames, ind1=1, ind2=4, arithOpeNo=2, fracOption=False))
### fanction trial END ###

>Liste des éléments calculés:  [ 2.  3.  1.  4.  4. 55.]
>Liste des tableaux caractérisés:  ['2' '3' '1' '4' '4' '55']
>
> ___index=1,Liste des éléments calculés mise à jour en multipliant le 4e___
>  [ 2. 12.  1.  4. 55.]
> ___index=1,Liste des tableaux caractérisés mis à jour en multipliant le 4e___
>  ['2' '(3 * 4)' '1' '4' '55']

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

■ Vous pouvez maintenant spécifier deux index du tableau que vous souhaitez calculer, effectuer votre opération à quatre règles préférée et mettre à jour le tableau des éléments de calcul et le tableau caractérisé des enregistrements de calcul.

■ Par conséquent, nous allons enfin définir une fonction qui recherche toutes les solutions en Jamaïque.

■ Les concepts suivants sont utilisés dans la recherche de solution.

[étape 1]5 lancers de dés blancs, soit 5 valeurs entières(1 ou plus et 6 ou moins)Sélectionnez deux d'entre eux et organisez-les (5P2)=20 combinaisons) et 4 règles (4 types d'addition, de soustraction, de multiplication et de division) sont exécutées.
[Étape 2]ce qui précède[1]1 nombre généré dans et les 3 valeurs entières restantes(1 ou plus et 6 ou moins)Sélectionnez-en deux et organisez-les(4P2=12 combinaisons), Effectue quatre règles (4 types d'addition, de soustraction, de multiplication et de division).
[Étape 3]ce qui précède[1][2]Continuez jusqu'à ce qu'un nombre soit émis dans le même flux que.

■ Par conséquent, définissez la fonction suivante qui met à jour le tableau de manière "récursive" pour effectuer une recherche de solution.

[Fonction de recherche d'une solution] jmcReduce()
＿＿＿Input 1: Un tableau qui enregistre le résultat du jet de dés en tant qu'élément de calcul calcDice
＿＿＿ Entrée 2: un tableau de caractères de résultats de jet de dés calcDNames
_____ Entrée 3: Option pour choisir d'autoriser ou non les fractions fracOption
＿＿＿Output: jmcReduce avec calcDice et calcDNames mis à jour par le résultat de l'opération à deux nombres quatre règles de l'index spécifié comme arguments()
＿＿＿Répéter: Rechercher uniquement l'index correspondant aux dés blancs(Deux index i, j (i ≠ j)Scanner avec)
_____ Itération: La clé de l'opération à quatre règles utilisant deux nombres représente l'addition, la soustraction, la multiplication et la division 0, 1, 2,Rechercher tout avec 3(Scanner avec k)

** ＿＿＿＿＿ [Article de référence] ＿＿＿＿＿ ** [^ ref005] Task005 ｜ Exemple le plus simple pour comprendre les fonctions récursives ➡︎ Lors de la définition récursive de la fonction de recherche, je me suis référé à celle-ci pour mieux comprendre les propriétés de base de la fonction récursive.

task005_jmcReduce

# [Fonction de recherche d'une solution] jmcReduce()
#＿＿＿Input 1: Un tableau qui enregistre le résultat du jet de dés en tant qu'élément de calcul calcDice
#＿＿＿ Entrée 2: un tableau de caractères de résultats de jet de dés calcDNames
#_____ Entrée 3: Option pour choisir d'autoriser ou non les fractions fracOption
#＿＿＿Output: jmcReduce avec calcDice et calcDNames mis à jour par le résultat de l'opération à deux nombres quatre règles de l'index spécifié comme arguments()
#＿＿＿Répéter: Rechercher uniquement l'index correspondant aux dés blancs(Deux index i, j (i ≠ j)Scanner avec)
#_____ Itération: La clé de l'opération à quatre règles utilisant deux nombres représente l'addition, la soustraction, la multiplication et la division 0, 1, 2,Rechercher tout avec 3(Scanner avec k)
###################################################

def jmcReduce(calcDice, calcDNames, fracOption):
  newDice = np.copy(calcDice) #Dupliquer pour ne pas modifier l'entrée 1
  newDNames = np.copy(calcDNames) #Dupliquer pour ne pas modifier l'entrée 2
  for i in range(newDice.shape[0] - 1): #Le premier indice est la gamme de dés blancs(0 ou plus de longueur de tableau NewDice-2 ou moins)Traitement en boucle avec
    for j in range(newDice.shape[0] - 1): #Le deuxième indice est la gamme des dés blancs(0 ou plus de longueur de tableau NewDice-2 ou moins)Traitement en boucle avec
      if i != j: #Si ind1=i, ind2=Si j n'est pas égal
        for k in range(4): #Numéro clé de l'opération de quatre règles arithOpeNo= 0,1,2,Variable itérative k qui parcourt 3
          if arithOperator(newDice[i],newDice[j],k, fracOption) != np.nan: #Le résultat du calcul est np.Je souhaite mettre à jour le tableau uniquement s'il ne devient pas nan
            if newDice.shape[0] == 3 \
              and renewDice(newDice,i,j,k,fracOption)[0] == renewDice(newDice,i,j,k,fracOption)[1]:
              #Si la longueur du tableau est de 3, c'est-à-dire qu'il se compose des 2 éléments de calcul restants des dés blancs et de 1 somme des dés noirs.
              #Lorsque le résultat des quatre règles de l'élément de calcul correspond à la somme des dés noirs
                print(renewDNames(newDNames,i,j,k,fracOption)[0], ' = ', renewDNames(newDNames,i,j,k,fracOption)[1],' ______!!!!! This pattern is OK !!!!!______')
                #Enregistrement de calcul des éléments de calcul(Valeur du tableau de caractères)Est sortie pour montrer qu'elle correspond à la valeur des dés noirs!(Voici la liste des solutions)
                break
            elif newDice.shape[0] == 3 \
              and renewDice(newDice,i,j,k,fracOption)[0] != renewDice(newDice,i,j,k,fracOption)[1]:
              #Si la longueur du tableau est de 3, c'est-à-dire qu'il se compose des 2 éléments de calcul restants des dés blancs et de 1 somme des dés noirs.
              #Lorsque le résultat des quatre règles de l'élément de calcul ne correspond pas à la somme des dés noirs
                #print(renewDNames(calcDNames,i,j,k,fracOption),' ___This pattern is NG xxx___')
                #Enregistrement de calcul des éléments de calcul(Valeur du tableau de caractères)Est sortie pour indiquer qu'elle ne correspond pas à la valeur des dés noirs!(C'est difficile à voir, donc je commente généralement)
                break
            else: #Si la longueur du tableau est toujours supérieure à 3
              jmcReduce(renewDice(newDice,i,j,k,fracOption),renewDNames(newDNames,i,j,k,fracOption),fracOption)
              #Mettre à jour récursivement vers un tableau plus court et recommencer
          else: #Le résultat du calcul est np.Si ça devient nan, ne rien faire et mettre à jour k
            continue
      else: #Si ind1=i, ind2=Mettre à jour j sans rien faire si j est égal
        continue

### fanction trial START ###
print('\n______START______')
jmcReduce(calcDice, calcDNames, fracOption=False)
### fanction trial END ###

______START______
(((2 + (4 * 4)) * 3) + 1)  =  55  ______!!!!! This pattern is OK !!!!!______
(1 + ((2 + (4 * 4)) * 3))  =  55  ______!!!!! This pattern is OK !!!!!______
((3 * (2 + (4 * 4))) + 1)  =  55  ______!!!!! This pattern is OK !!!!!______
(1 + (3 * (2 + (4 * 4))))  =  55  ______!!!!! This pattern is OK !!!!!______
((3 * ((4 * 4) + 2)) + 1)  =  55  ______!!!!! This pattern is OK !!!!!______
(1 + (3 * ((4 * 4) + 2)))  =  55  ______!!!!! This pattern is OK !!!!!______
(1 + (((4 * 4) + 2) * 3))  =  55  ______!!!!! This pattern is OK !!!!!______
((((4 * 4) + 2) * 3) + 1)  =  55  ______!!!!! This pattern is OK !!!!!______
(((2 + (4 * 4)) * 3) + 1)  =  55  ______!!!!! This pattern is OK !!!!!______
(1 + ((2 + (4 * 4)) * 3))  =  55  ______!!!!! This pattern is OK !!!!!______
((3 * (2 + (4 * 4))) + 1)  =  55  ______!!!!! This pattern is OK !!!!!______
(1 + (3 * (2 + (4 * 4))))  =  55  ______!!!!! This pattern is OK !!!!!______
((3 * ((4 * 4) + 2)) + 1)  =  55  ______!!!!! This pattern is OK !!!!!______
(1 + (3 * ((4 * 4) + 2)))  =  55  ______!!!!! This pattern is OK !!!!!______
(1 + (((4 * 4) + 2) * 3))  =  55  ______!!!!! This pattern is OK !!!!!______
((((4 * 4) + 2) * 3) + 1)  =  55  ______!!!!! This pattern is OK !!!!!______
_______END_______

Examen au premier tour

résultat

■ Cette fois, j'ai cherché une solution tout en mettant progressivement à jour le tableau à un temps plus court avec la fonction jmcReduce () **, qui était définie de manière récursive.

■ En conséquence, ** toutes les solutions de sortie sont correctes **, et je pense qu'au moins certaines des solutions jamaïcaines qui devraient être établies peuvent être présentées.

problème

_______ [1] Plusieurs solutions sont dupliquées selon la signification de la formule _______

■ En particulier dans le cas de solutions utilisant l'addition et la multiplication, plusieurs groupes de solutions avec un ordre différent des quatre règles ont été affichés même s'ils ont la même signification mathématique. Exemple) (((2 + (4 * 4)) * 3) + 1) = 55 La solution ((((4 * 4) + 2) * 3) + 1) = 55 a la même signification mathématique.

■ Pour améliorer cela, le traitement de l'addition (fonction somme, add ()) et de la multiplication (produit, multiplication ()) doit être modifié.

_______ [2] J'ai présenté plusieurs solutions identiques _______

■ Dans cet exemple de calcul, vous pouvez voir que les deux groupes ont présenté exactement la même solution. Exemple) ((((4 * 4) + 2) * 3) + 1) = 55 La solution ((((4 * 4) + 2) * 3) + 1) = 55 a exactement la même apparence et la même signification mathématique.

■ Probablement, si le même nombre existe dans les dés blancs **, le résultat du calcul peut être dupliqué plusieurs fois en se répétant ** </ strong> Je pense que la police>.

_______ [3] Avez-vous pu trouver toutes les solutions? _______

■ En général, il existe plusieurs types de solutions jamaïcaines dans un jeu de dés.

■ Certaines solutions utilisant la soustraction et la division peuvent y être incluses.

■ En essayant ce jmc Reduce avec plusieurs types de résultats de jet de dés, je me demandais: "N'est-il pas possible de trouver une solution en utilisant la soustraction ou la division?" (Surtout la division)

■ Par conséquent, j'ai essayé jmcReduce en utilisant l'exemple du résultat du jet de dés et de la solution de la Jamaïque dans l'article de référence suivant. Exemple) Dés blancs 2 4 2 4 5 Dés noirs 20 3 En revanche, les quatre solutions suivantes peuvent être envisagées, par exemple. (C'est un modèle qui utilise uniformément l'addition, la soustraction, la multiplication et la division.) 　　　　(2 × 6) + 2 + 4 + 5 = 23 　　　　((6 + 4) × 2) + 5 - 2 = 23 　　　　4 × (6 + (2 ÷ 2)) - 5 = 23 　　　　5 × (6 ÷ 2) + (4 × 2) = 23

** ＿＿＿＿＿ [Article de référence] ＿＿＿＿＿ ** [^ ref006] Vérifiez ｜ Site d'implémentation avancé pour la recherche de solutions en Jamaïque ➡︎ Un site qui ne recherche qu'une seule solution pour la Jamaïque. (Avec possibilité d'utiliser des fractions)

Liste des éléments calculés:  [ 2.  6.  2.  4.  5. 23.]
Liste des tableaux caractérisés:  ['2' '6' '2' '4' '5' '23']

______START______
((((2 * 6) + 2) + 4) + 5)  =  23  ______!!!!! This pattern is OK !!!!!______
(5 + (((2 * 6) + 2) + 4))  =  23  ______!!!!! This pattern is OK !!!!!______
((((2 * 6) + 2) + 5) + 4)  =  23  ______!!!!! This pattern is OK !!!!!______
(4 + (((2 * 6) + 2) + 5))  =  23  ______!!!!! This pattern is OK !!!!!______
((4 + ((2 * 6) + 2)) + 5)  =  23  ______!!!!! This pattern is OK !!!!!______

===== Omis Omis Omis =====

(5 + (2 + ((2 * 6) + 4)))  =  23  ______!!!!! This pattern is OK !!!!!______
(((2 * 6) + 4) + (2 + 5))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 + 5) + ((2 * 6) + 4))  =  23  ______!!!!! This pattern is OK !!!!!______
(2 + (5 + ((2 * 6) + 4)))  =  23  ______!!!!! This pattern is OK !!!!!______
((5 + ((2 * 6) + 4)) + 2)  =  23  ______!!!!! This pattern is OK !!!!!______
(((2 * 6) + 4) + (5 + 2))  =  23  ______!!!!! This pattern is OK !!!!!______
((5 + 2) + ((2 * 6) + 4))  =  23  ______!!!!! This pattern is OK !!!!!______
((((2 * 6) + 5) + 2) + 4)  =  23  ______!!!!! This pattern is OK !!!!!______
(4 + (((2 * 6) + 5) + 2))  =  23  ______!!!!! This pattern is OK !!!!!______
((((2 * 6) + 5) + 4) + 2)  =  23  ______!!!!! This pattern is OK !!!!!______
(2 + (((2 * 6) + 5) + 4))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 + ((2 * 6) + 5)) + 4)  =  23  ______!!!!! This pattern is OK !!!!!______
(4 + (2 + ((2 * 6) + 5)))  =  23  ______!!!!! This pattern is OK !!!!!______

===== Omis Omis Omis =====

(((5 + 4) + (2 * 6)) + 2)  =  23  ______!!!!! This pattern is OK !!!!!______
((2 * 6) + ((5 + 4) + 2))  =  23  ______!!!!! This pattern is OK !!!!!______
(((5 + 4) + 2) + (2 * 6))  =  23  ______!!!!! This pattern is OK !!!!!______
((((2 + 2) * 6) - 5) + 4)  =  23  ______!!!!! This pattern is OK !!!!!______
(4 + (((2 + 2) * 6) - 5))  =  23  ______!!!!! This pattern is OK !!!!!______
(((6 * (2 + 2)) - 5) + 4)  =  23  ______!!!!! This pattern is OK !!!!!______
(4 + ((6 * (2 + 2)) - 5))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 + 2) + ((6 * 4) - 5))  =  23  ______!!!!! This pattern is OK !!!!!______
(((6 * 4) - 5) + (2 + 2))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 + 2) + ((4 * 6) - 5))  =  23  ______!!!!! This pattern is OK !!!!!______
(((4 * 6) - 5) + (2 + 2))  =  23  ______!!!!! This pattern is OK !!!!!______
((((2 * 2) * 6) - 5) + 4)  =  23  ______!!!!! This pattern is OK !!!!!______
(4 + (((2 * 2) * 6) - 5))  =  23  ______!!!!! This pattern is OK !!!!!______
(((6 * (2 * 2)) - 5) + 4)  =  23  ______!!!!! This pattern is OK !!!!!______
(4 + ((6 * (2 * 2)) - 5))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 * 2) + ((6 * 4) - 5))  =  23  ______!!!!! This pattern is OK !!!!!______
(((6 * 4) - 5) + (2 * 2))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 * 2) + ((4 * 6) - 5))  =  23  ______!!!!! This pattern is OK !!!!!______
(((4 * 6) - 5) + (2 * 2))  =  23  ______!!!!! This pattern is OK !!!!!______
((((2 + 4) * 2) + 6) + 5)  =  23  ______!!!!! This pattern is OK !!!!!______

===== Omis Omis Omis =====

((6 * 2) + (4 + (2 + 5)))  =  23  ______!!!!! This pattern is OK !!!!!______
((4 + (2 + 5)) + (6 * 2))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 * 6) + (4 + (2 + 5)))  =  23  ______!!!!! This pattern is OK !!!!!______
((4 + (2 + 5)) + (2 * 6))  =  23  ______!!!!! This pattern is OK !!!!!______
((((6 - 2) * 4) + 2) + 5)  =  23  ______!!!!! This pattern is OK !!!!!______
(5 + (((6 - 2) * 4) + 2))  =  23  ______!!!!! This pattern is OK !!!!!______
((((6 - 2) * 4) + 5) + 2)  =  23  ______!!!!! This pattern is OK !!!!!______
(2 + (((6 - 2) * 4) + 5))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 + ((6 - 2) * 4)) + 5)  =  23  ______!!!!! This pattern is OK !!!!!______
(5 + (2 + ((6 - 2) * 4)))  =  23  ______!!!!! This pattern is OK !!!!!______
(((6 - 2) * 4) + (2 + 5))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 + 5) + ((6 - 2) * 4))  =  23  ______!!!!! This pattern is OK !!!!!______
(2 + (5 + ((6 - 2) * 4)))  =  23  ______!!!!! This pattern is OK !!!!!______
((5 + ((6 - 2) * 4)) + 2)  =  23  ______!!!!! This pattern is OK !!!!!______
(((6 - 2) * 4) + (5 + 2))  =  23  ______!!!!! This pattern is OK !!!!!______
((5 + 2) + ((6 - 2) * 4))  =  23  ______!!!!! This pattern is OK !!!!!______
(((6 - 2) * 4) + (2 + 5))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 + 5) + ((6 - 2) * 4))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 + 5) + (4 * (6 - 2)))  =  23  ______!!!!! This pattern is OK !!!!!______
((4 * (6 - 2)) + (2 + 5))  =  23  ______!!!!! This pattern is OK !!!!!______
((2 + (4 * (6 - 2))) + 5)  =  23  ______!!!!! This pattern is OK !!!!!______

===== Omis Omis Omis =====

(((5 + 4) + 2) + (2 * 6))  =  23  ______!!!!! This pattern is OK !!!!!______
((6 * 2) + ((5 + 4) + 2))  =  23  ______!!!!! This pattern is OK !!!!!______
(((5 + 4) + 2) + (6 * 2))  =  23  ______!!!!! This pattern is OK !!!!!______

_______END_______

résultat de l'inspection

■ En raison des problèmes [1] et [2], le résultat de sortie est très long, j'ai donc omis la partie centrale.

■ En conséquence, la solution utilisant la soustraction ** a été produite, mais la solution utilisant la division ** </ font> ** Il n'y avait aucune sortie. ** </ font>

■ Les causes possibles sont un dysfonctionnement de fracOption ou une erreur dans la définition de arisOperator, mais lorsque le résultat de l'opération des quatre règles a été affiché dans Task.004, 6/6 a également été affiché comme 1, donc La cause exacte n'a pas été étudiée.

Défiez jusqu'à la prochaine fois

_______ [1] Dans le cas de l'addition / multiplication, pré-fusionner ceux avec le même résultat _______

■ En particulier dans le cas de solutions utilisant l'addition et la multiplication, plusieurs groupes de solutions avec un ordre différent des quatre règles ont été affichés même s'ils ont la même signification mathématique.

■ Lors de la définition de la fonction add (), de la fonction multiplication (), de la fonction arisoprerator () ou lors de la mise en boucle de la fonction jmcReduce (), pouvons-nous concevoir un moyen d'éliminer à l'avance l'ensemble de i et j avec les mêmes résultats d'addition et de multiplication? ??

■ Il peut être difficile de résoudre ce problème par la définition de fonction récursive.

■ *** Après avoir sorti le nombre de combinaisons possibles de 2 nombres et 4 règles d'opérations à l'avance et le résultat, l'ensemble des tableaux à rechercher est statique (statique). J'ai pensé qu'il serait efficace de préparer un tableau stocké et de le résoudre *** </ font>.

_______ [2] Amélioration des erreurs de division ________

■ Je ne connais pas la cause exacte, mais je n'ai pas pu afficher la solution en utilisant la division **. ** </ font>.

■ Je voudrais commencer par rechercher la cause exacte tout en passant en revue les définitions liées aux quatre règles et à l'algorithme autour de la solution.

Aperçu de la prochaine fois

Cette fois, j'ai contesté la solution de la Jamaïque en implémentant la définition de fonction de l'opération à quatre règles et la fonction de balayage récursif au tableau d'éléments de calcul.

La prochaine fois, après avoir amélioré le problème survenu cette fois, *** Définissez une fonction pour compléter, générer et traiter de manière statique des solutions candidates sans effectuer de recherche récursive </ font> *** Je veux aussi essayer de le faire. ..

Le titre est ** vol.04 "Viser à trouver une solution à la Jamaïque - Round 2-" **.

REF. Informations de base sur la Jamaïque

Q1. Qu'est-ce que l'outil d'enseignement arithmétique "Jamaica" </ font>?

A1. "Jamaica" est vendu comme un outil d'enseignement arithmétique avec le thème du "jeu des nombres" en utilisant des dés </ font>.

■ *** Il s'agit d'un produit général qui est également vendu sur des sites d'achat en ligne tels qu'Amazon et Yahoo! Shopping. *** *** ➡︎ Cliquez ici pour la page de vente Amazon (https://www.amazon.co.jp/dp/4902756161/ref=cm_sw_r_tw_dp_U_x_XrEPEbCJ5VRST). ➡︎ Veuillez vous référer à la figure ci-dessous pour l'image (citée de la page ci-dessus)

■ *** Il existe deux types de dés, blanc et noir, et 5 et 2 sont inclus, respectivement. *** *** ➡︎ Un dé blanc x 5 et un dé noir x 1 sont attachés à la partie anneau, et un dé noir x 1 est attaché à la partie centrale.

Couleur/ Color	quantité/ amount	Numéros répertoriés/ Numbers
blanc/ white	5 pièces/ 5 dice	1, 2, 3, 4, 5, 6
noir/ black	1 pièce/ 1 dice	1, 2, 3, 4, 5, 6
noir/ black	1 pièce/ 1 dice	10, 20, 30, 40, 50, 60

Q2. Qu'est-ce que comment jouer </ font> de la Jamaïque?

A2. Exécutez quatre règles </ font> en utilisant chacun des dés blancs x 5 nombres une fois pour faire la somme des dés noirs x 2 nombres.

Par exemple, si le jet de dés blanc est (1,2,3,5,5) et le jet de dés noir est (10,6), Vous pouvez ajouter tous les lancers des dés blancs pour créer l'équation 1 + 2 + 3 + 5 + 5 = 10 + 6.

■ *** Les dés blancs x 5 numéros ne peuvent être utilisés qu'une seule fois chacun. *** *** ➡︎ Par exemple, si le jet de dés blanc est (2,4,5,3,3), il peut être utilisé pour le calcul. 2 est 1 fois, 3 est 2 fois, 4 est 1 fois, 5 est 1 fois. N'en utilisez plus. (Vous ne pouvez pas utiliser 2 deux fois ou 3 trois fois.) ➡︎ Bien sûr, ** "Ne pas utiliser le nombre de fois spécifié" est également une loi **. (Dans l'exemple ci-dessus, vous ne pouvez pas utiliser 3 une seule fois.)

■ *** Quatre règles sont addition, soustraction, multiplication et division </ font>. *** *** ➡︎ ** "Addition" ** </ font> est "addition", c'est-à-dire ** "addition" **. Par exemple, calculez la somme (résultat de l'addition) telle que 2 + 3 = 5. </ font> ➡︎ ** "Réduire" ** </ font> est une "réduction", c'est-à-dire ** "soustraire" **. Par exemple, calculez la différence (résultat de la soustraction) telle que 5-2 = 3. </ font> ➡︎ ** "Multiply" ** </ font> est un "multiplicateur", c'est-à-dire ** "multiplier" **. Par exemple, calculez le produit (résultat de la multiplication) tel que 3 × 4 = 12. </ font> ➡︎ ** "Exclusion" ** </ font> est "division", c'est-à-dire ** "division" **. Par exemple, calculez le quotient (résultat de la division *) tel que 4/2 = 2. </ font>

• Il existe des règles qui n'autorisent que des opérations divisibles, c'est-à-dire des règles qui n'autorisent pas les fractions irréductibles et des règles qui autorisent des fractions irréductibles. [1] ** Dans le cas d'une règle qui n'autorise pas les fractions irréductibles ** Lorsque les dés blancs lancent (2,4,6,3,5), vous pouvez calculer 6/3 = 2, mais Le résultat 6/4 = 3/2 n'est pas disponible. [2] ** Dans le cas d'une règle qui autorise les choses qui sont des fractions contractées ** Lorsque les dés blancs lancent (2,4,6,3,5), non seulement le calcul 6/3 = 2 peut être effectué, mais aussi Le résultat 6/4 = 3/2 est également disponible.
• ** Certains jets de dés ne peuvent pas être résolus sans utiliser les fractions irréductibles. ** </ font> Exemple) Lorsque les dés blancs lancent (2,2,4,4,6) et les dés noirs (30,3) L'équation {(2- 2/4) + 4} x 6 = 30 + 3 est vraie. </ font>

■ *** Les quatre règles de fonctionnement peuvent être exécutées dans n'importe quel ordre. *** *** ➡︎ Vous pouvez d'abord ajouter les deux nombres, puis multiplier par un autre nombre. En d'autres termes, vous pouvez utiliser des parenthèses un nombre illimité de fois n'importe où. Exemple) Lorsque les dés blancs lancent (3,6,4,4,1) et les dés noirs (20,6) L'équation {(3 + 6) + (4 × 4)} + 1 = 20 + 6 est vraie. </ font>

Résumé de l'article de référence

[^ ref001]: Recollection ｜ Reproduisons l'article précédent de l'outil d'enseignement arithmétique "Jamaica" ❗️ (vol.01) [^ ref002]: Recollection ｜ Reproduisons l'article précédent de l'outil d'enseignement arithmétique "Jamaica" ❗️ (vol.02) [^ ref003]: Task004 ｜ [Qu'est-ce que NAN? ] Signification et utilisation [^ ref004]: Task005 ｜ Comment écrire une branche conditionnelle par instruction if en Python [^ ref005]: Task005 ｜ Exemple le plus simple pour comprendre les fonctions récursives [^ ref006]: Vérifiez ｜ Site d'implémentation avancé pour la recherche de solutions en Jamaïque

Recommended Posts

Reproduisons l'outil d'enseignement de l'arithmétique "Jamaïque" ❗️ vol.03 "Visant à trouver une solution pour la Jamaïque ~ Round 1 ~"

Reproduisons l'outil d'enseignement arithmétique "Jamaica" ❗️ vol.02 "Notes pour créer des fonctions en Python"

Reproduisons l'outil d'enseignement de l'arithmétique "Jamaica" ❗️ vol.01 "Notes pour l'affichage des images en Python"

Changer la liste dans l'instruction for

Création de l'outil de gestion des utilisateurs Let's Chat

Enregistrer une tâche dans cron pour la première fois