Verificador de isograma

13

Desafio:

Dada uma palavra, verifique se é um isograma.

O que :

Um isograma é uma palavra que consiste apenas em letras sem duplicatas (sem distinção entre maiúsculas e minúsculas). A cadeia vazia é um isograma.

Exemplos :

"Dermatoglyphics"     ---> true
"ab"                  ---> true
"aba"                 ---> false
"moOse"               ---> false
"abc1"                ---> false
""                    ---> true

Entrada :

Você pode aceitar entrada em qualquer formato razoável

A entrada conterá apenas letras e / ou números, sem espaços ( [a-zA-Z0-9])

Resultado :

true ou qualquer valor verdadeiro se a entrada for um isograma
false ou qualquer valor falso, caso contrário

Este é o código-golfe, pelo que o código mais curto em bytes em cada idioma vence.

code-golf string decision-problem

— Muhammad Salman
fonte

3

Caso de teste sugerido:sad2

— Adám 17/04/19

1

Sua definição de isograma inclui duas declarações contraditórias diferentes. Qual é?

— Post Rock Garf Hunter

9

Eu recomendo que você comece a usar a sandbox para que esses problemas possam ser detectados antes da publicação do desafio.

— fənɛtɪk

3

@ MuhammadSalman Isso é muito desleixado, remova ". Any" do final de sua citação e dê mais alguns exemplos ( sad2dasfalharia mesmo sem o, 2para que não mostre nada).

— Asone Tuhid

4

O "What" e o "Notes" parecem contradizer um ao outro: "Implementar uma função que determina se uma string que contém apenas letras é um isograma" (ênfase adicionada) e "Pode haver números e esses devem e devem retornar falsos" diga coisas opostas. Votei em encerrar como pouco claro no momento, mas felizmente o retirarei assim que estiver esclarecido!

— 21718 Giuseppe

Respostas:

9

Python 2/ 3, 36 52 48 bytes

lambda s:len(s)==len({*s.lower()}-{*str(56**7)})

Experimente online!

Aproveito o fato de que setcontém apenas elementos únicos. Invocando o __len__método de cada um, posso determinar se stambém contém apenas elementos únicos (ignorando maiúsculas e minúsculas).

EDIT: Atualizado para satisfazer o requisito anteriormente esquecido de retornar False para entradas numéricas. O conjunto de todos os dígitos é codificado como set(str(56**7)).

EDIÇÃO 2: Seguindo esta sugestão do usuário , agora aproveito a descompactação dos argumentos para definir a compreensão. Isso formalmente quebra a compatibilidade com o Python 2.

— Scott Norton
fonte

3

bem-vindo ao PPCG! Isso também deve retornar falsequando scontém um caractere de dígito.

— Giuseppe

está usando `56**7`(como na outra resposta python) em vez de str()mais curto? Eu não estou familiarizado com python, mas essa parece ser a principal diferença entre suas duas respostas.

— 21718 Giuseppe

@Giuseppe python3 não têm ``, uma versão somente python2 iria salvar 4 bytes (3 neste + 1 sobre a divisão em vez iguala)

— Rod

@ Rod exatamente certo. Curiosamente, o texto 56**7foi inspirado na sua própria codificação dos dígitos 0-9 abaixo, mas economiza no seu por 1 byte.

— Scott Norton

Talvez você possa adicionar uma versão do Python 2? 46 Bytes:lambda s:len(s)==len(set(s.lower())-{`56**7`})

— Sunny Patel

5

05AB1E , 5 bytes

lDáÙQ

Experimente online!

Explicação

l        # convert input to lower-case
 D       # duplicate
  á      # keep only letters
   Ù      # remove duplicates
    Q     # compare for equality

— Emigna
fonte

4

R , 41 bytes

!grepl("(.).*\\1|\\d",tolower(scan(,"")))

Experimente online!

Abordagem Regex. !grepl(regex,scan(,""),F)não funcionou, então acho que capturar não corresponde a maiúsculas e minúsculas no R? Eu sou ruim em regex em geral, no entanto, então não ficarei surpreso se estiver fazendo errado ...

