Esta competencia ha terminado.

El ganador es CJam con 22 caracteres, superando la respuesta de TwiNight por un personaje. ¡Felicidades Dennis !

Una mención de honor es para Falko , quien se volvió completamente loco con las importaciones gratuitas.

.

Hace un tiempo quería saber cómo puedo sobrescribir los teléfonos inteligentes modernos con mi Nokia 3310, y aunque algunas respuestas fueron realmente buenas, ¡todavía no puedo seguir el ritmo! Tal vez debería adoptar un enfoque diferente y simplemente no escribir palabras que sean difíciles de escribir.

Llamaremos a un texto fácilmente escribible si no hay dos letras consecutivas en el mismo botón en el teclado del teléfono, dada la disposición estándar:

Tu tarea

Su tarea es escribir un programa / función que acepte una cadena sde stdin / como parámetro y devuelva un valor verdadero si ses fácil de escribir y un valor falso de lo contrario. ¡La entrada solo consistirá en letras minúsculas y espacios y se garantiza que no estará vacía!

Tanteo

Este es codegolf, por lo que gana el recuento de caracteres más bajo.

Declaraciones de importación no serán contados hacia su resultado final, por lo que si alguna vez has querido para su uso std::set_symmetric_difference, liftM4o itertools.combinationsen su código, ahora es el momento!

-3 si su código fuente es fácil de escribir, suponiendo que todo lo que no sea una letra esté en el botón 0. ¡Después de todo, me gustaría enviar su código a algunos amigos!

Casos de prueba

Aquí hay algunos casos de prueba para verificar si su código funciona según lo 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

¡Feliz golf!

CJam, 34 31 27 22 caracteres

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

Pruébalo en línea.

Ejecución de ejemplo

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

Cómo funciona

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

Fondo

El núcleo del código consiste en aplicar un mapa F a cada carácter C de la cadena de entrada para que coincidan las imágenes de los símbolos en la misma tecla. Encontré un mapa adecuado observando lo siguiente:

El mapa T: C ↦ (C - 'h') + 13 transforma la cadena S: = "abcdefghijklmnopqrstuvxyz" de la siguiente manera:

[-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]

Para las teclas 0a 6, bastaría con dividir T (C) por 3 , pero tenemos que aplicar algún tipo de corrección a los personajes de s , t , v , y y z .

El mapa D: C ↦ (C - 'h') / 9 transforma la cadena S en la siguiente matriz:

[ -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]

Esto corrige los cocientes de s , t , v , y y z , sin afectar a los demás.

Finalmente, el mapa F: C ↦ (T (C) - D (C)) / 3 transforma la cadena S de la siguiente manera:

[-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]

Todo lo que descansa es comparar los caracteres consecutivos de alguna manera. Para ese propósito, hacemos XOR F (C) con la imagen del personaje anterior; para el primero, hacemos XOR F (C) con 1 (valor predeterminado de la variable X ), que no tiene preimagen, y multiplicamos todos los resultados.

El producto será Falsy si y sólo si uno de los factores es cero, es decir, si y sólo si dos caracteres consecutivos tienen la misma imagen por F .

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

Aunque ahora se está volviendo un poco ridículo, seguiré utilizando las importaciones gratuitas de la biblioteca, incluso la __builtin__biblioteca:

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

Entonces, solo la siguiente línea corta cuenta para la longitud del código:

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

Créditos a Markuz por las ideas con respecto input()! Estos desafíos de importación gratuita siempre le presentan algunas bibliotecas menos conocidas. ;)

Alternativa usando solo la operatorbiblioteca ( 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]))

Me detendré aquí. Pero se podría avanzar en campo utilizando esta versión sys, pprinty otras bibliotecas ...

