Cette compétition est terminée.

Le gagnant est CJam avec 22 caractères, battant la réponse de TwiNight par un caractère. Félicitations Dennis !

Une mention honorable va à Falko , qui est devenu complètement fou avec les importations gratuites.

.

Il y a quelque temps, je voulais savoir comment surpasser les smartphones modernes avec mon Nokia 3310, et même si certaines réponses étaient vraiment bonnes, je n'arrive toujours pas à suivre! Je devrais peut-être adopter une approche différente et ne pas écrire de mots difficiles à taper.

Nous appellerons un morceau de texte facilement saisissable s'il n'y a pas deux lettres consécutives sur le même bouton du clavier du téléphone, étant donné la disposition standard:

Ta tâche

Votre tâche consiste à écrire un programme / une fonction qui accepte une chaîne sde stdin / comme paramètre et renvoie une valeur véridique si elle sest facilement typable et une valeur falsifiée dans le cas contraire. L'entrée se composera uniquement de lettres minuscules et d'espaces et est garantie d'être non vide!

Notation

Il s'agit de codegolf, donc le nombre de caractères le plus bas l'emporte.

Les instructions d'importation ne seront pas prises en compte pour votre score final, donc si vous avez toujours voulu utiliser std::set_symmetric_difference, liftM4ou itertools.combinationsdans votre code, est maintenant le temps!

-3 si votre code source est facilement saisissable, en supposant que tout ce qui n'est pas une lettre est sur le bouton 0. Après tout, je pourrais vouloir envoyer votre code à des amis!

Cas de test

Voici quelques tests pour vérifier si votre code fonctionne comme prévu:

"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

Bon golf!

CJam, 34 31 27 22 caractères

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

Essayez-le en ligne.

Exemple d'exécution

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

Comment ça marche

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

Contexte

Le cœur du code consiste à appliquer une mappe F à chaque caractère C de la chaîne d'entrée afin que les images des symboles sur la même clé correspondent. J'ai trouvé la carte appropriée en observant ce qui suit:

La carte T: C ↦ (C - 'h') + 13 transforme la chaîne S: = "abcdefghijklmnopqrstuvxyz" comme suit:

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

Pour les touches 0de 6, il suffirait de diviser T (C) par 3 , mais nous devons appliquer une sorte de correction aux caractères de s , t , v , y et z .

La carte D: C ↦ (C - 'h') / 9 transforme la chaîne S dans le tableau suivant:

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

Cela corrige les quotients de s , t , v , y et z , sans affecter les autres.

Enfin, la carte F: C ↦ (T (C) - D (C)) / 3 transforme la chaîne S comme suit:

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

Il ne reste plus qu'à comparer les personnages consécutifs d'une manière ou d'une autre. Pour cela, nous XOR F (C) avec l'image du caractère précédent - pour le premier, nous XOR F (C) avec 1 (valeur par défaut de la variable X ), qui n'a pas de pré-image - et multiplions tous les résultats.

Le produit sera falsy si et seulement si l' un des facteurs est égal à zéro, à savoir, si et seulement si deux caractères consécutifs ont la même image par F .

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

Même si cela devient un peu ridicule maintenant, je continuerai à utiliser les importations de bibliothèque gratuites, même la __builtin__bibliothèque:

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

Ainsi, seule la ligne courte suivante compte pour la longueur du code:

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

Remerciements à Markuz pour les idées concernant input()! Ces défis d'importation gratuite vous présentent toujours des bibliothèques moins connues. ;)

Alternative utilisant uniquement la operatorbibliothèque ( 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]))

Je m'arrête ici. Mais vous pouvez approfondir cette version en utilisant sys, pprintet d'autres bibliothèques ...

Alternative sans bibliothèques (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 (saveurs les plus populaires), 106 83 octets

Parce que regex

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

Je viens de couper l'intermédiaire (Ruby) et en ai fait une solution pure-regex. Fonctionne dans beaucoup de saveurs et ne trouve une correspondance que si la chaîne ne contient pas deux caractères consécutifs sur le même bouton.

Bash + coreutils, 49

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

Renvoie un code de sortie de 1 pour VRAI et de 0 pour FAUX:

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

Explication

⍞: Prend l'entrée de chaîne de l'écran
⎕AV: C'est le vecteur atomique qui est fondamentalement une chaîne de tous les caractères reconnus par APL, qui comprend bien sûr toutes les lettres minuscules (index 18 ~ 43) et l'espace (index 5)
⍳: IndexOffonction. Pour de nombreuses fonctions dans APL qui prennent un ou deux arguments scalaires, vous pouvez lui fournir un tableau à la place d'un scalaire - APL fera la boucle pour vous. ⍳Retourne donc un tableau numérique d'indices. .21-.31×: Fois 0,31 puis soustraire de 0,21. C'est une petite astuce qui mappe une lettre sur la même clé (en particulier PQRS) au même nombre (lorsqu'il est arrondi à des entiers), sauf Z, qui est mappé à son propre groupe
¯13⌈: maxavec -13. Cela ramène Z au groupe avec WXY
⌊: Arrondir aux nombres entiers
2≠/: Pairwise-≠. Renvoie un tableau booléen pour chaque paire consécutive.
∧/: ET ensemble toutes les entrées du tableau résultant.