R , 58 bytes

!anyDuplicated(c(el(strsplit(tolower(scan(,"")),"")),0:9))

Experimente online!

Anexa os dígitos 0:9à lista (em minúsculas) de caracteres e testa se há duplicatas.

— Giuseppe
fonte

3

Ruby , 25 23 21 bytes

-2 bytes em ambos graças a Giuseppe

->s{/(.).*\1|\d/i!~s}

Experimente online!

-2 bytes graças a Kirill L.

Ruby `-n` , 21 19 18 16 bytes

p !/(.).*\1|\d/i

Experimente online!

— Asone Tuhid
fonte

@Giuseppe Eu não acho que iria trabalhar, graças

— asone Tuhid

1

Eu acho que, na segunda versão, você não precisa mesmo $_- apenas jogando em um regex sem qualquer outra coisa corresponde implicitamente contra $_: 16 bytes

— Kirill L.

@KirillL. obrigado, eu nunca vi !/.../antes, não consigo nem encontrá-lo em ruby-doc.org

— Asone Tuhid 18/04/19

Não é de estranhar, eu também aprendi sobre isso aqui depois de obter o conselho de um cara Perl :)

— Kirill L.

@KirillL. não surpreende tanto, rubi estranheza é geralmente herdada de perl

— asone Tuhid

3

Braquilog , 4 bytes

ḷo⊆Ạ

Experimente online!

O predicado será bem-sucedido se a entrada for um isograma e falhará se não for, exibindo o alfabeto latino em minúsculas se for bem-sucedido. Como o ⊆predicado interno do Brachylog não corresponde exatamente ao relacionamento comum entre um subconjunto e um superconjunto, tive que gastar um byte na classificação da entrada em minúsculas, mas economizei um byte por não ter que procurar explicitamente por duplicatas. (Se não precisasse falhar com os números, poderíamos usar ḷ≠.)

— String não relacionada
fonte

2

Casca , 6 bytes

§=f√ü_

Experimente online!

Explicação

§=f√ü_  -- takes a string as argument, eg: "sAad2"
§       -- fork the argument..
  f√    -- | filter out non-letters: "sad"
    ü_  -- | deduplicate by lower-case: "sAd2"
 =      -- ..and compare: 0

— ბიმო
fonte

2

Japonês , 12 bytes

;v
oC ¬â eUq

Explicação:

;v
;         // Set alternative default vars, where C is the lowercase alphabet
 v        // Make the implicit input lowercase and reassign it
oC ¬â eUq
oC        // Remove all items from the input that are not in the alphabet
   ¬â     // Split into chars and select unique array items
      eUq // Check if the result is equal to the input split into chars

Experimente aqui.

— Nit
fonte

2

MATL , 9 bytes

kt2Y2X&X=

Experimente online!

k   % Lowercase implicit input
t   % Duplicate that
2Y2 % Push lowercase alphabet
X&  % Intersection of alphabet and duplicate lowercase input
X=  % Check for exact equality.

— Sanchises
fonte

2

Python 3 , 46 bytes

lambda s:s.isalpha()*len(s)==len({*s.lower()})

Experimente online!

— musicman523
fonte

2

Japonês 2.0, 12 11 bytes

-1 byte graças a Nit

v
f\l â eUq

— Oliver
fonte

Por que você mudou a versão para uma mais longa? Além disso, eu acho que a última versão do Japt é 1.4.4 ...

— Erik o Outgolfer

@EriktheOutgolfer O original não contava com números retornando automaticamente falso.

— 194 Oliver Oliver

Ah, então você usou uma versão alfa porque é realmente mais curta.

— Erik the Outgolfer

@EriktheOutgolfer Right. O regex custaria +2 em baunilha Japt. ethproductions.github.io/japt/…

— Oliver

1

Obrigado @Nit! Bom uso dee

— Oliver

2

JavaScript (Node.js) , 29 25 bytes

s=>!/(.).*\1|\d/i.test(s)

Experimente online!

Obrigado pela atualização da resposta para @BMO , @ l4m2 , @KevinCruijssen

