J'ai eu spontanément l'idée de créer une série de défis d'utilisateurs qui ont aidé et continuent d'aider la communauté des PPCG à devenir un lieu agréable pour tous, ou peut-être plus précisément pour moi. : P

Si vous convertissez le nom de Dennis en un tableau de 1s et 0s où chaque consonne 1et chaque voyelle sont 0, le tableau [1, 0, 1, 1, 0, 1]est symétrique. Votre défi consiste donc à déterminer quels autres noms sont comme ceci.

Défi

Avec une chaîne ASCII, supprimez tous les caractères qui ne sont pas des lettres et déterminez si la configuration des voyelles et des consonnes est symétrique. yn'est pas une voyelle.

Veuillez noter que votre programme ne doit pas nécessairement être ce type de chaîne lui-même.

Cas de test

Dennis -> truthy
Martin -> truthy
Martin Ender -> truthy
Alex -> falsy
Alex A. -> truthy
Doorknob -> falsy
Mego -> falsy

Mise en oeuvre de référence

Ce code Python 3 donnera la sortie correcte à partir d’un scénario de test. Il est aussi non-golfé que je pourrais le faire sans être ridicule.

Python 3

s = input()
l = []
for c in s:
	if c in 'AEIOUaeiou':
		l.append(0)
	elif c in 'BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz':
		l.append(1)
print(l == list(reversed(l)), end = '')

Essayez-le en ligne!

05AB1E , 9 octets

žM¹álSåÂQ

Essayez-le en ligne!

-2 grâce à Adnan .

Cela attaque le point de douleur de Jelly exactement. Il utilise let A, des équivalents sur 1 octet pour Jelly Œlet Øarespectivement.

Gelée , 11 octets

ŒufØAe€ØCŒḂ

Essayez-le en ligne!

Versions alternatives:

ŒlfØae€ØCŒḂ

ŒufØAe€ØcŒḂ

ŒlfØae€ØcŒḂ

Bien sûr, un défi appréciant Dennis doit avoir une réponse dans une langue à lui.

Fonction de code machine x86 32 bits, 42 à 41 octets

Actuellement, la réponse la plus courte dans une langue autre que le golf est 1B plus courte que q / kdb + de @ streetster .

Avec 0 pour la vérité et non nul pour la fausseté: 41 à 40 octets. (en général, enregistre 1 octet pour 32 bits, 2 octets pour 64 bits).

Avec des chaînes de longueur implicite (style C terminé par 0): 45 44 octets

Code machine x86-64 (avec pointeurs 32 bits, comme l’ABI x32): 44 43 octets .

x86-64 avec des chaînes de longueur implicite, toujours 46 octets (la stratégie de bitmap décalage / masque est équilibrée à présent).

Ceci est une fonction avec la signature C _Bool dennis_like(size_t ecx, const char *esi). La convention d'appel est légèrement non standard, proche de MS vectorcall / fastcall mais avec des registres arg différents: string dans ESI et la longueur dans ECX. Il ne fait que clobber ses arg-regs et EDX. AL conserve la valeur de retour, avec les octets élevés contenant des déchets (comme le permettent les ABI SysV x86 et x32. IDK ce que les ABI de MS disent à propos des déchets élevés lors du renvoi de nombres entiers bool ou étroit).

Explication de l'algorithme :

Boucle sur la chaîne d'entrée, filtrage et classification en un tableau booléen sur la pile: pour chaque octet, vérifiez s'il s'agit d'un caractère alphabétique (sinon, passez au caractère suivant) et transformez-le en entier de 0 à 25 (AZ) . Utilisez cet entier 0-25 pour vérifier un bitmap de voyelle = 0 / consonne = 1. (Le bitmap est chargé dans un registre en tant que constante immédiate 32 bits). Poussez 0 ou 0xFF sur la pile en fonction du résultat bitmap (en fait, dans l'octet de poids faible d'un élément 32 bits, ce qui peut avoir des défauts dans les 3 premiers octets).

La première boucle produit un tableau de 0 ou 0xFF (dans les éléments dword complétés avec garbage). Effectuez la vérification palindrome habituelle avec une deuxième boucle qui s’arrête lorsque les pointeurs se croisent au milieu (ou quand ils pointent tous deux vers le même élément s’il existe un nombre impair de caractères alphabétiques). Le pointeur qui se déplace vers le haut est le pointeur de la pile et nous utilisons POP pour charger + incrémenter. Au lieu de comparer / setcc dans cette boucle, nous pouvons simplement utiliser XOR pour détecter same / different puisqu'il n'y a que deux valeurs possibles. Nous pourrions accumuler (avec OR) si nous avons trouvé des éléments non correspondants, mais une branche précurseur sur les drapeaux définis par XOR est au moins aussi bonne.

Notez que la seconde boucle utilise la bytetaille de l'opérande, elle ne tient donc pas compte de ce que la première boucle laisse en dehors de l'octet de poids faible de chaque élément du tableau.

