Password Bishop Dio

10

Derivato da questo , ora cancellato, post.

Data una stringa, rispondi (verità / falsità o due valori coerenti) se costituisce una buona password Bishop, che è quando sono soddisfatte tutte le seguenti condizioni:

ha almeno 10 caratteri
ha almeno 3 cifre ( [0-9])
non è un palindromo (identico a se stesso quando invertito)

Ricevi 0 byte di bonus se il tuo codice è una buona password Bishop.

Attenzione: Do non utilizzare Vescovo bontà come una misura della forza effettiva della password!

Esempi

Buone password per Bishop

PPCG123GCPP
PPCG123PPCG
PPCG123gcpp
0123456789
Tr0ub4dor&3

Non buone password per Bishop

PPCG123 (troppo corto)
correct horse battery staple (cifre insufficienti)
PPCG121GCPP (palindromo)
( cifre troppo corte e non sufficienti)
abc121cba (troppo corto e palindromo)
aaaaaaaaaaaa (palindromo e cifre non sufficienti)
abc99cba (tutto sbagliato)

code-golf string decision-problem palindrome

— Adamo
fonte

@KrystosTheOverlord Il termine è definito in questa sfida stessa. ;-P

— Erik the Outgolfer,

9

Oh, mi aspettavo alcune regole per la password della logica degli scacchi ...

— Bergi,

1

Ho letto tutte le risposte e nessuno ha richiesto il bonus.

— Veskah,

1

@JDL puoi davvero sottrarre 0 byte dal tuo punteggio se ti qualifichi per questo bonus molto reale! Che cosa state aspettando?

— Aaron,

1

Uno dei tuoi criteri è in realtà il contrario di ciò che Bishop (2013) ha proposto. Ha proposto che le password debbano contenere almeno 10 caratteri, non di più.

— PyRulez,

Risposte:

5

Python 2 , 61 59 54 51 byte

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

Provalo online!

_{-5 byte, grazie a Erik the Outgolfer}
_{-3 byte, grazie a xnor}

— TFeld
fonte

Choo Choo!

— Erik the Outgolfer,

@EriktheOutgolfer Thanks :)

— TFeld,

Puoi eseguire il controllo di lunghezza come s[:9]<s, che si combina bene con il controllo non palindromo:s[:9]<s!=s[::-1]

— xnor

@xnor Thanks :)

— TFeld

4

05AB1E , 12 byte

gT@Iþg3@IÂÊP

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Japt , 17 14 byte

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

-3 byte riorganizzati da @Shaggy

Provalo online!

Japt , 15 byte (bonus 0 byte: v)

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

Provalo online!

— Luis Felipe De Jesus Munoz
fonte

1

Dang! Avrei dovuto controllare le soluzioni prima di iniziare la mia! 14 byte

— Shaggy,

4

R , 80 70 62 64 63 byte

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

Provalo online!

Da digEmAll, e anche qualche riarrangiamento

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

Provalo online!

Abbastanza semplice, nessun vero trucco qui. Dopo la stringa di input dell'utente:

Separa e cerca la stringa per più di 2 numeri. (3 o più cifre)
Verifica se non tutti gli elementi sono uguali alla versione invertita della stringa (palindromo)
Verifica che la lunghezza sia maggiore di 9 (10 o più caratteri)

— Sumner18
fonte

Penso che puoi sostituire !all(s==rev(s))con il any(s!=rev(s))quale salverà un byte. Sento che anche il controllo della lunghezza può essere ridotto, ma non sono sicuro di come (uno ncharo qualche tipo di sum(x|1)hack)

— JDL

1

in realtà, penso any(s>rev(s))che funzionerà --- se un personaggio è inferiore alla sua controparte palindromica, all'altra estremità della password il contrario sarà vero. Ciò salva un altro byte.

— JDL,

2

62 byte usando utf8ToInt

— digEmAll

1

@digEmAll il tuo esempio ritorna vero quando c'è un solo numero, dovrai includere un>2

— Aaron Hayman

1

64 ma corretto;)

— digEmAll

3

APL + WIN, 36, 30 29 byte

7 byte salvati grazie ad Adám

Origine indice = 0

Richiede la stringa di input

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

Provalo online! Per gentile concessione di Dyalog Classic

Spiegazione:

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

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

>v≡⌽v Palindrome test

Il codice si qualifica anche per il bonus in quanto è una buona password Bishop.

— Graham
fonte

@Adamo. Grazie per aver salvato 6 byte. Su ⎕IO concordato. v≡⌽v funziona bene se antepongo ~. Per quanto riguarda l'uso di x, tendo ad usarlo quando si mettono insieme test booleani. Stesso risultato stesso numero di byte.

— Graham,

Hai ≢qual è ~... ≡? E anche se non lo fai, è possibile unire ×~in>

— Adám

@ Adám No, non ho ≢. Posso unire × ~ in> per un altro byte. Grazie. Temo che il mio "mettere il gioco" abbia ancora bisogno di più pratica;)

— Graham,

3

