Code Golf

#6: Post edited by

WheatWizard‭ · 2023-06-22T11:55:37Z (almost 2 years ago)
Better wording.

Copy Link

Raw

Markdown

# Task
You are going to take three strings as input $A$ , $B$ and $X$ . And your goal is to determine if there exists a third string $S$ such that both $A$ and $B$ can be formed by iteratively removing contiguous substrings of $S $t h a t a r e e q u a l t o$ X $. F o r e x a m p l e i f$ X = 10101 $t h e n b o t h$ 10 $a n d$ 01 $c a n b e f o r m e d f r o m t h e s t a r t i n g s t r i n g$ S = 1010101$
$$
10\,\,(10101) \rightarrow 10
$$
$$
(10101)\,\,01 \rightarrow 01
$$
Input may be either a list of positive integers or a string of alphanumberic ascii characters. Output should be one of two distinct consistent values for each of the cases. One value should be given if an $S$ exists, and the other if not.
This is code-golf. The goal is to minimize the size of your source code as measured in bytes.
# Test cases
## True
The following cases should give a *true* value. In each I give an example $S$ , but this is neither input nor output, it is just provided for demonstration.
```text
A, B, X -> S
10, 0110, 01 -> 0110
10, 001110, 01 -> 001110
10, 01, 10101 -> 1010101
1100, 0101, 10101 -> 11010101101010110101011010101
102, 021, 1021021 -> 1021021021
10, 01, 1010101 -> 101010101
```
## False
```text
A, B, X
100, 01, 10101
10201, 1100, 10
10, 01, 001
10, 01, 1010
```

# Task
You are going to take three strings as input $A$ , $B$ and $X$ . And your goal is to determine if there exists a third string $S$ such that both $A$ and $B$ can be formed by iteratively removing contiguous instances of $X $i n$ S $. F o r e x a m p l e i f$ X = 10101 $t h e n b o t h$ 10 $a n d$ 01 $c a n b e f o r m e d f r o m t h e s t a r t i n g s t r i n g$ S = 1010101$
$$
10\,\,(10101) \rightarrow 10
$$
$$
(10101)\,\,01 \rightarrow 01
$$
Input may be either a list of positive integers or a string of alphanumberic ascii characters. Output should be one of two distinct consistent values for each of the cases. One value should be given if an $S$ exists, and the other if not.
This is code-golf. The goal is to minimize the size of your source code as measured in bytes.
# Test cases
## True
The following cases should give a *true* value. In each I give an example $S$ , but this is neither input nor output, it is just provided for demonstration.
```text
A, B, X -> S
10, 0110, 01 -> 0110
10, 001110, 01 -> 001110
10, 01, 10101 -> 1010101
1100, 0101, 10101 -> 11010101101010110101011010101
102, 021, 1021021 -> 1021021021
10, 01, 1010101 -> 101010101
```
## False
```text
A, B, X
100, 01, 10101
10201, 1100, 10
10, 01, 001
10, 01, 1010
```

#5: Post edited by

WheatWizard‭ · 2023-06-22T11:24:48Z (almost 2 years ago)

Copy Link

Raw

Markdown

# Task
You are going to take three strings as input $A$ , $B$ and $X$ . And your goal is to determine if there exists a third string $S$ such that both $A$ and $B$ can be formed by iteratively removing contiguous substrings of $X $f r o m$ S $. F o r e x a m p l e i f$ X = 10101 $t h e n b o t h$ 10 $a n d$ 01 $c a n b e f o r m e d f r o m t h e s t a r t i n g s t r i n g$ S = 1010101$
$$
10\,\,(10101) \rightarrow 10
$$
$$
(10101)\,\,01 \rightarrow 01
$$
Input may be either a list of positive integers or a string of alphanumberic ascii characters. Output should be one of two distinct consistent values for each of the cases. One value should be given if an $S$ exists, and the other if not.
This is code-golf. The goal is to minimize the size of your source code as measured in bytes.
# Test cases
## True
The following cases should give a *true* value. In each I give an example $S$ , but this is neither input nor output, it is just provided for demonstration.
```text
A, B, X -> S
10, 0110, 01 -> 0110
10, 001110, 01 -> 001110
10, 01, 10101 -> 1010101
1100, 0101, 10101 -> 11010101101010110101011010101
102, 021, 1021021 -> 1021021021
10, 01, 1010101 -> 101010101
```
## False
```text
A, B, X
100, 01, 10101
10201, 1100, 10
10, 01, 001
10, 01, 1010
```

# Task
You are going to take three strings as input $A$ , $B$ and $X$ . And your goal is to determine if there exists a third string $S$ such that both $A$ and $B$ can be formed by iteratively removing contiguous substrings of $S $t h a t a r e e q u a l t o$ X $. F o r e x a m p l e i f$ X = 10101 $t h e n b o t h$ 10 $a n d$ 01 $c a n b e f o r m e d f r o m t h e s t a r t i n g s t r i n g$ S = 1010101$
$$
10\,\,(10101) \rightarrow 10
$$
$$
(10101)\,\,01 \rightarrow 01
$$
Input may be either a list of positive integers or a string of alphanumberic ascii characters. Output should be one of two distinct consistent values for each of the cases. One value should be given if an $S$ exists, and the other if not.
This is code-golf. The goal is to minimize the size of your source code as measured in bytes.
# Test cases
## True
The following cases should give a *true* value. In each I give an example $S$ , but this is neither input nor output, it is just provided for demonstration.
```text
A, B, X -> S
10, 0110, 01 -> 0110
10, 001110, 01 -> 001110
10, 01, 10101 -> 1010101
1100, 0101, 10101 -> 11010101101010110101011010101
102, 021, 1021021 -> 1021021021
10, 01, 1010101 -> 101010101
```
## False
```text
A, B, X
100, 01, 10101
10201, 1100, 10
10, 01, 001
10, 01, 1010
```

