Этот конкурс окончен.

Победителем стал CJam с 22 персонажами, победивший ответ TwiNight одним персонажем. Поздравляем Дениса !

Похвальная грамота идет Фалько , который сошел с ума от бесплатного импорта.

,

Некоторое время назад я хотел знать, как я могу превзойти современные смартфоны с моей Nokia 3310, и хотя некоторые ответы были действительно хорошими, я все еще не могу идти в ногу! Может быть, я должен использовать другой подход и просто не писать слова, которые неудобно набирать.

Мы назовем фрагмент текста легко набираемым, если на одной клавиатуре телефонной клавиатуры нет двух последовательных букв, учитывая стандартную раскладку:

Твое задание

Ваша задача - написать программу / функцию, которая принимает строку sиз stdin / в качестве параметра и возвращает истинное значение, если sего легко ввести, и ложное значение в противном случае. Ввод будет состоять только из строчных букв и пробелов и гарантированно будет непустым!

счет

Это Codegolf, поэтому выигрывает меньшее количество символов.

Заявления на импорт не будут засчитаны ваш окончательный счет, так что если вы когда - либо хотели использовать std::set_symmetric_difference, liftM4или itertools.combinationsв вашем коде, сейчас самое время!

-3, если ваш исходный код легко набирается, при условии, что все, что не является буквой, находится на кнопке 0. В конце концов, я мог бы хотеть сообщить ваш код некоторым друзьям!

Testcases

Вот несколько тестов, чтобы проверить, работает ли ваш код так, как задумано:

"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

Удачного игры в гольф!

CJam, 34 31 27 22 персонажа

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

Попробуйте онлайн.

Пример запуска

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

Как это работает

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

Задний план

Суть кода состоит в применении карты F к каждому символу C входной строки, чтобы изображения символов на одном и том же ключе совпадали. Я нашел подходящую карту, наблюдая следующее:

Карта T: C ↦ (C - 'h') + 13 преобразует строку S: = "abcdefghijklmnopqrstuvxyz" следующим образом:

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

Для ключей 0к 6, было бы достаточно , чтобы разделить T (C) на 3 , но мы должны применить какой - то коррекции к персонажам в ы , т , V , у и г .

Карта D: C ↦ (C - 'h') / 9 преобразует строку S в следующий массив:

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

Это исправляет коэффициенты s , t , v , y и z , не влияя на другие.

Наконец, карта F: C ↦ (T (C) - D (C)) / 3 преобразует строку S следующим образом:

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

Осталось только сравнить последовательные символы как-то. Для этого мы XOR F (C) с изображением предыдущего символа - для первого мы XOR F (C) со значением 1 (значение по умолчанию для переменной X ), которое не имеет прообраза, - и умножаем все результаты.

Продукт будет falsy тогда и только тогда , когда один из факторов равен нулю, то есть, если и только если два последовательных символа имеют один и тот же образ на F .

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

Несмотря на то, что сейчас это немного смешно, я буду продолжать использовать бесплатный импорт библиотеки, даже __builtin__библиотеки:

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

Таким образом, только следующая короткая строка учитывает длину кода:

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

Кредиты Маркуз за идеи относительно input()! Эти проблемы бесплатного импорта всегда знакомят вас с некоторыми менее известными библиотеками. ;)

Альтернатива с использованием только operatorбиблиотеки ( 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]))

Я остановлюсь здесь. Но вы могли бы в дальнейшем в гольф эту версию , используя sys, pprintи другие библиотеки ...

