Contraseña Obispo Dios

10

Derivado de esta publicación, ahora eliminada.

Dada una cadena, responda (verdadero / falso o dos valores consistentes) si constituye una buena contraseña de Bishop, que es cuando se cumplen las siguientes condiciones:

  1. tiene al menos 10 caracteres

  2. tiene al menos 3 dígitos ( [0-9])

  3. no es un palíndromo (idéntico a sí mismo cuando se invierte)

Obtiene un bono de 0 bytes si su código es una buena contraseña de Bishop.

Advertencia: ¡ No use la bondad de Bishop como una medida de la fuerza real de la contraseña!

Ejemplos

Good Bishop contraseñas

PPCG123GCPP
PPCG123PPCG
PPCG123gcpp
0123456789
Tr0ub4dor&3

No son buenas contraseñas de Bishop

PPCG123 (demasiado corto)
correct horse battery staple (no hay suficientes dígitos)
PPCG121GCPP (palíndromo)
 (demasiado corto y no hay suficientes dígitos)
abc121cba (demasiado corto y palíndromo)
aaaaaaaaaaaa (palíndromo y no hay suficientes dígitos)
abc99cba (todo está mal)

code-golf string decision-problem palindrome Adán
fuente
@KrystosTheOverlord El término se define en este desafío en sí. ;-P
Erik the Outgolfer
99
Aw, esperaba algunas reglas de contraseña de lógica de ajedrez ...
Bergi
1
Leí todas las respuestas y ninguna reclamó el bono.
Veskah
1
¡@JDL realmente puedes restar 0 bytes de tu puntaje si calificas para este bono muy real! ¿Que estas esperando?
Aaron
1
Uno de sus criterios es en realidad el reverso de lo que propuso Bishop (2013). Propuso que las contraseñas deben tener 10 caracteres o menos, no más.
PyRulez

Respuestas:

5

Python 2 , 61 59 54 51 bytes

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

Pruébalo en línea!

-5 bytes, gracias a Erik the Outgolfer
-3 bytes, gracias a xnor

TFeld
fuente
¡Chú chú!
Erik the Outgolfer
@EriktheOutgolfer Gracias :)
TFeld
Puede hacer la verificación de longitud como s[:9]<s, que combina bien con la verificación sin palíndromo:s[:9]<s!=s[::-1]
xnor
@xnor Gracias :)
TFeld
4

05AB1E , 12 bytes

gT@Iþg3@IÂÊP

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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
fuente
4

R , 80 70 62 64 63 bytes

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

Pruébalo en línea!

Desde digEmAll, y algunos reorganizando también

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

Pruébalo en línea!

Bastante sencillo, no hay trucos realmente sorprendentes aquí. Después de que el usuario ingrese la cadena:

  • Separa y busca en la cadena más de 2 números. (3 o más dígitos)
  • Comprueba si no todos los elementos son iguales a la versión invertida de la cadena (palíndromo)
  • Comprueba que la longitud es mayor que 9 (10 o más caracteres)
Sumner18
fuente
Creo que puede reemplazar !all(s==rev(s))con any(s!=rev(s))lo que ahorrará un byte. Siento que la verificación de longitud también se puede reducir, pero no estoy seguro de cómo (cualquiera ncharo algún tipo de sum(x|1)pirateo)
JDL
1
en realidad, creo any(s>rev(s))que funcionará --- si un personaje es menor que su contraparte palindrómica, entonces en el otro extremo de la contraseña, lo contrario será cierto. Eso ahorra otro byte.
JDL
2
62 bytes usando utf8ToInt
digEmAll
1
@digEmAll su ejemplo devuelve verdadero cuando solo hay un número, deberá incluir un>2
Aaron Hayman
1
64 pero correcto;)
digEmAll
3

APL + WIN, 36, 30 29 bytes

7 bytes guardados gracias a Adám

Origen del índice = 0

Solicita cadena de entrada

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

Pruébalo en línea! Cortesía de Dyalog Classic.

Explicación:

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

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

>v≡⌽v Palindrome test

El código también califica para el bono, ya que es una buena contraseña de Bishop.

Graham
fuente
@Adán. Gracias por guardar 6 bytes. El ⎕IO estuvo de acuerdo. v≡⌽v funciona bien si prefiero ~. En cuanto al uso de x, tiendo a usarlo cuando se unen pruebas booleanas. Mismo resultado mismo número de bytes.
Graham
¿Tienes ≢cuál es ~... ≡? E incluso si no lo haces, puedes unirte ×~a>
Adám
@ Adám No, no tengo ≢. Puedo fusionar × ~ en> por un byte más. Gracias. Me temo que mi "juego de poner" todavía necesita más práctica;)
Graham
3

