Eu entrei recentemente no golfe de código e tentei escrever o menor verificador de tautograma.

Um tautograma é uma frase na qual todas as palavras começam com a mesma letra, por exemplo: Flores florescem da França .

Dada uma frase como entrada, determine se é um tautograma.

Casos de teste

Flowers flourish from France
    True

This is not a Tautogram
    False

Eu vim com esse código python (porque é minha linguagem principal):

print(True if len(list(set([x.upper()[0] for x in __import__('sys').argv[1:]]))) == 1 else False)

Uso:

python3 tautogram.py Flowers flourish from France
# True
python3 tautogram.py This is not a Tautogram
# False

A frase pode conter vírgulas e pontos, mas nenhum outro caractere especial, apenas letras maiúsculas e minúsculas e espaços.

Seu tamanho é 98 bytes. Existe uma solução menor em qualquer idioma?

code-golf string decision-problem

— Jaime Tenorio
fonte

11

Pretende-se como uma tipsquestão limitada a Python? Nesse caso, essas duas tags devem ser adicionadas.

— Arnauld

2

Ei, amigo! Este site geralmente é reservado para problemas definidos explicitamente. Coisas como "a entrada pode conter pontuação" devem ser respondidas antes da publicação, mas, além disso, essa é uma ótima primeira pergunta comparativamente às outras perguntas de novos usuários que normalmente vemos. A julgar pelos seus exemplos, eu apenas esclareceria que os únicos caracteres na entrada serão "[A-Za-z]" e sua pergunta será puramente objetiva. Gostaria de abordar algumas outras perguntas por aqui, caso contrário, isso pode ser honestamente um ajuste melhor no estouro.

— Urna de polvo mágico

11

O que você quer dizer com pontuação? Quais caracteres estão incluídos?

— Modalidade de ignorância

11

@MagicOctopusUrn Às vezes, quando você solicita uma solução curta no stackOverflow, consulte este site :) #

— Luis Felipe De jesus Munoz

6

Bem-vindo ao PPCG! Mais alguns casos de teste (incluindo pontuação) seriam um ótimo complemento para esse desafio.

— ### AdmBorkBork #

7

05AB1E , 5 bytes

l#€нË

Experimente online!

l      # Lowercase input.
 #     # Split on spaces.
  €н   # a[0] of each.
    Ë  # All equal?

Isso no celular desculpou a ausência de explicação.

— Urna de polvo mágico
fonte

4

Python 2 , 47 bytes

lambda s:len(set(zip(*s.lower().split())[0]))<2

Experimente online!

Veio com isso no celular. Provavelmente pode ser jogado mais.

— TFeld
fonte

3

Clojure , 80 bytes

Experimente online! . O TIO não suporta a biblioteca String padrão do Clojure, portanto, a primeira versão gera um erro "Não é possível encontrar letras minúsculas".

