PSet5 Y17C2

PSet5: Mispellings
1. Objetivos
Permitirle diseñar e implementar su propia estructura de datos.
Optimizar el tiempo (real) de ejecución de su codigo.
2. Honestidad Académica
Puede leer el código de conducta en: http://soporte.code-fu.net.ni/codigo-de-conducta-
con-el-curso/
3. Evaluación
Su trabajo en este PSet se evaluará a lo largo de cuatro ejes principalmente.
3.1. Alcance
¿En qué medida su código implementa las características requeridas por nuestra
especificación?
3.2. Exactitud
¿Hasta qué punto su código está libre de errores?
3.3. Diseño
¿En qué medida está su código bien escrito (claramente, eficientemente, elegante-
mente, y/o lógicamente)?
3.4. Estilo
¿En qué medida es su código legible (comentado, sangrado, con variables adecua-
damente nombradas)?
Copyright © 2015 – 2016, David J. Malan 1 http://code-fu.net.ni

of Harvard University. This course’s content is licensed by http://soporte.code-fu.net.ni
David J. Malan of Harvard University under a Creative Commons https://facebook.com/codefu.net.ni
Attribution-Noncommercial-Share Alike 3.0 Unported License https://facebook.com/groups/cs50xni
4. Preparándonos
Primero, acompañá a Jackson y Lauren en una vuelta por listas enlazadas sencillas y
tablas hash. ¡Mirá el video aquí!
Luego, acompaña a Kevin en una vuelta por intentos. ¡Mirá el video aquí!
Por último, recuerda cómo funciona valgrind por si lo ha olvidado o todavia no lo ha
utilizado! ¡Mirá el video aquí!
5. Empezando
Vaya a su cuenta en cs50.io y ejecute el comando
update50
en la terminal para asegurarte workspace está actualizado.
Como en el Problem Set 4, este Problem Set viene con cierto código de distribución que
necesitarás descargar antes de empezar. Ejecutá
cd ∼/workspace
para navegar en tu directorio ∼/workspace . Ahora, ejecutá
wget http://cdn.cs50.net/2015/fall/psets/5/pset5/pset5.zip
para descargar un ZIP del distro de este problem set. Si luego ejecutás
ls
deberías ver que ahora tenes un archivo llamado pset5.zip en tu directorio ∼/workspace .
Descomprimelo al ejecutar lo siguiente.

unzip pset5.zip
Si luego ejecutás
ls
deberías ver ahora tenés también un directorio pset5 . A continuación te invitamos a

borrar el archivo ZIP con el siguiente comando:
rm -f pset5.zip
Ahora, entrá en ese directorio pset5 al ejecutar lo siguiente.
cd pset5
Ahora, ejecutá
ls
y deberías ver que ese directorio contiene lo siguiente.
dictionaries/ dictionary.c dictionary.h keys/ Makefile questions.txt

speller.c texts/
¡Interesante!

De cualquier manera, teóricamente, en la entrada de tamaño n, un algoritmo con un
tiempo de ejecución de n es asintóticamente equivalente, en términos de O, a un algo-
ritmo con un tiempo de ejecución de 2n. En el mundo real, sin embargo, el hecho de la
cuestión es que este último se siente dos veces más lento que el primero.
¡El reto que tiene por delante es implementar el programa revisión de deletreo más rápido
que pueda! Por "más rápido", estamos hablando de tiempo real, notable—nada de esa
cosa asintótica esta vez.
En speller.c , hemos creado un programa que está diseñado para verificar el deletreo
de las palabras de un archivo después de cargar un diccionario de palabras del disco a
la memoria. Desafortunadamente, no implementamos la sección de carga. O la parte de
verificación. ¡Ambos (y un poco más) te lo dejamos a ti!
Antes de llevarte a través de speller.c , ve y abre dictionary.h . Se declaran en