Il utilise l' instruction non documentéesalc pour définir AL à partir de CF, de la même manière sbb al,al. Il est pris en charge sur tous les processeurs Intel (sauf en mode 64 bits), même dans Knight's Landing! Agner Fog en indique également le minutage sur tous les processeurs AMD (y compris Ryzen). Par conséquent, si les fournisseurs x86 insistent pour bloquer cet octet d'espace disque depuis 8086, nous pourrions également en profiter.

Trucs intéressants:

• astuce - Comparaison astuce pour un isalpha () et toupper () combinés, et zéro-étend l'octet pour remplir eax, mise en place pour:
• bitmap immédiat dans un registre pour bt, inspiré par quelques bons résultats du compilateur pourswitch .
• Création d'un tableau de taille variable sur la pile avec insertion dans une boucle. (Standard pour asm, mais pas quelque chose que vous pouvez faire avec C pour la version de chaîne de longueur implicite). Il utilise 4 octets d’espace de pile pour chaque caractère saisi, mais enregistre au moins 1 octet par rapport à un jeu optimal stosb.
• Au lieu de cmp / setne sur le tableau booléen, XOR booléens ensemble pour obtenir directement une valeur de vérité. ( cmp/ salcn’est pas une option, car salcne fonctionne que pour CF, et 0xFF-0 ne définit pas CF. seteest de 3 octets, mais éviterait l’ incextérieur de la boucle, pour un coût net de 2 octets (1 en mode 64 bits )) vs xor dans la boucle et le réparer avec inc.

; explicit-length version: input string in ESI, byte count in ECX
08048060 <dennis_like>:
 8048060:       55                      push   ebp
 8048061:       89 e5                   mov    ebp,esp  ; a stack frame lets us restore esp with LEAVE (1B)
 8048063:       ba ee be ef 03          mov    edx,0x3efbeee ; consonant bitmap

08048068 <dennis_like.filter_loop>:
 8048068:       ac                      lods   al,BYTE PTR ds:[esi]
 8048069:       24 5f                   and    al,0x5f    ; uppercase
 804806b:       2c 41                   sub    al,0x41    ; range-shift to 0..25
 804806d:       3c 19                   cmp    al,0x19    ; reject non-letters
 804806f:       77 05                   ja     8048076 <dennis_like.non_alpha>
 8048071:       0f a3 c2                bt     edx,eax    # AL = 0..25 = position in alphabet
 8048074:       d6                      SALC     ; set AL=0 or 0xFF from carry.  Undocumented insn, but widely supported
 8048075:       50                      push   eax
08048076 <dennis_like.non_alpha>:
 8048076:       e2 f0                   loop   8048068 <dennis_like.filter_loop>   # ecx = remaining string bytes
 ; end of first loop

 8048078:       89 ee                   mov    esi,ebp  ; ebp = one-past-the-top of the bool array
0804807a <dennis_like.palindrome_loop>:
 804807a:       58                      pop    eax      ; read from the bottom
 804807b:       83 ee 04                sub    esi,0x4
 804807e:       32 06                   xor    al,BYTE PTR [esi]
 8048080:       75 04                   jne    8048086 <dennis_like.non_palindrome>
 8048082:       39 e6                   cmp    esi,esp             ; until the pointers meet or cross in the middle
 8048084:       77 f4                   ja     804807a  <dennis_like.palindrome_loop>

08048086 <dennis_like.non_palindrome>:
 ; jump or fall-through to here with al holding an inverted boolean
 8048086:       40                      inc    eax
 8048087:       c9                      leave  
 8048088:       c3                      ret    
;; 0x89 - 0x60 = 41 bytes

C’est probablement aussi l’une des réponses les plus rapides, puisqu’aucune partie du golf ne fait vraiment mal, du moins pour les chaînes de quelques milliers de caractères où l’utilisation de la mémoire 4x ne cause pas beaucoup de pertes de mémoire cache. (Il pourrait aussi perdre des réponses qui prennent une précoce pour non-Dennis comme des chaînes avant en boucle sur tous les caractères.) salcEst plus lent que setccsur plusieurs unités centrales (par exemple 3 uops contre 1 sur Skylake), mais un contrôle bitmap avec bt/salcest toujours plus rapide qu'une recherche de chaîne ou une correspondance de regex. Et comme il n’ya pas de frais généraux de démarrage, c’est donc extrêmement économique pour les chaînes courtes.

Le faire en une passe à la volée impliquerait de répéter le code de classification pour les directions montante et descendante. Ce serait plus rapide mais une plus grande taille de code. (Bien sûr, si vous voulez aller vite, vous pouvez faire 16 ou 32 caractères à la fois avec SSE2 ou AVX2, en utilisant toujours l’astuce de comparaison en décalant l’échelle vers le bas de l’étendue signée).

