Pour votre chose difficile à faire, vous devez faire en sorte qu'un ordinateur fasse pour savoir si certains mots sont expliqués de manière simple. Quelque chose est expliqué de manière simple s'il n'utilise que les dix cents mots les plus utilisés. Sinon, cela s'explique de manière difficile. Cela peut être une chose informatique complète ou une partie d'une chose informatique. (programme ou fonction complète)

Il y a une chose à lire pour un ordinateur qui contient tous les dix cents mots avec un espace entre chaque mot. Le nom de la chose que l'ordinateur doit lire est appelé «le plus utilisé.txt». Vous pouvez prendre cette chose depuis cet ordinateur .

La personne qui utilise le truc informatique entrera quelques mots. (Cela peut provenir de STDIN, des arguments de fonction ou des arguments de ligne de commande) L'ordinateur doit dire quelque chose comme un vrai si les mots sont simples et quelque chose comme un faux si c'est difficile. ( vérité-fausseté ) La personne qui fait le plus court travail pour l'ordinateur est la meilleure. Les choses que chaque personne sait mauvaises sont mauvaises. ( les échappatoires standard s'appliquent )

Plus de choses à savoir sur le fonctionnement de l'ordinateur:

• Peu importe que les mots soient GRANDS ou peu.

• Les images qui facilitent la connaissance du mot (ponctuation) n'ont pas d'importance. Donc, si la personne qui utilise l'ordinateur dit "ne fais pas" ce n'est pas un mot différent du mot "ne fais pas". Les chiffres et autres images importent également peu. Donc, si la personne dit "HE $$ ll9o", l'ordinateur devrait le lire comme "bonjour"

• Les petites lignes entre les mots (tirets) fonctionnent de la même manière que les espaces. Ainsi, le mot "up-goer-five" est le même que les mots "up goer five".

Plus de choses à savoir sur la création de mots comme celui-ci:

https://xkcd.com/1133/

http://splasho.com/upgoer5/#

CJam, 41 octets

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

Cela fait l'hypothèse plutôt impure qui se most used.txttrouve dans le répertoire racine, car CJam ne peut pas gérer les chemins relatifs.

Alternativement, nous avons les solutions Web suivantes (78 et 29 octets):

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

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

La manière "correcte" de le faire dans CJam serait de lire les deux entrées depuis STDIN (entrée sur la première ligne, dictionnaire sur la seconde), ce qui est possible en 18 octets:

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

Vous pouvez essayer la dernière version dans l' interpréteur CJam . (permalien testé dans Chrome)

Exemples

$ 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 octets

Je ne sais pas si c'est comprendre le défi parce qu'il a du mal à lire.

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

Cela crée une partie sans nom d'une chose informatique qui accepte une chaîne et renvoie quelque chose comme un vrai ou comme un faux.

Non golfé + explication:

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))
}

Merci à Dennis pour son inspiration.

Python 3, 148 octets

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

Sorties TrueetFalse

Exemples

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 octets

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

Tests, où ce qui précède est le fichier common.pyth

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

Explication:

!-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 octets

Suppose que le fichier se trouve dans le répertoire en cours.

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

Essayez-le en ligne!

La première ligne définit une fonction d'assistance de normalisation et de division en liste de chaînes, s :

s← s est
819⌶ le
' '( résultat en minuscule de la fonction suivante, avec un espace comme argument de gauche… en
 1↓¨ supprimer un de chacune de
 , la concaténation des arguments
 ⊂⍨ coupés avant chaque élément où
 ⊣ l'argument de gauche
 = est égal à
 , la concaténation des arguments
) appliqués au
'[- ]' '\W'⎕R' ' '' tableau de bord des remplacements PCRE / espace → espace, non-word-char → rien

∧/(… ) Est-il vrai que
 s les
 ⍞ entrées de texte normalisées et divisées
∊ sont membres du  premier élément
s normalisé et divisé  du (contenu, codage, style de nouvelle ligne) du fichier
⊃
⎕NGET'most used.txt'

JavaScript (ES7), 161 octets

(Non concurrent car la question est antérieure à la spécification 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,"")))))

Quelqu'un a-t-il obtenu une copie du fichier en ligne que je peux utiliser pour créer un extrait de travail?

PHP, 101 octets

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

prend l'entrée de STDIN, suppose que le dictionnaire à une seule ligne se termine
avec 1(erreur) pour faux, 0(ok) pour vrai. Courez avec -R.

Fractionner l'entrée par des caractères non-mot, parcourir le tableau résultant (mots):
Si le mot est dans le dictionnaire, continuer; sinon exit(1).
implicite exit(0).

ou, mettez simplement:

un mot après l'autre: Si le mot est dans les mots les plus utilisés, continuez; sinon retourner 1. retourner 0.

et: je pourrais économiser deux points si les mots les plus utilisés avaient chacun un espace devant et à la fin.

Java, 248 octets

Avec la phrase passée en argument.

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);}

entrée sortie:

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

Espacé et tabulé:

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);
}