Senha Bishop Goodness

10

Derivado desta postagem, agora excluída.

Dada uma sequência, responda (verdade / falsidade ou dois valores consistentes) se constitui uma boa senha de bispo, ou seja, quando todas as seguintes condições são atendidas:

  1. tem pelo menos 10 caracteres

  2. tem pelo menos 3 dígitos ( [0-9])

  3. não é um palíndromo (idêntico a si mesmo quando invertido)

Você recebe um bônus de 0 bytes se o seu código for uma boa senha de bispo.

Aviso: Do não usar Bishop bondade como uma medida de força da senha real!

Exemplos

Senhas do bom bispo

PPCG123GCPP
PPCG123PPCG
PPCG123gcpp
0123456789
Tr0ub4dor&3

Senhas do Bispo Não Bom

PPCG123 (muito curto)
correct horse battery staple (dígitos insuficientes)
PPCG121GCPP (palíndromo)
 ( dígitos muito curtos e insuficientes)
abc121cba (muito curto e palíndromo)
aaaaaaaaaaaa (palíndromo e dígitos insuficientes)
abc99cba (tudo errado)

code-golf string decision-problem palindrome Adão
fonte
@KrystosTheOverlord O termo é definido neste desafio. ;-P
Erik the Outgolfer,
9
Ah, eu estava esperando algumas regras de senha lógica de xadrez ...
Bergi
11
Eu li todas as respostas e nenhuma reivindicou o bônus.
Veskah 13/02/19
11
@JDL, você realmente consegue subtrair 0 bytes da sua pontuação se se qualificar para esse bônus muito real! O que você está esperando?
Aaron
11
Um de seus critérios é, na verdade, o inverso do que Bishop (2013) propôs. Ele propôs que as senhas devessem ter 10 caracteres ou menos, não mais.
PyRulez 17/02/19

Respostas:

5

Python 2 , 61 59 54 51 bytes

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

Experimente online!

-5 bytes, graças a Erik, o Outgolfer
-3 bytes, graças ao xnor

TFeld
fonte
Choo choo!
Erik the Outgolfer
@EriktheOutgolfer Thanks :) #
TFeld
Você pode fazer a verificação do comprimento como s[:9]<s, que combina bem com a verificação não palíndromo:s[:9]<s!=s[::-1]
xnor
@xnor Thanks :) #
TFeld
4

05AB1E , 12 bytes

gT@Iþg3@IÂÊP

Experimente online ou verifique todos os casos de teste .

Explicação:

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)
Kevin Cruijssen
fonte
4

R , 80 70 62 64 63 bytes

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

Experimente online!

De digEmAll, e algumas reorganizações também

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

Experimente online!

Bem simples, sem truques realmente incríveis aqui. Após o usuário inserir a string:

  • Separa e procura na string mais de 2 números. (3 ou mais dígitos)
  • Verifica se nem todos os elementos são iguais à versão invertida da sequência (palíndromo)
  • Verifica se o comprimento é maior que 9 (10 ou mais caracteres)
Sumner18
fonte
Eu acho que você pode substituir !all(s==rev(s))com o any(s!=rev(s))que salvará um byte. Eu me sinto como a verificação de comprimento pode ser reduzida também, mas não sei como (seja ncharou algum tipo de sum(x|1)corte)
JDL
11
na verdade, acho any(s>rev(s))que funcionará --- se um caractere for menor que seu equivalente palindrômico, no outro extremo da senha o inverso será verdadeiro. Isso economiza outro byte.
JPL
2
62 bytes usando utf8ToInt
digEmAll 14/02/19
11
@digEmAll seu exemplo retorna verdadeiro quando houver apenas um número, você precisará incluir um #>2
Aaron Hayman
11
64 mas correto;)
digEmAll 15/02/19
3

APL + WIN, 36, 30 29 bytes

7 bytes salvos graças a Adám

Origem do índice = 0

Solicita a sequência de entrada

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

Experimente online! Cortesia de Dyalog Classic

Explicação:

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

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

>v≡⌽v Palindrome test

O código também se qualifica para o bônus, pois é uma boa senha de bispo.

Graham
fonte
@Adão. Obrigado por salvar 6 bytes. Em ⎕IO concordou. v≡⌽v funciona bem se eu acrescentar ~. Quanto ao uso de x, eu costumo usá-lo ao juntar testes booleanos. Mesmo resultado, mesmo número de bytes.
Graham
Você tem o ≢que é ~... ≡? E mesmo se não o fizer, você pode se fundir ×~em:>
Adám
@ Adám Não, eu não tenho ≢. Eu posso mesclar × ~ em> por mais um byte. Obrigado. Temo meu "colocando jogo" ainda precisa de mais prática;)
Graham
3

Braquilog , 18 12 bytes

Obrigado pelas dicas, Kroppeb e Fatalize !

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

Experimente online!

Explicação

O programa é um único predicado, composto por duas partes encadeadas &.

Primeiro:

¬       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