Programme de test (pour ia32 ou x32 Linux) pour appeler cette fonction avec un argument cmdline, et quitter avec status = valeur de retour. strlenimplémentation de int80h.org .

; build with the same %define macros as the source below (so this uses 32-bit regs in 32-bit mode)
global _start
_start:
    ;%define PTRSIZE 4   ; true for x32 and 32-bit mode.

    mov  esi, [rsp+4 + 4*1]  ; esi = argv[1]
    ;mov  rsi, [rsp+8 + 8*1]  ; rsi = argv[1]   ; For regular x86-64 (not x32)

%if IMPLICIT_LENGTH == 0
        ; strlen(esi)
         mov     rdi, rsi
         mov     rcx, -1
        xor     eax, eax
        repne scasb    ; rcx = -strlen - 2
        not     rcx
        dec     rcx
%endif

    mov  eax, 0xFFFFAEBB   ; make sure the function works with garbage in EAX
    call dennis_like

    ;; use the 32-bit ABI _exit syscall, even in x32 code for simplicity
    mov ebx, eax
    mov eax, 1
    int 0x80           ; _exit( dennis_like(argv[1]) )

    ;; movzx edi, al   ; actually mov edi,eax is fine here, too
    ;; mov eax,231     ; 64-bit ABI exit_group( same thing )
    ;; syscall

Une version 64 bits de cette fonction pourrait utiliser sbb eax,eax, qui n’est que 2 octets au lieu de 3 pour setc al. Il faudrait également un octet supplémentaire pour decou notà la fin (car seul 32 bits a un octet inc / dec r32). En utilisant l'ABI x32 (pointeurs 32 bits en mode long), nous pouvons toujours éviter les préfixes REX même si nous copions et comparons des pointeurs.

setc [rdi]peut écrire directement dans la mémoire, mais réserver des octets ECX d’espace de pile coûte plus de taille de code que ce qui est économisé. (Et nous devons nous déplacer dans le tableau de sortie. [rdi+rcx]Prend un octet supplémentaire pour le mode d'adressage, mais nous avons réellement besoin d'un compteur qui ne soit pas mis à jour pour les caractères filtrés, ce qui sera pire que cela.)

C'est la source YASM / NASM avec des %ifconditions. Il peut être construit avec -felf32(code 32 bits) ou -felfx32( code 64 bits avec l'ABI x32), et avec une longueur implicite ou explicite . J'ai testé les 4 versions. Voir cette réponse pour un script permettant de créer un binaire statique à partir d'une source NASM / YASM.

Pour tester la version 64 bits sur un ordinateur ne prenant pas en charge l'interface ABI x32, vous pouvez modifier les paramètres de pointeur sur 64 bits. (Ensuite, soustrayez simplement le nombre de préfixes REX.W = 1 (0x48 octets). Dans ce cas, 4 instructions nécessitent des préfixes REX pour fonctionner sur des registres 64 bits). Ou appelez-le simplement avec le rspet le pointeur d'entrée dans la 4G basse de l'espace d'adressage.

%define IMPLICIT_LENGTH 0

; This source can be built as x32, or as plain old 32-bit mode
; x32 needs to push 64-bit regs, and using them in addressing modes avoids address-size prefixes
; 32-bit code needs to use the 32-bit names everywhere

;%if __BITS__ != 32   ; NASM-only
%ifidn __OUTPUT_FORMAT__, elfx32
%define CPUMODE 64
%define STACKWIDTH 8    ; push / pop 8 bytes
%else
%define CPUMODE 32
%define STACKWIDTH 4    ; push / pop 4 bytes
%define rax eax
%define rcx ecx
%define rsi esi
%define rdi edi
%define rbp ebp
%define rsp esp
%endif

    ; A regular x86-64 version needs 4 REX prefixes to handle 64-bit pointers
    ; I haven't cluttered the source with that, but I guess stuff like %define ebp rbp  would do the trick.


    ;; Calling convention similar to SysV x32, or to MS vectorcall, but with different arg regs
    ;; _Bool dennis_like_implicit(const char *esi)
    ;; _Bool dennis_like_explicit(size_t ecx, const char *esi)
global dennis_like
dennis_like:
    ; We want to restore esp later, so make a stack frame for LEAVE
    push  rbp
    mov   ebp, esp   ; enter 0,0 is 4 bytes.  Only saves bytes if we had a fixed-size allocation to do.

    ;         ZYXWVUTSRQPONMLKJIHGFEDCBA
    mov  edx, 11111011111011111011101110b   ; consonant/vowel bitmap for use with bt

;;; assume that len >= 1
%if IMPLICIT_LENGTH
    lodsb   ; pipelining the loop is 1B shorter than  jmp .non_alpha
.filter_loop:
%else
.filter_loop:
    lodsb
