Aleatoriamente inspirado por los números aumentan mientras las letras disminuyen

Dada una lista de letras y enteros mixtos (p. Ej. ['a', 2, 3, 'b']) , Aumente las letras en una posición en el alfabeto (ajustando za a) y disminuya los números en 1. Para el ejemplo anterior, la salida debería ser ['b', 1, 2, 'c'].

• La entrada puede ser una lista de tipo mixto, una cadena delimitada, una lista de cadenas, etc.
• zse ajusta a a, pero 1va a 0, y 0va a-1 , etc.
• La entrada solo será una vez [a-z]y enteros. Puedes elegir letras mayúsculas[A-Z] como entrada si es más fácil para usted.
• La entrada está garantizada no vacía.
• La entrada puede contener solo números o solo letras.

Ejemplos:

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]

Reglas y aclaraciones

• La entrada y salida se pueden dar por cualquier método conveniente .
• Puede imprimir el resultado en STDOUT o devolverlo como resultado de una función.
• La salida no tiene que tener el mismo formato que la entrada (por ejemplo, podría tomar la entrada como una cadena y la salida como una lista).
• Un programa completo o una función son aceptables.
• Si corresponde, puede suponer que los enteros de entrada / salida se ajustan al intrango nativo de su idioma .
• Lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

05AB1E , 5 bytes

<AAÀ‡

Pruébalo en línea!

<          # 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]

Pruébalo en línea!

-1 byte gracias a Erik the Outgolfer

Perl 5 (-p), 17 bytes

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

Pruébalo en línea!

Bonus de 19 bytes:

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

TIO . Este presenta algunos trucos geniales, pero no supera la solución directa anterior.

Rubí , 34 bytes

Para cada elemento, intente devolver el elemento -1. Las cadenas no pueden hacer esto, por lo que se equivocan y son recogidas por la rescuecláusula, que en su lugar le pide succque devuelva la siguiente letra del alfabeto. succ"vuelca" zy regresa aa, así que simplemente tomamos el primer carácter en la cadena devuelta.

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

Pruébalo en línea!

JavaScript (Node.js) , 55 bytes

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

Pruébalo en línea!

Python 3 , 182 130 118 bytes

-51 bytes gracias a @AdmBorkBork y @Black Owl Kai, -1 byte gracias a @Black Owl Kai, -12 bytes reemplazando .append()con +=[]y reemplazando n+1con-~n

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

Pruébalo en línea!

Hice esto mientras la pregunta estaba en el Sandbox, pero no la vi publicada hasta ahora. :PAG

Sin golf

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

Explicación

Para cada elemento en la lista ingresada x, intenta restar 1 y agregarlo a la lista devuelta eventual. Si se produce un error (porque el elemento es una cadena), el índice de la letra en el alfabeto se agrega por 1 y se toma ese mod 26. El mod 26 envuelve un índice de 26 a 0.

J , 30 bytes

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

Pruébalo en línea!

Gema , 55 caracteres

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

Solución sucia Ajustar el incremento de letras es dolorosamente largo, por lo que obtuve una regla por separado.

La entrada puede ser cualquier cosa, solo use algunos separadores. (Incluso puede omitir separadores entre números y letras. Con el precio de 1 carácter por cambiar, <L1>también puede omitir separadores entre letras).

Ejecución de muestra:

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']

Pruébalo en línea!

Gema, 66 personajes

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

Solución limpia Mitad relativamente eficiente, luego mitad dolor puro.

Ejecución de muestra:

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']

Pruébalo en línea!

R , 77 85 bytes

Gracias @Giuseppe por los 8 bytes.

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

Pruébalo en línea!

Toma la entrada como una lista. Después de un gran cambio por @Giuseppe, esto hace uso de Mapaplicar una función a la lista. Se utiliza matchpara probar un personaje. Durante la prueba, la lista de letras extendidas y el índice se guardan para la devolución.

MathGolf , 14 bytes

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

Pruébalo en línea!

Toma la letra en minúscula.

Explicación

▄\╧              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 gracias a @FryAmTheEggman (y por mencionar que tuve un error: en 1 → -1lugar de 1 → 0).
+10 bytes para arreglar un error con 1y 0... Un caso de borde tan molesto que me fastidió durante bastante tiempo ... Pero ahora lo jugué a 41 bytes. (Ahora tengo curiosidad acerca de las versiones de <40 bytes @Neil y @CowsQuack mencionadas en los comentarios ... Gracias @Neil por la sugerencia de convertir el 0a -, y tratar con los valores negativos primero. Convirtiendo esos de vuelta de unario a entero ayudó mucho)
Aparentemente no necesito los límites en este punto, así que -4 bytes ..>.>

E / S está separada por comas.

Pruébalo en línea.

Explicación:

Transliterar todo "zabcdefghijklmnopqrstuvwxy(z)"a "abcdefghijklmnopqrstuvwxyz":

T`zl`l

Reemplace todos los 0s independientes con un -:

\b0
-

Convierta todos los números a unarios, reemplazándolos con esa cantidad de guiones bajos:

\d+
*

Para todos los valores negativos, con cero o más líneas unarias detrás: mantenga el signo menos y obtenga la longitud total de esta coincidencia (incluida la - ), convertida de nuevo a un entero:

-_*
-$.0

