Questa competizione è finita.

Il vincitore è CJam con 22 personaggi, battendo la risposta di TwiNight di un personaggio. Congratulazioni Dennis !

Una menzione d'onore va a Falko , che è impazzito per le importazioni gratuite.

.

Qualche tempo fa volevo sapere come posso digitare più velocemente gli smartphone moderni con il mio Nokia 3310, e mentre alcune risposte erano davvero buone, non riesco ancora a tenere il passo! Forse dovrei adottare un approccio diverso e semplicemente non scrivere parole difficili da scrivere.

Chiameremo un testo facilmente scrivibile se non ci sono due lettere consecutive sullo stesso pulsante sulla tastiera del telefono, dato il layout standard:

Il tuo compito

Il tuo compito è quello di scrivere un programma / funzione che accetta una stringa sda stdin / come parametro e restituisca un valore di verità se sè facilmente digitabile e un valore di falsa in caso contrario. L'input consisterà solo di lettere minuscole e spazi ed è garantito che non sia vuoto!

punteggio

Questo è codegolf, quindi vince il conteggio dei personaggi più basso.

Istruzioni di importazione non saranno conteggiati verso il vostro punteggio finale, quindi se hai mai desiderato di utilizzo std::set_symmetric_difference, liftM4o itertools.combinationsnel codice, ora è il momento!

-3 se il tuo codice sorgente è facilmente digitabile, supponendo che tutto ciò che non è una lettera sia sul pulsante 0. Dopo tutto, potrei voler inviare il tuo codice ad alcuni amici!

Casi test

Ecco alcuni test per verificare se il codice funziona come previsto:

"x" -> True
"aardvark" -> False
"ardvark" -> True
"flonk" -> False

"im codegolfing all day long" -> False
"i indulge in minimizing bytecount" -> True

"havent heard from you in a long time" -> False
"your silence was of undue permanence" -> True

"how are  you" -> False
"how are you" -> True

Buon golf!

CJam, 34 31 27 22 caratteri

1l{'h-_9/-D+3/X\:X^*}/

Provalo online.

Esempio di esecuzione

$ cjam <(echo "1l{'h-_9/-D+3/X\:X^*}/") <<< 'aardvark'; echo
0
$ cjam <(echo "1l{'h-_9/-D+3/X\:X^*}/") <<< 'ardvark'; echo
66000

Come funziona

1l                         " Push a R := 1 and read a line L from STDIN.                  ";
                           " Initialize X := 1. (implicit)                                ";
  {                  }/    " For each character C of L, do the following:                 ";
    'h-                    "     C -= 'h'                                                 ";
       _9/-D+3/            "     Y := (C - C / 9 + 13) / 3                                ";
               X\  ^*      "     R *= X ^ Y                                               ";
                 :X        "     X := Y                                                   ";
                           " Print R. (implicit)                                          ";

sfondo

Il nucleo del codice consiste nell'applicare una mappa F a ciascun carattere C della stringa di input in modo che le immagini dei simboli sulla stessa chiave corrispondano. Ho trovato la mappa adatta osservando quanto segue:

La mappa T: C ↦ (C - 'h') + 13 trasforma la stringa S: = "abcdefghijklmnopqrstuvxyz" come segue:

[-59   6  7  8   9 10 11  12 13 14  15 16 17  18 19 20  21 22 23 24  25 26 27  28 29 30 31]

Per le chiavi 0a 6, basterebbe dividere T (C) da 3 , ma dobbiamo applicare una sorta di correzione ai personaggi s , t , v , y e z .

La mappa D: C ↦ (C - 'h') / 9 trasforma la stringa S nel seguente array:

[ -8   0  0  0   0  0  0   0  0  0   0  0  0   0  0  0   0  1  1  1   1  1  1   1  1  1  2]

Ciò corregge i quozienti di s , t , v , y e z , senza influenzare le altre.

Infine, la mappa F: C ↦ (T (C) - D (C)) / 3 trasforma la stringa S come segue:

[-17   2  2  2   3  3  3   4  4  4   5  5  5   6  6  6   7  7  7  7   8  8  8   9  9  9  9]

Tutto ciò che resta da fare è confrontare i caratteri consecutivi in ​​qualche modo. A tale scopo, XOR F (C) con l'immagine del carattere precedente - per il primo, XOR F (C) con 1 (valore predefinito della variabile X ), che non ha preimmagini - e moltiplichiamo tutti i risultati.

Il prodotto sarà falsy se e solo se uno dei fattori è zero, vale a dire, se e solo se due caratteri consecutivi hanno la stessa immagine da F .

Python 2-80, 68, 64, 61, 58, 50, 48, 45, 44 42

Anche se ora sta diventando un po 'ridicolo, continuerò a fare uso delle importazioni di librerie gratuite, persino della __builtin__libreria:

from numpy import diff as D
from pprint import pprint as P
from __builtin__ import all as A
from __builtin__ import raw_input as I
from __builtin__ import bytearray as B

Quindi solo la seguente breve linea conta per la lunghezza del codice:

P(A(D([(o-o/112-o/59)/3for o in B(I())])))

Ringraziamo Markuz per le idee riguardanti input()! Queste sfide di importazione libera ti presentano sempre alcune librerie meno conosciute. ;)