%endif

    and   al, 0x7F ^ 0x20  ; force ASCII to uppercase.
    sub   al, 'A'          ; range-shift to 'A' = 0
    cmp   al, 'Z'-'A'      ; if al was less than 'A', it will be a large unsigned number
    ja  .non_alpha
    ;; AL = position in alphabet (0-25)

    bt    edx, eax              ; 3B
%if CPUMODE == 32
    salc                        ; 1B   only sets AL = 0 or 0xFF.  Not available in 64-bit mode
%else
    sbb   eax, eax              ; 2B   eax = 0 or -1, according to CF.
%endif
    push  rax

.non_alpha:
%if IMPLICIT_LENGTH
    lodsb
    test   al,al
    jnz .filter_loop
%else
    loop .filter_loop
%endif
    ; al = potentially garbage if the last char was non-alpha
    ; esp = bottom of bool array

    mov   esi, ebp  ; ebp = one-past-the-top of the bool array
.palindrome_loop:
    pop   rax

    sub   esi, STACKWIDTH
    xor   al, [rsi]   ; al = (arr[up] != arr[--down]).  8-bit operand-size so flags are set from the non-garbage
    jnz .non_palindrome

    cmp   esi, esp
    ja .palindrome_loop

.non_palindrome:  ; we jump here with al=1 if we found a difference, or drop out of the loop with al=0 for no diff
    inc   eax     ;; AL transforms 0 -> 1  or  0xFF -> 0.
    leave
    ret           ; return value in AL.  high bytes of EAX are allowed to contain garbage.

J'ai regardé déconner avec DF (le drapeau de direction qui contrôle lodsd/ scasdet ainsi de suite), mais cela ne semblait pas être une victoire. Les ABI habituelles requièrent que DF soit effacé à l’entrée et à la sortie de la fonction. En supposant que l’entrée soit effacée à l’entrée mais qu’elle reste réglée à la sortie, ce serait de la triche, IMO. Il serait bien d’utiliser LODSD / SCASD pour éviter les 3 octets sub esi, 4, en particulier dans les cas où il n’ya pas de déchets élevés.

Stratégie de bitmap alternative (pour les chaînes de longueur implicite x86-64)

Il s'avère que cela ne sauvegarde aucun octet, car bt r32,r32il fonctionne toujours avec un niveau élevé de garbage dans l'index de bits. Ce n'est pas documenté comme ça shr.

Au lieu d’ bt / sbbobtenir le bit dans / hors de CF, utilisez un décalage / masque pour isoler le bit souhaité du bitmap.

%if IMPLICIT_LENGTH && CPUMODE == 64
    ; incompatible with LOOP for explicit-length, both need ECX.  In that case, bt/sbb is best
    xchg  eax, ecx
    mov   eax, 11111011111011111011101110b   ; not hoisted out of the loop
    shr   eax, cl
    and   al, 1
%else
    bt    edx, eax
    sbb   eax, eax
%endif
    push  rax

Puisque ceci produit 0/1 en AL à la fin (au lieu de 0 / 0xFF), nous pouvons faire l’inversion nécessaire de la valeur de retour à la fin de la fonction avec xor al, 1(2B) au lieu de dec eax(également 2B dans x86-64) pour toujours produire une valeur correcte bool/ de_Bool retour.