ese archivo cuatro funciones; toma nota de lo que cada una debería hacer. Ahora abre
dictionary.c . Observe que hemos implementado esas cuatro funciones, pero justa-
mente lo suficiente para que este código compile. Su trabajo para este Problem Set es
volver a implementar esas funciones tan inteligentemente como sea posible para que este
corrector ortográfico funcione como se anuncia. ¡Y rápido!
Vamos a empezar.
5.1. Makefile
Recuerde que make automatiza la compilación de su código para que no tenga que
ejecutar clang manualmente junto con un montón de interruptores. Sin embargo, a
medida que sus programas crecen en tamaño, make no podrá inferir por contexto cómo
compilar su código; tendrá que empezar a decir cómo compilar su programa, en particular
cuando se trata de varios archivos de origen (i.e., .c ), como en el caso de este conjunto
de problemas. Así que vamos a utilizar un Makefile , una configuración que le dice a
make exactamente qué hacer. Abra Makefile , y vamos a hacer un recorrido por sus
líneas.
La línea de abajo define una variable llamada CC que especifica que make debería usar
clang para compilar.
CC = clang

La linea de abajo define una variable llamada CFLAGS , que especifica, a su vez, que
clang debería utilizar algunas banderas, la mayoría de las cuales debe parecer familiar.
CFLAGS = -ggdb3 -O0 -Qunused-arguments -std=c11 -Wall -Werror
La línea de abajo define una variable llamada EXE , cuyo valor sera el nombre de nuestro
programa.
EXE = spelller
La línea de abajo define una variable llamada HDRS , cuyo valor es una lista de archivos
de cabecera usados por speller .
HDRS = dictionary.h
La línea de abajo define una variable llamada LIBS , cuyo valor debería ser una lista de
bibliotecass separadas por espacios, las cuales deben ser prefijadas con -l . (Recuarde
que usamos -lcs50 anteriormente.) Lo más probable es que no necesite enumerar ninguna
biblioteca para este conjunto de problemas, pero hemos incluido la variable por si acaso.
LIBS =
La línea de abajo define una variable llamada SRCS , cuyo valor es una lista de archivos
C separadas por espacios que van a implementar colectivamente speller.
SRCS = speller.c dictionary.c
La linea de abajo define una variable llamada OBJS , cuyo valor es igual al de SRCS ,
except that each file’s extension is not .c but .o .

OBJS = $(SRCS:.c=.o)
Las líneas de abajo definen un "targetüsando estas variables que le dicen a make como
compilar speller.
$(EXE): $(OBJS) Makefile

$(CC) $(CFLAGS) -o $@ $(OBJS) $(LIBS)
La línea de abajo específica que nuestros archivos .o todos “dependan de” dictionary.h
y Makefile tal que cambios a cualquiera de los dos induce la recompilación del otro al
correr make .
$(OBJS): $(HDRS) Makefile
Finalmente, las líneas de abajo definen otro “target” para limpiar el directorio del Problem
Set.
clean:
rm -f core $(EXE) *.o
Sepa que puede modificar este Makefile como mejor le parezca. De hecho debe, si crea
cualquier archivo .c o .h propio. Pero asegúrese de no cambiar ninguna tabulacion
(es decir, \t ) A los espacios, ya que make espera que el primero esté presente debajo
de cada "target".
El effecto en conjunto de todas estas líneas es que usted puede compilar speller con
un solo comando, a pesar que contiene varios archivos:
make speller