#4: Post edited by

trichoplax‭ · 2023-06-22T11:23:38Z (almost 2 years ago)
Typos

Copy Link

Raw

Markdown

Are these reduced forms of the same thing?

# Task
You are going to take three strings as input $A$ , $B$ and $X$ . And your goal is to determine if there exists a third string $S$ such that both $A$ and $B$ can be formed by iteratively removing contiguous substrings of $X$ from $S$ . For example if $X = 10101$ then both $10$ and $01$ can be formed from the staring string $S = 1010101$
$$
10\,\,(10101) \rightarrow 10
$$
$$
(10101)\,\,01 \rightarrow 01
$$
Input may be either a list of positive integers or a string of alphanumberic ascii characters. Output should be one of two distinct consistent values for each of the cases. One value should be given if an $S$ exists, and the other if not.
~~This is code-golf the goal is to minimize the size of your source code as measured in bytes.~~
# Test cases
## True
The following cases should give a *true* value. In each I give an example $S$ , but this is neither input nor output, it is just provided for demonstration.
```text
A, B, X -> S
10, 0110, 01 -> 0110
~~10 001110, 01 -> 001110~~
10, 01, 10101 -> 1010101
1100, 0101, 10101 -> 11010101101010110101011010101
102, 021, 1021021 -> 1021021021
10, 01, 1010101 -> 101010101
```
## False
```text
A, B, X
100, 01, 10101
10201, 1100, 10
10, 01, 001
10, 01, 1010
```

# Task
You are going to take three strings as input $A$ , $B$ and $X$ . And your goal is to determine if there exists a third string $S$ such that both $A$ and $B$ can be formed by iteratively removing contiguous substrings of $X$ from $S$ . For example if $X = 10101$ then both $10$ and $01$ can be formed from the starting string $S = 1010101$
$$
10\,\,(10101) \rightarrow 10
$$
$$
(10101)\,\,01 \rightarrow 01
$$
Input may be either a list of positive integers or a string of alphanumberic ascii characters. Output should be one of two distinct consistent values for each of the cases. One value should be given if an $S$ exists, and the other if not.
This is code-golf. The goal is to minimize the size of your source code as measured in bytes.
# Test cases
## True
The following cases should give a *true* value. In each I give an example $S$ , but this is neither input nor output, it is just provided for demonstration.
```text
A, B, X -> S
10, 0110, 01 -> 0110
10, 001110, 01 -> 001110
10, 01, 10101 -> 1010101
1100, 0101, 10101 -> 11010101101010110101011010101
102, 021, 1021021 -> 1021021021
10, 01, 1010101 -> 101010101
```
## False
```text
A, B, X
100, 01, 10101
10201, 1100, 10
10, 01, 001
10, 01, 1010
```

#3: Post undeleted by

WheatWizard‭ · 2023-06-22T01:47:08Z (almost 2 years ago)

Copy Link

Raw

Markdown

#2: Post deleted by

WheatWizard‭ · 2023-06-22T01:44:17Z (almost 2 years ago)

Copy Link

Raw

Markdown

#1: Initial revision by

WheatWizard‭ · 2023-06-22T00:15:48Z (almost 2 years ago)

Copy Link

Raw

Markdown

Are these reduced forms of the same thing?

# Task

You are going to take three strings as input $A$, $B$ and $X$. And your goal is to determine if there exists a third string $S$ such that both $A$ and $B$ can be formed by iteratively removing contiguous substrings of $X$ from $S$.  For example if $X = 10101$ then both $10$ and $01$ can be formed from the staring string $S = 1010101$

$$
10\,\,(10101) \rightarrow 10
$$
$$
(10101)\,\,01 \rightarrow 01
$$

Input may be either a list of positive integers or a string of alphanumberic ascii characters.  Output should be one of two distinct consistent values for each of the cases. One value should be given if an $S$ exists, and the other if not.

This is code-golf the goal is to minimize the size of your source code as measured in bytes.

# Test cases

## True
The following cases should give a *true* value. In each I give an example $S$, but this is neither input nor output, it is just provided for demonstration.

```text
A, B, X -> S
10, 0110, 01 -> 0110
10  001110, 01 -> 001110
10, 01, 10101 -> 1010101
1100, 0101, 10101 -> 11010101101010110101011010101
102, 021, 1021021 -> 1021021021
10, 01, 1010101 -> 101010101
```

## False

```text
A, B, X
100, 01, 10101
10201, 1100, 10
10, 01, 001
10, 01, 1010
```

code-golf string abstract-algebra

Communities

Post History