Numbers Decrease while Letters Increase

Question

Randomly inspired by Numbers Increase While Letters Decrease

Given a list of mixed letters and integers (e.g., ['a', 2, 3, 'b']) increase the letters by one position in the alphabet (wrapping at z to a) and decrease the numbers by 1. For the above example, the output should be ['b', 1, 2, 'c'].

• The input can be a mixed-type list, a delimited string, a list of strings, etc.
• z wraps to a, but 1 goes to 0, and 0 goes to -1, etc.
• The input will only ever be [a-z] and integers. You can choose capital letters [A-Z] as input if that's easier for you.
• The input is guaranteed non-empty.
• The input may contain only numbers or only letters.

Examples:

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]

Rules and Clarifications

• Input and output can be given by any convenient method.
• You can print the result to STDOUT or return it as a function result.
• The output doesn't have to be the same format as the input (e.g., you could take input as a string and output as a list).
• Either a full program or a function are acceptable.
• If applicable, you can assume the input/output integers fit in your language's native int range.
• Standard loopholes are forbidden.
• This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Answer 1

05AB1E, 5 bytes

<AAÀ‡

Try it online!

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

Answer 2

Python 3, 59 bytes

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

Try it online!

-1 byte thanks to Erik the Outgolfer

Answer 3

Perl 5 (-p), 17 bytes

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

Try it online!

Bonus 19-byter:

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

TIO. This one features some cool tricks, but fails to beat the straightforward solution above.

Answer 4

Ruby, 34 bytes

For each element, attempt to return the element -1. Strings cannot do this, so they error out and are picked up by the rescue clause, which instead calls succ on it to return the next letter in the alphabet. succ "rolls over" on z and returns aa though, so we simply take the first character in the returned string.

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

Try it online!

Answer 5

JavaScript (Node.js), 55 bytes

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

Try it online!

Answer 6

Python 3, 182 130 118 bytes

-51 bytes thanks to @AdmBorkBork and @Black Owl Kai, -1 byte thanks to @Black Owl Kai, -12 bytes by replacing .append() with +=[] and replacing n+1 with -~n

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

Try it online!

I made this while the question was in the Sandbox but didn't see it posted until just now. :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

Explanation

For each element in the inputted list x, it tries to subtract 1 and add it to the eventual returned list. If an error occurs (because the element is a string), the letter's index in the alphabet is added by 1 and that mod 26 is taken. The mod 26 wraps an index of 26 back to 0.

Answer 7

J, 30 bytes

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

Try it online!

Answer 8

Gema, 55 characters

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

Dirty solution. Wrapping around on letter increment is painfully long, so got a separate rule.

Input can be quite anything, just use some separators. (You can even omit separators between numbers and letters. With the price of 1 character for changing to <L1> you could omit separators between letters too.)

Sample run:

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

Try it online!

Gema, 66 characters

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

Clean solution. Half relatively efficient, then half pure pain.

Sample run:

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

Try it online!

Answer 9

R, 77 85 bytes

Thanks @Giuseppe for a whooping 8 bytes

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

Try it online!

Takes the input as a list. After a big change by @Giuseppe, this makes use of Map to apply a function to the list. It makes use of match to test for a character. During the test the extended letter list and index are saved for the return.

Answer 10

MathGolf, 14 bytes

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

Try it online!

Takes letter as lowercase.

Explanation

▄\╧              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

Answer 11

Retina, 52 50 48 58 41 37 bytes

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

-4 bytes thanks to @FryAmTheEggman (and for mentioning I had a bug: 1 → -1 instead of 1 → 0).
+10 bytes to fix a bug with 1 and 0.. Such an annoying edge case which screwed me over for quite a while.. But golfed it to 41 bytes now. (Now I'm curious about the <40 bytes versions @Neil and @CowsQuack mentioned in the comments.. Thanks @Neil for the tip of converting the 0 to -, and dealing with the negative values first. Converting those right back from unary to integer helped a lot.)
Apparently I don't need the boundaries at this point, so -4 bytes.. >.>

I/O is comma-separated.

Try it online.

Explanation:

Transliterate all "zabcdefghijklmnopqrstuvwxy(z)" to "abcdefghijklmnopqrstuvwxyz":

T`zl`l

Replace all standalone 0s with a -:

\b0
-

Convert all numbers to unary, by replacing them with that amount of underscores:

\d+
*

For all negative values, with zero or more unary-lines behind it: keep the minus sign, and get the total length of this match (including the -), converted back to an integer:

-_*
-$.0

As for the positive integers: match a positive integer by matching a single unary-line, followed by zero or more unary-lines. And then replace them with the length of that capture group to remove that single unary-line and convert them back to integers simultaneously:

_(_*)
$.1

Answer 12

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

Try it online!

Answer 13

PHP, 50 bytes

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

Try it online!

Tests

Outputs letters/integers separated by _ with a trailing separator.

In PHP you can increment letters directly, so I took advantage of it. But the z is incremented to aa, to convert it to a, the (++$a)[0] is used which only outputs the first character of the incremented value.

Answer 14

Japt -m, 13 12 bytes

-1 byte thanks to Shaggy

;¤?UÉ:Cg8+Uc

Try it

Explanation:

;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

Note: ; turns C into the lowercase alphabet

Answer 15

Haskell, 52 51 bytes

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

As Haskell doesn't allow lists of mixed types, letters and numbers are taken and returned as strings.

Try it online!

Check for every list element: if the string is "z", return "a"; if the first character of the string is > '`' (i.e. a letter, not a digit), return the successor of the char(s) in the string; else it must be number, so convert to an integer, subtract 1 and turn into a string again.

Edit: -1 byte thanks to @cole.

Answer 16

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.

Answer 17

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!

Answer 18

dzaima/APL, 21 20 bytes

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

Try it online!

-1 thanks to ngn.

Answer 19

K (oK), 27 bytes

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

Try it online!

-8 thanks to ngn and dzaima :)

Answer 20

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.

Answer 21

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.

Answer 22

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!

Answer 23

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

Answer 24

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.

Answer 25

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

Answer 26

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

Answer 27

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.

Answer 28

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

Answer 29

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.

Answer 30

Perl, 64 bytes

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