Aún mejor, también puede ejecutar:
make
Y si alguna vez quiere borrar speller y cualquier core o archivos .o , tambien puede
hacerlo con un solo comando:
make clean
En general, sin embargo, cada vez que desee compilar el código para este conjunto de
problemas, debería bastar con correr:
make
5.2. speller.c
Ok, a continuación, abra speller.c y pase un tiempo mirando el código y los comenta-
rios en él. No necesitará cambiar nada en este archivo, pero debe comprenderlo. Observe
cómo, a través de getrusage , vamos a estar “benchmarking” (es decir, midiendo el
tiempo de ejecución de) sus implementaciones de check , load , size y unload . Tam-
bién observe cómo vamos a pasar a check , palabra por palabra, el contenido de algún
archivo para ser chequeado de forma ortográfica. En última instancia, informamos cada
error ortográfico en ese archivo junto con un montón de estadísticas.
Note que hemos definido el uso de speller como:
Usage: speller [dictionary] text
donde dictionary se supone que es un archivo que contiene una lista de palabras
en minúscula, una por línea, y text es un archivo para ser verificado por ortografía.
Como sugieren los corchetes, la provisión de dictionary es opcional; si se omite este

argumento, speller utilizará dictionaries/large por defecto. En otras palabras,
correr
./speller text
será equivalente a correr
./speller dictionaries/large text
donde text es el archivo al que usted le desea revisar la ortografía. Basta con decir, el
primero es más fácil de escribir! (Por supuesto, speller no podrá cargar ningún diccionario
hasta que implemente load en dictionary.c ! Hasta entonces, verás Could not load.)
Tenga en cuenta que por defecto dentro del diccionario, son 143,091 palabras, todas
las cuales deben ser cargadas en la memoria! De hecho, eche un vistazo a ese archivo
para tener una idea de su estructura y tamaño. Observe que cada palabra en ese archivo
aparece en minúsculas (incluso, por simplicidad, nombres propios y siglas). De arriba a
abajo, el archivo se clasifica lexicográficamente, con sólo una palabra por línea (cada
una termina con \ n ). Ninguna palabra tiene más de 45 caracteres, y ninguna palabra
aparece más de una vez. Durante el desarrollo, puede resultar útil proveer a speller con
un dictionary hecho por usted que contenga menos palabras, de modo que no tenga
problemas para depurar una enorme estructura en la memoria. En dictionaries/small es
uno de esos diccionarios. Para usarlo, ejecute
./speller dictionaries/small text
donde text es el archivo que desea chequear. No avance hasta que este seguro usted
entienda como speller funciona.
Lo mas probable, es que no paso suficiente tiempo revisando speller.c . Retroceda un
paso y pase por él una vez mas.
5.3. questions.txt
Bueno, técnicamente ese último problema indujo un bucle infinito. Pero asumiremos que

lo rompiste. Abra questions.txt y conteste cada una de las siguientes preguntas en una
o más oraciones.
0. ¿Qué es pneumonoultramicroscopicsilicovolcanoconiosis?
1. ¿De acuerdo con la entrada en man , qué hace getrusage ?
2. ¿Por esa misma página de man , cuántos miembros hay en una variable de tipo
struct rusage ?
3. ¿Porqué cree usted que pasamos before y after por referencia (en vez de por
valor) para calculate , a pesar de que no cambiamos sus contenidos?
4. Explicar con la mayor precisión posible, en un párrafo o más, cómo main lee
palabras de un archivo. En otras palabras, convencernos de que usted realmente
entiende cómo funciona el bucle for de esa función.
5. ¿Por qué crees que usamos fgetc para leer los caracteres de cada palabra una a
la vez en lugar de usar fscanf con una cadena de formato como " % s"para leer
palabras completas de una vez? Dicho de otra manera, ¿qué problemas pueden
surgir al dependiendo solo en fscanf ?
6. ¿Porqué cree que declaramos los parametros de check y load como const ?
5.4. texts
Para que puedas probar la implementación de speller , también te hemos proporcionado
un montón de textos, entre ellos el guión de Austin Powers: El Agente Internacional
del Misterio, un sonido de Ralph Wiggum, tres millones de bytes de Tolstoy, algunos
fragmentos de Maquiavelo y Shakespeare, la totalidad de la Biblia King James V, y más.
Para que sepas qué esperar, abre y desplaza cada uno de esos archivos, todos los cuales
están en un directorio llamado text dentro de tu directorio pset5 .
Ahora, como debes saber al leer sobre speller.c cuidadosamente, la salida de speller , si
ejecutada por ejemplo con,
./speller texts/austinpowers.txt
eventualmente se asemejara a lo de abajo. Por ahora, intenta ejecutar la solución de