Alternativa usando solo la operatorlibreria ( 98, 83 79):

from operator import ne as n
K=[(ord(c)-1-(c>'p')-(c>'w'))/3for c in input()]
print all(map(n,K[1:],K[:-1]))

Mi fermerò qui. Ma si potrebbe ulteriormente golf utilizzando questa versione sys, pprinte altre librerie ...

Alternativa senza librerie (105):

s=input()
n=lambda c:(ord(c)-1-(c>'p')-(c>'w'))/3
print all([n(s[i])!=n(s[i+1])for i in range(len(s)-1)])

Ruby Regex (sapori più popolari), 106 83 byte

Perché regex

^(?!.*(  |[abc]{2}|[def]{2}|[ghi]{2}|[jkl]{2}|[mno]{2}|[p-s]{2}|[tuv]{2}|[w-z]{2}))

Ho appena tagliato l'intermediario (Ruby) e ho reso questa soluzione una pura regex. Funziona in molti modi e trova una corrispondenza solo se la stringa non contiene due caratteri consecutivi sullo stesso pulsante.

Bash + coreutils, 49

tr a-z $[36#8g7e9m4ddqd6]7778888|grep -Pq '(.)\1'

Restituisce un codice di uscita 1 per TRUE e 0 per FALSE:

$ for s in "x" "aardvark" "ardvark" "flonk" "im codegolfing all day long" "i indulge in minimizing bytecount" "havent heard from you in a long time" "your silence was of undue permanence" "how are  you" "how are you"; do echo "./3310.sh <<< \"$s\" returns $(./3310.sh <<< "$s"; echo $?)"; done
./3310.sh <<< "x" returns 1
./3310.sh <<< "aardvark" returns 0
./3310.sh <<< "ardvark" returns 1
./3310.sh <<< "flonk" returns 0
./3310.sh <<< "im codegolfing all day long" returns 0
./3310.sh <<< "i indulge in minimizing bytecount" returns 1
./3310.sh <<< "havent heard from you in a long time" returns 0
./3310.sh <<< "your silence was of undue permanence" returns 1
./3310.sh <<< "how are  you" returns 0
./3310.sh <<< "how are you" returns 1
$ 

APL (Dyalog), 24 23

~∨/2=/⌊¯13⌈.21-.31×⎕AV⍳⍞

∧/2≠/⌊¯13⌈.21-.31×⎕AV⍳⍞

Spiegazione

⍞: Accetta l'input di stringa dallo schermo
⎕AV: questo è il vettore atomico che è fondamentalmente una stringa di tutti i caratteri che APL riconosce, che ovviamente include tutte le lettere minuscole (indice 18 ~ 43) e lo spazio (indice 5)
⍳: IndexOffunzione. Per molte funzioni in APL che accettano uno o due argomenti scalari, è possibile alimentare un array al posto di uno scalare: APL eseguirà il ciclo per te. Quindi ⍳restituisce una matrice numerica di indici. .21-.31×: Tempi 0,31 e quindi sottrazione da 0,21. Questo è un piccolo trucco che associa la lettera sullo stesso tasto (in particolare PQRS) allo stesso numero (se arrotondato per difetto a numeri interi), tranne Z, che viene mappato sul proprio gruppo
¯13⌈: maxcon -13. Questo riporta Z al gruppo con WXY
⌊: arrotondamento per difetto agli interi
2≠/: Pairwise-≠. Restituisce un array booleano per ogni coppia consecutiva.
∧/: E insieme tutte le voci dell'array risultante.

Perl - 44

Questo è fondamentalmente un adattamento Perl della risposta di @ DigitalTrauma pubblicata con il suo permesso. Rasato 2 caratteri grazie a @KyleStrand.

y/b-y/aadddgggjjjmmmpppptttzzz/;$_=!/(.)\1/

43 caratteri + 1 per la -pbandiera. y///è lo stesso di tr///. Stampa 1per vero e niente per falso. Posso inviare una spiegazione dettagliata se richiesto.

Esempio di esecuzione:

perl -pE'y/b-y/aadddgggjjjmmmpppptttzzz/;$_=!/(.)\1/' <(echo "x")

Perl - 81

$s=join"]{2}|[",qw(abc def ghi jkl mno p-s tuv w-z);say/^(?!.*(  |[$s]{2}))/?1:0

+1 per la -nbandiera. Funziona usando joinper creare la regex (la stessa di Martin ), che si rade di pochi byte.

Esempio di esecuzione:

perl -nE'$s=join"]{2}|[",qw(abc def ghi jkl mno p-s tuv w-z);say/^(?!.*(  |[$s]{2}))/?1:0' <(echo "your silence was of undue permanence")

JavaScript - 159 156 byte

function g(s){p=n=-1;for(i=0;i!=s.length;i++){p=n;n=s.charCodeAt(i);n-=97;if(n>17)n--;if(n>23)n--;if(p==-1)continue;if(~~(p/3)==~~(n/3))return 0;}return 1;}

Restituisce 1 per verità e 0 per falsità.

Se solo potessi liberarmi delle parole chiave.

c, 74 byte

main(c,d,r){for(;~(c=getchar());r*=d!=c/3,d=c/3)c-=--c/'p'*(c-'k')/7;c=r;}

Restituisce uno stato di uscita diverso da zero per TRUE e 0 per FALSE:

$ for s in "x" "aardvark" "ardvark" "flonk" "im codegolfing all day long" "i indulge in minimizing bytecount" "havent heard from you in a long time" "your silence was of undue permanence" "how are  you" "how are you"; do echo "./3310 <<< \"$s\" returns $(./3310 <<< "$s"; echo $?)"; done
./3310 <<< "x" returns 40
./3310 <<< "aardvark" returns 0
./3310 <<< "ardvark" returns 216
./3310 <<< "flonk" returns 0
./3310 <<< "im codegolfing all day long" returns 0
./3310 <<< "i indulge in minimizing bytecount" returns 72
./3310 <<< "havent heard from you in a long time" returns 0
./3310 <<< "your silence was of undue permanence" returns 232
./3310 <<< "how are  you" returns 0
./3310 <<< "how are you" returns 8
$ 

Ruby 1.8, 89 83 81 78 byte

p$*[0].chars.map{|c|c=c[0];(c-c/?p-c/?w-1)/3}.each_cons(2).map{|a,b|a!=b}.all?

Ecco un'altra presentazione. Con mia vergogna, batte il regex. :(

Questo prende la stringa tramite argomento della riga di comando e stampa un valore booleano.

Per quanto riguarda l'algoritmo, sto spostando le lettere dopo pdi uno e dopo zdi due, quindi controllo che non ci siano collisioni dopo la divisione di 3.

PS: Questa è la prima volta che l'uso di Ruby 1.8 riduce il codice (a causa del modo più breve per ottenere i codici carattere).

Cobra - 80

def f(s)
    for c in s
        for x in 9,if' adgjmptw'[x]>c,break
        t,f=x,t<>x
    print f

JavaScript (ES6) 66 74

F=s=>[...s].every(c=>[...' adgjmptw'].map(x=>s+=c<x,w=s,s=0)|s!=w)

Il ciclo interno trova il gruppo per ogni personaggio. Concettualmente è una "riduzione", ma la "mappa" è più breve. Il ciclo esterno confronta il gruppo di caratteri consecutivi ed esce con false se sono uguali.

Test nella console Firefox / Firebug

;["x","aardvark","ardvark","flonk","im codegolfing all day long",
"i indulge in minimizing bytecount","havent heard from you in a long time",
"your silence was of undue permanence","how are  you","how are you"]
.forEach(x=>console.log(x + ' -> ' + F(x)))

Produzione

x -> true
aardvark -> false
ardvark -> true
flonk -> false
im codegolfing all day long -> false
i indulge in minimizing bytecount -> true
havent heard from you in a long time -> false
your silence was of undue permanence -> true
how are  you -> false
how are you -> true

Perl, 83 byte

$_=<>;chop;map{$_=ord;$_=($_-$_/112-$_/119-1)/3;die 0 if$l==$_;$l=$_}split//;die 1

Fare un grave abuso di $ _ in Perl.

Due compiti sono complicati in Python; rilevare catene e assegnare i gruppi. Entrambi possono essere assistiti usando numpy, ma non è nella libreria standard.

Python 2 (solo libreria standard) - funzione 59 caratteri

from itertools import imap as M
from __builtin__ import bytearray as A, all as E
from operator import ne as D, not_ as N
from re import S, sub as X, search as F

# 68
#def f(s):
# g=[(n-n/115-n/61)/3for n in A(s)]
# return E(M(D,g,g[1:]))

# 67 with regex via regex
#f=lambda s:N(F(X('(\S)(.)',r'|[\1-\2]{2}','  acdfgijlmopstvwz'),s))

# 59 slightly optimized ordinal classifier and regex sequence detector
f=lambda s:N(F(r'(.)\1',A((n-n/23-n/30)/3for n in A(s)),S))

# 69 using itertools.groupby
#from itertools import groupby as G
#from __builtin__ import sum as S, len as L
#f=lambda s:N(S(L(A(g))-1for _,g in G((n-n/115-n/61)/3for n in A(s))))

Python 2 (solo libreria standard) - 53 caratteri stdin per uscire dal valore

Qui abuso del fatto che issubclass(bool,int), cambiando in modo all()da any()ottenere un valore di uscita valido, rasando not()il valore di ritorno. La rimozione del sovraccarico della funzione ha fatto sì che le versioni di regex fossero in ritardo.

from itertools import groupby as G, imap as M
from __builtin__ import bytearray as A, any as E
from __builtin__ import raw_input as I
from sys import exit as Q
from operator import eq as S

g=[(n-n/23-n/30)/3for n in A(I())]
Q(E(M(S,g,g[1:])))

J - 42 caratteri

Funzione che prende la stringa a destra.

*/@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.)