-4 bytes graças a @KevinCruijssen

s=>!/(.).*\1|[^a-z]/i.test(s)?

— L4m2 18/04

@KevinCruijssen: Eu não vi a versão atualizada

Tenho certeza de que [^a-z]pode ser substituído por\d

— Kevin Cruijssen

@KevinCruijssen: Obrigado. atualizado

2

Retina , 16 bytes

Ci`(.).*\1|\d
^0

Retorna 1como valores Truthy e 0Falsey.
obrigado @ Neil por descobrir e corrigir um bug no meu código inicial.

Experimente online.

Explicação:

C             Check if the input matches part of the following regex:
 i`            Case insensitivity enabled
               Check if part of the input matches either:
  (.)           A character `C`
     .*         followed by zero or more characters
       \1       followed by the same character `C` again
         |     Or
          \d    A digit
^0             Invert Truthy/Falsey, basically replacing every 0 with a 1,
               and every other value with a 1

— Kevin Cruijssen
fonte

Por que o seu é o oposto?

— Muhammad Salman

@MuhammadSalman Duas razões: reverter as correspondências custaria mais bytes. E eu não estou muito hábil com Retina, então eu não tenho certeza de como reverter os jogos para começar .. xD

— Kevin Cruijssen

razão 1). Ah ok. razão 2). LOL

— Muhammad Salman

1

PowerShell , 91 bytes

param($b)($a=[char[]]$b.ToUpper()|group|sort c*)[0].Count-eq$a[-1].count-and$b-notmatch'\d'

Experimente online!

Solução ingênua, mas não consigo criar um algoritmo melhor. Pega entrada $b, converte ToUppercaixa, lança como charmatriz. Canais na matriz na Group-Objectqual constrói um objeto que possui pares nome / contagem para cada letra de entrada. Nós, então, sortque, com base na count e tomar o 0th um dos mesmos. Verificamos se .Counté -equal ao .Countúltimo [-1]par. Nesse caso, as contagens são todas iguais, caso contrário, temos uma quantidade diferente de letras.

Em seguida, -andverificamos se a entrada -notmatché contra \dpara excluir algum dígito na entrada. Esse resultado booleano é deixado no pipeline e a saída é implícita.

— AdmBorkBork
fonte

1

Geléia , 8 bytes

ŒufØA⁼QƲ

Experimente online!

— Erik, o Outgolfer
fonte

1

Python 2 , 57 56 bytes

x=input().lower()
print len(set(x)-set(`763**4`))/len(x)

Experimente online!

Primeiro, ele transforma a entrada em um conjunto, removendo as duplicatas, depois remove os dígitos (codificados `763**4`), depois verifica se o comprimento é igual ao da entrada original

— Cajado
fonte

1

Java 8, 61 39 bytes

s->!s.matches("(?i).*((.).*\\2|\\d).*")

Explicação:

Experimente online.

s->  // Method with String parameter and boolean return-type
  !s.matches("(?i).*((.).*\\2|\\d).*")
     //  Return whether the input does not match the regex

Explicação Regex:

String#matchesadiciona implicitamente ^...$.

^(?i).*((.).*\2|\d).*$
 (?i)                      Enable case insensitivity
^    .*                    Zero or more leading characters
       (       |  )        Followed by either:
        (.)                 Any character `C`
           .*               with zero or more characters in between
             \2             followed by that same character `C` again
               |           Or:
                \d          Any digit
                   .*$     Followed by zero or more trailing characters

— Kevin Cruijssen
fonte

1

APL (Dyalog Unicode) , 12 bytes

Função tácita anônima.

(∪≡~∘⎕D)819⌶

Experimente online!

819⌶ minúsculas

(… ) Aplique a seguinte função tácita nisso:

~∘⎕D remover D igits do argumento

∪≡ os elementos únicos do argumento são idênticos a isso?

— Adão
fonte

1

Perl 6 , 22 bytes

{!(.uc~~/(.).*$0|\d/)}

Experimente online!