nuestro equipo (usando el diccionario por defecto) con lo de abajo.
∼cs50/pset5/speller texts/austinpowers.txt

A continuación se muestran algunos de los resultados que verá. Por diversión, hemos ex-
traído algunos de nuestros errores ortográficos favoritos. Y para no estropear la diversión,
hemos omitido nuestras propias estadísticas por ahora.
MISSPELLED WORDS
[...]
Bigglesworth
[...]
Virtucon
[...]
friggin'
[...]
trippy
[...]
WORDS MISSPELLED:
WORDS IN DICTIONARY:
WORDS IN TEXT:
TIME IN load:
TIME IN check:
TIME IN size:
TIME IN unload:
TIME IN TOTAL:
TIME IN LOAD representa el número de segundos que speller tarda en ejecutar tu im-
plementación de load . TIME IN check representa el número de segundos que speller
tarda en ejecutar tu implementación de check . TIME IN size representa el número de
segundos que speller tarda en ejecutar tu implementación de size . TIME IN unload
representa el número de segundos que speller tarda en ejecutar tu implementación de
unload . TIME IN TOTAL es la suma de aquellas cuatro medidas.
Note que estos tiempos pueden variar algo entre las ejecuciones de speller ,
dependiendo en que mas el CS50 IDE está haciendo, incluso si no has cambiado
tu código.
Por cierto, para ser claros, por “misspelled”(mal deletrado, en español), simplmenete nos
referimos a que cierta palabra no está en el dictionary provided.

Y ahora, esto: https://youtu.be/RIevazPIPzU
6. Spell Checking
Bien, ahora el reto frente a vos es implementar load , check , size y unload
tan eficientemente como sea posible, de forma que TIME IN load , TIME IN check ,
TIME IN size , y TIME IN unload estén todos minimizados. Para estar seguros, no es
obvio lo que siquiera significa ser minimizado, en tanto como estas referencias ciertamen-
te van a variar mientras alimentás a speller con diferentes valores para dictionary
y para text . Pero en esto yace el reto, por no decir que la parte divertida, del problema
set. El problem set es tu oportunidad para diseñar. A pesar de que te invitamos a mini-
mizar espacio, tu enemigo definitivo es el tiempo. Pero antes de que te metás de cabeza
en esto, te daremos algunas especificaciones.
No puede alterar speller.c .
Usted puede alterar dictionary.c (y, de hecho, debe hacerlo para completar las
implementaciones de load , check , size , y unload ), pero no puede alterar
las delclaraciones de load , check , size , y unload ).
Puede alterar dictionary.h , pero no puede alterar las declaraciones de load ,

check , size , y unload ).
Usted puede alterar Makefile .
Usted puede agregar funciones a dictionary.c o a archivos de su propia creación

mientras tu código compile vía make .
Su implementación de check debe distinguir mayúsculas y minúsculas. En otras

palabras, si foo esta en el diccionario, entonces check debería retornar verdadero
dada cualquier combinación de mayúsculas y minúsculas en esto; nada de entre
foo , foO , fOo , fOO , Foo , FoO , FOo , y FOO debería ser considerado mal
deletrado.
Dejando a un lado esto de las mayúsculas y las minúsculas, tu implementación

de check solamente debería retornar true para palabras que estén de hecho
en dictionary . Tenga cuidado con palabras reservadas (por ejemplo, the ),
para que no le pasemos a tu implementación un dictionary sin esas mismas
palabras. Por otra parte, los únicos posesivos permitidos son los que está de he-
cho en dictionary . En otras palabras incluso si foo está en dictionary ,
check debería retornar false al pasar foo’s si foo’s no está también en
dictionary .

