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:

tem pelo menos 10 caracteres
tem pelo menos 3 dígitos ( [0-9])
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

Japonês , 17 14 bytes

Ê¨A&U¦Ô&3§Uè\d

-3 bytes reorganizados por @Shaggy

Experimente online!

Japonês , 15 bytes (Bônus de 0 bytes: v)

Ê¨10&U¦Ô&3§Uè\d

Experimente online!

— Luis felipe De jesus Munoz
fonte

11

Dang! Deveria ter verificado as soluções antes de começar a minha! 14 bytes

— Shaggy

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

— 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

JavaScript (Node.js) , 70 bytes

a=>a.length>9&(a.match(/\d/g)||[]).length>2&a!=[...a].reverse().join``

Experimente online!

Retorna 1 para verdadeiro e 0 para falso

— T. Dirks
fonte

0

C # (compilador interativo do Visual C #) , 67 bytes

n=>n.Count(char.IsDigit)>2&!n.Reverse().SequenceEqual(n)&n.Length>9

Experimente online!

— Modalidade de ignorância
fonte

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

Stax , 14 bytes

ûc╖»¬ë⌂╓âó╗cCé

Execute e depure

— recursivo
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

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.

Licensed under cc by-sa 3.0 with attribution required.