Cela permettait de sauvegarder 1B pour x86-64 avec des chaînes de longueur implicite, en évitant la nécessité de mettre à zéro les octets de poids fort de EAX. (J'avais l'habitude and eax, 0x7F ^ 0x20de forcer à mettre en majuscule et à zéro le reste de eax avec un 3 octets and r32,imm8. Mais maintenant, j'utilise le codage à 2 octets immédiat-avec-AL que la plupart des instructions 8086 ont, comme je le faisais déjà. pour le subet cmp.)

Il perd en bt/ salcen mode 32 bits et les chaînes de longueur explicite ont besoin de ECX pour le décompte, de sorte que cela ne fonctionne pas là non plus.

Mais ensuite, j'ai réalisé que j'avais tort: ​​je bt edx, eaxtravaille toujours avec des déchets très élevés dans eax. Apparemment, cela masque le compte de décalage de la même manièreshr r32, cl (en ne regardant que les 5 bits les plus bas de cl). Ceci est différent de bt [mem], regce qui peut accéder en dehors de la mémoire référencée par le mode / taille d'adressage, en le traitant comme une chaîne de bits. (Crazy CISC ...)

Le manuel insn set ref d'Intel ne documente pas le masquage. Il s'agit donc peut-être d'un comportement non documenté qu'Intel préserve pour le moment. (Ce genre de chose n'est pas rare. bsf dst, srcAvec src = 0, dst reste toujours non modifié, même s'il est documenté de laisser dst détenir une valeur indéfinie dans ce cas. AMD documente le comportement de src = 0.) J'ai testé sur Skylake et Core2, et la btversion fonctionne avec des ordures non nulles dans EAX en dehors de AL.

Une astuce intéressante consiste à utiliser xchg eax,ecx(1 octet) pour obtenir le nombre dans CL. Malheureusement, BMI2 shrx eax, edx, eaxest de 5 octets, contre seulement 2 octets pour shr eax, cl. L'utilisation bextrnécessite 2 octets mov ah,1(pour le nombre de bits à extraire), donc encore 5 + 2 octets comme SHRX + AND.

Le code source est devenu assez compliqué après l’ajout de %ifconditions. Voici le désassemblage des chaînes de longueur implicite x32 (en utilisant la stratégie alternative pour le bitmap, donc il reste 46 octets).

La principale différence par rapport à la version à longueur explicite réside dans la première boucle. Remarquez comment il y a un lodsavant, et au bas, au lieu d'un seul en haut de la boucle.

    ; 64-bit implicit-length version using the alternate bitmap strategy
    00400060 <dennis_like>:
      400060:       55                      push   rbp
      400061:       89 e5                   mov    ebp,esp
      400063:       ac                      lods   al,BYTE PTR ds:[rsi]

    00400064 <dennis_like.filter_loop>:
      400064:       24 5f                   and    al,0x5f
      400066:       2c 41                   sub    al,0x41
      400068:       3c 19                   cmp    al,0x19
      40006a:       77 0b                   ja     400077 <dennis_like.non_alpha>
      40006c:       91                      xchg   ecx,eax
      40006d:       b8 ee be ef 03          mov    eax,0x3efbeee  ; inside the loop since SHR destroys it
      400072:       d3 e8                   shr    eax,cl
      400074:       24 01                   and    al,0x1
      400076:       50                      push   rax
    00400077 <dennis_like.non_alpha>:
      400077:       ac                      lods   al,BYTE PTR ds:[rsi]
      400078:       84 c0                   test   al,al
      40007a:       75 e8                   jne    400064 <dennis_like.filter_loop>

      40007c:       89 ee                   mov    esi,ebp
    0040007e <dennis_like.palindrome_loop>:
      40007e:       58                      pop    rax
      40007f:       83 ee 08                sub    esi,0x8
      400082:       32 06                   xor    al,BYTE PTR [rsi]
      400084:       75 04                   jne    40008a <dennis_like.non_palindrome>
      400086:       39 e6                   cmp    esi,esp
      400088:       77 f4                   ja     40007e <dennis_like.palindrome_loop>

    0040008a <dennis_like.non_palindrome>:
      40008a:       ff c8                   dec    eax  ; invert the 0 / non-zero status of AL.  xor al,1 works too, and produces a proper bool.
      40008c:       c9                      leave  
      40008d:       c3                      ret    

   0x8e - 0x60 = 0x2e = 46 bytes

La rétine ,49 47 45 octets

\P{L}

i`[aeiou]
1
\D
2
+`^(.)(.*)\1$
$2
^.?$

Essayez-le en ligne!

2 octets sauvés grâce à Neil.

Sauvé encore 2 octets grâce à Martin.

Supprime les non-lettres puis remplace les voyelles par 1 et les consonnes par 2 pour obtenir des valeurs cohérentes. Ensuite, supprime à plusieurs reprises le premier et le dernier caractère s’ils sont identiques. Une fois qu'ils ne le sont pas, le mot était symétrique s'il ne reste qu'un ou zéro caractères.

PHP, 82 octets

<?=strrev($s=preg_replace(["#[^a-z]#i","#[aeiou]#i","#\pL#"],["",0,1],$argn))==$s;

Essayez-le en ligne!

MATL, 14 octets

t3Y2m)13Y2mtP=

Essayez-le sur MATL Online .

Voici une version légèrement modifiée pour vérifier tous les cas de test.

Explication

        % Implicitly grab the input as a string
        %     STACK: {'Martin Ender'}
t       % Duplicate the input
        %     STACK: {'Martin Ender', 'Martin Ender'}
3Y2     % Push the string 'ABC...XYZabc...xyz'
        %     STACK: {'Martin Ender', 'Martin Ender', 'ABC...XYZabc...xyz'}
m       % Find which characters of the input are letters using this string
        %     STACK: {'Martin Ender', [1 1 1 1 1 1 0 1 1 1 1]}
)       % Use this boolean array to select only the letters
        %     STACK: {'MartinEnder'}
13Y2    % Push the string literal 'aeiouAEIOU' to the stack
        %     STACK: {'MartinEnder', 'aeiouAEIOU'}
m       % Check for membership of each letter of the input in this string.
        %     STACK: {[0 1 0 0 1 0 1 0 0 1 0]}
tP      % Create a reversed copy
        %     STACK: {[0 1 0 0 1 0 1 0 0 1 0], [0 1 0 0 1 0 1 0 0 1 0]}
