Sfida:

Data una parola, controlla se si tratta o meno di un isogramma.

Che cosa :

Un isogramma è una parola composta solo da lettere senza duplicati (senza distinzione tra maiuscole e minuscole). La stringa vuota è un isogramma.

Esempi:

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

Input:

È possibile accettare input in qualsiasi formato ragionevole

L'input conterrà solo lettere e / o numeri, nessuno spazio ( [a-zA-Z0-9])

Produzione :

true o qualsiasi valore di verità se l'input è un isogramma
false o qualsiasi valore di falsa altrimenti

Questo è code-golf, quindi vince il codice più breve in byte in ogni lingua.

code-golf string decision-problem

— Muhammad Salman
fonte

3

Caso di prova suggerito:sad2

— Adám,

1

La tua definizione di isogramma include due diverse dichiarazioni contraddittorie. Cos'è questo?

— Post Rock Garf Hunter,

9

Ti consiglio di iniziare a utilizzare la sandbox in modo che questi problemi possano essere risolti prima di pubblicare la sfida.

— fəˈnɛtɪk,

3

@MuhammadSalman Questo è molto sciatto, per favore rimuovi ". Any" dalla fine del tuo preventivo e fai qualche esempio in più ( sad2dasfallirebbe anche senza il 2quindi non mostra nulla).

— Asone Tuhid,

4

Il "Cosa" e le "Note" sembrano contraddirsi a vicenda: "Implementa una funzione che determina se una stringa che contiene solo lettere è un isogramma" (sottolineatura aggiunta) e "Potrebbero esserci numeri e quelli saranno e devono restituire false" dire cose opposte. Ho votato per il momento poco chiaro, ma per il momento lo ritratterò felicemente!

— Giuseppe,

9

Python 2/3 , 36 52 48 byte

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

Provalo online!

Approfitto del fatto che setcontiene solo elementi unici. Invocando il __len__metodo di ciascuno, posso determinare se scontiene anche solo elementi unici (ignorando il caso).

EDIT: aggiornato per soddisfare il requisito precedentemente trascurato di restituire False per input numerici. L'insieme di tutte le cifre è codificato come set(str(56**7)).

EDIT 2: Seguendo questo suggerimento dell'utente , ora approfitto di spacchettare gli argomenti per impostare la comprensione. Ciò rompe formalmente la compatibilità con Python 2.

— Scott Norton
fonte

3

benvenuto in PPCG! Anche questo dovrebbe tornare falsequando scontiene un carattere cifra.

— Giuseppe,

sta usando `56**7`(come nell'altra risposta di Python) invece di str()più breve? Non ho familiarità con Python ma questa sembra essere la principale differenza tra le tue due risposte.

— Giuseppe,

@Giuseppe python3 non ce l'hanno ``, una versione solo per python2 risparmierebbe 4 byte (3 su questo + 1 in divisione invece è uguale)

— Rod

@ Rod esattamente. Stranamente, è 56**7stato ispirato dalla tua codifica delle cifre 0-9 di seguito, ma salva sulla tua di 1 byte.

— Scott Norton,

Forse puoi aggiungere una versione di Python 2? 46 byte:lambda s:len(s)==len(set(s.lower())-{`56**7`})

— Sunny Patel,

5

05AB1E , 5 byte

lDáÙQ

Provalo online!

Spiegazione

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

— Emigna
fonte

4

R , 41 byte

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

Provalo online!

Approccio Regex. !grepl(regex,scan(,""),F)non ha funzionato, quindi immagino che la cattura non corrisponda al maiuscolo / minuscolo in R? Sono cattivo con regex in generale, quindi non mi sorprenderò se lo sto facendo male ...

R , 58 byte

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

Provalo online!

Aggiunge le cifre 0:9all'elenco (in caratteri minuscoli) dei caratteri e verifica se sono presenti duplicati.

— Giuseppe
fonte

3

rubino , 25 23 21 byte

-2 byte su entrambi grazie a Giuseppe

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

Provalo online!

-2 byte grazie a Kirill L.

Rubino `-n` , 21 19 18 16 byte

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

Provalo online!

— Solo Tuhid
fonte

@Giuseppe Non pensavo che avrebbe funzionato, grazie

— Asone Tuhid,

1

Penso che, nella seconda versione, non ti serva nemmeno $_- semplicemente lanciare una regex senza nient'altro che lo combini implicitamente contro $_: 16 byte

— Kirill L.

@KirillL. grazie, non l'ho mai visto !/.../prima, non riesco nemmeno a trovarlo su ruby-doc.org

— Asone Tuhid,

Non sorprende, l'ho imparato anche qui dopo aver ricevuto consigli da un ragazzo Perl :)

— Kirill L.

@KirillL. neanche sorprendente, la stranezza di rubini è generalmente ereditata dal perl

— Asone Tuhid,

3

Brachylog , 4 byte

ḷo⊆Ạ

Provalo online!

Il predicato avrà successo se l'input è un isogramma e fallirà in caso contrario, producendo l'alfabeto latino minuscolo se riesce. Poiché il ⊆predicato incorporato di Brachylog non corrisponde esattamente alla relazione ordinaria tra un sottoinsieme e un superset, ho dovuto dedicare un byte all'ordinamento dell'input con lettere minuscole, ma ho salvato un byte senza dover controllare esplicitamente la presenza di duplicati in esso. (Se non dovesse fallire con i numeri, potremmo semplicemente usare ḷ≠.)

— Stringa non correlata
fonte

2

Buccia , 6 byte

§=f√ü_

Provalo online!

Spiegazione

§=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

Japt , 12 byte

;v
oC ¬â eUq

Spiegazione:

;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

Provalo qui.

— lendine
fonte

2

MATL , 9 byte

kt2Y2X&X=

Provalo 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 byte

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

Provalo online!

— musicman523
fonte

2

Japt 2.0, 12 11 byte

-1 byte grazie a Nit

v
f\l â eUq

Provalo online!

— Oliver
fonte

Uh, perché hai cambiato la versione in una più lunga? Inoltre, penso che l'ultima versione di Japt sia la 1.4.4 ...

— Erik the Outgolfer,

@EriktheOutgolfer L'originale non tiene conto dei numeri che restituiscono automaticamente false.

— Oliver,

Ah, quindi hai usato una versione alfa perché in realtà è più corta.

— Erik the Outgolfer,

@EriktheOutgolfer Right. La regex sarebbe costata +2 in Japt alla vaniglia. ethproductions.github.io/japt/…

— Oliver

1

@Nit Grazie! Buon uso die

— Oliver

2

JavaScript (Node.js) , 29 25 byte

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

Provalo online!

Grazie per l'aggiornamento sulla risposta a @BMO , @ l4m2 , @KevinCruijssen

-4 byte grazie a @KevinCruijssen

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

— l4m2

@KevinCruijssen: non ho visto la versione aggiornata

Sono abbastanza sicuro che [^a-z]possa essere sostituito con\d

— Kevin Cruijssen,

@KevinCruijssen: grazie. aggiornato

2

Retina , 16 byte

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

Ritorna 1come valori di verità e 0di Falsey.
Grazie @Neil per aver scoperto e corretto un bug nel mio codice iniziale.

Provalo online.

Spiegazione:

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

Perché il tuo è contrario?

— Muhammad Salman,

@MuhammadSalman Due motivi: invertire le partite costerebbe più byte. E non sono troppo abile con Retina, quindi non sono sicuro di come invertire le partite per iniziare .. xD

— Kevin Cruijssen,

motivo 1). Ah ok. motivo 2). LOL

