Пароль епископа Боже

10

Получено из этого , сейчас удалено, пост.

Если дана строка, ответьте (правда / ложно или два непротиворечивых значения), если она представляет собой хороший пароль епископа, то есть когда выполняются все следующие условия:

  1. в нем не менее 10 символов

  2. в нем как минимум 3 цифры ( [0-9])

  3. это не палиндром (идентичный самому себе при обращении)

Вы получаете бонус в 0 байт, если ваш код - хороший пароль епископа.

Предупреждение: Do не использовать Bishop Совершенства как мера фактической силы пароля!

Примеры

Хорошие епископские пароли

PPCG123GCPP
PPCG123PPCG
PPCG123gcpp
0123456789
Tr0ub4dor&3

Не Хорошие Епископские пароли

PPCG123 (слишком короткий)
correct horse battery staple (недостаточно цифр)
PPCG121GCPP (палиндром)
 (слишком короткий и недостаточно цифр)
abc121cba (слишком короткий и палиндром)
aaaaaaaaaaaa (палиндром и недостаточно цифр)
abc99cba (все неправильно)

code-golf string decision-problem palindrome Адам
источник
@KrystosTheOverlord Термин определен в этой самой задаче. ;-P
Эрик Outgolfer
9
О, я ожидал некоторых правил логики паролей в шахматах ...
Берги
1
Я прочитал все ответы, и никто не претендовал на бонус.
Веска
1
@JDL, вы действительно можете вычесть 0 байтов из вашего счета, если вы имеете право на этот очень реальный бонус! Чего ты ждешь?
Аарон
1
Один из ваших критериев на самом деле противоположен тому, что предложил Бишоп (2013). Он предположил, что пароли должны быть не более 10 символов.
PyRulez

Ответы:

5

Python 2 , 61 59 54 51 байт

lambda s:sum(map(str.isdigit,s))>2<s[:9]<s<>s[::-1]

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

-5 байт, благодаря Эрику-аутголферу
-3 байт, благодаря xnor

TFeld
источник
Чу Чу!
Эрик Outgolfer
@EriktheOutgolfer Спасибо :)
TFeld
Вы можете выполнить проверку длины как s[:9]<s, которая хорошо сочетается с проверкой без палиндрома:s[:9]<s!=s[::-1]
xnor
@xnor Спасибо :)
TFeld
4

05AB1E , 12 байтов

gT@Iþg3@IÂÊP

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

g      # Get the length of the (implicit) input
 T@    # Check if this length >= 10
Iþ     # Get the input and only leave the digits
  g    # Then get the length (amount of digits)
   3@  # And check if the amount of digits >= 3
IÂ     # Get the input and the input reversed
  Ê    # Check if they are not equal (so not a palindrome)
P      # Check if all three above are truthy (and output implicitly)
Кевин Круйссен
источник
4

R , 80 70 62 64 63 байта

any(rev(U<-utf8ToInt(scan(,'')))<U)&sum(U>47&U<58)>2&sum(U|1)>9

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

От digEmAll, а некоторые тоже переставляют

sum((s<-el(strsplit(scan(,''),"")))%in%0:9)>2&!all(s==rev(s))&s[10]>''

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

Довольно просто, никаких удивительных трюков здесь нет. После ввода пользователем строки:

  • Разделяет и ищет в строке более 2 чисел. (3 или более цифр)
  • Проверяет, не все ли элементы совпадают с обращенной версией строки (палиндром)
  • Проверяет, что длина больше 9 (10 или более символов)
Sumner18
источник
Я думаю , вы можете заменить !all(s==rev(s))с any(s!=rev(s))которой будет сохранить один байт. Я чувствую, что проверка длины тоже может быть уменьшена, но я не уверен, как это сделать (какой-либо ncharили какой-то sum(x|1)хак)
JDL
1
на самом деле, я думаю any(s>rev(s)), сработает - если символ меньше своего палиндромного аналога, то на другом конце пароля обратное утверждение будет верным. Это сохраняет еще один байт.
JDL
2
62 байта, используя utf8ToInt
digEmAll
1
@digEmAll ваш пример возвращает true, когда есть только одно число, вам нужно будет включить>2
Аарон Хейман
1
64 но правильно;)
digEmAll
3

APL + WIN, 36, 30 29 байт