Não há correspondências para algum caractere e depois o mesmo caractere. Função implícita como um bloco de código, corresponde implicitamente a $ _, inverte livro com !. Adicionado |\d(ta Adam), mas também necessário .uc~~, que precisava de parênteses ...

Alternativa com malas, 23 bytes

{.uc.ords.Bag⊆65..97}

Experimente online!

Este caso normaliza, em seguida, faz uma bolsa (definida com contagens de incidência). Subconjunto ou igual a true somente se todos os membros forem membros da Bolsa de comparação e todas as contagens de incidência forem menores ou iguais às da Bolsa de comparação. Portanto, qualquer repetição ou dígito tornaria a comparação falsa.

— Phil H
fonte

Falha abc1.

— Adám 19/04/19

Ah, escrevi esta resposta antes que a especificação de números fosse adicionada.

— 21418 Phil

Você não pode adicionar |\d?

— Adám 19/04/19

@ Adám: Mais ou menos. Percebeu que também não detectava letras repetidas se os casos dessas letras eram diferentes; portanto, era necessário normalizar e adicionar parênteses.

— Phil H

1

19 bytes

— Jo King

1

Rápido , 81 bytes

let s=readLine()!.lowercased().characters;print(s.count<1||Set(s).count==s.count)

Experimente online!

— Tamás Sengel
fonte

Agradável! 25 bytes mais curto que o meu.

— onnoweb 25/03/19

1

Visual Basic for Applications (32 bits), 102 bytes

s=LCase(InputBox(u)):j=1:For i=1To Len(s):k=Mid(s,i,1):j=j*0^Instr(i+1,s,k)*(k Like"[a-z]"):Next:?j<>0

Usou o fato de que no VBA 0^xproduz 1 se x for zero e 0 caso contrário. Execute na janela imediata (depuração).

Edit: como apontado por Taylor nos comentários, isso só funciona em instalações de 32 bits do MS Office.

— dnep
fonte

Se você restringir seu idioma ao Excel VBA, poderá trocá-lo por s=LCase([A1]):j=1:For i=1To Len(s):k=Mid(s,i,1):j=j*0^InStr(i+1,s,k)*(k Like"[a-z]"):Next:?j<>095 bytes, recebendo informações de [A1]. Além disso, vale a pena notar que, como a exponenciação no VBA é estranha, essa solução é restrita a instalações de escritório de 32 bits.

— Taylor Scott

Além disso, você pode fazer a sua resposta olhar melhor e mais legível usando a capitalização apropriada (ver acima) e adicionando uma bandeira para a sua resposta para adicionar realce de sintaxe

— Taylor Scott

1

@TaylorScott thanks! Adicionado destaque de sintaxe e anotada restrição de 32 bits. Sobre a entrada do Excel, prefiro manter a solução invariante do aplicativo sempre que possível.

— Dnep 26/04/19

1

05AB1E , 4 bytes

lDÔQ

Experimente online!

Explicação

l      # convert input to lowercase
 D     # duplicate and push to stack
  Ô    # uniquify the list of characters
   Q   # check for equality

— LordColus
fonte

Isso falhará se a entrada contiver caracteres não alfabéticos.

— Shaggy

Isso funciona

— LordColus

The input will only contain letters and/or numbers, no spaces ([a-zA-Z0-9])

— 26818 LordColus

" Um isograma é uma palavra que consiste apenas em letras sem duplicatas " - ou seja, "palavras" contendo números devem retornar um valor de falsey. Veja o quinto caso de teste para um exemplo.

— Shaggy

Foi mal. Veja a resposta da @ Enigma para o código 05AB1E correto.

— 26818 LordColus

1

C (gcc) , 87 85 83 bytes

Salvou ~~dois~~ quatro bytes graças ao ceilingcat .

f(s,p,b,P)char*s,*p;{for(b=s;*s;++s)for(p=b*=*s>64;b&&p<s;b=(*s^*p++)&95?b:0);s=b;}

Experimente online!

— Jonathan Frech
fonte

@ceilingcat Sugestão fina, obrigado.

— Jonathan Frech

@ceilingcat Obrigado.

— Jonathan Frech

0

K (ngn / k) , 18 bytes

