Alcune versioni dell'app calcolatrice Android standard ti consentono di premere un tasto, come 'sin' e quindi il tasto 'del' per renderlo 'si'. Probabilmente solo un bug che non possono essere disturbati con la rimozione.

Sono scrivibili le seguenti lettere / raggruppamenti di lettere:

 

peccato
SI
S
cos
co
c
abbronzatura
ta
t
ln
l
log
Lo
e

Quindi, "insipido" è tipizzabile, perché ta-steless e così è "zoccoli" perché "c-log-s". Tuttavia 'got' non è tipizzabile, né è 'an' o 'xyz'.

Scrivi un programma che accetta una singola parola (o sequenza di lettere, solo az nell'input) come input e produce output per indicare se una parola è scrivibile o meno.

L'output può essere un singolo carattere / lettera / cifra / ecc. o potrebbe essere più grande. Tutte le parole digitabili dovrebbero produrre lo stesso output. Tutte le parole non tipizzabili dovrebbero anche produrre lo stesso output.

PS Solo per curiosità, "insipido" è la parola del dizionario più lunga che si possa scrivere?

Perl, 47 43 41 + 1 = 42 byte

-4 byte grazie a @Sunny Pun. -2 byte grazie a @Brad Gilbert b2gills e @Downgoat

Corri con la -nbandiera.

say!/^(s(in?)?|co?|t(an?)?|ln?|log?|e)+$/

Può sicuramente essere ulteriormente giocato a golf, ma nello spirito della competizione, sto lasciando la regex per lo più originale che mi è venuta in mente all'inizio. Non restituisce nulla se vero, 1se falso.

Provalo online!

Ho scaricato un file di dizionario e la parola più lunga che ho trovato era di 11 lettere - tattletales

JavaScript (ES6), 44 byte

s=>/^((si|ta|l)n?|co?|log?|[ste])+$/.test(s)

Penso che questa sia la regex più breve possibile, ma ovviamente potrei sbagliarmi.

Spiegazione

Un primo ovvio punto di partenza sarebbe una regex che include semplicemente tutte le opzioni separatamente:

s=>/^(sin|si|s|cos|co|c|tan|ta|t|log|lo|l|ln|e)+$/.test(s)

Innanzitutto, possiamo osservare che cospuò essere formato da coe s, rendendolo inutile:

s=>/^(sin|si|s|co|c|tan|ta|t|log|lo|l|ln|e)+$/.test(s)

Alcuni di questi, come sine si, possono essere combinati rendendo facoltativa l'ultima lettera:

s=>/^(sin?|s|co?|tan?|t|log?|ln?|e)+$/.test(s)

Questo funziona perché si sin?combina sicon o senza un nalla fine, coprendo così sia sine si.

Sembra che ci siano anche molti messaggi n?. E se li mettessimo tutti insieme?

s=>/^((si|ta|l)n?|s|co?|t|log?|e)+$/.test(s)

Un altro modo per giocare a golf sarebbe quello di combinare le restanti opzioni a carattere singolo in una gamma di caratteri, ma questo esce alla stessa lunghezza:

s=>/^((si|ta|l)n?|co?|log?|[ste])+$/.test(s)

Ed è così che giochi a golf una regex semplice. Credo che questa sia la regex più breve possibile che corrisponda correttamente ad ogni stringa, ma forse no. Assegnerò una taglia +100 a chiunque riesca a migliorare questa regex.

Pyth, 37 33 29 28 byte

Il codice contiene un carattere non stampabile, quindi ecco un xxdhexdump.

00000000: 737d 5173 4d5e 733c 5252 6336 2e22 6174  s}QsM^s<RRc6."at
00000010: 14d0 69ba 76f1 ac59 6422 346c            ..i.v..Yd"4l

Provalo online.

Estremamente inefficiente dal punto di vista astronomico. La complessità del tempo e dello spazio è O (16 ⁿ ) O (24 ⁿ ).

Spiegazione

Innanzitutto, Qviene aggiunto implicitamente a.

s}QsM^s<RRc6."…"4lQ     Implicit: Q = input
            ."…"        Generate "logsincostanlnee"
          c6            Split in 6 parts: ["log", "sin", "cos", "tan", "ln", "ee"]
         R      4       For each n from 0 to 3
       <R               Take the first n chars from each string
      s                 Flatten the results
                 lQ     Get length of input
     ^                  Take that Cartesian power of the list
   sM                   Join each resulting list
 }Q                     Check if the input is found
s                       Cast to integer

Gelatina , 32 31 30 28 26 byte

