Saya mendapat ide spontan membuat serangkaian tantangan pengguna yang telah membantu dan terus membantu komunitas PPCG menjadi tempat yang menyenangkan bagi semua orang, atau mungkin hanya khusus untuk saya. : P

Jika Anda mengonversi nama Dennis menjadi array 1s dan 0s di mana setiap konsonan berada 1dan setiap vokal 0, arraynya adalah [1, 0, 1, 1, 0, 1], yang simetris. Dengan demikian, tantangan Anda adalah menentukan apa nama-nama lain seperti ini.

Tantangan

Diberikan string ASCII, hapus semua karakter yang bukan huruf dan tentukan apakah konfigurasi vokal dan konsonan simetris. ybukan vokal.

Harap dicatat bahwa program Anda tidak harus berupa tipe string itu sendiri.

Uji Kasus

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

Implementasi Referensi

Kode Python 3 ini akan memberikan output yang benar diberikan kasus uji. Itu sama seperti tidak serigala yang saya bisa membuatnya tanpa menjadi konyol.

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 = '')

Cobalah online!

05AB1E , 9 byte

žM¹álSåÂQ

Cobalah online!

Terima kasih kepada Adnan .

Ini tepatnya menyerang titik rasa sakit Jelly. Ini menggunakan ldan A, setara 1-byte untuk Jelly Œldan Øamasing - masing.

Jelly , 11 byte

ŒufØAe€ØCŒḂ

Cobalah online!

Versi alternatif:

ŒlfØae€ØCŒḂ

ŒufØAe€ØcŒḂ

ŒlfØae€ØcŒḂ

Tentu saja sebuah tantangan untuk menghargai Dennis harus memiliki jawaban dalam bahasanya.

x86 32-bit fungsi kode mesin, 42 41 byte

Saat ini jawaban non-golf-bahasa terpendek, 1B lebih pendek dari @ streetster's q / kdb + .

Dengan 0 untuk truey dan non-zero untuk falsy: 41 40 bytes. (secara umum, menyimpan 1 byte untuk 32-bit, 2 byte untuk 64-bit).

Dengan string implisit-panjang (gaya-C diakhiri): 45 44 byte

kode mesin x86-64 (dengan pointer 32-bit, seperti x32 ABI): 44 43 byte .

x86-64 dengan string implisit-panjang, masih 46 byte (strategi bitmap shift / mask adalah impas sekarang).

Ini adalah fungsi dengan C tanda tangan _Bool dennis_like(size_t ecx, const char *esi). Konvensi panggilan agak non-standar, dekat dengan MS vectorcall / fastcall tetapi dengan register arg yang berbeda: string dalam ESI dan panjang dalam ECX. Hanya clobbers arg-regs dan EDX-nya. AL memegang nilai balik, dengan byte tinggi yang menyimpan sampah (sebagaimana diizinkan oleh SysV x86 dan x32 ABI. IDK apa yang dikatakan ABI MS tentang sampah tinggi ketika mengembalikan bool atau integer sempit.)

Penjelasan algoritma :

Ulangi string input, memfilter dan mengklasifikasikan ke dalam array boolean pada stack: Untuk setiap byte, periksa apakah itu karakter alfabet (jika tidak, lanjutkan ke karakter berikutnya), dan ubah ke integer dari 0-25 (AZ) . Gunakan bilangan bulat 0-25 untuk memeriksa bitmap vow = 0 / konsonan = 1. (Bitmap dimuat ke dalam register sebagai konstanta langsung 32-bit). Dorong 0 atau 0xFF ke tumpukan sesuai dengan hasil bitmap (sebenarnya dalam byte rendah elemen 32-bit, yang mungkin memiliki sampah di 3 byte teratas).

Loop pertama menghasilkan array 0 atau 0xFF (dalam elemen kata yang diisi dengan sampah). Lakukan pemeriksaan palindrom yang biasa dengan loop kedua yang berhenti ketika pointer melintas di tengah (atau ketika keduanya menunjuk ke elemen yang sama jika ada sejumlah karakter alfabet yang aneh). Pointer yang bergerak ke atas adalah stack pointer, dan kami menggunakan POP untuk memuat + kenaikan. Daripada membandingkan / setcc dalam loop ini, kita bisa menggunakan XOR untuk mendeteksi yang sama / berbeda karena hanya ada dua nilai yang mungkin. Kami dapat mengakumulasikan (dengan OR) apakah kami menemukan elemen yang tidak cocok, tetapi cabang awal pada flag yang ditetapkan oleh XOR setidaknya sama baiknya.

