Le 18ème comment écrire un problème de référence en temps réel hors ligne en Python

Cliquez ici pour le problème http://nabetani.sakura.ne.jp/hena/ord18mafovafo/ Cliquez ici pour les résultats d'exécution http://ideone.com/ZSJEH2 Cliquez ici pour des exemples de réponses d'autres personnes http://qiita.com/Nabetani/items/373105e7fafd12f5e9fd Cliquez ici pour l’annonce de l’événement du groupe d’étude sur la programmation de Yokohama Henachoko «18e écriture en temps réel hors ligne» http://atnd.org/events/47025 (tenue le samedi 01 février 2014)

#!/usr/bin/env python

# FOLD = { operation:(front side fold, back side fold), ... }
# '0':front side paper, '1':back side paper, 'm':mountain fold, 'V':valley fold
FOLD = {'L':('1V0','1m0'), 'J':('0V1','0m1'), 'Z':('0m1V0','1m0V1'), 'U':('1V0V1','0m1m0'), 'S':('0V1m0','1V0m1'), '':('','')}

solve = lambda operation, side=0: ''.join(solve(operation[1:], int(f)) if f in '01' else f for f in FOLD[operation[:1]][side])

def test(data, correct):
    answer = solve(data)
    print 'xo'[answer==correct], data, correct, answer

0, test( "JZ", "mVVmV" );
1, test( "J", "V" );
2, test( "L", "V" );
3, test( "Z", "mV" );
4, test( "U", "VV" );
5, test( "S", "Vm" );
6, test( "JL", "VVm" );
7, test( "JS", "VmVVm" );
8, test( "JU", "VVVmm" );
9, test( "LU", "mmVVV" );
10, test( "SL", "VVmmV" );
11, test( "SS", "VmVVmmVm" );
12, test( "SU", "VVVmmmVV" );
13, test( "SZ", "mVVmVmmV" );
14, test( "UL", "mVVVm" );
15, test( "UU", "mmVVVVmm" );
16, test( "UZ", "mVVmVVmV" );
17, test( "ZJ", "VmmVV" );
18, test( "ZS", "VmmVmVVm" );
19, test( "ZZ", "mVmmVVmV" );
20, test( "JJJ", "VVmVVmm" );
21, test( "JJZ", "mVVmVVmVmmV" );
22, test( "JSJ", "VVmmVVmVVmm" );
23, test( "JSS", "VmVVmmVmVVmVVmmVm" );
24, test( "JUS", "VmVVmVVmVVmmVmmVm" );
25, test( "JUU", "mmVVVVmmVVVmmmmVV" );
26, test( "JUZ", "mVVmVVmVVmVmmVmmV" );
27, test( "LJJ", "VmmVVVm" );
28, test( "LLS", "VmmVmVVmVVm" );
29, test( "LLU", "mmmVVVmmVVV" );
30, test( "LLZ", "mVmmVVmVVmV" );
31, test( "LSU", "mmVVVmmmVVVVmmmVV" );
32, test( "LSZ", "mVVmVmmVVmVVmVmmV" );
33, test( "LZL", "mmVVmVVmmVV" );
34, test( "LZS", "VmmVmVVmVVmmVmVVm" );
35, test( "LZU", "mmmVVVmmVVVmmmVVV" );
36, test( "SJL", "VVmVVmmmVVm" );
37, test( "SLU", "mmVVVVmmmVVmmmVVV" );
38, test( "SLZ", "mVVmVVmVmmVmmVVmV" );
39, test( "SSU", "VVVmmmVVVmmVVVmmmmVVVmmmVV" );
40, test( "SUJ", "mVVVmVVmmmVmmVVVm" );
41, test( "SUS", "VmVVmVVmVVmmVmmVmmVmVVmVVm" );
42, test( "SZZ", "mVmmVVmVVmVmmVVmVmmVmmVVmV" );
43, test( "UJJ", "VmmVVVmVVmm" );
44, test( "ULU", "mmmVVVmmVVVVmmmVV" );
45, test( "ULZ", "mVmmVVmVVmVVmVmmV" );
46, test( "UUU", "VVmmmmVVVmmVVVVmmVVVmmmmVV" );
47, test( "ZJU", "VVVmmmVVmmmVVVVmm" );
48, test( "ZLS", "VmVVmmVmmVmVVmVVm" );
49, test( "ZSJ", "VVmmVmmVVmmVVVmmV" );
50, test( "ZUJ", "mVVVmmVmmmVVmVVVm" );
51, test( "JJLJ", "mVVVmmVVmVVmmmV" );
52, test( "JLJJ", "VmmVVVmVVmmmVVm" );
53, test( "JLJL", "VmmVVVmVVmmmVVm" );
54, test( "LJJL", "VVmmVmmVVVmVVmm" );
55, test( "LLJJ", "VmmmVVmVVmmVVVm" );
56, test( "SZUS", "VmVVmVVmmVmmVmmVmVVmVVmVVmVVmmVmmVmmVmVVmVVmVVmmVmmVmmVmVVmVVmmVmmVmmVmVVmVVmVVm" );
57, test( "ULLS", "VmmVmmVmVVmVVmmVmVVmVVmVVmmVmmVmVVm" );
58, test( "JJJJZJ", "VmmVVVmmVVmVVmmVVmmmVVmVVmmVVVmmVVmmVmmVVmmmVVmVVmmVVVmmVVmVVmmVVmmmVVmmVmmVVVmmVVmmVmmVVmmmVVm" );
59, test( "JULLLJ", "mmVmmVVmmmVVmVVVmmVmmVVVmmVVmVVVmmVmmVVmmmVVmVVVmmVmmVVVmmVVmVVmmmVmmVVmmmVVmVVmmmVmmVVVmmVVmVV" );
60, test( "LJJJUL", "mVVVmVVmmmVVmVVVmmVmmmVmmVVVmVVmmmVmmVVVmmVmmmVVmVVVmVVmmmVVmVVVmmVmmmVVmVVVmVVmmmVmmVVVmmVmmmV" );
61, test( "LJSJJL", "VVmVVmmVVVmmVmmmVVmVVmmmVVmmVmmVVVmVVmmmVVmmVmmVVVmVVmmVVVmmVmmmVVmVVmmVVVmmVmmVVVmVVmmmVVmmVmm" );
62, test( "LZLLLJ", "mmVmmVVmmmVVmVVmmmVmmVVVmmVVmVVVmmVmmVVmmmVVmVVVmmVmmVVVmmVVmVVmmmVmmVVmmmVVmVVVmmVmmVVVmmVVmVV" );
63, test( "SJJJJL", "VVmVVmmVVVmmVmmVVVmVVmmmVVmmVmmVVVmVVmmVVVmmVmmmVVmVVmmmVVmmVmmmVVmVVmmVVVmmVmmVVVmVVmmmVVmmVmm" );
64, test( "ZLJLJL", "VmmVVVmmVmmmVVmVVmmVVVmVVmmmVVmmVmmVVVmmVmmmVVmmVmmVVVmVVmmmVVmVVmmVVVmmVmmmVVmVVmmVVVmVVmmmVVm" );