En cuanto a los enteros positivos: haga coincidir un entero positivo haciendo coincidir una sola línea unaria, seguida de cero o más líneas unarias. Y luego reemplácelos con la longitud de ese grupo de captura para eliminar esa única línea unaria y convertirlos nuevamente a enteros simultáneamente:

_(_*)
$.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

Pruébalo en línea!

PHP , 50 bytes

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

Pruébalo en línea!

Pruebas

Emite letras / enteros separados por _ un separador final.

En PHP puedes incrementar letras directamente, así que lo aproveché. Pero zse incrementa a aa, para convertirlo a, (++$a)[0]se usa el que solo genera el primer carácter del valor incrementado.

Japt -m , 13 12 bytes

-1 byte gracias a Shaggy

;¤?UÉ:Cg8+Uc

Intentalo

Explicación:

;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 : se ;convierte Cen el alfabeto en minúsculas

Haskell, 52 51 bytes

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

Como Haskell no permite listas de tipos mixtos, las letras y los números se toman y se devuelven como cadenas.

Pruébalo en línea!

Verifique cada elemento de la lista: si la cadena es "z", devuelva "a"; si el primer carácter de la cadena es> '`'(es decir, una letra, no un dígito), devuelve el sucesor de los caracteres en la cadena; de lo contrario, debe ser un número, así que conviértalo en un entero, reste 1 y vuelva a convertirlo en una cadena.

Editar: -1 byte gracias a @cole.

Jelly, 13 bytes

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

Try it online!

Clever fix by Jonathan Allan.

Note: This is not a full program, the footer over TIO makes it possible to input using a command-line argument to test the function.

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

Here f is the required function; l is both the input and output parameter, and it is expected to be a container of objects which are compatible with std::variant<char, int> or vice versa.

Try it online!

dzaima/APL, 21 20 bytes

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

Try it online!

-1 thanks to ngn.

K (oK), 27 bytes

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

Try it online!

-8 thanks to ngn and dzaima :)

Runic Enchantments, 36 bytes

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

Try it online!

General process is to read input, prepend with a 0 (coercion to string), convert back to a number (single char will always return -1), compare with input. If same, it must be a numerical value, subtract 1 and print. If not same, it must be a char, subtract 1, compare with {. If less than, print, otherwise replace it with a and print.

Repeat until program performs a stack underflow.

Output is separated by ; in order to save 1 byte (and has a trailing one). Input is space-separated.

Stax, 17 bytes

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

Run and debug it

This feels like it should be possible to do shorter, but I can't resist the opportunity to use a new stax feature from the last release.

Treating the entire input as a string:

1. Regex replace runs of digits with eval(match) - 1. This is the new feature, as the regex block replacement is not a string, but an integer.
2. Regex replace runs of letters by ring-translating them around the lower-case alphabet.

Python 3, 66 bytes

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

Edit:

I didn't see the solution of Jitse until now. The trick of if''!=i*0 is awesome!

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

Charcoal, 16 bytes

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

Try it online! Link is to verbose version of code. Takes input on STDIN, each line being either a single lowercase letter or an integer, and outputs on separate lines on STDOUT. Explanation:

ＷＳ

Repeatedly input from STDIN until an empty line is reached.

⟦

Make this expression output on its own line.

⎇№βι

Is this a substring of the predefined lowercase alphabet?

§β⊕⌕βι

If so then print the next letter cyclically indexed.

Ｉ⊖ι

Otherwise decrement the value and cast back to string for implicit print.

Zsh, 47 bytes

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

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

Try it online!

The input is a NULL-terminated array of '\0'-terminated strings, e.g. {"a", "b", "c", "17", NULL}.

-7 bytes thanks to @ceilingcat

Perl 6, 31 bytes

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

Try it online!

Anonymous Whatever lambda that maps each element to the list and attempts to subtract one from it, otherwise incrementing it and taking the first character in the case that z wraps over to aa.

T-SQL 2012, 61 bytes

Capital letters needed in input.

Using table variable as input.

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

Try it online

SimpleTemplate, 80 bytes

This was written on a language I've made.

Due to limitations in the compiler, I can't reduce it any more.

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

And now, ungolfed:

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

And the explanation:

• {@each argv as value} - loops through all values in argv. (argv contains all the arguments passed).
  If the as <var> isn't present, the default _ variable is assumed.
• {@if value is matches "@\d+@"} - checks that value matches with the regular expression "@\d+@".
• {@inc by -1 value} - increments the value by -1 (basically, a decrement).
• {@echo value, "\n"} and {@echol_} - echol outputs the values passed and appends a line at the end.
• {@else} - self-explanatory
• {@inc by 1 value} - increments the value by 1. If the by <value> is missing, it is assumed to be 1.
• {@echo value.0, "\n"} and {@echol_.0} - echol outputs the values passed and appends a line at the end.
  This is required because of the challenge rules: z wraps to a.
  When an @inc is used on a string, it increments the chars and, once it hits z, it wraps to aa.
  Outputting the first character satisfies the challenge, at the cost of 7 bytes.
• {@/} - closes the {@else} above (optional).
• {@/} - closes the {@each} above (optional).

You can try this on: http://sandbox.onlinephpfunctions.com/code/7533641a0aa1fc8bf4699a9c758690de186b052f

Each passed argument to render() will be a new value that is considered.

Perl, 64 bytes

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