(fn[s](use '[clojure.string])(apply =(map first(map lower-case(split s #" ")))))

Ungolfed:

(defn tautogram? [s]
  (use '[clojure.string])
  (->> (split s #" ") ; Get words
       (map lower-case)
       (map first) ; Get first letter of each word
       (apply =))) ; And make sure they're all the same

Eu fiz uma versão que evita a importação:

(fn [s](apply =(map #(if(<(-(int %)32)65)(int %)(-(int %) 32))(map first(take-nth 2(partition-by #(= %\ )s))))))

 ; -----

(defn tautogram? [s]
  (->> s
       (partition-by #(= % \ )) ; Split into words
       (take-nth 2) ; Remove spaces
       (map first) ; Get first letter
       ; Convert to uppercased letter code
       (map #(if (< (- (int %) 32) 65) ; If attempting to uppercase puts the letter out of range,
               (int %) ; Go with the current code
               (- (int %) 32))) ; Else go with the uppercased  code
       (apply =))) ; And check if they're all equal

Mas são 112 bytes .

— Carcinigenicado
fonte

Aqui está a minha solução de raquete:(define(f s)(apply char=?(map(λ(x)(char-upcase(car(string->list x))))(string-split s))))

— Galen Ivanov

Muito mais curto no PicoLisp:(de f(s)(apply =(mapcar car(split(chop(lowc s))" "))))

— Galen Ivanov

3

PowerShell , 57 50 41 bytes

(-split$args|% s*g 0 1|sort -u).count-eq1

Experimente online!

Recebe e splitcoloca no espaço em branco. Passa por cada palavra e pega a primeira letra, pegando o substrin gcomeçando na posição 0e indo para o 1personagem. Em seguida, sorts as letras (sem distinção entre maiúsculas e minúsculas) com o-u bandeira nique para retirar apenas uma cópia de cada letra, e verifica o countdesses nomes são -equal a 1. A saída está implícita.

-9 bytes graças ao mazzy.

— AdmBorkBork
fonte

41 bytes

— mazzy 26/03/19

35 bytes com regexp

— mazzy 26/03/19

11

@mazzy fixo tentando entender a intenção

— Nahuel FOUILLEUL

@mazzy Vou deixar você postar a versão regex quando a pergunta for reaberta. É diferente o suficiente para garantir sua própria resposta.

— AdmBorkBork 26/03/19

Estou de acordo. mas essa pergunta é colocada em espera, então não consigo criar uma nova resposta.

— Mazzy

2

05AB1E (herdado) , 5 bytes

#€¬uË

Experimente online!

#     // split on spaces
 €¬   // get the first letter of each word
   uË // check if they're the same (uppercase) letter

— Riley
fonte

2

Braquilog , 5 bytes

ḷṇ₁hᵛ

Experimente online!

         The input
ḷ        lowercased
 ṇ₁      and split on spaces
   hᵛ    is a list of elements which all start with the same thing.

— String não relacionada
fonte

Eu só agora percebeu que isso tem que ser capaz de lidar com a pontuação, mas sem quaisquer casos de teste pontuadas Eu não posso dizer se isso faz ou não faz o trabalho ainda ...

— Não relacionado Cordas

2

Haskell , 71 bytes

f s|c<-fromEnum.head<$>words s=all(`elem`[-32,0,32]).zipWith(-)c$tail c

Experimente online!

Haskell , 61 58 bytes (usando `Data.Char.toLower`)

Economizou três bytes graças a nimi .

import Data.Char
(all=<<(==).head).(toLower.head<$>).words

Experimente online!

— Jonathan Frech
fonte

@nimi Obrigado.

— Jonathan Frech

2

Perl 5 ( `-p`), 20 bytes

$_=!/^(.).* (?!\1)/i

TIO

comentários a seguir em caso de pontuação incorreta (31 bytes)

$_=!/^\W*+(.).*(?=\b\w)(?!\1)/i

31 bytes

caso contrário, há outra abordagem, também com 31 bytes:

$h{ord()%32}++for/\w+/g;$_=2>%h

31 bytes outros

— Nahuel Fouilleul
fonte

e as pontuações? e quanto a espaços ou pontuações no fio da corda?

— Mazzy

Esta resposta obras para os casos de teste dadas, poderia ser melhorado, dependendo dos requisitos poderia ser$_=!/^\W*+(.).*(?=\b\w)(?!\1)/i

— Nahuel FOUILLEUL

mas, lendo atentamente a pergunta e a solução fornecida, os espaços no início não podem ocorrer porque os espaços são usados pelo shell para dividir os argumentos. O programa verifica apenas se todos os argumentos começam com o mesmo caractere

— Nahuel Fouilleul 26/03/19

1

JavaScript (Node.js) , 54 bytes

s=>!s.match(/\b\w+/g).some(p=s=>p-(p=Buffer(s)[0]&31))

Experimente online!

Ou 47 bytes, se for garantido que cada palavra (mas a primeira) seja precedida por um espaço.

— Arnauld
fonte

ou em um regex ou com um espaço em vez de\W

— Nahuel Fouilleul

@NahuelFouilleul, usar testsalva outro byte.

— Shaggy

11

@NahuelFouilleul Você provavelmente deve publicar separadamente.

— Arnauld

já postou a versão perl, eu não mestre bem javascript, eu estou feliz em lhe dar uma dica

— Nahuel FOUILLEUL

1

Japt `-¡` , 5 bytes

¸mÎro

Tente

¸mÎro     :Implicit input of string
¸         :Split on spaces
 m        :Map
  Î       :  Get first character
   r      :Reduce by
    o     :  Keeping the characters that appear in both, case-insensitive
          :Implicit output as boolean

— Shaggy
fonte

1

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

n=>n.Split().GroupBy(c=>c[0]|32).Single()

Lança uma exceção se falsa, nada se for verdade.

Experimente online!

— Modalidade de ignorância
fonte

1

Perl 6 , 19 bytes

{[eq] m:g/<<./}o&lc

Experimente online!

— Nwellnhof
fonte

1

Java, (36 bytes)

s->!s.matches("(?i)(.).* (?!\\1).*")

TIO

— Nahuel Fouilleul
fonte

11

Eu acho que a entrada pode começar com um espaço, e isso não funciona para entradas como essa .

— Sara J

na verdade, não é um caso de teste, mas isso pode ser manipulado adicionando (?> *), usando grupo atômica para coincidir com o espaço no início e bactracking pevent. apenas `*` não funciona porque, após falhas nas correspondências, retornará `*` para corresponder à sequência vazia

— Nahuel Fouilleul 26/03/19

no entanto lendo a pergunta novamente espaços podem ocorrer no beause início no exemplo o uso é para passar as palavras como argumento e espaços são shell delimitador argumento

— Nahuel FOUILLEUL

Existe um verificador de tautograma menor? [fechadas]

Casos de teste

05AB1E , 5 bytes

Python 2 , 47 bytes

Clojure , 80 bytes

PowerShell , 57 50 41 bytes

05AB1E (herdado) , 5 bytes

Braquilog , 5 bytes

Haskell , 71 bytes

Haskell , 61 58 bytes (usando Data.Char.toLower)

Perl 5 ( -p), 20 bytes

JavaScript (Node.js) , 54 bytes

Japt -¡ , 5 bytes

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

Perl 6 , 19 bytes

Java, (36 bytes)

Haskell , 61 58 bytes (usando `Data.Char.toLower`)

Perl 5 ( `-p`), 20 bytes

Japt `-¡` , 5 bytes