Dieser Wettbewerb ist vorbei.

Der Gewinner ist CJam mit 22 Charakteren, der die Antwort von TwiNight um einen Charakter übertrifft . Glückwunsch Dennis !

Eine lobende Erwähnung geht an Falko , der von den kostenlosen Importen total verrückt geworden ist.

.

Vor einiger Zeit wollte ich wissen, wie ich moderne Smartphones mit meinem Nokia 3310 übertreffen kann, und obwohl einige Antworten wirklich gut waren, kann ich immer noch nicht mithalten! Vielleicht sollte ich einen anderen Ansatz wählen und einfach keine Wörter schreiben, die schwer zu tippen sind.

Wir rufen einen Text auf, der leicht zu tippen ist, wenn sich auf der Telefontastatur keine zwei aufeinanderfolgenden Buchstaben auf derselben Schaltfläche befinden, wenn das Standardlayout verwendet wird:

Deine Aufgabe

Ihre Aufgabe ist es, ein Programm / eine Funktion zu schreiben, das / die eine Zeichenfolge svon stdin / als Parameter sakzeptiert und einen Wahrheitswert zurückgibt, wenn dies leicht zu tippen ist, und einen falschen Wert, wenn dies nicht der Fall ist. Die Eingabe besteht nur aus Kleinbuchstaben und Leerzeichen und ist garantiert nicht leer!

Wertung

Das ist Codegolf, also gewinnt die niedrigste Anzahl an Charakteren.

Import - Anweisungen werden nicht auf Ihre Endnote gezählt werden, so dass , wenn Sie jemals Gebrauch gewünscht haben std::set_symmetric_difference, liftM4oder itertools.combinationsin Ihrem Code, jetzt ist die Zeit!

-3 wenn Ihr Quellcode leicht zu tippen ist, vorausgesetzt, alles, was kein Buchstabe ist, befindet sich auf Button 0. Schließlich möchte ich Ihren Code vielleicht an einige Freunde senden!

Testfälle

Hier sind einige Testfälle, um zu überprüfen, ob Ihr Code wie beabsichtigt funktioniert:

"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

Viel Spaß beim Golfen!

CJam, 34 31 27 22 Zeichen

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

Probieren Sie es online aus.

Beispiellauf

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

Wie es funktioniert

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

Hintergrund

Der Kern des Codes besteht darin, auf jedes Zeichen C der Eingabezeichenfolge eine Abbildung F anzuwenden , damit die Bilder der Symbole auf demselben Schlüssel übereinstimmen. Ich habe die passende Karte gefunden, indem ich Folgendes beobachtet habe:

Die Karte T: C ↦ (C - 'h') + 13 transformiert die Zeichenfolge S: = "abcdefghijklmnopqrstuvxyz" wie folgt:

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

Für die Schlüssel 0zu 6würde es genügen, T (C) durch 3 zu teilen , aber wir müssen eine Art Korrektur auf die Zeichen in s , t , v anwenden , y und z .

Die Karte D: C ↦ (C - 'h') / 9 transformiert den String S in folgendes 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]

Dies korrigiert die Quotienten von s , t , v , y und z , ohne die anderen zu beeinflussen.

Schließlich transformiert die Abbildung F: C ↦ (T (C) - D (C)) / 3 die Zeichenkette S wie folgt:

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

Alles was übrig bleibt ist, die aufeinanderfolgenden Zeichen irgendwie zu vergleichen. Zu diesem Zweck XOR F (C) mit dem Bild des vorherigen Zeichens - für das erste, wir XOR F (C) mit 1 (Standardwert der Variablen X ), die kein Vorbild hat - und multiplizieren alle Ergebnisse.

Das Produkt ist nur dann falsch, wenn einer der Faktoren Null ist, dh wenn zwei aufeinanderfolgende Zeichen dasselbe Bild von F haben .

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

Obwohl es jetzt ein bisschen lächerlich wird, werde ich weiterhin kostenlose Bibliotheksimporte verwenden, sogar die __builtin__Bibliothek:

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

Für die Codelänge zählt also nur die folgende kurze Zeile:

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

Dank an Markuz für die Ideen bezüglich input() ! Diese Herausforderungen des freien Imports führen Sie immer in einige weniger bekannte Bibliotheken ein. ;)

Alternativ nur mit der operatorBibliothek ( 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]))

Ich höre hier auf. Aber man konnte diese Version weiter Golf spielen mit sys, pprintund andere Bibliotheken ...