Puede asumir que en check solo se pasarán cadenas con caracteres alfabéticos
y/o apóstrofes.
Puede asumir que cualquier dictionary pasado a tu programa será estructurado

exactamente como el nuestro, ordenado lexicográficamente de arriba hacia abajo
con una palabra por línea, cada una de las cuales termina con \n Puede asumir
que dictionary contendrá al menos una palabra, que ninguna palabra será más
larga que los caracteres de LENGTH (una constante definida en dictionary.h ),
que ninguna palabra aparecerá más de una vez, y que cada palabra contendrá
únicamente caracteres alfabéticos en minúscula y posiblemente apóstrofes.
Su spell-checker puede tomar únicamente text y, opcionalmente, dictionary

como input. Aunque usted pueda inclinarse (particularmente si entre esos más
cómodos) a “pre-procesar” nuestro diccionario predefinido para derivar una “fun-
ción hash ideal” para este, usted no puede guardar el output de ninguno de tales
pre-procesamientos al disco para cargarlo de vuelta en la memoria en ejecuciones
subsecuentes de su spell-checker para ganar una ventaja.
Usted puede investigar funciones has en libros o en la Web, siempre y cuando usted
cite el origen de cualquier función hash que integre en su código
Muy bien, ¿está listo?
6.1. load
¡Implemente load !
Permítanos sugerirle que tome algunos diccionarios más pequeños que el predefinido de
143, 091 palabras con los cuales probar su código durante el desarrollo. Y aquí está
Zamyla con algo de ayuda extra:
https://www.youtube.com/watch?v=E_1D17P-bM0
6.2. check
¡Implemente check !
Permítanos sugerirle que tome algunos pegueños archivos para hacer spell-check (revisión
de deletreo) antes de intentar. Aquí está Zamyla de nuevo:
https://www.youtube.com/watch?v=r7CVY6O-XJw
6.3. size
¡Implemente size !

Si lo habías planedo, este es uno sencillo. Aquí está Zamyla vídeo
6.4. unload
¡Implemente unload !
Asegúrse de liberar toda la memoria alocada en load . Aquí está Zamyla con algunas
sugerencias finales.
https://www.youtube.com/watch?v=VodrNEvdBBc
De hecho, asegúrese que su spell-checker (revisor de deletreo) no filtre nada de memoria.
Recuerde que valgrind es tu nuevo mejor amigo. Sepa que valgrind vigila por
fugas mientras su programa está en efecto ejecutándose, así que aségurese de proveer
de argumentos de líneas de comando si usted quiere que valgrind analice speller
mientras usa un dictionary en particular y/o texto, a como se hace a continuación.
valgrind –leak-check=full ./speller texts/austinpowers.txt
Si usted ejecuta valgrind sin especificar un text para speller , sus implementa-
ciones de load y unload no serán llamadas (ni analizadas).
Y no se olvide de su otro buen camarada, gdb .
7. Checking Spell Checking

¿Cómo revisar si tu programa está generando las palabras mal deletreadas? Bueno, eres
bienvenido a consultar las “answer keys” (claves de respuesta) que están dentro del
directorio keys que se encuentra dentro de su directorio pset5 . Por ejemplo, dentro
de keys/austinpowers.txt están todas las palabras que to programa debería pensar
que están mal escritas.
Podría, por tanto, correr su programa sobre algún texto en una ventana, a como se hace
a continuación
./speller texts/austinpowers.txt
Y luego usted podría correr la solución del staff sobre el mismo texto en otra ventana, a
como se hace a continuación

cs50/pset5/speller texts/austinpowers.txt
Luego, podría comparar las ventanas visualmente. Aunque, eso podría volverse tedioso
rápidamente. Así que en vez de eso, podría querer “redirigir” el output de su programa
hacia un archivo (justo como usted pudo haber hecho con generate en Problem Set
3), a como se muesrta a continuación.
./speller texts/austinpowers.txt > student.txt