Perhatikan bahwa loop kedua menggunakan byteukuran operan, jadi tidak peduli sampah apa yang ditinggalkan loop pertama di luar byte rendah dari setiap elemen array.

Ia menggunakan instruksi tidak berdokumensalc untuk mengatur AL dari CF, dengan cara yang sama sbb al,alakan. Ini didukung pada setiap CPU Intel (kecuali dalam mode 64-bit), bahkan Knight's Landing! Agner Fog mencantumkan penetapan waktu untuk itu pada semua CPU AMD juga (termasuk Ryzen), jadi jika vendor x86 bersikeras untuk mengikat byte ruang opcode itu sejak 8086, sebaiknya kita memanfaatkannya.

Trik menarik:

• trik unsigned-bandingkan untuk isalpha () dan toupper () yang dikombinasikan, dan zero-extends byte untuk mengisi eax, mengatur untuk:
• bitmap langsung dalam register untuk bt, terinspirasi oleh beberapa keluaran kompiler yang bagus untukswitch .
• Membuat array berukuran variabel pada stack dengan mendorong dalam satu lingkaran. (Standar untuk asm, tetapi bukan sesuatu yang dapat Anda lakukan dengan C untuk versi string implisit-panjang). Ini menggunakan 4 byte ruang stack untuk setiap karakter input, tetapi menyimpan setidaknya 1 byte vs bermain golf yang optimal stosb.
• Alih-alih cmp / setne pada array boolean, XOR booleans bersama-sama untuk mendapatkan nilai kebenaran secara langsung. ( cmp/ salcbukan pilihan, karena salchanya berfungsi untuk CF, dan 0xFF-0 tidak mengatur CF seteadalah 3 byte, tetapi akan menghindari incloop luar, dengan biaya bersih 2 byte (1 dalam mode 64-bit) )) vs. xor di loop dan memperbaikinya dengan 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

Ini mungkin juga salah satu jawaban tercepat, karena tidak ada golf yang benar-benar sakit terlalu parah, setidaknya untuk string di bawah beberapa ribu karakter di mana penggunaan memori 4x tidak menyebabkan banyak cache-misses. (Mungkin juga kalah dari jawaban yang mengambil string awal untuk string yang tidak seperti Dennis sebelum mengulang semua karakter.) Lebih salclambat daripada setccpada banyak CPU (misalnya 3 uops vs 1 pada Skylake), tetapi bitmap memeriksa dengan bt/salcmasih lebih cepat dari pencarian string atau pertandingan-regex. Dan tidak ada overhead startup, jadi sangat murah untuk string pendek.

Melakukannya dalam satu pass on the fly berarti mengulang kode klasifikasi untuk arah naik dan turun. Itu akan lebih cepat tetapi ukuran kode lebih besar. (Tentu saja jika Anda ingin cepat, Anda dapat melakukan 16 atau 32 karakter sekaligus dengan SSE2 atau AVX2, masih menggunakan trik perbandingan dengan menggeser rentang ke bagian bawah rentang yang ditandatangani).

Uji program (untuk ia32 atau x32 Linux) untuk memanggil fungsi ini dengan argumen cmdline, dan keluar dengan status = nilai balik. strlenimplementasi dari 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

Versi 64-bit dari fungsi ini dapat digunakan sbb eax,eax, yang hanya 2 byte, bukan 3 untuk setc al. Itu juga akan membutuhkan byte tambahan untuk decatau notdi akhir (karena hanya 32-bit memiliki 1-byte inc / dec r32). Menggunakan ABI x32 (pointer 32-bit dalam mode panjang), kita masih dapat menghindari awalan REX meskipun kita menyalin dan membandingkan pointer.

setc [rdi]dapat menulis langsung ke memori, tetapi memesan byte ruang stack ECX biaya lebih banyak ukuran kode daripada menghemat. (Dan kita perlu bergerak melalui array output. [rdi+rcx]Membutuhkan satu byte tambahan untuk mode pengalamatan, tetapi sebenarnya kita membutuhkan penghitung yang tidak memperbarui untuk karakter yang difilter sehingga akan lebih buruk dari itu.)

