Aleatoriamente inspirados por números aumentam enquanto letras diminuem

Dada uma lista de letras mistas e números inteiros (por exemplo, ['a', 2, 3, 'b']) aumente as letras em uma posição no alfabeto (envolvendo em za a) e diminua os números em 1. No exemplo acima, a saída deve ser ['b', 1, 2, 'c'].

• A entrada pode ser uma lista de tipos mistos, uma string delimitada, uma lista de strings, etc.
• zenvolve a, mas 1vai para 0e 0vai para -1etc.
• A entrada será sempre [a-z]e inteiros. Você pode escolher letras maiúsculas [A-Z]como entrada, se for mais fácil para você.
• A entrada é garantida não vazia.
• A entrada pode conter apenas números ou apenas letras.

Exemplos:

Input
Output

['a', 2, 3, 'b']
['b', 1, 2, 'c']

['a', 'b', 'z']
['b', 'c', 'a']

[-1, 0, 257, 'x']
[-2, -1, 256, 'y']

[0, 3, 1, 20382876]
[-1, 2, 0, 20382875]

Regras e esclarecimentos

• A entrada e a saída podem ser fornecidas por qualquer método conveniente .
• Você pode imprimir o resultado em STDOUT ou retorná-lo como resultado da função.
• A saída não precisa ter o mesmo formato que a entrada (por exemplo, você pode usar a entrada como uma string e a saída como uma lista).
• Um programa completo ou uma função são aceitáveis.
• Se aplicável, você pode assumir que os números inteiros de entrada / saída se encaixam no intintervalo nativo do seu idioma .
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

05AB1E , 5 bytes

<AAÀ‡

Experimente online!

<          # decrement the numbers
 A         # constant "abcdefghijklmnopqrstuvwxyz"
  AÀ       # same, but rotated left ("bcd...yza")
    ‡      # transliterate

Python 3 , 59 bytes

lambda a:[i-1if''!=i*0else chr(97+(ord(i)+8)%26)for i in a]

Experimente online!

-1 byte graças a Erik the Outgolfer

Perl 5 (-p), 17 bytes

y/a-z/b-za/or$_--

Experimente online!

Bônus de 19 byter:

$_>$_++?$_-=2:s/a//

TIO . Este apresenta alguns truques interessantes, mas não consegue superar a solução direta acima.

Rubi , 34 bytes

Para cada elemento, tente retornar o elemento -1. As strings não podem fazer isso, então elas cometem erros e são captadas pela rescuecláusula, que solicita que succela retorne a próxima letra do alfabeto. succ"rola sobre" ze retorna aa, portanto, simplesmente pegamos o primeiro caractere na string retornada.

->a{a.map{|e|e-1rescue e.succ[0]}}

Experimente online!

JavaScript (Node.js) , 55 bytes

a=>a.map(s=>1/s?s-1:B([(B(s)[0]+8)%26+97])+'',B=Buffer)

Experimente online!

Python 3 , 182 130 118 bytes

-51 bytes graças a @AdmBorkBork e @Black Owl Kai, -1 byte graças a @Black Owl Kai, -12 bytes substituindo .append()por +=[]e substituindo n+1por-~n

def a(x):
 b='abcdefghijklmnopqrstuvwxyz';c=[]
 for d in x:
  try:c+=[d-1]
  except:c+=[b[(-~b.find(d)%26)]]
 return c

Experimente online!

Fiz isso enquanto a pergunta estava na Sandbox, mas não a vi publicada até agora. : P

Ungolfed

def a(x):
    b = 'abcdefghijklmnopqrstuvwxyz'
    c = []
    for d in x:
        try:
            c.append(d - 1)
        except:
            c.append(b[((b.find(d) + 1) % 26)])
    return c

Explicação

Para cada elemento na lista inserida x, ele tenta subtrair 1 e adicioná-lo à eventual lista retornada. Se ocorrer um erro (porque o elemento é uma string), o índice da letra no alfabeto é adicionado por 1 e esse mod 26 é utilizado. O mod 26 envolve um índice de 26 de volta a 0.

J , 30 bytes

<: ::((26|>:)&.(_97+a.i.]))&.>

Experimente online!

Gema , 55 caracteres

<N>=@sub{$1;1}
z=a
<L>=@int-char{@add{@char-int{$1};1}}

