Revisions to Same length, different string

Notice removed Reward existing answer by Adám

occurred Mar 15, 2023 at 12:12

Bounty Ended with The Thonnu's answer chosen by Adám

occurred Mar 15, 2023 at 12:12

Notice added Reward existing answer by Adám

occurred Mar 8, 2023 at 9:20

Bounty Started worth 100 reputation by Adám

occurred Mar 8, 2023 at 9:20

edited body

Source Link

edited Sep 6, 2017 at 0:13

MD XF

13.9k
4
66
104

Challenge

Given a non-empty string S of length L consisting entirely of printable ASCII chars, output another string of length L that consists entirely of printable ASCII chars, but is not equal to S.

For the purposes of this challenge, a printable ASCII char is one between \u0020U+0020 and \u007EU+007E, inclusive; that is, from (space) to ~ (tilde). Newlines and tabs are not included.

For example, given "abcde", some valid outputs could be:

"11111"
"abcdf"
"edcba"

But these would be invalid:

"abcde"
"bcde"
"abcde0"

Test cases

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Rules

You may assume the input consists entirely of printable ASCII chars.
You may not assume that the input does not contain all 95 printable chars.
You may assume the input contains at least one character and is less than 256 chars long.
The output must also consist entirely of printable ASCII chars. You could not, for example, output the byte \x7F for input "~".
The output must be different than the input with probability 1; that is, you may generate random strings until one is different than the input, but you can't just output L random characters and hope it's different.
Newlines are disallowed in the output, but you may output one trailing newline which is not counted toward the string.

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

Challenge

Given a non-empty string S of length L consisting entirely of printable ASCII chars, output another string of length L that consists entirely of printable ASCII chars, but is not equal to S.

For the purposes of this challenge, a printable ASCII char is one between \u0020 and \u007E, inclusive; that is, from (space) to ~ (tilde). Newlines and tabs are not included.

For example, given "abcde", some valid outputs could be:

"11111"
"abcdf"
"edcba"

But these would be invalid:

"abcde"
"bcde"
"abcde0"

Test cases

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Rules

You may assume the input consists entirely of printable ASCII chars.
You may not assume that the input does not contain all 95 printable chars.
You may assume the input contains at least one character and is less than 256 chars long.
The output must also consist entirely of printable ASCII chars. You could not, for example, output the byte \x7F for input "~".
The output must be different than the input with probability 1; that is, you may generate random strings until one is different than the input, but you can't just output L random characters and hope it's different.
Newlines are disallowed in the output, but you may output one trailing newline which is not counted toward the string.

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

Challenge

Given a non-empty string S of length L consisting entirely of printable ASCII chars, output another string of length L that consists entirely of printable ASCII chars, but is not equal to S.

For the purposes of this challenge, a printable ASCII char is one between U+0020 and U+007E, inclusive; that is, from (space) to ~ (tilde). Newlines and tabs are not included.

For example, given "abcde", some valid outputs could be:

"11111"
"abcdf"
"edcba"

But these would be invalid:

"abcde"
"bcde"
"abcde0"

Test cases

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Rules

You may assume the input consists entirely of printable ASCII chars.
You may not assume that the input does not contain all 95 printable chars.
You may assume the input contains at least one character and is less than 256 chars long.
The output must also consist entirely of printable ASCII chars. You could not, for example, output the byte \x7F for input "~".
The output must be different than the input with probability 1; that is, you may generate random strings until one is different than the input, but you can't just output L random characters and hope it's different.
Newlines are disallowed in the output, but you may output one trailing newline which is not counted toward the string.

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

deleted 16 characters in body

Source Link

edited May 30, 2017 at 20:39

ETHproductions

50.1k
6
94
240

Challenge

Given a non-empty string S of positive length L consisting entirely of printable ASCII chars, output another string of length L that also consists entirely of printable ASCII chars, but is not equal to S.

For completenessthe purposes of this challenge, a printable ASCII char is one between \u0020 and \u007E, inclusive; that is, from (space) to ~ (tilde). Newlines and tabs are not included for this particular challenge.

For example, given "abcde", some valid outputs could be:

"11111"
"abcdf"
"edcba"

But these would be invalid:

"abcde"
"bcde"
"abcde0"

Test cases

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Rules

You may assume the input consists entirely of printable ASCII chars.
You may not assume that the input does not contain all 95 printable chars.
You may assume the input contains at least one character and is less than 256 chars long.
The output must also consist entirely of printable ASCII chars. You could not, for example, output the byte \x7F for input "~".
The output must be different than the input with probability 1; that is, you may generate random strings until one is different than the input, but you can't just output L random characters and hope it's different.
Newlines are disallowed in the output, but you may output one trailing newline which is not counted toward the string.

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

Challenge

Given a string S of positive length L consisting entirely of printable ASCII chars, output another string of length L that also consists entirely of printable ASCII chars, but is not equal to S.

For completeness, a printable ASCII char is one between \u0020 and \u007E, inclusive; that is, from (space) to ~ (tilde). Newlines and tabs are not included for this particular challenge.

For example, given "abcde", some valid outputs could be:

"11111"
"abcdf"
"edcba"

But these would be invalid:

"abcde"
"bcde"
"abcde0"

Test cases

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Rules