Ini adalah sumber YASM / NASM dengan %ifkondisional. Ia dapat dibangun dengan -felf32(kode 32-bit) atau -felfx32(kode 64-bit dengan ABI x32), dan dengan panjang implisit atau eksplisit . Saya sudah menguji semua 4 versi. Lihat jawaban ini untuk skrip untuk membuat biner statis dari sumber NASM / YASM.

Untuk menguji versi 64-bit pada mesin tanpa dukungan untuk ABI x32, Anda dapat mengubah regs penunjuk menjadi 64-bit. (Kemudian kurangi jumlah REX.W = 1 awalan (0x48 byte) dari hitungan. Dalam hal ini, 4 instruksi memerlukan awalan REX untuk beroperasi pada regs 64-bit). Atau cukup sebut saja dengan rspdan input pointer di ruang alamat 4G rendah.

%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.

Saya melihat bermain-main dengan DF (bendera arah yang mengontrol lodsd/ scasddan sebagainya), tapi sepertinya tidak menang. ABI yang biasa mengharuskan DF dihapus pada entri fungsi dan keluar. Dengan asumsi dibersihkan pada entri tetapi membiarkannya ditetapkan pada saat keluar akan curang, IMO. Akan lebih baik menggunakan LODSD / SCASD untuk menghindari 3-byte sub esi, 4, terutama dalam kasus di mana tidak ada sampah yang tinggi.

Strategi bitmap alternatif (untuk string panjang implisit x86-64)

Ternyata ini tidak menyimpan byte, karena bt r32,r32masih berfungsi dengan sampah tinggi di bit-index. Hanya saja tidak terdokumentasi seperti apa shradanya.

Alih-alih bt / sbbmemasukkan bit ke / keluar dari CF, gunakan shift / mask untuk mengisolasi bit yang kita inginkan dari 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

Karena ini menghasilkan 0/1 dalam AL di akhir (bukan 0 / 0xFF), kita dapat melakukan inversi yang diperlukan dari nilai pengembalian di akhir fungsi dengan xor al, 1(2B) alih-alih dec eax(juga 2B di x86-64) untuk masih menghasilkan nilai yang layak bool/_Bool kembali.

Ini digunakan untuk menghemat 1B untuk x86-64 dengan string panjang implisit, dengan menghindari kebutuhan untuk nol byte tinggi EAX. (Saya telah menggunakan and eax, 0x7F ^ 0x20untuk memaksa huruf besar dan nol sisa eax dengan 3-byte and r32,imm8. Tapi sekarang saya menggunakan 2-byte langsung-dengan-AL pengkodean yang paling 8086 instruksi miliki, seperti yang sudah saya lakukan untuk subdan cmp.)

Itu hilang ke bt/ salcdalam mode 32-bit, dan string panjang-eksplisit membutuhkan ECX untuk hitungan sehingga ini tidak berfungsi di sana juga.

Tetapi kemudian saya menyadari bahwa saya salah: bt edx, eaxmasih bekerja dengan sampah tinggi di eax. Ini rupanya menutupi hitungan shift dengan cara yang sama shr r32, cltidak (melihat hanya pada 5 bit cl rendah). Ini berbeda dari bt [mem], reg, yang dapat mengakses di luar memori yang dirujuk oleh mode / ukuran pengalamatan, memperlakukannya sebagai bitstring. (Gila CISC ...)

Manual referensi yang ditetapkan Intel tidak mendokumentasikan penutupan, jadi mungkin itu perilaku tidak berdokumen yang dipertahankan Intel untuk saat ini. (Hal semacam itu tidak jarang terjadi. bsf dst, srcDengan src = 0 selalu meninggalkan dst tidak dimodifikasi, meskipun itu didokumentasikan untuk meninggalkan dst memegang nilai yang tidak ditentukan dalam kasus itu. AMD sebenarnya mendokumentasikan perilaku src = 0.) Saya menguji Skylake dan Core2, dan btversi ini bekerja dengan sampah non-nol di EAX di luar AL.

Trik yang rapi di sini adalah menggunakan xchg eax,ecx(1 byte) untuk mendapatkan hitungan ke CL. Sayangnya, BMI2 shrx eax, edx, eaxadalah 5 byte, vs hanya 2 byte untuk shr eax, cl. Menggunakan bextrmembutuhkan 2-byte mov ah,1(untuk jumlah bit untuk diekstrak), jadi itu lagi 5 + 2 byte seperti SHRX + AND.

Kode sumber menjadi sangat berantakan setelah menambahkan %ifkondisional. Inilah pembongkaran string x32 implisit-panjang (menggunakan strategi alternatif untuk bitmap, jadi itu masih 46 byte).