Solução suja. Contornar o incremento de letra é dolorosamente longo, por isso temos uma regra separada.

A entrada pode ser qualquer coisa, basta usar alguns separadores. (Você pode até omitir separadores entre números e letras. Com o preço de 1 caractere para mudar para<L1> você, também é possível omitir separadores entre letras.)

Exemplo de execução:

bash-5.0$ gema '<N>=@sub{$1;1};z=a;<L>=@int-char{@add{@char-int{$1};1}}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']

Experimente online!

Gema, 66 caracteres

<N>=@sub{$1;1}
<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}

Solução limpa. Metade relativamente eficiente, depois metade dor pura.

Exemplo de execução:

bash-5.0$ gema '<N>=@sub{$1;1};<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']

Experimente online!

R , 77 85 bytes

Obrigado @ Giuseppe por um grito de 8 bytes

function(l)Map(function(x)"if"(i<-match(x,L<-c(letters,"a"),0),L[i+1],x-1),l)

Experimente online!

Toma a entrada como uma lista. Após uma grande alteração de @ Giuseppe, isso Mapaplica-se à aplicação de uma função à lista. Faz uso matchpara testar um personagem. Durante o teste, a lista estendida de letras e o índice são salvos para o retorno.

MathGolf , 14 bytes

▄\╧¿ò'z=¿Å'a)(

Experimente online!

Leva a letra como minúscula.

Explicação

▄\╧              Is the element in the lowercase alphabet?
   ¿ò            If so:
     'z=           Is it equal to z?
        ¿Å         If so:
          'a         Push 'a'
            )      Else: Increment the string
             (   Else: Decrement the number

Retina , 52 50 48 58 41 37 bytes

T`zl`l
\b0
-
\d+
*
-_*
-$.0
_(_*)
$.1

-4 bytes graças a @FryAmTheEggman (e por mencionar eu tive um bug: em 1 → -1vez de 1 → 0).
+10 bytes para corrigir um bug com 1e 0.. Tal um caso extremo irritante que me ferrou por um bom tempo .. Mas golfed-lo para 41 bytes agora. (Agora, estou curioso sobre as versões < Neil e @CowsQuack <40 bytes mencionadas nos comentários. Obrigado @Neil pela dica de converter o 0para -e lidar com os valores negativos primeiro. ajudou bastante.)
Aparentemente, não preciso dos limites neste momento, então -4 bytes ..>.>

A E / S é separada por vírgula.

Experimente online.

Explicação:

Transliterar tudo "zabcdefghijklmnopqrstuvwxy(z)"para "abcdefghijklmnopqrstuvwxyz":

T`zl`l

Substitua todos os 0s autônomos por -:

\b0
-

Converta todos os números em unários, substituindo-os por essa quantidade de sublinhados:

\d+
*

Para todos os valores negativos, com zero ou mais linhas unárias atrás dele: mantenha o sinal de menos e obtenha a duração total dessa correspondência (incluindo a -), convertida novamente em um número inteiro:

-_*
-$.0

Quanto aos números inteiros positivos: combine um número inteiro positivo combinando uma única linha unária, seguida por zero ou mais linhas unárias. E substitua-os pelo comprimento desse grupo de captura para remover essa única linha unária e convertê-los novamente em números inteiros simultaneamente:

_(_*)
$.1

SNOBOL4 (CSNOBOL4) , 103 bytes

	U =&UCASE 'A'
N	X =INPUT	:F(END)
	U X @P	:F(D)
	U POS(P) LEN(1) . OUTPUT	:(N)
D	OUTPUT =X - 1	:(N)
END

Experimente online!

PHP , 50 bytes

for(;''<$a=$argv[++$i];)echo$a<a?--$a:(++$a)[0],_;

Experimente online!

Testes

Gera letras / números inteiros separados por _um separador à direita.

No PHP, você pode incrementar as letras diretamente, então eu tirei vantagem disso. Mas o zé incrementado para aa, para convertê-lo a, o (++$a)[0]é usado, o que apenas gera o primeiro caractere do valor incrementado.

Japonês -m , 13 12 bytes

-1 byte graças a Shaggy

;¤?UÉ:Cg8+Uc

Tente

Explicação:

;o ?UÉ:Cg8+Uc
-m              // Map U through the input:
 o              // Try to create a range [1...U]
   ?            //   If that creates a range (number):
    UÉ          //     Return U-1
      :         //   Else, return:
;      C        //     alphabet (a...z)
        g       //     Index:
         8+Uc   //       8 + char-code of U

Nota : ;transforma C- se no alfabeto minúsculo

Haskell, 52 51 bytes

map q
q"z"="a"
q x|x>"`"=succ<$>x|1<2=show$read x-1

Como Haskell não permite listas de tipos mistos, letras e números são tomados e retornados como seqüências de caracteres.

Experimente online!

Verifique todos os elementos da lista: se a sequência for "z", retorne "a"; se o primeiro caractere da string for> '`'(ou seja, uma letra, não um dígito), retorne o sucessor do caractere na string; caso contrário, ele deve ser número; portanto, converta para um número inteiro, subtraia 1 e transforme-o em uma sequência novamente.

Edit: -1 byte graças a @cole.

Gelatina , 13 bytes

®i‘ị®µ’e?€Øa©

Experimente online!

Correção inteligente por Jonathan Allan .

Nota: Este não é um programa completo, o rodapé sobre o TIO possibilita a entrada usando um argumento de linha de comando para testar a função.

C ++ 17 (gcc) , 120 bytes

#define O int operator()
struct V{O(char&c){c++-90?:c=65;}O(int&i){--i;}};int f(auto&l){for(auto&x:l)std::visit(V{},x);}

Aqui festá a função necessária; lé o parâmetro de entrada e saída e espera-se que seja um contêiner de objetos que sejam compatíveis std::variant<char, int>ou vice-versa.

Experimente online!

dzaima / APL, 21 20 bytes

{0::⍵-1⋄⎕l(⍳⊇1⌽⊣)⍵}¨

Experimente online!

-1 graças a ngn.

K (oK) , 27 bytes

{$[9+@x;`c$97+26!8+x;x-1]}'

Experimente online!

-8 graças a ngn e dzaima :)

Encantos Rúnicos , 36 bytes

\$ka'~?*3({':+1\
R';$ >i::0Sqn=?/1-$

Experimente online!

O processo geral é ler a entrada, acrescentar um 0 (coerção à string), converter novamente em um número (o único caracter sempre retornará -1), comparar com a entrada. Se for o mesmo, deve ser um valor numérico, subtrair 1 e imprimir. Se não for o mesmo, deve ser um caractere, subtrair 1, comparar com {. Se for menor que, imprima, caso contrário, substitua-o por ae imprima.

Repita até que o programa execute um estouro de pilha.

A saída é separada por ;para salvar 1 byte (e possui um à direita). A entrada é separada por espaço.

Stax , 17 bytes

àºÇ╝'♫d▬♣ΩÜEƒ6╩╬ó

Execute e depure

Parece que deve ser possível reduzir o tempo, mas não resisto à oportunidade de usar um novo recurso stax do último lançamento.

Tratando toda a entrada como uma sequência:

1. Regex substitui execuções de dígitos por eval(match) - 1 . Esse é o novo recurso, pois a substituição do bloco regex não é uma sequência, mas um número inteiro.
2. O Regex substitui as execuções de letras traduzindo-as em volta do alfabeto em letras minúsculas.

Python 3, 66 bytes

lambda X:[x-1if type(x)==int else chr(97+(ord(x)+8)%26)for x in X]

Editar:

Eu não vi a solução do Jitse até agora. O truque de if ''! = I * 0 é incrível!

C #, 148 bytes

(object[] o)=>{var l=new List<object>();foreach(var h in o){try{l.Add((int)h-1);}catch{var c=((char)h+1);if(c>122){c=97;}l.Add((char)c);}}return l;}

Repl.it link

Ungolfed:

var inputList = new object[] {'a', 2, 'z', 6};
var outputList = new List<object>();
foreach (var currentItem in inputList)
{
    try
    {
        outputList.Add((int)currentItem-1);
    }
    catch
    {
        var currentItemPlusOne = ((char)currentItem + 1);
        if (currentItemPlusOne > 122)
        {
            currentItemPlusOne = 97;
        }
        outputList.Add((char)currentItemPlusOne);
    }
}

Carvão , 16 bytes

ＷＳ⟦⎇№βι§β⊕⌕βιＩ⊖ι

Experimente online! Link é a versão detalhada do código. Recebe entrada em STDIN, cada linha sendo uma única letra minúscula ou um número inteiro e sai em linhas separadas em STDOUT. Explicação:

ＷＳ

Insira repetidamente de STDIN até que uma linha vazia seja alcançada.

⟦

Faça essa expressão sair em sua própria linha.

⎇№βι

Isso é uma substring do alfabeto em minúsculas predefinido?

§β⊕⌕βι

Nesse caso, imprima a próxima letra indexada ciclicamente.

Ｉ⊖ι

Caso contrário, diminua o valor e retorne à string para impressão implícita.

Zsh , 47 bytes

a=({a..z} a)
for i
<<<${a[$a[(i)$i]+1]:-$[--i]}

Experimente online!

a=({a..z} a)                  # append extra 'a' to the end to handle 'z' case
for i                         # for i in "$@" arguments
<<<${a[$a[(i)$i]+1]:-$[--i]}
       $a[(i)$i]              # first (i)ndex of $i in list (if not found, set to after last index)
      [         +1]           # increment
   ${a[           ]        }  # value in array at index. if lookup fails, empty string
   ${              :-$[--i]}  # if empty, decrement $i and substitute instead
<<<                           # print to stdout

C (gcc) , 93 86 bytes

f(int**s){for(char**p=s,*z;z=*p++;)64&*z?*z=*z-'z'?++*z:97:sprintf(z,"%d",atoi(z)-1);}

Experimente online!

A entrada é uma NULLmatriz '\0'terminada de seqüências terminadas, por exemplo {"a", "b", "c", "17", NULL}.

-7 bytes graças a @ceilingcat

Perl 6 , 31 bytes

*>>.&{(try $_-1)||chr ord ++$_}

Experimente online!

Anonymous O que quer lambda que mapeia cada elemento à lista e tentativas de subtrair um, caso contrário incrementá-lo e tomar o primeiro caractere no caso em que zenvoltórios até aa.

T-SQL 2012, 61 bytes

Letras maiúsculas necessárias na entrada.

Usando variável de tabela como entrada.

SELECT iif(x<'a',left(x-1,9),char((ascii(x)-64)%26+65))FROM @

Experimente online

SimpleTemplate, 80 bytes

Isso foi escrito em um idioma que eu fiz.

Devido a limitações no compilador, não posso mais reduzi-lo.

{@eachargv}{@if_ is matches"@\d+@"}{@incby-1_}{@echol_}{@else}{@inc_}{@echol_.0}

E agora, não destruído:

{@each argv as value}
    {@if value is matches "@\d+@"}
        {@inc by -1 value}
    {@else}
        {@inc by 1 value}
    {@/}
    {@echo value, "\n"}
{@/}

E a explicação:

• {@each argv as value}- percorre todos os valores em argv. ( argvcontém todos os argumentos passados).
  Se as <var>não estiver presente, o padrão_ variável será assumida.
• {@if value is matches "@\d+@"}- verifica a valuecorrespondência com a expressão regular"@\d+@" .
• {@inc by -1 value} - incrementa o valor em -1 (basicamente, um decremento).
• {@echo value, "\n"}e {@echol_}-echol gera os valores passados ​​e acrescenta uma linha no final.
• {@else} - auto-explicativo
• {@inc by 1 value}- incrementa o valor em 1. Se by <value>estiver faltando, presume-se que seja 1.
• {@echo value.0, "\n"}e {@echol_.0}- echolgera os valores passados ​​e acrescenta uma linha no final.
  Isso é necessário por causa das regras de desafio: z wraps to a.
  Quando um @incé usado em uma seqüência de caracteres, ele incrementa os caracteres e, uma vez atingido z, é finalizado aa.
  A saída do primeiro caractere satisfaz o desafio, ao custo de 7 bytes.
• {@/} - fecha o {@else}acima (opcional).
• {@/}- fecha o {@each}acima (opcional).

Você pode tentar isso em: http://sandbox.onlinephpfunctions.com/code/7533641a0aa1fc8bf4699a9c758690de186b052f

Cada argumento passado para render()será um novo valor que é considerado.

Perl, 64 bytes

foreach (@ARGV){$_=~m/[a-zA-Z]/?++$_:--$_;print substr $_,0,1;}