∼cs50/pset5/speller texts/austinpowers.txt > staff.txt
Usted puede entonces comparar ambos archivos lado a lado en la misma ventana con un
programa como diff , a como se musetra a continuación.
diff -y student.txt staff.txt
Alternativamente, para ahorrar tiempo, usted podría solo comparar el out de su programa
(asumiendo que usted lo redirigió, por ejemplo, student.txt ) con una de las claves de
respuesta sin correr la solución del staff, a como se muestra a continuación.
diff -y student.txt keys/austinpowers.txt
Si el output de su programa encaja con el del staff, diff generará dos columnas que
deberían ser idénticas excepto por, quizá, la cantidad de veces que se corre, al fondo.
Aunque si las columnas difieren, usted verá > o | donde difieran. Por ejemplo, si usted
ve (siguiente página):

MISPELLED WORDS MISPELLED
WORDS
FOTTAGE FOTTAGE
INT INT
>EVIL'S
s s
>EVIL'S
Farbissina Farbissina
significa que su programa (cuyo output está a la izquierda) no piensa que EVIL’S esté
mal escrito, incluso si el out del staff (a la derecha) sí lo hace, a como es implicado por la
ausencia de EVIL’S en el la columna izquierda y la presencia de EVIL’S en la columna
derecha.
Para probar su código de forma menos manual (aunque incluso más exhaustivamente),
usted puede ejecutar lo que se muestra a continuación.
check50 cs50/2017/x/speller
Note que check50 no busca fugas de memoria, así que también asegúrese de correr
valgrind a como fue dicho.
¿Cómo evaluar cuán rápido (y correcto) es nuestro código? Bueno, a como siempre,
siéntase libre de jugar con la solución del staff, a través del siguiente comando, y compare
estos números con los suyos.
∼cs50/pset5/speller texts/austinpowers.txt
7.1. Big Board

¡Pero también, séntase libre (solo por diversión) de poner su código a prueba contra
los códigos de sus compañeros de clase! Ejecute el siguiente comando para retar al
Big Board .

∼cs50/pset5/challenge ∼/workspace/pset5
7.2. questions.txt
¡Felicitaciones! En este punto, su speller-checker (corrector de deletreo) es presumible-
mente completo (y rápido), así que es tiempo de la interrogación. En questions.txt ,
responda cada una de las siguientes preguntas en un párrafo corto.
7. ¿Qué estructura de datos utilizó para implementar su spell-checker? Asegúrese de
no dejar su respuesta en solo “hash table”, “árboles” o algo similar. Exponga lo
que hay dentro de sus “nodos”.
8. ¿Qué tan lento fue tu código la primera vez que lograste que trabajara correcta-
mente?
9. ¿Qué tipos de cambios, si hubo alguno, hiciste en tu código para mejorar su desem-
peño.
10. ¿Siente que su código tiene algún cuelo de botella que no fuiste capaz de superar?

8. Entrega
Debe de compartir su espacio de trabajo en su cuenta de cs50.io por lo cual deberá de
seguir los siguientes pasos (por favor omitir los que muestran cómo crear la cuenta desde
cero si ya tiene una. Estas instrucciones ya estaban descritas también en el PSet4: y si
ya compartió su espacio de trabajo no es necesario repetir el proceso):
Acceda a edx.org y dé clic en el botón Registrer (parte superior derecha del sitio).
Rellene todos los datos que se le solicitan o acceda con una de sus redes sociales
(es preferencial).
Una vez que se registró diríjase a cs50.io y será redirigido a una página donde
deberá escoger la opción edX como CS50 ID (dé clic en Submit).
Se le redirigirá a un formulario de acceso del sitio de edx.org donde deberá ingresar