{(a^,/$!10)~?a:_x}

Experimente online!

— ngn
fonte

0

CJam , 11 bytes

qelA,s+_L|=

Experimente online!

Explicação

A idéia básica é acrescentar cada dígito e procurar duplicatas. Como o apêndice garante que cada dígito já esteja presente uma vez, qualquer presença adicional de dígitos será duplicada, fazendo com que ele retorne falso.

q      e# read the input:            | "MOoSE1"
el     e# convert to lowercase:      | "moose1"
A      e# push 10:                   | "moose1" 10
,      e# range [0,N):               | "moose1" [0 1 2 3 4 5 6 7 8 9]
s      e# string representation:     | "moose1" "0123456789"
+      e# concatenate:               | "moose10123456789"
_      e# duplicate:                 | "moose10123456789" "moose10123456789"
L|     e# union with the empty list: | "moose10123456789" "mose1023456789"
       e# (this gets rid of duplicates)
=      e# Equal to original:         | 0

— Esolanging Fruit
fonte

0

Vermelho , 76 bytes

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]parse s[any[copy c a ahead not to c]]]

Experimente online!

— Galen Ivanov
fonte

0

Smalltalk, 57 bytes

Método a ser definido na classe String:

s^(self select:#isLetter)asUppercase asSet size=self size

Isso é provavelmente auto-explicativo.

— Hans-Martin Mosner
fonte

0

Pitão , 17 bytes

.Am&!t/rz0d}dGrz0

Suíte de teste

Explicação:

.Am&!t/rz0d}dGrz0 # Code
  m           rz0 # Map the following over the lowercase input:
      /rz0d       #  Count occurrences of d in lowercase input
     t            #   minus 1
    !             #    inverted (0 -> True)
   &              #     and
           }dG    #      d is in the lowercase alphabet
.A                # Print whether all values are truthy

Tradução Python 3:

z=input()
print(all(map(lambda d:not z.lower().count(d)-1and d in "abcdefghijklmnopqrstuvwxyz",z.lower())))

— hakr14
fonte

0

C #, 82 bytes

bool f(string s)=>!!(s.GroupBy(c=>c).Any(c=>c.Count()>1|(!Char.IsLetter(c.Key))));

editar: teste adicionado para char

edit: usando GroupBy para encurtá-lo em 5 bytes

— Raymond Osterbrink
fonte

1

Bem-vindo ao PPCG! Acho que você está perdendo o requisito de que também precisa verificar se a entrada não contém dígitos.

— Martin Ender

0

APL (Dyalog Unicode) , 25 20 22 bytes

''≡'(.).*\1|\d'⎕S'&'⍠1

Experimente online!

Retorna 1 para true, caso contrário 0.

Guardado 5 bytes graças a @ H.PWiz

Corrigido e salvo outro byte graças a @ Adám

Quão?

''≡'(.).*\1|\d'⎕S'&'⍠1 ⍝ Tacit fn
                    ⍠1 ⍝ Ignore case
               ⎕S'&'   ⍝ Search and return the match(es)
   '(.).*\1|\d'        ⍝ For this regex
''≡                    ⍝ And compare to the empty string

— J. Sallé
fonte

Falha no abc1.

— Adám 18/04/19

\w→ não é .válido?

— Adám 19/04/19

Se você quer dizer (.).*\1, não. Também falha para abc1: /

— J. Sallé

Eu não entendo O que você quer dizer com "também falha"?

— Adám 19/04/19

Se você experimentá-lo online! você pode ver que retorna 1 para abc1, quando ele deve retornar 0.

— J. Sallé

0

Tcl , 114 bytes

proc I w {lmap c [set L [split $w ""]] {if {[regexp -all -nocase $c $w]>1|![string is alp $c]} {return 0}}
expr 1}

Experimente online!

Tcl , 121 bytes

proc I w {lmap c [set L [split $w ""]] {if {[llength [lsearch -al -noc $L $c]]>1|![string is alp $c]} {return 0}} expr 1}

Experimente online!

Ainda é muito longo para o meu gosto!

— sergiol
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.