Scrivi un programma che emetta il numero totale di caratteri e la frequenza di ciascun carattere nella sua sorgente e nel suo output. È necessario seguire il formato illustrato nell'esempio.
Esempio
Se il tuo codice era
abb1
Il suo output dovrebbe essere
My source has 4 characters.
1 is "a"
2 are "b"
1 is "1"
Besides unquoted numbers, my output has 383 characters.
34 are "
"
79 are " "
63 are """
2 are "'"
2 are ","
4 are "."
2 are "1"
2 are "B"
2 are "I"
2 are "M"
39 are "a"
4 are "b"
6 are "c"
4 are "d"
38 are "e"
3 are "g"
5 are "h"
4 are "i"
4 are "m"
3 are "n"
8 are "o"
3 are "p"
2 are "q"
38 are "r"
12 are "s"
8 are "t"
7 are "u"
3 are "y"
It's good to be a program.
(L'output deve andare su stdout.)
Si noti, ad esempio, che l'output contiene due m maiuscole. Uno per Mye uno per 2 are "M". Questo deve valere per tutti i caratteri, quindi l'output non si contraddice in alcun modo.
I numeri non quotati vengono ignorati nell'output per evitare insiemi di frequenze insoddisfacenti. Ad esempio, 1 is "1"non è corretto se vengono contati entrambi gli 1. Dovrebbe leggere 2 are "1", ma poi ce n'è di nuovo solo uno.
Chiarimenti sul formato
"is" deve essere utilizzato per le occorrenze di singoli caratteri.
"are" deve essere utilizzato per più ricorrenze di caratteri.
"is" non dovrebbe mai apparire nell'elenco dei caratteri di output perché sarebbe superfluo.
1 is 'Z'si riferisce alla Z in sé, quindi l'intera riga può essere rimossa.Le tre frasi a frase intera devono apparire in ordine con le liste di frequenza dei caratteri tra (come mostra l'esempio). Quindi il tuo output inizierà con
My source...e finirà con...be a program.. Si noti che non esiste una nuova riga alla fine dell'output.Gli elenchi di frequenza dei caratteri stessi possono essere in qualsiasi ordine.
Le newline contano come un carattere (nel caso siano \ r \ n).
Controllo formato
Il seguente script Python prende il tuo codice e il suo output come stringhe e afferma che l'output non ha contraddizioni. Fornisce un utile messaggio di errore se qualcosa non va. È possibile eseguirlo online all'indirizzo http://ideone.com/6H0ldu eseguendo il fork, sostituendo le stringhe CODE e OUTPUT, quindi eseguendolo. Non darà mai falsi positivi o negativi (supponendo che sia privo di errori).
#Change the CODE and OUTPUT strings to test your program
CODE = r'''abb1'''
OUTPUT = r'''My source has 4 characters.
1 is "a"
2 are "b"
1 is "1"
Besides unquoted numbers, my output has 383 characters.
34 are "
"
79 are " "
63 are """
2 are "'"
2 are ","
4 are "."
2 are "1"
2 are "B"
2 are "I"
2 are "M"
39 are "a"
4 are "b"
6 are "c"
4 are "d"
38 are "e"
3 are "g"
5 are "h"
4 are "i"
4 are "m"
3 are "n"
8 are "o"
3 are "p"
2 are "q"
38 are "r"
12 are "s"
8 are "t"
7 are "u"
3 are "y"
It's good to be a program.'''
#######################################################
import re
amountPattern = r'(\d+) (is|are) "(.)"\n'
class IntrospectionException(Exception):
pass
def getClaimedAmounts(string, errorOnIs):
groups = re.findall(amountPattern, string, re.DOTALL)
for amount, verb, char in groups:
if verb == 'is':
if errorOnIs:
raise IntrospectionException('\'1 is "%s"\' is unnecessary' % char)
elif amount != '1':
raise IntrospectionException('At "%s", %s must use "are"' % (char, amount))
elif verb == 'are' and amount == '1':
raise IntrospectionException('At "%s", 1 must use "is"' % char)
amounts = {}
for amount, verb, char in groups:
if char in amounts:
raise IntrospectionException('Duplicate "%s" found' % char)
amounts[char] = int(amount)
return amounts
def getActualAmounts(string):
amounts = {}
for char in string:
if char in amounts:
amounts[char] += 1
else:
amounts[char] = 1
return amounts
def compareAmounts(claimed, actual):
for char in actual:
if char not in claimed:
raise IntrospectionException('The amounts list is missing "%s"' % char)
for char in actual: #loop separately so missing character errors are all found first
if claimed[char] != actual[char]:
raise IntrospectionException('The amount of "%s" characters is %d, not %d' % (char, actual[char], claimed[char]))
if claimed != actual:
raise IntrospectionException('The amounts are somehow incorrect')
def isCorrect(code, output):
p1 = r'^My source has (\d+) characters\.\n'
p2 = r'Besides unquoted numbers, my output has (\d+) characters\.\n'
p3 = r"It's good to be a program\.$"
p4 = '%s(%s)*%s(%s)*%s' % (p1, amountPattern, p2, amountPattern, p3)
for p in [p1, p2, p3, p4]:
if re.search(p, output, re.DOTALL) == None:
raise IntrospectionException('Did not match the regex "%s"' % p)
claimedCodeSize = int(re.search(p1, output).groups()[0])
actualCodeSize = len(code)
if claimedCodeSize != actualCodeSize:
raise IntrospectionException('The code length is %d, not %d' % (actualCodeSize, claimedCodeSize))
filteredOutput = re.sub(r'([^"])\d+([^"])', r'\1\2', output)
claimedOutputSize = int(re.search(p2, output).groups()[0])
actualOutputSize = len(filteredOutput)
if claimedOutputSize != actualOutputSize:
raise IntrospectionException('The output length (excluding unquoted numbers) is %d, not %d' % (actualOutputSize, claimedOutputSize))
splitIndex = re.search(p2, output).start()
claimedCodeAmounts = getClaimedAmounts(output[:splitIndex], False)
actualCodeAmounts = getActualAmounts(code)
compareAmounts(claimedCodeAmounts, actualCodeAmounts)
claimedOutputAmounts = getClaimedAmounts(output[splitIndex:], True)
actualOutputAmounts = getActualAmounts(filteredOutput)
compareAmounts(claimedOutputAmounts, actualOutputAmounts)
def checkCorrectness():
try:
isCorrect(CODE, OUTPUT)
print 'Everything is correct!'
except IntrospectionException as e:
print 'Failed: %s.' % e
checkCorrectness()
punteggio
Questo è code-golf. Vince l'invio con il minor numero di personaggi. Gli invii devono superare il controllo del formato per essere validi. Si applicano scappatoie standard, sebbene sia possibile leggere il proprio codice sorgente e / o codificare il proprio output .
r'''CODE''').