=       % Perform an element-wise comparison yielding a truthy (all 1's) or 
        % falsey (any 0's) result
        %     STACK: {[1 1 1 1 1 1 1 1 1 1 1]}
        % Implicitly display the result

Haskell, 84 75 74 69 octets

-10 grâce à @nimi
-5 grâce à @Zgarb

f x=(==)<*>reverse$[elem c"aeiouAEIOU"|c<-x,'@'<c,c<'{','`'<c||c<'[']

La compréhension de la liste remplace chaque lettre par un booléen et supprime tous les autres caractères. La première partie vérifie si la liste résultante est un palindrome.

Essayez-le en ligne!

Pyth, 18 à 15 octets

_I/L"aeiou"@Gr0

Essayez ici.

-2 grâce à KarlKastor , puis -1.

Brachylog , 13 octets

ḷ{∈Ṿg|∈Ḅg}ˢ.↔

Essayez-le en ligne!

Explication

ḷ                Lowercase the input
 {       }ˢ.     Select each char if:
  ∈Ṿg              it's a vowel, and replace it with ["aeiou"]            
     |             Or
      ∈Ḅg          it's a consonant, and replace it with ["bcdfghjklkmnpqrstvwxyz"]
           .↔    The resulting list is a palindrome

Alice , 28 octets

/uia.QN."-e@
\1"lyuy.Ra$i1/o

Essayez-le en ligne!

Sorties en 1tant que vérité et rien en tant que fausseté.

Explication

Chaque commande de ce programme s'exécute en mode ordinal, mais avec une légère torsion dans le modèle qui me permet de sauvegarder un octet. Si une nouvelle ligne est une valeur de vérité acceptable, je peux enregistrer un octet de plus par la même méthode.

Linéarisé, le programme est le suivant:

1il.uN."aei ou"ayQy.R-$@1o1@

1                           % Append "1" to top of stack
                            % STACK: ["1"]
 i                          % Push input to stack
                            % STACK: ["1", "Dennis"]
  l                         % Convert to lowercase
                            % STACK: ["1", "dennis"]
   .                        % Duplicate
                            % STACK: ["1", "dennis", "dennis"]
    u                       % Convert to uppercase
                            % STACK: ["1", "dennis", "DENNIS"]
     N                      % Take multiset difference; this removes all non-alphabetic characters
                            % STACK: ["1", "dennis"]
      .                     % Duplicate
                            % STACK: ["1", "dennis", "dennis"]
       "aei ou"             % Push "aei ou"
                            % STACK: ["1", "dennis", "dennis", "aei ou"]
              a             % Push newline
                            % STACK: ["1", "dennis", "dennis", "aeiou", "\n"]
               y            % Transliterate: replace all vowels with newlines
                            % STACK: ["1", "dennis", "d\nnn\ns"]
                Q           % Reverse stack
                            % STACK: ["d\nnn\ns", "dennis", "1"]
                 y          % Transliterate: replace remaining characters with "1"
                            % STACK: ["1\n11\n1"]
                  .         % Duplicate
                            % STACK: ["1\n11\n1", "1\n11\n1"]
                   R        % Reverse top of stack
                            % STACK: ["1\n11\n1", "1\n11\n1"]
                    -       % Remove occurrences: for same-length strings, result is "" iff strings are equal.
                            % STACK: [""]
                     $      % Pop stack, and skip next command if ""
                      @     % Terminate (skipped if c/v pattern is palindromic)
                       1o   % Output "1"
                         1  % Push "1" (useless)
                          @ % Terminate

Python 3 , 72 71 octets

-1 octet grâce à @ovs

def f(s):s=[c in'AEIOU'for c in s.upper()if'@'<c<'['];return s==s[::-1]

Essayez-le en ligne!

JavaScript (ES6), 72 69 octets

3 octets sauvés grâce à Neil

Retourne un booléen.

s=>(a=s.match(/[a-z]/gi).map(c=>!/[aeiou]/i.exec(c)))+''==a.reverse()

Cas de test

let f =

s=>(a=s.match(/[a-z]/gi).map(c=>!/[aeiou]/i.exec(c)))+''==a.reverse()

console.log(f("Dennis"))        // -> truthy
console.log(f("Martin"))        // -> truthy
console.log(f("Martin Ender"))  // -> truthy
console.log(f("Alex"))          // -> falsy
console.log(f("Alex A."))       // -> truthy
console.log(f("Doorknob"))      // -> falsy
console.log(f("Mego"))          // -> falsy

Mathematica, 113 octets

PalindromeQ@StringCases[StringReplace[#,{Characters["aeiouAEIOU"]->"1",CharacterRange["A","z"]->"0"}],{"0","1"}]&

GolfScript , 42 octets

{123,65>.26>6<-?)},{"AEIOUaeiou"?)!}%.-1%=

Essayez-le en ligne!

La partie difficile consiste à générer l’alphabet en majuscule et en minuscule dans une chaîne, que nous utiliserons dans une fonction de filtrage pour filtrer les lettres hors de l’entrée. Heureusement, étant donné que les chaînes dans GolfScript ne sont que des tableaux de points de code dotés d'une propriété spéciale, nous pouvons donc générer les points de code de manière efficace. Voici comment nous les générons:

Tout d'abord, nous générons la plage [0..122], 122 étant le codepoint pour z. Ensuite, nous prenons les éléments de l'élément à partir de l'indice 65. 65 est le codepoint pour A. À l'heure actuelle, nous avons [65..122]. Tout va bien, sauf que nous avons quelques codes codés indésirables ([91..96]). Donc, nous faisons d’abord une copie de cette gamme. Ensuite, nous prenons les éléments à partir de l'index 26, et nous avons [91..122]. Après cela, nous obtenons les éléments jusqu’à l’index 5 inclus. Nous avons maintenant [91..96]. Enfin, nous retirons ces éléments de notre [65..122], nous laissant ainsi [65..90, 97..122]. Ce sont les codes que nous voulons.

Maintenant que nous avons créé la liste des points de code de l'alphabet supérieur / inférieur, nous continuons notre fonction de filtrage. La fonction est mappée sur chaque caractère de la chaîne d'entrée qui, comme je l'ai dit au début, est analysé comme son code-point à la place. Alors maintenant, nous avons essentiellement [codepoint, [65..90, 97..122]]. Pour savoir si le caractère codepointest une lettre, il suffit de prendre son index dans la liste que nous avons créée. Si ce n'est pas là, nous aurons -1comme index.

À l'heure actuelle, nous obtenons une valeur de falsey uniquement si codepoint == 65, c'est-à-dire le premier index de notre liste, car alors seulement, il serait 0. Mais un incrément unique résoudra ce problème et, s'il codepointest dans notre liste, nous le ferons. obtenir son indice + 1, qui est toujours un nombre positif, donc toujours une vérité, alors que s'il n'est pas là, on aura -1 + 1 = 0, c'est-à-dire Falsey.

Nous appliquons enfin la fonction que j'ai décrite à chaque caractère de l'entrée, et nous prenons uniquement les caractères pour lesquels la fonction a renvoyé un résultat de vérité.

Ensuite, nous devons déterminer si chaque caractère est une voyelle ou une consonne. Comme les voyelles sont moins nombreuses que les consonnes, créer une chaîne de voyelles afin de vérifier si cette condition est plus courte que de créer une chaîne de consonnes, nous vérifions donc si chaque caractère est une voyelle. Mais, pour vérifier si la liste booléenne est palindromique, nous avons besoin de booléens, que nous ne obtenons pas simplement en prenant l'index + 1, car cela peut donner un nombre quelconque de [1..10] si le caractère est une voyelle. Et, comme la plupart des langues de golf, celle-ci n’a pas non plus de boolfonction. Donc, nous utilisons simplement not not x, puisque notretourne toujours un booléen. Mais attendez; Avons-nous vraiment besoin d'avoir des booléens spécifiques? Puisque notretourne toujours un booléen, pourquoi ne pas simplement enlever le secondnotet vérifie réellement si chaque caractère est une consonne? Oui, c'est exactement ce que nous allons faire!

Après la vérification, qui renvoie une liste de booléens, nous vérifions si cette liste booléenne est un palindrome, ce que ce défi nous demande de faire. Eh bien, quelle est la définition d'un palindrome? Oui, un palindrome est une liste ou une chaîne égale à son inverse. Alors, comment vérifions-nous? Simple, nous le dupliquons, prenons son revers et vérifions par rapport à la liste originale. Le résultat obtenu est, enfin , ce que notre code devrait renvoyer.

PHP , 87 octets

Regex version gratuite de PHP. Ajout d'une "voyelle" puisque les stripos peuvent retourner 0, ce qui est faux en PHP.

Faille corrigée par Jörg.

for(;a&$c=$argn[$p++];)!ctype_alpha($c)?:$s.=stripos(_aeiou,$c)?0:1;echo$s==strrev($s);

Essayez-le en ligne!

q / kdb +, 42 38 octets

Solution:

{x~|:[x]}{inter[x;.Q.a]in"aeiou"}lower

Exemple:

q){x~|:[x]}{inter[x;.Q.a]in"aeiou"}lower"Dennis"
1b
q){x~|:[x]}{inter[x;.Q.a]in"aeiou"}lower"Adam"
0b
q){x~|:[x]}{inter[x;.Q.a]in"aeiou"}lower"Alex A."
1b