Commentaire

Le recto du papier est «0», le verso est «1» et le pli de la montagne est «m». Que le pli de la vallée soit «V». Le résultat du pli en L sur la face avant est (arrière, vallée, avant), donc «1V0». Le résultat du pli en L sur la face arrière est (arrière, montagne, avant), donc '1m0'. Convertissez la conversion du pliage en L au résultat du pliage en données du dictionnaire FOLD = {'L': ('1V0', '1m0')}. Le résultat du pli en L sur la face avant peut être récupéré sous la forme «1V0» avec FOLD [«L»] [0]. Le résultat du pliage en L sur la face arrière est FOLD ['L'] [1], et '1m0' peut être retiré. S'il n'y a qu'un seul pli L, la réponse est d'extraire uniquement le «V» des données de pli de «1V0». Dans le cas du pliage LL, 1 et 0 représentant la partie papier de «1V0» peuvent être remplacés par le résultat du pliage L, respectivement. Résultat du pli LL = Opération supplémentaire de pli en L pour le résultat du pli en L sur la face avant → Pliez FOLD ['L'] [0] plus loin L → Autre opération de pliage en L de '1V0' (opération de pliage en L pour 1 et 0) → FOLD['L'][1]+'V'+FOLD['L'][0] → '1m0'+'V'+'1V0' → '1m0V1V0' Ensuite, ne collectez que les caractères de pli et répondez "mVV". Si cela est transformé en programme, ce sera comme suit.

1. Extrayez le premier caractère d'opération de la chaîne de caractères d'opération
2. Convertir en caractères d'opération Recherchez le dictionnaire et convertissez-le en résultat de pliage
3. S'il y a une opération ultérieure, effectuez la deuxième opération et les suivantes de manière récursive pour 0 et 1 du résultat du pliage.
4. Enfin, le travail de suppression des 0 et des 1 sera remplacé par «» en tant qu'opération vide à la fin. Cela entraînera une erreur lorsque le caractère d'opération disparaîtra lorsque le caractère d'opération est récupéré avec l'opération [0], mais lorsqu'il n'y a pas d'opération en écrivant l'opération [: 1], il devient un caractère vide, et le résultat du pliage pour le caractère vide Si vous vous inscrivez en tant que «»: («», «») dans le dictionnaire de conversion, «0» et «1» seront remplacés par des caractères vides lorsqu'il n'y aura plus de caractères d'opération.

solve = lambda operation, side=0: ...
    #résoudre la définition de la fonction. Identique à la fonction utilisant def ci-dessous
    # def solve(operation, side=0):
    #     return ...    
operation[:1]
    #Extraire le premier caractère d'opération dans la chaîne de caractères d'opération
    #Si l'opération est une chaîne vide''devenir
FOLD[operation[:1]][side]
    #Extraire la chaîne de caractères de pliage pour le premier caractère d'opération de la chaîne de caractères d'opération
    #Si l'opération est une chaîne vide''devenir
for f in FOLD[operation[:1]][side]
    #Pour chaque caractère de la chaîne de pliage
operation[1:]
    #Chaînes de caractères de la deuxième opération et des suivantes
solve(operation[1:], int(f)) if f in '01' else f
    # '0'Ou'1'Effectuez ensuite récursivement la deuxième opération et les suivantes,'m'Ou'V'Puis ce personnage
    #Resté dans la dernière opération'0'Quand'1'Résoudre('', side)Appel''devenir
''.join(...)
    #Les chaînes de caractères pliées de parties partielles sont combinées sans espaces pour former une chaîne de caractères