Prima mappiamo l'alfabeto ( u:97+i.26) nei numeri da 0 a 25, tutti gli altri caratteri (inclusi gli spazi) vanno a 26 ( i.). Quindi mappiamo ( {~) i primi tre elementi mappano sul primo tasto, i successivi tre sul tasto successivo e così via attraverso i tasti del pad del telefono, assicurandoci di mappare lo spazio / altri segni di punteggiatura su un tasto separato alla fine . ( 4 3 4 1,~5#3è uguale 3 3 3 3 3 4 3 4 1e lo I.trasforma in un array di 27 elementi in cui i primi tre sono la chiave 1, ecc.) Quindi controlliamo la disuguaglianza a coppie ( 2~:/\) e AND tutti i risultati insieme ( */).

   */@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.) 'i indulge in minimizing bytecount'
1
   f =: */@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.)
   f 'im codegolfing all day long'
0
   f '*/@(2~:/\(I.4 3 4 1,~5#3){~(u:97+i.26)&i.)'  NB. no -3 bonus :(
0

Racchetta, 119

(define(f t)(for*/and([s(map ~a'(abc def ghi jkl mno pqrs tuv wxyz))][i s][j s])(not(regexp-match(format"~a~a"i j)t))))

Ungolfed (regexing combinatorio):

(define(f t)
  (for*/and([s (map ~a '(abc def ghi jkl mno pqrs tuv wxyz))]
            [i s]
            [j s])
    (not (regexp-match (format "~a~a" i j) t))))

JavaScript - 152

Non un vincitore, ma ci ho provato. Batte @Lozzaaa di 4 byte al momento della pubblicazione :)

function m(a){c="abc-def-ghi-jkl-mno-pqrstuv-wxyz";j=a.split("");for(z in j)if(j[z]=Math.floor(c.indexOf(j[z])/4),0!=z&&j[z-1]==j[z])return 0;return 1};

Supera tutti i test.
Sfrutta la mancanza di digitazione di JS per creare un array multi-tipo e sfrutta l'indice di restituire -1 per il supporto dello spazio.

Uso:

m("string here")

Presuppone solo caratteri alfabetici e spazi minuscoli. Restituisce 1 per vero, 0 per falso.

Forse se conoscessi ES6 potrei provare la seconda sfida ...

ES6, JavaScript 89 70 caratteri

So che non è un vincitore perché quando si tratta di operazioni utili come ottenere il valore ASCII del personaggio, JS mette molto bloat ( .charCodeAt()).

N=s=>[...s].every(c=>l-(l=(c.charCodeAt()-(c>"r")-(c>"y")-1)/3|0),l=1)

Eseguilo nella console Web dell'ultimo Firefox.

Uso:

N("testing if this works")

La funzione restituisce vero o falso.

EDIT : [...x].everyho giocato molto a golf usando il trucco appreso da @ edc65 (Grazie!)

Proverò a giocare a golf di più :)

GML (Game Maker Language), 149

s=argument0p=n=-1for(i=0;i<string_length(s);i++){p=n;n=string_char_at(s,i)-97;x=n>17&&n--;x=n>23&&n--‌​;if(!p)x=1if(!(p/3)=!(n/3))x=0}show_message(x)

Python 3 - 152 caratteri

Non il più breve che potessi fare, ma per ora lo farà

k=['abc','def','ghi','jkl','mno','pqrs','tuv','wxyz',' ']
x=input()
l=2>1
for i in range(len(x)-1):
 for j in k:
  if x[i+1] in j and x[i] in j:l=1>2
print(l)