Para lo difícil que debe hacer, debe hacer algo para que una computadora haga que descubra si algunas palabras se explican de una manera simple. Algo se explica de manera simple si solo usa las diezcientas palabras más usadas. Si no, se explica de una manera difícil. Esto puede ser una cosa de computadora completa o parte de una cosa de computadora. (programa completo o función)

Hay una cosa para que una computadora lea que tiene todas las diezcientas palabras con un espacio entre cada palabra. El nombre de la cosa para que la computadora lea se llama 'most used.txt'. Puedes tomar esto de este lugar de la computadora .

La persona que usa la computadora ingresará algunas palabras. (Esto puede ser de STDIN, argumentos de función o argumentos de línea de comando) La computadora debe decir algo como verdadero si las palabras son simples y algo como verdadero si es difícil. ( verdad-falsedad ) La persona que hace lo más corto para que la computadora haga es la mejor. Las cosas que toda persona sabe que son malas son malas. ( se aplican lagunas estándar )

Más cosas para saber sobre cómo funciona la computadora:

• No importa si las palabras son GRANDES o pequeñas.

• Las imágenes que hacen que el significado de la palabra sea más fácil de saber (puntuación) no importan. Entonces, si la persona que usa la computadora dice "no", no es una palabra diferente a la palabra "no". Los números y otras imágenes tampoco importan. Entonces, si la persona dice "HE $$ ll9o", la computadora debería leerlo como "hola"

• Las pequeñas líneas entre palabras (guiones) funcionan de la misma manera que los espacios. Entonces, la palabra "up-goer-five" es la misma que las palabras "up-goer five".

Más cosas que debes saber sobre cómo hacer palabras como esta:

https://xkcd.com/1133/

http://splasho.com/upgoer5/#

CJam, 41 bytes

q"file:///most used.txt"g]{el_euS--S%}/-!

Esto hace la suposición bastante impura que most used.txtestá en el directorio raíz, ya que CJam no puede manejar rutas relativas.

Alternativamente, tenemos las siguientes soluciones basadas en web (78 y 29 bytes):

q"https://docs.google.com/uc?id=0B2sM8IORrbL3RVpJWTZNUy1rOFU"g]{el_euS--S%}/-!

q"j.mp/-o_O"g]{el_euS--S%}/-!

La forma "adecuada" de hacer esto en CJam sería leer ambas entradas de STDIN (entrada en la primera línea, diccionario en la segunda), que es posible en 18 bytes:

qN%{el_euS--S%}/-!

Puede probar la última versión en el intérprete de CJam . (Enlace permanente probado en Chrome)

Ejemplos

$ cjam <(echo 'q"file:///most used.txt"g]{el_euS--S%}/-!') <<< 'ten hundred'; echo
1
$ cjam <(echo 'q"file:///most used.txt"g]{el_euS--S%}/-!') <<< 'thousand'; echo
0

R, 106 bytes

No está seguro si se entiende el desafío porque le cuesta leer.

function(s){u=toupper;all(strsplit(gsub("[^A-Z -']","",u(s)),"[ -]")[[1]]%in%u(scan("most used.txt","")))}

Esto crea una parte sin nombre de una cosa de computadora que acepta una cadena y devuelve algo como verdadero o como no verdadero.

Ungolfed + explicación:

partOfAComputerThing <- function(s) {
    # Remove everything but letters, spaces, dashes, and single quotes
    s <- gsub("[^A-Z -']", "", toupper(s))

    # Split s into a vector on spaces/dashes
    v <- strsplit(s, "[ -]")[[1]]

    # Read the file of words (assumed to reside in the current directory)
    m <- scan("most used.txt", "")

    # Determine if all words in the input are in the file
    all(v %in% toupper(m))
}

Gracias a Dennis por la inspiración.

Python 3, 148 bytes

import re
print(all(i in open("most used.txt").read().lower().split(' ')for i in re.sub("[^a-z ']+","",input().replace("-"," ").lower()).split(" ")))

Salidas TrueyFalse

Ejemplos

Input:  Don't
Output: True