Brachylog , 18 12 byte

Grazie per i suggerimenti, Kroppeb e Fatalize !

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

Provalo online!

Spiegazione

Il programma è un predicato unico, composto da due parti che sono concatenate &.

Primo:

¬       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

Secondo:

 ˢ     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

{∋.∈Ị∧}ᶜpuò essere{∋ị}ᶜ

— Kroppeb il

Mettendo prima la clausola "non palindromo" e cambiando il modo di selezionare le cifre, è possibile salvare 6 byte:¬↔?l>9&ịˢl>2

— Fatalizzare il

@Kroppeb Oh, interessante! Non ho considerato ị, ma ha senso che avrebbe successo se il personaggio fosse una cifra. Grazie!

— DLosc

@Fatalize Aha - riutilizzare il ?simile è pulito. Grazie!

— DLosc

2

Gelatina , 12 byte

~Tṫ3ȧL9<Ɗ>ṚƑ

Provalo online!

[]se non abbastanza cifre (lista vuota, falsa), 0se altrimenti cattivo (zero, falsa), 1se buono (diverso da zero, verità).

— Erik l'Outgolfer
fonte

2

Java 8, 92 byte

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

Provalo online.

Spiegazione:

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 byte

Accetta input come una matrice di caratteri. Output 1per verità e 0falsità.

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

Provalo online!

Salvato 10 byte (!) Grazie ad Arnauld .

— ispido
fonte

2

Racchetta , 122 byte

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

Provalo online!

— Galen Ivanov
fonte

2

APL (Dyalog Unicode) , ^{SBCS da} 25 byte

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

Provalo online!

— voidhawk
fonte

1

Buona. Ora puoi giocare a golf trasformandolo in un treno: (9<≢)∧(3≤1⊥∊∘⎕D)∧⊢≢⌽e poi salva un altro byte riorganizzando per evitare le parentesi: (9<≢)∧≢∘⌽⍨∧3≤1⊥∊∘⎕Dfai sapere loro se hai bisogno di una spiegazione di questi passaggi.

— Adám,

1

Perl 5 `-p`, 33 byte

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

— Nahuel Fouilleul
fonte

1

Pulito , 66 byte

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

Provalo online!

s<>reverse s: snon è un palindromo
s%%(0,8)<s: i primi 9 caratteri di ssono meno di tuttis
sum[1\\c<-s|isDigit c]>2: sha più di due cifre

— Οurous
fonte

1

Retina 0.8.2 , 40 byte

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

Provalo online! Il link include casi di test. Spiegazione:

G`.{10}

Controlla almeno 10 caratteri.

G`(\d.*){3}

Controlla almeno 3 cifre.

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

Rimuovi il primo e l'ultimo personaggio se corrispondono.

^..

Se ci sono almeno 2 personaggi, allora non era un palindromo.

I gruppi di bilanciamento di .NET significano che ciò può essere fatto in una singola espressione regolare, ma che richiede 47 byte:

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

Provalo online! Il link include casi di test.

— Neil
fonte

1

Rosso , 117 111 byte

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

Provalo online!

— Galen Ivanov
fonte

1

Python 3 , 74 72 64 byte

Grazie Neil A. per -2 byte!
Grazie Jo King per -8 byte!

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

Spiegazione:

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

Provalo online!

— Epicness
fonte

-2 byte spostando le parentesi

— Neil A.

1

Perl 6 , 32 byte

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

Provalo online!

Blocco di codice anonimo che fa semplicemente rispettare tutte le regole.

Spiegazione:

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

1

K (oK) , 31 28 byte

-3 byte grazie a ngn!

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

Provalo online!

— Galen Ivanov
fonte

1

potresti usare +//(somma fino alla convergenza) invece di +/+/(somma somma)

— ngn

1

In alternativa, è possibile utilizzare x^x^yper trovare l'intersezione tra due liste: #x^x^,/!10. questo può essere abbreviato in #x^x^/!10( ^è "senza", x^/... è ^-riduzione con valore iniziale x)

— ngn

1

un'altra cosa, >(o <) può essere usata come "e non":{(x~|x)<(2<#x^x^/$!10)*9<#x}

— ngn

@ngn Grazie! Bel modo di trovare l'incrocio!

— Galen Ivanov,

0

JavaScript (Node.js) , 70 byte

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

Provalo online!

Restituisce 1 per true e 0 per false

— T. Dirks
fonte

0

C # (compilatore interattivo Visual C #) , 67 byte

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

Provalo online!

— Incarnazione dell'ignoranza
fonte

0

Pip , 19 byte

#a>9&XD Na>2&aNERVa

Provalo online!(tutti i casi di test)

Spiegazione

Con aessendo il primo argomento della riga di 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 byte

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

Esegui ed esegui il debug

— ricorsivo
fonte

0

Pyth, 17 byte

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

Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

&&<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 byte)

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

(L'inclusione del bonus è lasciata come esercizio al lettore)

— randomsimon
fonte

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.

Licensed under cc by-sa 3.0 with attribution required.