— Muhammad Salman,

1

PowerShell , 91 byte

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

Provalo online!

Soluzione ingenua, ma non riesco a trovare un algoritmo migliore. Prende input $b, converte il ToUppercaso, lo lancia come un chararray. Pipa l'array in Group-Objectcui costruisce un oggetto che ha coppie nome / conteggio per ogni lettera di input. Quindi basiamo sortquello sulla czia e prendiamo 0quello. Controlliamo che .Countsia -eqidentico a .Countquello dell'ultima [-1]coppia. In tal caso, i conteggi sono tutti uguali, altrimenti abbiamo una diversa quantità di lettere.

Quindi, -andverificando se l'input è -notmatchcontrario \dper escludere qualsiasi cifra nell'input. Tale risultato booleano viene lasciato sulla pipeline e l'output è implicito.

— AdmBorkBork
fonte

1

Gelatina , 8 byte

ŒufØA⁼QƲ

Provalo online!

— Erik l'Outgolfer
fonte

1

Python 2 , 57 56 byte

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

Provalo online!

Prima gira, quindi immette in un set, rimuove i duplicati, quindi rimuove le cifre (codificate `763**4`), quindi controlla se la lunghezza è uguale all'input originale

— asta
fonte

1

Java 8, 61 39 byte

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

Spiegazione:

Provalo online.

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

Spiegazione Regex:

String#matchesaggiunge 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 byte

Funzione tacita anonima.

(∪≡~∘⎕D)819⌶

Provalo online!

819⌶ minuscolo

(... ) applica la seguente funzione tacita su quella:

~∘⎕D rimuove D igits dall'argomento

∪≡ gli elementi unici dell'argomento sono identici a quello?

— Adamo
fonte

1

Perl 6 , 22 byte

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

Provalo online!

Nessuna corrispondenza per alcuni personaggi, quindi più tardi lo stesso personaggio. Funzione implicita come blocco di codice, abbinabile implicitamente a $ _, inverti libro con !. aggiunto|\d (ta Adam) ma anche necessario.uc~~, which needed parentheses...

Alternativa con sacchetti, 23 byte

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

Provalo online!

Questo caso normalizza quindi un sacchetto (impostato con conteggi di incidenza). Il sottoinsieme o uguale è vero solo se tutti i membri sono membri della borsa comparativa e tutti i conteggi dell'incidenza sono inferiori o uguali a quelli nella borsa comparativa. Quindi qualsiasi ripetizione o cifra renderebbe falso il confronto.

— Phil H
fonte

Non funziona abc1.

— Adám,

Ah, ho scritto questa risposta prima di aggiungere le specifiche dei numeri.