Альтернатива без библиотек (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 (самые популярные вкусы), 106 83 байта

Потому что регулярное выражение

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

Я только что сократил посредника (Ruby) и сделал это решение с использованием регулярных выражений. Работает во многих вариантах и ​​находит совпадение только в том случае, если строка не содержит двух последовательных символов на одной кнопке.

Bash + coreutils, 49

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

Возвращает код выхода 1 для TRUE и 0 для 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
$ 

АПЛ (Дьялог), 24 23

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

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

объяснение

⍞: Принимает строковый ввод с экрана
⎕AV: это атомный вектор, который в основном является строкой всех символов, распознаваемых APL, которые, конечно, включают все строчные буквы (индекс 18 ~ 43) и пробел (индекс 5)
⍳: IndexOfфункция. Для многих функций в APL, которые принимают один или два скалярных аргумента, вы можете передать их вместо скалярного массива - APL сделает цикл за вас. Так ⍳возвращает числовой массив индексов. .21-.31×: Времена 0,31, а затем вычесть из 0,21. Это небольшая хитрость, которая отображает буквы на одном и том же ключе (особенно PQRS) на одно и то же число (при округлении до целых чисел), за исключением Z, который отображается в свою собственную группу
¯13⌈: maxс -13. Это возвращает Z обратно в группу с WXY: округлить
⌊до целых чисел
2≠/: Pairwise-≠ . Возвращает логический массив для каждой последовательной пары.
∧/: И вместе все записи результирующего массива.

Perl - 44

Это в основном Perl-адаптация ответа @ DigitalTrauma, опубликованного с его разрешения. Сбрил 2 символа благодаря @KyleStrand.

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

43 символа + 1 для -pфлага. y///так же, как tr///. Он печатает 1за правду и ничего за ложь. Я могу опубликовать подробное объяснение, если требуется.

Пример выполнения:

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 за -nфлаг. Он работает, используя joinдля создания регулярного выражения (тот же, что и у Мартина ), которое сбрасывает несколько байтов.

Пример выполнения:

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 байт

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

Возвращает 1 для правдивых и 0 для ложных.

Если бы я только мог избавиться от ключевых слов.

с, 74 байта

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

Возвращает ненулевой статус выхода для TRUE и 0 для 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
$ 

Рубин 1,8, 89 83 81 78 байт

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

Вот еще одно представление. К моему стыду, это бьет регулярное выражение. :(

Это берет строку через аргумент командной строки и печатает логическое значение.

Что касается алгоритма, я сдвигаю буквы после pодного на один и послеz на две, а затем проверяю, нет ли коллизий после целочисленного деления на 3.

PS: Впервые Ruby 1.8 сократил код (из-за более короткого способа получения кодов символов).

Кобра - 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)

Внутренний цикл поиска группы для каждого символа. Концептуально это «уменьшить», но «карта» короче. Внешний цикл сравнивает группу последовательных символов и выходов с ложным, если они равны.

Тест In 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)))

Выход

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 байта

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

Злоупотребление $ _ в Perl.

Две задачи сложны в Python; обнаружение цепочек и назначение групп. И то, и другое можно использовать с помощью numpy, но его нет в стандартной библиотеке.

Python 2 (только стандартная библиотека) - функция 59 символов

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 (только стандартная библиотека) - 53 символа stdin для выхода из значения

Здесь я злоупотребляю тем фактом, что issubclass(bool,int)при переходе all()к any()действительному значению выхода я сбрасываю его not()с возвращаемого значения. Удаление служебных функций привело к отставанию версий регулярных выражений.

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 символа

Функция взятия строки справа.

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

Сначала мы сопоставляем алфавит ( u:97+i.26) с номерами от 0 до 25, все остальные символы (включая пробелы) переходят в 26 ( i.). Затем мы сопоставляем ( {~) первые три элемента, которые сопоставляются с первой клавишей, следующие три - со следующей клавишей и т. Д. С помощью клавиш телефонной панели, проверяя соответствие пробела / другой пунктуации отдельной клавише в конце , ( 4 3 4 1,~5#3равно 3 3 3 3 3 4 3 4 1и I.превращает его в массив из 27 элементов, где первые три являются ключом 1 и т. д.) Затем мы проверяем парное неравенство ( 2~:/\) и И все результаты вместе ( */).

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

Ракетка, 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 (комбинаторное регулярное выражение):

(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

Не победитель, но я дал ему шанс. Превосходит @Lozzaaa на 4 байта на момент публикации :)

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

Проходит все тесты.
Использует отсутствие в JS типизации для создания многотипного массива, а также использует indexOf, возвращающий -1 для поддержки пространства.

Использование:

m("string here")

Предполагается только строчные буквенные символы и пробелы. Возвращает 1 для истины, 0 для ложных.

Может быть, если бы я знал ES6, я мог бы попробовать второй вызов ...

ES6, JavaScript 89 70 символов

Я знаю, что это не победитель, потому что когда дело доходит до полезных операций, таких как получение ASCII-значения символа, JS добавляет много bloat ( .charCodeAt()).

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

Запустите его в веб-консоли последней версии Firefox.

Использование:

N("testing if this works")

Функция возвращает либо true, либо false.

РЕДАКТИРОВАТЬ : много играл в гольф, используя[...x].every трюк, извлеченный из @ edc65 (спасибо!)

Я постараюсь в гольф это больше :)

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 символа

Не самое короткое, на что я мог пойти, но пока подойдет

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)