Explication:

lower        // converts argument on the right to lowercase
.Q.a         // lowercase alphabet "abc..xyz"
inter[x;y]   // intersection of x and y (thus only return a-z)
x in "aeiou" // returns boolean list whether x is a vowel; "dennis" = 010010b
|:           // k shorthand for 'reverse'

Modifications:

• -4 octets; sortie reversepour k équivalent|:

CJam , 26 octets

lel_'{,97>--"aeiou"fe=_W%=

Essayez-le en ligne!

-1 grâce à Esolanging Fruit .

Braingolf,  4  3 octets

&JP

-1 octet grâce à Erik l'Outgolfer

Il se trouve que j'avais Ptout le temps, même avant ce défi.

J cependant, bien qu’il ait été créé avant ce défi, n’a pas été poussé à github avant le défi, il n’est donc pas compétitif.

Explication:

&JP  Implicit input, push ASCII value of each char in string to stack
&J   Replace each item in stack with 1 if vowel, otherwise 0
  P  Pop entire stack, push 1 if stack is palindromic, 0 otherwise
     Implicit output of last item on stack

Python 2, 83 octets

def f(x):k=map(lambda y:y.lower()in"aeiou",filter(str.isalpha,x));return k==k[::-1]

Définit une fonction qui donne TrueouFalse