Perbedaan utama dari versi panjang eksplisit di loop pertama. Perhatikan bagaimana ada lodssebelumnya, dan di bagian bawah, bukan hanya satu di bagian atas loop.

    ; 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

Retina ,49 47 45 byte

\P{L}

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

Cobalah online!

Disimpan 2 byte berkat Neil.

Disimpan 2 byte lagi berkat Martin.

Menghapus non-huruf kemudian mengganti vokal dengan 1 dan konsonan dengan 2, untuk mendapatkan nilai yang konsisten. Kemudian berulang kali menghapus karakter pertama dan terakhir jika mereka sama. Begitu mereka tidak, kata itu simetris jika ada satu atau nol karakter yang tersisa.

PHP, 82 Bytes

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

Cobalah online!

MATL, 14 byte

t3Y2m)13Y2mtP=

Cobalah di MATL Online .

Ini adalah versi yang sedikit dimodifikasi untuk memeriksa semua kasus uji.

Penjelasan

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

-10 Berkat @nimi
-5 Berkat @Zgarb

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

Pemahaman daftar menggantikan setiap huruf dengan boolean dan menghapus semua karakter lainnya. Bagian pertama memeriksa apakah daftar yang dihasilkan adalah palindrome atau tidak.

Cobalah online!

Pyth, 18 15 byte

_I/L"aeiou"@Gr0

Coba di sini.

-2 Berkat KarlKastor , dan selanjutnya -1.

Brachylog , 13 byte

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

Cobalah online!

Penjelasan

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

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

Cobalah online!

Output 1sebagai kebenaran dan tidak ada yang palsu.

Penjelasan

Setiap perintah dalam program ini dijalankan dalam mode ordinal, tetapi dengan sedikit sentuhan pada template yang memungkinkan saya untuk menyimpan byte. Jika baris baru adalah nilai kebenaran yang dapat diterima, saya dapat menyimpan satu byte lagi dengan metode yang sama.

Secara linier, programnya adalah sebagai berikut:

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 byte

-1 byte terima kasih kepada @ovs

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

Cobalah online!

JavaScript (ES6), 72 69 byte

Disimpan 3 byte berkat Neil

Mengembalikan boolean.

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

Uji kasus

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 byte

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

GolfScript , 42 byte

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

Cobalah online!

Bagian yang sulit adalah menghasilkan alfabet huruf besar dan kecil dalam satu string, yang akan kita gunakan dalam fungsi filter untuk menyaring huruf keluar dari input. Untungnya, karena string dalam GolfScript hanyalah array codepoint dengan properti khusus, jadi kami hanya dapat menghasilkan codepoint dengan cara yang efisien. Inilah cara kami membuatnya:

Pertama, kami menghasilkan rentang [0..122], 122 menjadi titik kode untuk z. Kemudian, kita mengambil elemen dari elemen di indeks 65 dan seterusnya. 65 adalah codepoint untuk A. Saat ini, kami memiliki [65..122]. Semua baik-baik saja, kecuali kita memiliki beberapa codepoint yang tidak diinginkan ([91,96]) di sana. Jadi, pertama-tama kita membuat duplikat rentang itu. Kemudian, kami mengambil elemen dari indeks 26 dan seterusnya, dan kami memiliki [91..122]. Setelah itu, kita mendapatkan elemen hingga dan termasuk indeks 5. Sekarang kita punya [91..96]. Akhirnya, kami menghapus elemen-elemen itu dari [65..122] kami, meninggalkan kami wil [65..90, 97..122]. Itu adalah codepoint yang kita inginkan.

Sekarang kami telah membuat daftar codepoint alfabet atas / bawah, kami melanjutkan fungsi penyaringan kami. Fungsi akan dipetakan ke setiap karakter pada string input, yang, seperti yang saya katakan sebelumnya, akan diurai sebagai codepoint sebagai gantinya. Jadi sekarang pada dasarnya kita miliki [codepoint, [65..90, 97..122]]. Untuk mengetahui apakah char codepointadalah surat, kita cukup mengambil indeksnya di daftar yang kita buat. Jika tidak ada di sana, kita akan mendapatkan -1sebagai gantinya indeks.

