Per la tua cosa difficile da fare, devi fare qualcosa per un computer che scopra se alcune parole sono spiegate in modo semplice. Qualcosa viene spiegato in modo semplice se utilizza solo le diecimila parole più utilizzate. In caso contrario, viene spiegato in modo difficile. Questa può essere una cosa al computer o parte di una cosa al computer. (programma completo o funzione)

C'è qualcosa da leggere per un computer che contiene tutte le diecimila parole con uno spazio tra ogni parola. Il nome della cosa che il computer deve leggere si chiama 'most used.txt'. Puoi prendere questa cosa da questo posto di computer .

La persona che usa il computer inserirà alcune parole. (Può trattarsi di STDIN, argomenti di funzioni o argomenti della riga di comando) Il computer deve dire qualcosa di vero se le parole sono semplici e qualcosa di simile a non vero se è difficile. ( verità-falsità ) La persona che fa la cosa più breve da fare per il computer è la migliore. Le cose che ogni persona sa sono cattive sono cattive. (si applicano scappatoie standard )

Altre cose da sapere su come funziona il computer:

• Non importa se le parole sono GRANDI o piccole.

• Le immagini che semplificano la comprensione del significato della parola (punteggiatura). Quindi se la persona che usa il computer dice "non" non è una parola diversa dalla parola "non". Anche i numeri e le altre immagini non contano. Quindi se la persona dice "HE $$ ll9o" il computer dovrebbe leggerlo come "ciao"

• Le piccole linee tra le parole (trattini) funzionano allo stesso modo degli spazi. Quindi la parola "up-goer-five" è la stessa delle parole "up-goer five".

Altre cose da sapere su come creare parole come questa:

https://xkcd.com/1133/

http://splasho.com/upgoer5/#

CJam, 41 byte

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

Questo rende l'assunto piuttosto impuro che si most used.txttrova nella directory principale, poiché CJam non può gestire percorsi relativi.

In alternativa, abbiamo le seguenti soluzioni basate sul web (78 e 29 byte):

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

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

Il modo "corretto" di farlo in CJam sarebbe leggere entrambi gli input da STDIN (input sulla prima riga, dizionario sulla seconda), che è possibile in 18 byte:

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

Puoi provare l'ultima versione nell'interprete CJam . (permalink testato in Chrome)

Esempi

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

Non è sicuro se è difficile capire perché è difficile leggere.

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

Questo crea una parte senza nome di un computer che accetta una stringa e restituisce qualcosa come un vero o come un non vero.

Ungolfed + spiegazione:

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

Grazie a Dennis per l'ispirazione.

Python 3, 148 byte

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

Uscite TrueeFalse

Esempi

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 byte

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

Test, dove sopra è il file common.pyth

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

Spiegazione:

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

Presuppone che il file sia nella directory corrente.

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

Provalo online!

La prima riga definisce una funzione helper di normalizzazione e suddivisione in elenco di stringhe, s :

s← s è
819⌶ il
' '( risultato in lettere minuscole della seguente funzione, con uno spazio come argomento sinistro ...
 1↓¨ rilascia uno da ciascuna delle
 , concatenazioni degli argomenti
 ⊂⍨ tagliati prima di ogni elemento in cui
 ⊣ l'argomento sinistro
 = è uguale alla
 , concatenazione degli argomenti
) applicati al
'[- ]' '\W'⎕R' ' '' trattino sostituzioni PCRE / spazio → spazio, non parola-char → niente

∧/(... ) è tutto vero che
 s l'normalizzata e dividere
 ⍞ l'immissione di testo
∊ sono membri
s del normalizzata e dividere
⊃ primo elemento
⎕NGET'most used.txt' del (contenuto, che codifica, ritorno a capo in stile) del file

JavaScript (ES7), 161 byte

(Non competitiva poiché la domanda precede le specifiche 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,"")))))

Qualcuno ha una copia del file online che posso usare per creare uno snippet funzionante?

PHP, 101 byte

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

accetta input da STDIN, presuppone che il dizionario a riga singola
esca con 1(errore) per falsy, 0(ok) per verità. Corri con -R.

Dividi input per caratteri non di parole, passa in rassegna l'array risultante (parole):
se la parola è nel dizionario, continua; altro exit(1).
implicito exit(0).

o, semplicemente, inserisci:

una parola dopo l'altra: se la parola è tra le parole più utilizzate, continua; else return 1. restituisce 0.

e: potrei risparmiare due punti se le parole più utilizzate avessero uno spazio ciascuna davanti e alla fine.

Java, 248 byte

Con la frase passata come argomento.

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

input Output:

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

Distanziati e a schede:

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