CJam , 79 octets

Première fois! (J'ai fait ce que j'ai pu)

r{:X"AEIOUaeiou"#W>{X"BCDFGHJKLMNPQRSTVWXYZbdfghjklmnpqrstvwxyz"#W={'0}&}'1?~}%

Essayez-le en ligne!

Python 3 , 92 87 74 72 69 68 octets

l=[c in'aeouiAEOUI'for c in input()if c.isalpha()]
print(l==l[::-1])

Essayez-le en ligne!

Ruby, 57 octets

->s{x=s.scan(/\p{L}/).map{|c|c=~/[aeiou]/i};x==x.reverse}

Essayez-le en ligne!

Bash , 82 octets

i=${1//[^a-zA-Z]};a=aeouiAEOUI;b=${i//[$a]/0};c=${b//[!0$a]/1};[ $c = `rev<<<$c` ]

Essayez-le en ligne!

Recives nomme en paramètre, supprime les non-leters, remplace les voyelles par 0, les non-voyelles ni 0 par 1 et compare avec les mêmes inverses.

Peut-on en jouer un peu plus si on peut se mettre au travail en double ou en triple substitution

Le statut de sortie est 0 pour vrai et 1 pour non.

Japt v2.0a0, 19 11 octets

k\L mè\v ê¬

Essayez-le en ligne

Explication

        :Implicit input of string U.
 k\L    :Remove all non-letter characters from U.
 m      :Map over resulting string, replacing each character ...
 è\v    :with the count of the number of vowels in each single character substring.
 ê¬     :Is the above a palindrome?
        :Implicit output of boolean result.

APL (Dyalog) , 34 33 octets

{(∧/⊢=⌽)'AEIOU'∊⍨⍵/⍨⍵∊⎕A}1∘(819⌶)

Essayez-le en ligne!

Golf en cours.

PowerShell, 108 octets

read-host|%{[char[]]$_|%{$d=$_-replace'\P{L}'-replace'[aeiou]',0-replace'\D',1;$s="$s$d";$r="$d$r"};$s-eq$r}

Axiome, 126 octets

g(x)==~member?(x,alphabetic());v(s:String):Boolean==(w:=remove(g,s);a:=[member?(w.r,"aeiouAEIOU")for r in 1..#w];a=reverse(a))

tester

(8) -> [[i,v(i)] for i in ["Dennis", "Martin", "Martin Ender", "Alex", "Alex A.", "Doorknob", "Mego"]]
   (8)
   [["Dennis",true], ["Martin",true], ["Martin Ender",true], ["Alex",false],
    ["Alex A.",true], ["Doorknob",false], ["Mego",false]]
                                                      Type: List List Any

Pyke, 12 octets

#B)l1~-L{D_q

Essayez-le ici!

#B)          -    filter(is_alpha, input)
   l1        -   ^.lower()
     ~-L{    -  ^ - "bcdfghjklmnpqrstvwxyz"
         D_q - ^ == reversed(^)

PowerShell, 87 octets

$s=("$args"-replace '\P{L}'-replace'[aeiou]',0-replace'\D',1);$s-eq(-join($s[-1..-99]))

Obtenir une copie de la chaîne où les voyelles sont 0 et les consonnes 1, tous les caractères spéciaux supprimés, comparer cette chaîne à une version inversée reliée à une chaîne

Sortie:

PS C:\Users\Connor> "Dennis","Martin","Martin Ender","Alex","Alex A.","Doorknob","Mego" | % {
    $s=("$_"-replace '\P{L}'-replace'[aeiou]',0-replace'\D',1);$s-eq(-join($s[-1..-99]))
}
True
True
True
False
True
False
False

Retina , 47 octets

i(`[^a-z]

[aeiou]
1
\D
0
+`^(.)(.*)\1$
$2
^.?$

Essayez-le en ligne!

Ceci est juste une approche différente pour les caractères non alphabet