Brachylog , 18 12 bytes

Gracias por los consejos, Kroppeb y Fatalize !

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

Pruébalo en línea!

Explicación

El programa es un predicado único, compuesto de dos partes que están encadenadas &.

Primero:

¬       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
fuente
{∋.∈Ị∧}ᶜpuede ser{∋ị}ᶜ
Kroppeb
Al poner primero la cláusula "no palíndromo" y cambiar la forma de seleccionar dígitos, puede guardar 6 bytes: ¬↔?l>9&ịˢl>2
Fatalize
@Kroppeb ¡Oh, interesante! No lo consideré ị, pero tiene sentido que tenga éxito si el personaje es un dígito. ¡Gracias!
DLosc
@Fatalize Aha: reutilizar cosas ?así es genial. ¡Gracias!
DLosc
2

Jalea , 12 bytes

~Tṫ3ȧL9<Ɗ>ṚƑ

Pruébalo en línea!

[]si no hay suficientes dígitos (lista vacía, falsedad), 0si no es correcto (cero, falsedad), 1si es bueno (distinto de cero, verdad).

Erik el Outgolfer
fuente
2

Java 8, 92 bytes

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

Pruébalo en línea.

Explicación:

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
fuente
2

JavaScript, 60 56 46 bytes

Toma entrada como una matriz de caracteres. Salidas 1para la verdad y 0para falsey.

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

¡Pruébelo en línea!

Guardado 10 bytes (!) Gracias a Arnauld .

Lanudo
fuente
2

Raqueta , 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))))))

Pruébalo en línea!

Galen Ivanov
fuente
2

APL (Dyalog Unicode) , SBCS de 25 bytes

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

Pruébalo en línea!

halcón vacío
fuente
1
Bueno. Ahora puede jugar golf convirtiéndolo en un tren: (9<≢)∧(3≤1⊥∊∘⎕D)∧⊢≢⌽y luego guardar un byte más reorganizándolo para evitar a los padres: dígales (9<≢)∧≢∘⌽⍨∧3≤1⊥∊∘⎕Dsi necesita una explicación de estos pasos.
Adám
1

Perl 5 -p, 33 bytes

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

TIO

Nahuel Fouilleul
fuente
1

Limpio , 66 bytes

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

Pruébalo en línea!

  • s<>reverse s: sno es un palíndromo
  • s%%(0,8)<s: los primeros 9 caracteres de sson menos que todoss
  • sum[1\\c<-s|isDigit c]>2: stiene más de dos dígitos
Οurous
fuente
1

Retina 0.8.2 , 40 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

G`.{10}

Comprueba al menos 10 caracteres.

G`(\d.*){3}

Verificaciones de al menos 3 dígitos.

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

Elimina el primer y último personaje si coinciden.

^..

Si hay al menos 2 caracteres, entonces no era un palíndromo.

Los grupos de equilibrio de .NET significan que esto se puede hacer en una sola expresión regular, pero que requiere 47 bytes:

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

Pruébalo en línea! El enlace incluye casos de prueba.

Neil
fuente
1

Rojo , 117111 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]]

Pruébalo en línea!

Galen Ivanov
fuente
1

Pitón 3 , 74 72 64 bytes

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

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

Explicación:

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

Pruébalo en línea!

Epicness
fuente
-2 bytes cambiando los paréntesis
Neil A.
1

Perl 6 , 32 bytes

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

Pruébalo en línea!

Bloqueo de código anónimo que simplemente exige que se cumplan todas las reglas.

Explicación:

{          &&         &&       }  # 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
Jo King
fuente
1

K (oK) , 31 28 bytes

-3 bytes gracias a ngn!

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

Pruébalo en línea!

Galen Ivanov
fuente
1
podría usar +//(suma hasta la convergencia) en lugar de +/+/(suma suma)
ngn
1
Alternativamente, se puede utilizar x^x^ypara encontrar la intersección entre dos listas: #x^x^,/!10. esto se puede acortar a #x^x^/!10( ^es "sin", x^/... es ^-reducción con valor inicial x)
ngn
1
una cosa más, >(o <) se puede usar como "y no":{(x~|x)<(2<#x^x^/$!10)*9<#x}
ngn
@ngn ¡Gracias! ¡Buena manera de encontrar la intersección!
Galen Ivanov
0

Pip , 19 bytes

#a>9&XD Na>2&aNERVa

Pruébalo en línea! (todos los casos de prueba)

Explicación

Con aser el primer argumento de la línea de comandos:

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

Pyth, 17 bytes

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

Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

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

Groovy, (47 bytes)

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

(La inclusión de bonificación se deja como ejercicio para el lector)

randomsimon
fuente