Input:  The poison air he's breathing has a dirty smell of dying
Output: False

Input:  Who let the dogs out?
Output: False

Pyth, 35 bytes

!-Fm@LGcrXd\-bZ),zs'"most used.txt

Pruebas, donde lo anterior es el archivo common.pyth

$ pyth common.pyth <<< 'I can write this way too-hell99#0O.'
True
$ pyth common.pyth <<< 'But I get confused easily.'
False

Explicación:

!-Fm@LGcrXd\-bZ),zs'"most used.txt
   m            ,zs'"most used.txt    Map over input and input file:
         Xd\-b                        Replace hyphens with newlines.
        r     Z                       Cast to lower case.
       c       )                      Split on whitespace.
    @LG                               Remove non-alphabetic characters.
 -F                                   Setwise difference - remove anything in
                                      the text file from the input.
!                                     Logical negation.

APL (Dyalog) , 69 bytes

Asume que el archivo está en el directorio actual.

s←819⌶' '(1↓¨,⊂⍨⊣=,)'[- ]' '\W'⎕R' ' ''
∧/(s⍞)∊s⊃⎕NGET'most used.txt'

Pruébalo en línea!

La primera línea define una función auxiliar de normalización y división en lista de cadenas, s :

s← s es
819⌶ el
' '( resultado en minúscula de la siguiente función, con un espacio como argumento izquierdo ...
 1↓¨ suelte uno de cada
 , concatenación de los argumentos
 ⊂⍨ cortados antes de cada elemento donde
 ⊣ el argumento izquierdo
 = es igual a
 , la concatenación de los argumentos
) aplicados al
'[- ]' '\W'⎕R' ' '' guión de reemplazos PCRE / espacio → espacio, sin palabra-char → nada

∧/(... ¿ ) es cierto que
 s la
 ⍞ entrada de texto normalizado y dividido
∊ son miembros del  primer elemento
s normalizado y dividido  del (contenido, codificación, estilo de nueva línea) del archivo
⊃
⎕NGET'most used.txt'

JavaScript (ES7), 161 bytes

(No compite ya que la pregunta es anterior a la especificación ES7)

s=>fetch("most used.txt").then(t=>t.text()).then(d=>alert(s.split(/[ -]/g).every(l=>d.split` `.map(w=>w.replace(/[\.']/,"")).includes(l.replace(/[^a-z]/g,"")))))

¿Alguien recibió una copia del archivo en línea que puedo usar para crear un fragmento de trabajo?

PHP, 101 bytes

foreach(preg_split("#[^\w']+#",$argn)as$w)preg_match("#\b$w\b#i",end(file("most used.txt")))?:die(1);

toma la entrada de STDIN, supone que el diccionario de una sola línea
sale con 1(error) para falsedad, 0(ok) para verdad. Corre con -R.

Dividir la entrada por caracteres que no sean palabras, recorrer la matriz resultante (palabras):
si la palabra está en el diccionario, continúe; otra cosa exit(1).
implícita exit(0).

o simplemente pon:

una palabra tras otra: si la palabra está en las palabras más usadas, continúe; más return 1. return 0.

y: podría ahorrar dos puntos si las palabras más utilizadas tuvieran un espacio al frente y al final.

Java, 248 bytes

Con la frase aprobada como argumento.

void g(String s) throws Exception{String c=new java.util.Scanner(new java.io.File("most used.txt")).useDelimiter("\\Z").next(),x="false";for(String l:s.split(" "))if(c.contains(l.toLowerCase().replaceAll("![a-z]","")))x="true";System.out.print(x);}

de entrada y salida:

g("was he")         --> "true"
g("was h!e")         --> "true"
g("delicious cake") --> "false"

Espaciado y tabulado:

void g(String s) throws Exception{
    String c=new java.util.Scanner(new java.io.File("most used.txt")).useDelimiter("\\Z").next()
      ,x="false";
    for(String l:s.split(" "))
      if(c.contains(l.toLowerCase().replaceAll("![a-z]","")))
          x="true";
    System.out.print(x);
}