su correo electrónico y contraseña.
Una vez que ha accedido ya podrá compartir su Workspace dando clic en el botón
Share ubicado en la parte superior derecha.
Dentro del mismo formulario en la sección Invite People escriba silfdv y pro-
porcione permisos de escritura (botón RW), luego de clic en Invite, le debería
aparecer lo siguiente:
Esto fue PSet5.


PSet5 Y17C2

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

PSet5 Y17C2

Enviado por

Direitos autorais:

Formatos disponíveis

PSet5: Mispellings

Optimizar el tiempo (real) de ejecución de su codigo.

Copyright © 2015 – 2016, David J. Malan 1 http://code-fu.net.ni

en la terminal para asegurarte workspace está actualizado.

para navegar en tu directorio ∼/workspace . Ahora, ejecutá

Copyright © 2015 – 2016, David J. Malan 2 http://code-fu.net.ni

deberías ver ahora tenés también un directorio pset5 . A continuación te invitamos a

Ahora, entrá en ese directorio pset5 al ejecutar lo siguiente.

y deberías ver que ese directorio contiene lo siguiente.

dictionaries/ dictionary.c dictionary.h keys/ Makefile questions.txt

Copyright © 2015 – 2016, David J. Malan 3 http://code-fu.net.ni

Antes de llevarte a través de speller.c , ve y abre dictionary.h . Se declaran en

Copyright © 2015 – 2016, David J. Malan 4 http://code-fu.net.ni

CFLAGS = -ggdb3 -O0 -Qunused-arguments -std=c11 -Wall -Werror

SRCS = speller.c dictionary.c

Copyright © 2015 – 2016, David J. Malan 5 http://code-fu.net.ni

$(EXE): $(OBJS) Makefile

$(OBJS): $(HDRS) Makefile

Copyright © 2015 – 2016, David J. Malan 6 http://code-fu.net.ni

Usage: speller [dictionary] text

Copyright © 2015 – 2016, David J. Malan 7 http://code-fu.net.ni

será equivalente a correr

./speller dictionaries/large text

./speller dictionaries/small text

Copyright © 2015 – 2016, David J. Malan 8 http://code-fu.net.ni

1. ¿De acuerdo con la entrada en man , qué hace getrusage ?

eventualmente se asemejara a lo de abajo. Por ahora, intenta ejecutar la solución de

Copyright © 2015 – 2016, David J. Malan 9 http://code-fu.net.ni

Copyright © 2015 – 2016, David J. Malan 10 http://code-fu.net.ni

No puede alterar speller.c .

Puede alterar dictionary.h , pero no puede alterar las declaraciones de load ,

Usted puede alterar Makefile .

Usted puede agregar funciones a dictionary.c o a archivos de su propia creación

Su implementación de check debe distinguir mayúsculas y minúsculas. En otras

Dejando a un lado esto de las mayúsculas y las minúsculas, tu implementación

Copyright © 2015 – 2016, David J. Malan 11 http://code-fu.net.ni

Puede asumir que cualquier dictionary pasado a tu programa será estructurado

Su spell-checker puede tomar únicamente text y, opcionalmente, dictionary

Muy bien, ¿está listo?

Copyright © 2015 – 2016, David J. Malan 12 http://code-fu.net.ni

valgrind –leak-check=full ./speller texts/austinpowers.txt

7. Checking Spell Checking

Copyright © 2015 – 2016, David J. Malan 13 http://code-fu.net.ni

./speller texts/austinpowers.txt > student.txt

diff -y student.txt staff.txt

diff -y student.txt keys/austinpowers.txt

Copyright © 2015 – 2016, David J. Malan 14 http://code-fu.net.ni

7.1. Big Board

Copyright © 2015 – 2016, David J. Malan 15 http://code-fu.net.ni

Copyright © 2015 – 2016, David J. Malan 16 http://code-fu.net.ni

Se le redirigirá a un formulario de acceso del sitio de edx.org donde deberá ingresar

Esto fue PSet5.

Copyright © 2015 – 2016, David J. Malan 17 http://code-fu.net.ni

Você também pode gostar