ŒṖw@€€“¡Ṡ[ẈKœịḲ-¢ȧ?-»’%3ḌẠ

Emette 0 se la parola è tipizzabile, 1 in caso contrario. Grazie a @JonathanAllan per il golf off 1 byte!

Provalo online!

Come funziona

ŒṖw@€€“¡Ṡ[ẈKœịḲ-¢ȧ?-»’%3ḌẠ  Main link. Argument: s (string of lowercase letters)

ŒṖ                          Yield all partitions of s.
      “¡Ṡ[ẈKœịḲ-¢ȧ?-»       Yield "sine  logcostanln". Every third character
                            marks the start of a typeable word.
  w@€€                      Find the indices of all substrings in the partitions
                            in the string to the right (1-based, 0 if not found).
                     ’      Decrement. "Good" indices are now multiples of 3.
                      %3    Modulo 3. "Good" indices are mapped to 0, "bad"
                            indices are mapped to 1 or 2.
                        Ḍ   Convert from decimal to integer. A partition will
                            yield 0 iff all indices are "good".
                         Ạ  All; yield 0 if one or more integers are falsy (0), 1
                            if all integers are truthy (non-zero).

Brachylog , 33 byte

Risolto un bug grazie a @Synoli.

~c:1a
,"sincostanloglneeee"@6e@[?

Provalo online!

Uscite true.se tipizzabili o false.altro.

Spiegazione

Proviamo a deconcatenare l'input fino a quando non ne troviamo uno per il quale tutte le stringhe che concateniamo sono un prefisso di uno di ["sin", "cos", "tan", "log", "lne", "eee].

~c                          A list of strings which when concatenated results in the Input
  :1a                       All strings of this list satisfy the predicate below:

,"sincostanloglneeee"@5           The list ["sin", "cos", "tan", "log", "lne", "eee"]
                       e          Take one element of that list
                        @[?       The input is a prefix of that element

Perl 6 ,  60 50  44 byte

primo tentativo ( 60 )

put +?(get~~/^<{<sin cos tan ln log e>».&{|m:ex/^.+/}}>*$/)

traduzione della risposta Perl 5 ( 50 )

put +?(get~~/^[s[in?]?|co?|t[an?]?|ln?|log?|e]*$/)

utilizzando l' -ninterruttore ( 43 + 1 )

put +?/^[s[in?]?|co?|t[an?]?|ln?|log?|e]*$/

Il primo ?converte il risultato in booleano e il primo lo +converte in un numero ( 1per True, 0per False)

Mathematica, 101 byte

If[StringMatchQ[#,("sin"|"si"|"s"|"cos"|"co"|"c"|"tan"|"ta"|"t"|"ln"|"l"|"log"|"lo"|"e")..],"T","F"]&

Sembra che le parti difficili di questa sfida stiano arrivando con la regex più breve e scegliendo il linguaggio più conciso per abbinare la regex. Non ho nulla per contribuire al primo, e Mathematica non è un buon candidato per il secondo dato che devi usare StringMatchQe RegularExpression. Quello che posso fare è rispondere al tuo PS: è "insipido" la parola più lunga che puoi scrivere?

In[1]:= f=StringMatchQ[#,("sin"|"si"|"s"|"cos"|"co"|"c"|"tan"|"ta"|"t"|"ln"|"l"|"log"|"lo"|"e")..]&;

In[2]:= Select[EntityList@"Word",f@#[[2,1]]&][[All,2,1]]//SortBy[StringLength]//DeleteDuplicates
Out[2]= {c,e,l,s,t,cc,cl,el,et,lo,si,sl,ta,te,ccc,col,cos,cot,eel,ell,eta,etc,lee,let,log,lot,sec,see,set,sic,sin,sit,tae,tan,tat,tec,tee,cell,clog,clot,coco,cole,colt,coss,cost,cote,else,less,loco,loge,loll,lose,loss,lota,sect,seel,sell,sess,seta,sett,sill,silo,silt,sine,sise,siss,site,sloe,slog,slot,stet,taco,tact,tael,talc,tale,tall,tect,tell,test,cello,close,cosec,costa,cotan,eccle,elect,elsin,ettle,loess,lotte,secle,setee,since,sleet,stale,stall,state,steel,stele,tasse,taste,tatee,teest,telco,testa,tetel,tsine,cellco,closet,coleta,collet,coltan,cosine,cosset,costal,ecesis,estate,lessee,scelet,select,sellee,sestet,settee,settle,siesta,silole,stacte,stance,stasis,tallet,tallot,taslet,tassel,tasset,tattle,tectal,teetan,tellee,testee,tsetse,celesta,cessile,cocotte,collect,costate,ecolect,ectasis,electee,sessile,sinless,sitelet,statant,tassell,tastant,testate,coestate,colessee,colocolo,cosiness,costless,electant,lossless,sceletal,siletane,statelet,tactless,tallness,telltale,telocoel,coelostat,sissiness,stateless,tasteless,tattletale}

Quindi "tattletale" sembra essere il più lungo di un personaggio.

Meraviglia , 41 byte

!.(mstr"^(s|t|co?|(l|ta|si)n?|log?|e)+$")

Uso:

(!.(mstr"^(s|t|co?|(l|ta|si)n?|log?|e)+$")) "tasteless"

Ho frainteso del tutto la domanda prima, ma ora è tutto risolto. Uscite Fper corrispondenza e Tper nessuna corrispondenza.

Non competitivo, 35 byte

!.`^(s|t|co?|(l|ta|si)n?|log?|e)+$`

Uso:

(!.`^(s|t|co?|(l|ta|si)n?|log?|e)+$`) "tasteless"

Questo si avvale delle regex applicabili, implementate dopo questa sfida.

Elaborazione, 223 byte

int d(String b){for(String p:"tan0log0sin0cos0ln0e".split("0"))if(p.startsWith(b))return 1;return 0;}

int l(String p){String b="";int t=1;for(char c:p.toCharArray()){b+=c;if(d(b)<1){b=c+"";t=d(b);}if(t<1)return t;}return t;}

Alla fine decisi di fare una risposta senza regex. Per chiamare la funzione, utilizzare l("tasteless");. Restituisce 0per falso e 1per vero.

Codice espanso con spiegazione

int d(String b){
  for(String p:"tan0log0sin0cos0ln0e".split("0"))
    if(p.startsWith(b))
      return 1;
  return 0;
}
//main function
int l(String p){
  String b="";
  int t=1;
  for(char c:p.toCharArray()){
    b+=c;
    if(d(b)<1){
      b=c+"";
      t=d(b);
    }
    if(t<1)return t;
  }
  return t;
}

Fondamentalmente, ripetiamo la stringa data, costruendo bchar con char. Controlliamo con d()se una qualsiasi delle tan, log, ... iniziare con b. Se lo fa, allora è valido. Altrimenti, controlliamo se il carattere in quella posizione è valido e ripristiniamo b. Ora, se non è valido, 0verrà restituito, altrimenti sarà comunque valido. Alla fine, se il programma non ha già restituito qualcosa, torna 1.

Scala, 49 byte

s=>s.matches("(s(in?)?|co?|t(an?)?|ln?|log?|e)+")

Restituisce vero se la stringa data corrisponde al regex, falso altrimenti.

Python 3 , 154 byte

r=1;i=input()
while r:
 r=0
 for s in'sin,cos,tan,log,ln,co,lo,si,ta,s,c,t,l,e'.split(','):
  if i.startswith(s):r=i=i.replace(s,'',1);break
print(i=='')

Provalo online!

Python 3 , 149 130 byte

i=input()
for a in 'tan,sin,cos,log,si,co,ta,lo,lo,ln,s,c,t,l,e'.split(','):
    if a in i:
        i=i.replace(a,"")
print(not i)

edit # 1: rasato 19 byte usando la soluzione @Henke

Python 2, 124 byte

f=lambda w:any(f(w[len(s):])if w[:len(s)]==s else 0for s in'sin,cos,tan,log,ln,co,lo,si,ta,s,c,t,l,e'.split(','))if w else 1

PHP, 60 byte

<?=preg_match("#^((si|ta|l)n?|co?|log?|s|e|t)+$#",$argv[1]);

regex rubato da ETHproductions :
accetta input dall'argomento della riga di comando; stampe 1per scrivere, 0per non scrivere.

versioni precedenti, 75 73 69 byte

<?=!preg_replace("#co|log|ln|lo|sin|si|tan|ta|[celst]#","",$argv[1]);

sostituisce tutte le parole possibili con una stringa vuota, restituisce il risultato, annulla.

<?=!preg_split("#co|log|ln|lo|sin|si|tan|ta|[celst]#",$argv[1],-1,1);

divide l'input per le corrispondenze regex. Flag 1sta per PREG_SPLIT_NO_EMPTYe dice preg_splitdi restituire solo risultati non vuoti. Se l'input è scrivibile, preg_splitavrà solo risultati vuoti, quindi restituirà un array vuoto, che è falso. !annulla il risultato.

Entrambe le versioni accettano input dall'argomento della riga di comando
e stampano 1se il risultato è vuoto (l'input è tipizzabile), altrimenti nulla.

Note: L'
imballaggio del regex usando ?non funziona qui; rende le espressioni non gradite; probabilmente a causa del backtracking. E l'ordine delle alternative è importante: tadeve stare davanti to il motore smetterà di combaciare quando lo trova t.

Ho trovato un cheat sheet quantificatore , pensato ??o ?+potrebbe aiutare; ma non hanno funzionato per me.

Java 8, 55 byte

s->return s.matches("^((si|ta|l)n?|co?|log?|[ste])+$");

Disclamer: ho usato il regex di ETHproductions perché era di molti byte più corto del mio. Credito completo sul Regex a lui. Quello che ho fatto è stato aggiungere 24 byte per renderlo una funzione Java.

Restituisce falsese la parola non rientrava nel Regex, altrimenti true.