7 байтов сохранено благодаря Адаму

Индекс происхождения = 0

Запрашивает ввод строки

(10≤⍴v)×(3≤+/v∊∊⍕¨⍳10)>v≡⌽v←⎕

Попробуйте онлайн! Предоставлено Dyalog Classic

Объяснение:

(10≤⍴v) Length test pass 1 fail 0

(3≤+/v∊∊⍕¨⍳10) Number of digits test

>v≡⌽v Palindrome test

Код также подходит для бонуса, поскольку это хороший пароль епископа.

Грэхем
источник
@Адам. Спасибо за сохранение 6 байтов. На ⎕IO согласился. V≡⌽V работает нормально, если я предпочитаю ~. Что касается использования x, я склонен использовать его при объединении булевых тестов. Тот же результат, такое же количество байтов.
Грэхем
Есть ли у вас ≢что ~... ≡? И даже если вы этого не сделаете, вы можете слиться ×~в>
Адам
@ Adám Нет, у меня нет ≢. Я могу объединить × ~ в> еще один байт. Спасибо. Боюсь, моя «игра в
Грэм,
3

Брахилог , 18 12 байт

Спасибо за советы, Kroppeb и Fatalize !

¬↔?l>9&ịˢl>2

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

объяснение

Программа представляет собой один предикат, состоящий из двух частей, которые связаны друг с другом &.

Первый:

¬       The following assertion must fail:
 ↔        The input reversed
  ?       can be unified with the input
        Also, the input's
   l    length
    >9  must be greater than 9

Во-вторых:

 ˢ     Get all outputs from applying the following to each character in the input:
ị        Convert to number
       This gives an integer for a digit character and fails for a non-digit, so
       we now have a list containing one integer for each digit in the password
  l    Its length
   >2  must be greater than 2
DLosc
источник
{∋.∈Ị∧}ᶜможет быть{∋ị}ᶜ
Kroppeb
Поместив сначала «не палиндром» и изменив способ выбора цифр, вы можете сохранить 6 байтов:¬↔?l>9&ịˢl>2
Fatalize
@ Kroppeb О, интересно! Я не учел ị, но имеет смысл, что это будет успешно, если персонаж будет цифрой. Спасибо!
DLosc
@ Fatalize Ага - повторное использование ?подобного, это аккуратно. Спасибо!
DLosc
2

Желе , 12 байт

~Tṫ3ȧL9<Ɗ>ṚƑ

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

[]если не достаточно цифр (пустой список, ложь), 0если в противном случае плохой (ноль, ложь), 1если хороший (ненулевой, правдивый).

Эрик Outgolfer
источник
2

Java 8, 92 байта

s->s.length()>9&s.replaceAll("\\D","").length()>2&!s.contains(new StringBuffer(s).reverse())

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

Объяснение:

s->                        // Method with String parameter and boolean return-type
  s.length()>9             //  Check if the length of the input-String is more than 9
  &s.replaceAll("\\D","")  //  AND: remove all non-digits from the input-String
    .length()>2            //       and check if the amount of digits is more than 2
  &!s.contains(new StringBuffer(s).reverse())
                           //  AND: check if the input-String does NOT have the reversed
                           //       input-String as substring (and thus is not a palindrome)
Кевин Круйссен
источник
2

JavaScript, 60 56 46 байт

Принимает ввод как массив символов. Выходы 1для правды и 0фальсея.

s=>/(\d.*){3}/.test(s[9]&&s)&s+``!=s.reverse()

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

Сохранено 10 байтов (!) Благодаря Арно .

мохнатый
источник
2

APL (Dyalog Unicode) , 25 байтов SBCS

{∧/(9<≢⍵)(3≤+/⍵∊⎕D),⍵≢⌽⍵}

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

voidhawk
источник
1
Хорошо. Теперь вы можете сыграть в гольф, превратив его в поезд, (9<≢)∧(3≤1⊥∊∘⎕D)∧⊢≢⌽а затем сохранить еще один байт, переставив, чтобы избежать скобок: (9<≢)∧≢∘⌽⍨∧3≤1⊥∊∘⎕Dдайте им знать, если вам нужно объяснение этих шагов.
Адам
1

Perl 5 -p, 33 байта

$_=/.{10}/&y/0-9//>2&reverse ne$_

TIO

Науэль Фуйе
источник
1