You may assume the input consists entirely of printable ASCII chars.
You may not assume that the input does not contain all 95 printable chars.
You may assume the input contains at least one character and is less than 256 chars long.
The output must also consist entirely of printable ASCII chars. You could not, for example, output the byte \x7F for input "~".
The output must be different than the input with probability 1; that is, you may generate random strings until one is different than the input, but you can't just output L random characters and hope it's different.
Newlines are disallowed in the output, but you may output one trailing newline which is not counted toward the string.

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

Challenge

Given a non-empty string S of length L consisting entirely of printable ASCII chars, output another string of length L that consists entirely of printable ASCII chars, but is not equal to S.

For the purposes of this challenge, a printable ASCII char is one between \u0020 and \u007E, inclusive; that is, from (space) to ~ (tilde). Newlines and tabs are not included.

For example, given "abcde", some valid outputs could be:

"11111"
"abcdf"
"edcba"

But these would be invalid:

"abcde"
"bcde"
"abcde0"

Test cases

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Rules

You may assume the input consists entirely of printable ASCII chars.
You may not assume that the input does not contain all 95 printable chars.
You may assume the input contains at least one character and is less than 256 chars long.
The output must also consist entirely of printable ASCII chars. You could not, for example, output the byte \x7F for input "~".
The output must be different than the input with probability 1; that is, you may generate random strings until one is different than the input, but you can't just output L random characters and hope it's different.
Newlines are disallowed in the output, but you may output one trailing newline which is not counted toward the string.

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

Tweeted twitter.com/StackCodeGolf/status/869627124889636864

occurred May 30, 2017 at 18:50

added 183 characters in body

Source Link

edited May 30, 2017 at 16:56

ETHproductions

50.1k
6
94
240

Challenge

Given a string S of positive length L consisting entirely of printable ASCII chars, output another string of length L that also consists entirely of printable ASCII chars, but is not equal to S.

For completeness, a printable ASCII char is one between \u0020 and \u007E, inclusive; that is, from (space) to ~ (tilde). Newlines and tabs are not included for this particular challenge.

For example, given "abcde", some valid outputs could be:

"11111"
"abcdf"
"edcba"

But these would be invalid:

"abcde"
"bcde"
"abcde0"

Test cases

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Rules

You may assume the input consists entirely of printable ASCII chars.

You may not assume that the input does not contain all 95 printable chars.
You may assume the input contains at least one character and is less than 256 chars long.
The output must also consist entirely of printable ASCII chars. You could not, for example, output the byte \x7F for input "~".
The output must be different than the input with probability 1; that is, you may generate random strings until one is different than the input, but you can't just output L random characters and hope it's different.
Newlines are disallowed in the output, but you may output one trailing newline which is not counted toward the string.

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

Challenge

Given a string S of positive length L consisting entirely of printable ASCII chars, output another string of length L that also consists entirely of printable ASCII chars, but is not equal to S.

For completeness, a printable ASCII char is one between \u0020 and \u007E, inclusive; that is, from (space) to ~ (tilde). Newlines and tabs are not included for this particular challenge.

For example, given "abcde", some valid outputs could be:

"11111"
"abcdf"
"edcba"

But these would be invalid:

"abcde"
"bcde"
"abcde0"

Test cases

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"

Rules

You may assume the input consists entirely of printable ASCII chars.
You may assume the input contains at least one character and is less than 256 chars long.
The output must also consist entirely of printable ASCII chars. You could not, for example, output the byte \x7F for input "~".
The output must be different than the input with probability 1; that is, you may generate random strings until one is different than the input, but you can't just output L random characters and hope it's different.
Newlines are disallowed in the output, but you may output one trailing newline which is not counted toward the string.

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

Challenge

Given a string S of positive length L consisting entirely of printable ASCII chars, output another string of length L that also consists entirely of printable ASCII chars, but is not equal to S.

For completeness, a printable ASCII char is one between \u0020 and \u007E, inclusive; that is, from (space) to ~ (tilde). Newlines and tabs are not included for this particular challenge.

For example, given "abcde", some valid outputs could be:

"11111"
"abcdf"
"edcba"

But these would be invalid:

"abcde"
"bcde"
"abcde0"

Test cases

"asdf"
"1111"
"       "
"~~~~~"
"abcba"
"1"
" "
"~"
" ~"
"~ "
"  0"
"!@#$%^&*()ABCDEFGhijklmnop1234567890"
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

Rules

You may assume the input consists entirely of printable ASCII chars.

You may not assume that the input does not contain all 95 printable chars.
You may assume the input contains at least one character and is less than 256 chars long.
The output must also consist entirely of printable ASCII chars. You could not, for example, output the byte \x7F for input "~".
The output must be different than the input with probability 1; that is, you may generate random strings until one is different than the input, but you can't just output L random characters and hope it's different.
Newlines are disallowed in the output, but you may output one trailing newline which is not counted toward the string.

Scoring

This is code-golf, so the shortest code in bytes in each language wins.

Source Link

asked May 30, 2017 at 15:57

ETHproductions

50.1k
6
94
240

Loading

Stack Exchange Network

Return to Question

Challenge

Test cases

Rules

Scoring

Challenge

Test cases

Rules

Scoring

Challenge

Test cases

Rules

Scoring

Challenge

Test cases

Rules

Scoring

Challenge

Test cases

Rules

Scoring

Challenge

Test cases

Rules

Scoring

Challenge

Test cases

Rules

Scoring

Challenge

Test cases

Rules

Scoring

Challenge

Test cases

Rules

Scoring