Saat ini, kami mendapatkan nilai falsey hanya jika codepoint == 65, yaitu indeks pertama dari daftar kami, karena hanya kemudian indeksnya menjadi 0. Tetapi satu peningkatan akan memperbaiki masalah ini, dan, sekarang, jika codepointada dalam daftar kami, kami akan dapatkan indeksnya + 1, yang selalu merupakan angka positif, dengan demikian selalu benar, sedangkan jika tidak ada kita akan mendapatkan -1 +1 = 0, yaitu falsey.

Kami akhirnya menerapkan fungsi yang saya jelaskan ke setiap karakter input, dan kami hanya mengambil karakter yang fungsinya mengembalikan hasil yang benar.

Selanjutnya kita harus menentukan apakah masing-masing karakter adalah vokal atau konsonan. Karena vokal lebih sedikit dari konsonan, membuat string vokal sehingga kami memeriksa kondisi itu lebih pendek daripada membuat string konsonan, jadi kami memeriksa apakah masing-masing karakter adalah vokal. Tetapi, untuk memeriksa apakah daftar boolean adalah palindromik, kita membutuhkan boolean, yang tidak kita dapatkan hanya dengan mengambil indeks +1, karena itu dapat menghasilkan sejumlah [1..10] jika char adalah vokal. Dan, seperti kebanyakan bahasa golf, yang satu ini, tidak memiliki boolfungsi juga. Jadi, kami cukup menggunakan not not x, karena notselalu mengembalikan boolean. Tapi tunggu; apakah kita benar-benar perlu memiliki boolean tertentu? Karena notselalu mengembalikan boolean, mengapa kita tidak menghapus yang kedua sajanot, dan benar-benar memeriksa apakah masing-masing char adalah konsonan? Ya, itulah yang akan kami lakukan!

Setelah cek, yang mengembalikan daftar boolean, kami memeriksa apakah daftar boolean yang kami dapatkan adalah palindrom, yang merupakan tantangan yang diminta oleh kami untuk dilakukan. Nah, apa definisi palindrome? Ya, palindrome adalah daftar atau string yang sama dengan kebalikannya. Jadi, bagaimana kita memeriksanya? Sederhana, kami menduplikasinya, mengambil kebalikannya, dan memeriksa daftar asli. Hasil yang kita dapatkan adalah, akhirnya , apa yang harus dikembalikan oleh kode kita.

PHP , 87 byte

Regex versi PHP gratis. Menambahkan "vokal" karena stripos dapat mengembalikan 0 yang salah dalam PHP.

Cacat diperbaiki oleh Jörg.

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

Cobalah online!

q / kdb +, 42 38 byte

Larutan:

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

Contoh:

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

Penjelasan:

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'

Suntingan:

• -4 byte; beralih reverseke k setara|:

CJam , 26 byte

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

Cobalah online!

-1 berkat Buah Esolanging .

Braingolf,  4  3 byte

&JP

-1 byte terima kasih kepada Erik the Outgolfer

Ternyata saya sudah Pbersama, bahkan sebelum tantangan ini.

J Namun, meskipun diciptakan sebelum tantangan ini, tidak didorong ke github sebelum tantangan, dengan demikian masih non-bersaing.

Penjelasan:

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

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

Menentukan fungsi yang memberikan TrueatauFalse

CJam , 79 byte

Timer pertama! (Saya melakukan apa yang saya bisa)

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

Cobalah online!

Python 3 , 92 87 74 72 69 68 byte

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

Cobalah online!

Ruby, 57 byte

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

Cobalah online!

Bash , 82 byte

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

Cobalah online!

Menerima nama sebagai parameter, menghapus non-leter, mengganti vokal dengan 0, non-vokal atau 0 dengan 1 dan membandingkan dengan yang sama terbalik.

Bisa bermain golf lagi jika bisa mulai bekerja substitusi ganda atau tiga kali lipat

Status keluar adalah 0 untuk true dan 1 untuk no.

Japt v2.0a0, 19 11 byte

k\L mè\v ê¬

Cobalah online

Penjelasan

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

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

Cobalah online!

Golf sedang berlangsung.

PowerShell, 108 byte

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

Aksioma, 126 byte

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

uji

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

#B)l1~-L{D_q

Coba di sini!

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

PowerShell, 87 Bytes

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

Dapatkan salinan string di mana vokal 0 dan konsonan 1, dengan semua karakter khusus dihapus, bandingkan string itu dengan versi terbalik yang digabungkan kembali ke string

Keluaran:

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 byte

i(`[^a-z]

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

Cobalah online!

Ini hanya pendekatan yang berbeda untuk karakter non-alfabet