Alternativa sin bibliotecas (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 (sabores más populares), 106 83 bytes

Porque regex

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

Acabo de cortar al intermediario (Ruby) e hice de esto una solución pura de expresiones regulares. Funciona en muchos sabores y solo encuentra una coincidencia si la cadena no contiene dos caracteres consecutivos en el mismo botón.

Bash + coreutils, 49

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

Devuelve un código de salida de 1 para VERDADERO y 0 para FALSO:

$ 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⍳⍞

Explicación

⍞: Toma la entrada de cadena de la pantalla
⎕AV: este es el vector atómico que es básicamente una cadena de todos los caracteres que APL reconoce, que por supuesto incluye todas las letras minúsculas (índice 18 ~ 43) y espacio (índice 5)
⍳: IndexOffunción. Para muchas funciones en APL que toman uno o dos argumentos escalares, puede alimentarlo con una matriz en lugar de un escalar: APL hará el bucle por usted. Entonces ⍳devuelve una matriz numérica de índices. .21-.31×: Veces 0.31 y luego resta de 0.21. Este es un pequeño truco que asigna la letra de la misma tecla (especialmente PQRS) al mismo número (cuando se redondea a enteros), excepto Z, que se asigna a su propio grupo
¯13⌈: maxcon -13. Esto hace que Z regrese al grupo con WXY
⌊: Redondear a enteros
2≠/: Pairwise-≠. Devuelve una matriz booleana para cada par consecutivo.
∧/: Y juntas todas las entradas de la matriz resultante.

Perl - 44

Esto es básicamente una adaptación de Perl de la respuesta de @ DigitalTrauma publicada con su permiso. Afeitado 2 personajes gracias a @KyleStrand.

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

43 caracteres + 1 para -pbandera. y///es el mismo que tr///. Imprime 1para verdadero y nada para falso. Puedo publicar una explicación detallada si así lo solicita.

Ejemplo de ejecución:

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 para -nbandera. Funciona mediante el uso joinpara crear la expresión regular (la misma que la de Martin ), que se afeita de unos pocos bytes.

Ejemplo de ejecución:

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 - 159156 bytes

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

Devuelve 1 para verdadero y 0 para falso.

Si tan solo pudiera deshacerme de las palabras clave.

c, 74 bytes

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

Devuelve un estado de salida distinto de cero para VERDADERO y 0 para FALSO:

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

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

Aquí hay otra presentación. Para mi vergüenza, supera la expresión regular. :(

Esto toma la cadena a través del argumento de la línea de comandos e imprime un booleano.

En cuanto al algoritmo, estoy bajando las letras después pde una en una y despuész por dos, y luego verifico que no haya colisiones después de la división de enteros por 3.

PD: Esta es la primera vez que usar Ruby 1.8 acorta el código (debido a la forma más corta de obtener códigos de caracteres).

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)

El bucle interno encuentra el grupo para cada personaje. Conceptualmente es un 'reducir' pero 'mapa' es más corto. El bucle externo compara el grupo de caracteres y salidas consecutivos con falso si son iguales.

Prueba en la consola 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)))

Salida

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 bytes

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

Haciendo un fuerte abuso de $ _ en Perl.

Dos tareas son complicadas en Python; detectando cadenas y asignando los grupos. Ambos pueden ser asistidos usando numpy, pero no está en la biblioteca estándar.

Python 2 (solo biblioteca estándar) - función de 59 caracteres

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 biblioteca estándar) - 53 caracteres stdin para salir del valor

Aquí abuso del hecho de que issubclass(bool,int), por lo tanto, cambiar all()a any()me da un valor de salida válido, eliminando not()el valor de retorno. La eliminación de la sobrecarga de la función hizo que las versiones regex se quedaran atrás en tamaño.

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 char

Función que toma una cuerda a la derecha.

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

Primero mapeamos el alfabeto ( u:97+i.26) en los números del 0 al 25, todos los demás caracteres (incluidos los espacios) van a 26 ( i.). Luego asignamos ( {~) los primeros tres elementos a la primera tecla, los siguientes tres a la siguiente tecla, y así sucesivamente a través de las teclas del teclado del teléfono, asegurándonos de asignar el espacio / otros signos de puntuación a una tecla separada al final . ( 4 3 4 1,~5#3es igual 3 3 3 3 3 4 3 4 1y lo I.convierte en una matriz de 27 elementos donde los tres primeros son la clave 1, etc.) Luego verificamos la desigualdad por pares ( 2~:/\) y Y todos los resultados juntos ( */).

   */@(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

Raqueta, 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))))

Sin golf (expresión combinatoria):

(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

No es un ganador, pero lo intenté. Supera a @Lozzaaa por 4 bytes al momento de publicar :)

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

Pasa todas las pruebas.
Aprovecha la falta de tipeo de JS para crear una matriz de tipos múltiples, y aprovecha la ventaja de indexOf return -1 para soporte de espacio.

Uso:

m("string here")

Asume solo caracteres alfabéticos en minúscula y espacios. Devuelve 1 para verdadero, 0 para falso.

Quizás si supiera ES6 podría intentar el segundo desafío ...

ES6, JavaScript 89 70 caracteres

Sé que no es un ganador porque cuando se trata de operaciones prácticas como obtener el valor ASCII del personaje, JS pone mucha hinchazón ( .charCodeAt()).

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

Ejecútelo en la consola web de la última versión de Firefox.

Uso:

N("testing if this works")

La función devuelve verdadero o falso.

EDITAR : Golfé mucho usando el [...x].everytruco aprendido de @ edc65 (¡Gracias!)

Intentaré jugar más al golf :)

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 caracteres

No es lo más corto que pude ir, pero lo hará por ahora

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)