Alternative ohne Bibliotheken (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 (beliebteste Geschmacksrichtungen), 106 83 Bytes

Weil Regex

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

Ich habe gerade den Mittelsmann (Ruby) geschnitten und dies zu einer reinen Regex-Lösung gemacht. Funktioniert in vielen Geschmacksrichtungen und findet nur dann eine Übereinstimmung, wenn die Zeichenfolge nicht zwei aufeinanderfolgende Zeichen auf derselben Schaltfläche enthält.

Bash + Coreutils, 49

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

Gibt einen Exit-Code von 1 für TRUE und 0 für FALSE zurück:

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

Erläuterung

⍞: Nimmt Zeichenketteneingabe vom Bildschirm entgegen
⎕AV: Dies ist der atomare Vektor, der im Wesentlichen eine Zeichenkette aller Zeichen ist, die APL erkennt, und die natürlich alle Kleinbuchstaben (Index 18 ~ 43) und Leerzeichen (Index 5) enthält
⍳: IndexOfFunktion. Für viele Funktionen in APL, für die ein oder zwei skalare Argumente erforderlich sind, können Sie ein Array anstelle eines Skalars angeben. APL führt die Schleife für Sie aus. So ⍳gibt einen numerischen Array von Indizes. .21-.31×: Male 0,31 und subtrahiere dann von 0,21. Dies ist ein kleiner Trick, der Buchstaben auf derselben Taste (insbesondere PQRS) derselben Zahl zuordnet (wenn auf ganze Zahlen abgerundet), mit Ausnahme von Z, das seiner eigenen Gruppe zugeordnet wird
¯13⌈: maxmit -13. Dies bringt Z mit WXY zurück in die Gruppe
⌊: Auf ganze Zahlen abrunden
2≠/: Pairwise-≠. Gibt für jedes aufeinanderfolgende Paar ein boolesches Array zurück.
∧/: UND zusammen alle Einträge des resultierenden Arrays.

Perl - 44

Dies ist im Grunde eine Perl-Anpassung von @ DigitalTraumas Antwort, die mit seiner Erlaubnis veröffentlicht wurde. 2 Charaktere dank @KyleStrand abgeschnitten.

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

43 Zeichen + 1 für -pFlag. y///ist das gleiche wie tr///. Es druckt1 für wahr und nichts für falsch. Auf Anfrage kann ich eine ausführliche Erklärung abgeben.

Beispiellauf:

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 für -nFlagge. Es funktioniert, indem es verwendet wird join, um den regulären Ausdruck (der gleiche wie der von Martin) zu erstellen ), die Rasuren von wenigen Bytes.

Beispiellauf:

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

Gibt 1 für wahr und 0 für falsch zurück.

Wenn ich nur die Schlüsselwörter loswerden könnte.

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

Gibt einen Exit-Status ungleich Null für TRUE und 0 für FALSE zurück:

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

Hier ist eine weitere Einreichung. Zu meiner Schande schlägt es den Regex. :(

Dies nimmt die Zeichenfolge über ein Befehlszeilenargument und gibt einen Booleschen Wert aus.

Was den Algorithmus anbelangt, verschiebe ich die Buchstaben pnacheinander um eins und nacheinander zum zwei und überprüfe dann, ob es nach der Ganzzahldivision durch 3 keine Kollisionen gibt.

PS: Dies ist das erste Mal, dass mit Ruby 1.8 der Code verkürzt wurde (aufgrund der kürzeren Art, Zeichencodes zu erhalten).

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)

Die innere Schleife findet die Gruppe für jedes Zeichen. Konzeptionell ist eine "Verkleinerung", aber "Karte" ist kürzer. Die äußere Schleife vergleicht die Gruppe aufeinanderfolgender Zeichen und gibt false aus, wenn sie gleich sind.

Test In der Firefox / Firebug-Konsole

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

Ausgabe

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

Making heavy abuse of $_ in Perl.

Two tasks are tricky in Python; detecting chains, and assigning the groups. Both can be assisted using numpy, but it is not in the standard library.

Python 2 (only standard library) - 59 chars function

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 (only standard library) - 53 chars stdin to exit value

Here I abuse the fact that issubclass(bool,int), so changing all() to any() gets me a valid exit value, shaving off the not() from the return value. The removal of function overhead made the regex versions fall behind in size.

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

Function taking string on the right.

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

First we map the alphabet (u:97+i.26) into the numbers 0 through 25, all other characters (including spaces) going to 26 (i.). Then we map ({~) the first three elements map to the first key, the next three to the next key, and so on through the keys of the phone pad, making sure to map the space/other punctuation to a separate key at the end. (4 3 4 1,~5#3 is equal to 3 3 3 3 3 4 3 4 1 and I. turns that into a 27-item array where the first three are key 1, etc.) Then we check for pairwise inequality (2~:/\) and AND all the results together (*/).

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

Racket, 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 (combinatoric regexing):

(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

Not a winner but I gave it a shot. Beats @Lozzaaa by 4 bytes as of posting time :)

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

Passes all the tests.
Takes advantage of JS's lack of typing to make a multi type array, and it takes advantage of indexOf returning -1 for space support.

Usage:

m("string here")

Assumes lowercase alphabetic characters and spaces only. Returns 1 for true, 0 for false.

Maybe if I knew ES6 I could try the second challenge...

ES6, JavaScript 89 70 characters

I know its not a winner because when coming to handy operations like getting ASCII value of character, JS puts a lot of bloat (.charCodeAt()).

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

Run it in Web Console of latest Firefox.

Usage:

N("testing if this works")

The function returns either true or false.

EDIT: Golfed a lot using the [...x].every trick learned from @edc65 (Thanks!)

I will try to golf it more :)

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 chars

Not the shortest I could go, but it'll do for now

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)