— Phil H

Non puoi semplicemente aggiungere |\d?

— Adám,

@ Adám: sorta di. Realizzato, inoltre, non ha rilevato lettere ripetute se i casi di quelle lettere erano diversi, quindi era necessario normalizzare il caso e aggiungere anche parentesi.

— Phil H

1

19 byte

— Jo King il

1

Rapido , 81 byte

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

Provalo online!

— Tamás Sengel
fonte

Nice! 25 bytes shorter than mine.

— onnoweb

1

Visual Basic for Applications (32 bit), 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

Used the fact that in VBA 0^x yields 1 if x is zero and 0 otherwise. Run in immediate (debug) window.

Edit: as pointed out by Taylor in the comments this only works in 32 bit installs of MS Office.

— dnep
fonte

Se limiti la tua lingua al VBA di Excel, puoi scambiarlo con 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 byte prendendo input da [A1]. Inoltre, vale la pena notare che, poiché Exponentiation in VBA è strano, questa soluzione è limitata alle installazioni a 32 bit di Office.

— Taylor Scott,

Inoltre, puoi rendere la tua risposta migliore e più leggibile utilizzando la corretta maiuscola (vedi sopra) e aggiungendo un flag alla tua risposta per aggiungere l'evidenziazione della sintassi

— Taylor Scott

1

@TaylorScott thanks! Added syntax highlighting and noted de 32 bit restriction. About the Excel input, I'd rather keep the solution application-invariant whenever possible.

— dnep

1

05AB1E, 4 bytes

lDÔQ

Try it online!

Explanation

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

— LordColus
fonte

This fails if the input contains non-letter characters.

— Shaggy

This works

— LordColus

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

— LordColus

"An isogram is a word consisting only of letters with no duplicates" - i.e., "words" containing numbers should return a falsey value. See the 5th test case for an example.

— Shaggy

My bad. See @Enigma's answer for the correct 05AB1E code.

— LordColus

1

C (gcc), 87 85 83 bytes

Saved ~~two~~ four bytes thanks to 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;}

Try it online!

— Jonathan Frech
fonte

@ceilingcat Fine suggestion, thanks.

— Jonathan Frech

@ceilingcat Thank you.

— Jonathan Frech

0

K (ngn/k), 18 bytes

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

Try it online!

— ngn
fonte

0

CJam, 11 bytes

qelA,s+_L|=

Try it online!

Explanation

The basic idea is to append each digit then check for duplicates. Since the append ensures that each digit is already present once, any further presence of digits will be a duplicate, causing it to return false.

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

Red, 76 bytes

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

Try it online!

— Galen Ivanov
fonte

0

Smalltalk, 57 bytes

Method to be defined in class String:

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

This is most likely self-explanatory.

— Hans-Martin Mosner
fonte

0

Pyth, 17 bytes

.Am&!t/rz0d}dGrz0

Test suite

Explanation:

.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

Python 3 translation:

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))));

edit: added test for char

edit: using GroupBy to shorten it by 5 byte

— Raymond Osterbrink
fonte

1

Welcome to PPCG! I think you're missing the requirement that you also need to check that the input contains no digits.

— Martin Ender

0

APL (Dyalog Unicode), 25 20 22 bytes

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

Try it online!

Returns 1 for true, else 0.

Saved 5 bytes thanks to @H.PWiz

Fixed, and saved another byte thanks to @Adám

How?

''≡'(.).*\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

Fails on abc1.

— Adám

Isn't \w → . valid?

— Adám

If you mean (.).*\1, no. It also fails for abc1 :/

— J. Sallé

I don't understand. What do you mean by "it also fails"?

— Adám

If you Try it Online! you can see it returns 1 for abc1, when it should return 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}

Try it 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}

Try it online!

Still too long for my taste!

— sergiol
fonte

Isogramma

Sfida:

Che cosa :

Esempi:

Input:

Produzione :

Python 2/3 , 36 52 48 byte

05AB1E , 5 byte

R , 41 byte

R , 58 byte

rubino , 25 23 21 byte

Rubino -n , 21 19 18 16 byte

Brachylog , 4 byte

Buccia , 6 byte

Spiegazione

Japt , 12 byte

MATL , 9 byte

Python 3 , 46 byte

Japt 2.0, 12 11 byte

JavaScript (Node.js) , 29 25 byte

Retina , 16 byte

PowerShell , 91 byte

Gelatina , 8 byte

Python 2 , 57 56 byte

Java 8, 61 39 byte

APL (Dyalog Unicode) , 12 byte

Perl 6 , 22 byte

Alternativa con sacchetti, 23 byte

Rapido , 81 byte

Visual Basic for Applications (32 bit), 102 bytes

05AB1E, 4 bytes

C (gcc), 87 85 83 bytes

K (ngn/k), 18 bytes

CJam, 11 bytes

Explanation

Red, 76 bytes

Smalltalk, 57 bytes

Pyth, 17 bytes

C#, 82 bytes

APL (Dyalog Unicode), 25 20 22 bytes

How?

Tcl, 114 bytes

Tcl, 121 bytes

Rubino `-n` , 21 19 18 16 byte