Segundo:

 ˢ     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
fonte
{∋.∈Ị∧}ᶜpode ser{∋ị}ᶜ
Kroppeb 14/02/19
Colocando a cláusula "not palindrome" em primeiro lugar e alterando a maneira de selecionar dígitos, você pode salvar 6 bytes:¬↔?l>9&ịˢl>2
Fatalize 14/02/19
@Kroppeb Oh, interessante! Não considerei ị, mas faz sentido que seja bem-sucedido se o personagem for um dígito. Obrigado!
21419 DLosc
@Fatalize Aha - reutilizar ?coisas assim é legal. Obrigado!
21419 DLosc #
2

Gelatina , 12 bytes

~Tṫ3ȧL9<Ɗ>ṚƑ

Experimente online!

[]se não houver dígitos suficientes (lista vazia, falsidade), 0se for incorreto (zero, falsidade), 1se for bom (diferente de zero, verdadeiro).

Erik, o Outgolfer
fonte
2

Java 8, 92 bytes

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

Experimente online.

Explicação:

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)
Kevin Cruijssen
fonte
2

JavaScript, 60 56 46 bytes

Recebe a entrada como uma matriz de caracteres. Saídas 1para verdade e 0para falsey.

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

Experimente Online!

Economizou 10 bytes (!) Graças a Arnauld .

Shaggy
fonte
2

Raquete , 122 bytes

(define(d s)(let([t(string->list s)])(and(< 2(length(filter char-numeric? t)))(< 9(length t))(not(equal? t(reverse t))))))

Experimente online!

Galen Ivanov
fonte
2

APL (Dyalog Unicode) , SBCS de 25 bytes

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

Experimente online!

voidhawk
fonte
11
Boa. Agora você pode jogar golfe transformando-o em um trem: (9<≢)∧(3≤1⊥∊∘⎕D)∧⊢≢⌽e depois salvar mais um byte, reorganizando para evitar parênteses: (9<≢)∧≢∘⌽⍨∧3≤1⊥∊∘⎕Dinforme-os se precisar de explicação sobre essas etapas.
Adám 15/02/19
1

Perl 5 -p, 33 bytes

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

TIO

Nahuel Fouilleul
fonte
1

Limpo , 66 bytes

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

Experimente online!

  • s<>reverse s: snão é um palíndromo
  • s%%(0,8)<s: os 9 primeiros caracteres de ssão menores que todoss
  • sum[1\\c<-s|isDigit c]>2: stem mais de dois dígitos
Furioso
fonte
1

Retina 0.8.2 , 40 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

G`.{10}

Verifica pelo menos 10 caracteres.

G`(\d.*){3}

Verifica pelo menos 3 dígitos.

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

Remova o primeiro e o último caractere, se eles corresponderem.

^..

Se houver pelo menos 2 caracteres, não foi um palíndromo.

Os grupos de balanceamento do .NET significam que isso pode ser feito em uma única expressão regular, mas isso requer 47 bytes:

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

Experimente online! O link inclui casos de teste.

Neil
fonte
1

Vermelho , 117 111 bytes

func[s][d: charset"0123456789"n: 0 parse s[any[d(n: n + 1)|
skip]]all[n > 2 9 < length? s s <> reverse copy s]]

Experimente online!

Galen Ivanov
fonte
1

Python 3 , 74 72 64 bytes

Obrigado Neil A. por -2 bytes!
Obrigado Jo King por -8 bytes! 

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

Explicação:

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

Experimente online!

Epicness
fonte
-2 bytes deslocando os parênteses
Neil A.
1

Perl 6 , 32 bytes

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

Experimente online!

Bloco de código anônimo que simplesmente impõe o cumprimento de todas as regras.

Explicação:

{          &&         &&       }  # 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
Brincadeira
fonte
1

K (oK) , 31 28 bytes

-3 bytes graças a ngn!

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

Experimente online!

Galen Ivanov
fonte
11
você poderia usar +//(soma até a convergência) em vez de +/+/(soma soma)
NGN
11
Alternativamente, você poderia usar x^x^ypara encontrar a intersecção entre duas listas: #x^x^,/!10. este pode ser reduzido para #x^x^/!10( ^é "sem", x^/... é ^-redução com valor inicial x)
NGN
11
mais uma coisa, >(ou <) pode ser usada como "e não":{(x~|x)<(2<#x^x^/$!10)*9<#x}
ngn 20/02/19
@ngn Obrigado! Ótima maneira de encontrar o cruzamento!
Galen Ivanov
0

Pip , 19 bytes

#a>9&XD Na>2&aNERVa

Experimente online! (todos os casos de teste)

Explicação

Com asendo o primeiro argumento de linha de comando:

#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
fonte
0

Pitão, 17 bytes

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

Experimente on-line aqui ou verifique todos os casos de teste de uma vez aqui .

&&<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
fonte
0

Groovy, (47 bytes)

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

(A inclusão de bônus é deixada como um exercício para o leitor)

randomsimon
fonte