Perl - 44

Il s'agit essentiellement d'une adaptation Perl de la réponse de @ DigitalTrauma publiée avec sa permission. Rasé 2 caractères grâce à @KyleStrand.

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

43 caractères + 1 pour le -pdrapeau. y///est le même que tr///. Il imprime 1pour le vrai et rien pour le faux. Je peux poster une explication détaillée sur demande.

Exemple d'exécution:

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 pour le -ndrapeau. Il fonctionne en utilisant joinpour créer l'expression régulière (la même que celle de Martin ), qui rase de quelques octets.

Exemple d'exécution:

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 octets

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

Renvoie 1 pour la vérité et 0 pour la fausse.

Si seulement je pouvais me débarrasser des mots-clés.

c, 74 octets

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

Renvoie un état de sortie non nul pour TRUE et 0 pour 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 octets

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

Voici une autre soumission. À ma honte, il bat le regex. :(

Cela prend la chaîne via un argument de ligne de commande et affiche un booléen.

En ce qui concerne l'algorithme, je décale les lettres après ppar une et après zpar deux, puis je vérifie qu'il n'y a pas de collisions après la division entière par 3.

PS: C'est la première fois que l'utilisation de Ruby 1.8 raccourcit le code (en raison de la manière plus courte d'obtenir les codes de caractères).

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)

La boucle intérieure trouve le groupe pour chaque personnage. Conceptuellement, c'est une «réduction», mais une «carte» est plus courte. La boucle externe compare le groupe de caractères consécutifs et les sorties avec false si elles sont égales.

Tester dans la 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)))

Sortie

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 octets

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

Faire de gros abus de $ _ en Perl.

Deux tâches sont délicates en Python; détecter les chaînes et attribuer les groupes. Les deux peuvent être assistés à l'aide de numpy, mais ce n'est pas dans la bibliothèque standard.

Python 2 (uniquement bibliothèque standard) - fonction 59 caractères

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 (uniquement bibliothèque standard) - 53 caractères stdin pour quitter la valeur

Ici, j'abuse du fait que issubclass(bool,int), donc changer all()pour any()obtenir une valeur de sortie valide, raser not()la valeur de retour. La suppression de la surcharge de fonction a fait prendre du retard aux versions regex.

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 caractères

Fonction prenant la chaîne à droite.

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

Tout d'abord, nous mappons l'alphabet ( u:97+i.26) sur les chiffres de 0 à 25, tous les autres caractères (y compris les espaces) allant à 26 ( i.). Ensuite, nous mappons ( {~) les trois premiers éléments mappent à la première clé, les trois suivants à la clé suivante, et ainsi de suite à travers les touches du clavier du téléphone, en veillant à mapper l'espace / autre ponctuation à une clé distincte à la fin . ( 4 3 4 1,~5#3est égal à 3 3 3 3 3 4 3 4 1et le I.transforme en un tableau de 27 éléments où les trois premiers sont la clé 1, etc.) Ensuite, nous vérifions l'inégalité par paire ( 2~:/\) et ET tous les résultats ensemble ( */).

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

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

Non golfé (regexing combinatoire):

(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

Pas un gagnant mais je lui ai donné un coup de feu. Beats @Lozzaaa de 4 octets au moment de la publication :)

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

Réussit tous les tests.
Profite du manque de typage de JS pour créer un tableau multi-types et profite de l'indexOf renvoyant -1 pour la prise en charge de l'espace.

Usage:

m("string here")

Suppose des caractères alphabétiques en minuscules et des espaces uniquement. Renvoie 1 pour vrai, 0 pour faux.

Peut-être que si je connaissais ES6, je pourrais essayer le deuxième défi ...

ES6, JavaScript 89 70 caractères

Je sais que ce n'est pas un gagnant parce que quand il s'agit d'opérations pratiques comme obtenir la valeur ASCII du caractère, JS met beaucoup de ballonnement ( .charCodeAt()).

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

Exécutez-le dans la console Web de la dernière version de Firefox.

Usage:

N("testing if this works")

La fonction renvoie true ou false.

EDIT : Golfé beaucoup en utilisant le [...x].everytruc appris de @ edc65 (Merci!)

Je vais essayer de jouer au golf plus :)

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 caractères

Pas le plus court possible, mais ça suffira pour l'instant

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)