Чистый , 66 байт

import StdEnv
$s=s<>reverse s&&s%(0,8)<s&&sum[1\\c<-s|isDigit c]>2

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

  • s<>reverse s: s Не палиндром
  • s%%(0,8)<s: первые 9 символов sменьше, чем всеs
  • sum[1\\c<-s|isDigit c]>2: sимеет более двух цифр
Οurous
источник
1

Сетчатка 0.8.2 , 40 байт

G`.{10}
G`(\d.*){3}
+`^(.)(.*)\1$
$2
^..

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Объяснение:

G`.{10}

Проверяет не менее 10 символов.

G`(\d.*){3}

Проверяет не менее 3 цифр.

+`^(.)(.*)\1$
$2

Удалите первый и последний символ, если они совпадают.

^..

Если есть хотя бы 2 символа, то это не палиндром.

Балансирующие группы .NET означают, что это можно сделать в одном регулярном выражении, но это занимает 47 байтов:

^(?!(.)*.?(?<-1>\1)*$(?(1).))(?=.{10})(.*\d){3}

Попробуйте онлайн! Ссылка включает в себя тестовые случаи.

Нил
источник
1

Python 3 , 74 72 64 байта

Спасибо Нейлу А. за -2 байта!
Спасибо Джо Кингу за -8 байт! 

lambda s:s[9:]and re.findall('\d',s)[2:]and s[::-1]!=s
import re

Объяснение:

lambda s: # Create lambda                                          
           s[9:] # Check if the string is at least 10 characters long                                 
                     and re.findall('\d',s)[2:] #Check for at least 3 matches of the regex \d (which matches all digits)
                     and s[::-1] != s # Check if the string reversed is equal to the string (palindrome test)
import re  # Import regex module

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

Эпичность
источник
-2 байта, сдвигая скобки вокруг
Нил А.
1

Perl 6 , 32 байта

{$_ ne.flip&&m:g/\d/>2&&.comb>9}

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

Блок анонимного кода, который просто обеспечивает соблюдение всех правил.

Объяснение:

{          &&         &&       }  # Anonymous code block
 $_ ne.flip                       # Input is not equal to its reverse
             m:g/\d/>2            # There are more than two digits
                        .comb>9   # There are more than 9 characters
Джо Кинг
источник
1

K (ок) , 31 28 байт

-3 байта благодаря ngn!

{(x~|x)<(2<#x^x^/$!10)*9<#x}

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

Гален Иванов
источник
1
Вы можете использовать +//(сумма до сходимости) вместо +/+/(сумма сумма)
нг
1
в качестве альтернативы, вы можете использовать , x^x^yчтобы найти пересечение между двумя списками: #x^x^,/!10. это может быть сокращено до #x^x^/!10( ^«без», x^/... is- ^сокращение с начальным значением x)
ngn
1
еще одна вещь, >(или <) может использоваться как «и не»:{(x~|x)<(2<#x^x^/$!10)*9<#x}
ngn
@ngn Спасибо! Хороший способ найти перекресток!
Гален Иванов
0

Пип , 19 байт

#a>9&XD Na>2&aNERVa

Попробуйте онлайн! (все тесты)

объяснение

С aбудучи первым аргументом командной строки:

#a > 9      Length of a is greater than 9
&           and
XD N a > 2  Number of matches of regex [0-9] iN a is greater than 2
&           and
a NE RV a   a is not (string-)equal to reverse of a
DLosc
источник
0

Pyth, 17 байт

&&<2l@`MTQ<9lQ!_I

Попробуйте онлайн здесь или проверьте все тестовые примеры сразу здесь .

&&<2l@`MTQ<9lQ!_IQ   Implicit: Q=eval(input()), T=10
                     Trailing Q inferred
      `MT            [0-10), as strings
     @   Q           Take characters from input which are in the above
    l                Length
  <2                 Is the above greater than 2?
            lQ       Length of Q
          <9         Is the above greater than 9?
               _IQ   Is Q unchanged after reversal?
              !      Logical NOT
&&                   Logical AND the three results together
Sok
источник
0

Groovy, (47 байт)

{p->p=~/.{10}/&&p=~/(\d.*){3}/&&p!=p.reverse()}

(Бонусное включение оставлено читателю в качестве упражнения)

randomsimon
источник