prompt
stringlengths 820
849
| label
dict | task_name
stringclasses 1
value | example_name
stringlengths 4
4
| problem_name
stringlengths 11
11
| __index_level_0__
int64 0
239
|
|---|---|---|---|---|---|
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: itstb | {
"final": "bistt",
"init": "itstb",
"intermediate": [
"btsti"
]
} | task01 | 0000 | task01_0000 | 0 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: gvkud | {
"final": "dgkuv",
"init": "gvkud",
"intermediate": [
"dvkug"
]
} | task01 | 0001 | task01_0001 | 1 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: mhtjah | {
"final": "ahhjmt",
"init": "mhtjah",
"intermediate": [
"ahtjmh"
]
} | task01 | 0002 | task01_0002 | 2 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: itwlw | {
"final": "iltww",
"init": "itwlw",
"intermediate": [
"ilwtw"
]
} | task01 | 0003 | task01_0003 | 3 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: imqup | {
"final": "impqu",
"init": "imqup",
"intermediate": [
"impuq"
]
} | task01 | 0004 | task01_0004 | 4 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: yfpduq | {
"final": "dfpquy",
"init": "yfpduq",
"intermediate": [
"dfpyuq"
]
} | task01 | 0005 | task01_0005 | 5 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: zujfa | {
"final": "afjuz",
"init": "zujfa",
"intermediate": [
"aujfz"
]
} | task01 | 0006 | task01_0006 | 6 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: spicv | {
"final": "cipsv",
"init": "spicv",
"intermediate": [
"cpisv"
]
} | task01 | 0007 | task01_0007 | 7 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: yqqywyks | {
"final": "kqqswyyy",
"init": "yqqywyks",
"intermediate": [
"kqqywyys"
]
} | task01 | 0008 | task01_0008 | 8 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: absczsbj | {
"final": "abbcjssz",
"init": "absczsbj",
"intermediate": [
"abbczssj"
]
} | task01 | 0009 | task01_0009 | 9 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: qmntvi | {
"final": "imnqtv",
"init": "qmntvi",
"intermediate": [
"imntvq",
"imnqvt"
]
} | task01 | 0010 | task01_0010 | 10 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: fllxa | {
"final": "afllx",
"init": "fllxa",
"intermediate": [
"allxf",
"aflxl"
]
} | task01 | 0011 | task01_0011 | 11 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: fakeesu | {
"final": "aeefksu",
"init": "fakeesu",
"intermediate": [
"afkeesu",
"aekfesu"
]
} | task01 | 0012 | task01_0012 | 12 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: dzlvjq | {
"final": "djlqvz",
"init": "dzlvjq",
"intermediate": [
"djlvzq",
"djlqzv"
]
} | task01 | 0013 | task01_0013 | 13 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: bmnmhw | {
"final": "bhmmnw",
"init": "bmnmhw",
"intermediate": [
"bhnmmw",
"bhmnmw"
]
} | task01 | 0014 | task01_0014 | 14 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: kblcfn | {
"final": "bcfkln",
"init": "kblcfn",
"intermediate": [
"bklcfn",
"bclkfn"
]
} | task01 | 0015 | task01_0015 | 15 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: heuaax | {
"final": "aaehux",
"init": "heuaax",
"intermediate": [
"aeuhax",
"aauhex"
]
} | task01 | 0016 | task01_0016 | 16 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: lqxho | {
"final": "hloqx",
"init": "lqxho",
"intermediate": [
"hqxlo",
"hlxqo"
]
} | task01 | 0017 | task01_0017 | 17 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: vtqsi | {
"final": "iqstv",
"init": "vtqsi",
"intermediate": [
"itqsv",
"iqtsv"
]
} | task01 | 0018 | task01_0018 | 18 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: qhyyxxcs | {
"final": "chqsxxyy",
"init": "qhyyxxcs",
"intermediate": [
"chyyxxqs",
"chqyxxys"
]
} | task01 | 0019 | task01_0019 | 19 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: pvyjjt | {
"final": "jjptvy",
"init": "pvyjjt",
"intermediate": [
"jvypjt",
"jjypvt",
"jjpyvt"
]
} | task01 | 0020 | task01_0020 | 20 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: qqhlpaz | {
"final": "ahlpqqz",
"init": "qqhlpaz",
"intermediate": [
"aqhlpqz",
"ahqlpqz",
"ahlqpqz"
]
} | task01 | 0021 | task01_0021 | 21 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ucvzi | {
"final": "ciuvz",
"init": "ucvzi",
"intermediate": [
"cuvzi",
"civzu",
"ciuzv"
]
} | task01 | 0022 | task01_0022 | 22 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: rztbhp | {
"final": "bhprtz",
"init": "rztbhp",
"intermediate": [
"bztrhp",
"bhtrzp",
"bhprzt"
]
} | task01 | 0023 | task01_0023 | 23 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: rxlzb | {
"final": "blrxz",
"init": "rxlzb",
"intermediate": [
"bxlzr",
"blxzr",
"blrzx"
]
} | task01 | 0024 | task01_0024 | 24 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: pdgnfda | {
"final": "addfgnp",
"init": "pdgnfda",
"intermediate": [
"adgnfdp",
"addnfgp",
"addfngp"
]
} | task01 | 0025 | task01_0025 | 25 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: zfydtp | {
"final": "dfptyz",
"init": "zfydtp",
"intermediate": [
"dfyztp",
"dfpzty",
"dfptzy"
]
} | task01 | 0026 | task01_0026 | 26 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: pjlbahz | {
"final": "abhjlpz",
"init": "pjlbahz",
"intermediate": [
"ajlbphz",
"abljphz",
"abhjplz"
]
} | task01 | 0027 | task01_0027 | 27 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: yxalj | {
"final": "ajlxy",
"init": "yxalj",
"intermediate": [
"axylj",
"ajylx",
"ajlyx"
]
} | task01 | 0028 | task01_0028 | 28 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: seraok | {
"final": "aekors",
"init": "seraok",
"intermediate": [
"aersok",
"aeksor",
"aekosr"
]
} | task01 | 0029 | task01_0029 | 29 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: outykqv | {
"final": "koqtuvy",
"init": "outykqv",
"intermediate": [
"kutyoqv",
"kotyuqv",
"koqyutv",
"koqtuyv"
]
} | task01 | 0030 | task01_0030 | 30 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: rxzvjuf | {
"final": "fjruvxz",
"init": "rxzvjuf",
"intermediate": [
"fxzvjur",
"fjzvxur",
"fjrvxuz",
"fjruxvz"
]
} | task01 | 0031 | task01_0031 | 31 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: vyfoav | {
"final": "afovvy",
"init": "vyfoav",
"intermediate": [
"ayfovv",
"afyovv",
"afoyvv",
"afovyv"
]
} | task01 | 0032 | task01_0032 | 32 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: qzmkyut | {
"final": "kmqtuyz",
"init": "qzmkyut",
"intermediate": [
"kzmqyut",
"kmzqyut",
"kmqzyut",
"kmqtyuz"
]
} | task01 | 0033 | task01_0033 | 33 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: kmnkrbq | {
"final": "bkkmnqr",
"init": "kmnkrbq",
"intermediate": [
"bmnkrkq",
"bknmrkq",
"bkkmrnq",
"bkkmnrq"
]
} | task01 | 0034 | task01_0034 | 34 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: qjflgbgw | {
"final": "bfggjlqw",
"init": "qjflgbgw",
"intermediate": [
"bjflgqgw",
"bfjlgqgw",
"bfgljqgw",
"bfggjqlw"
]
} | task01 | 0035 | task01_0035 | 35 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: zieuinx | {
"final": "eiinuxz",
"init": "zieuinx",
"intermediate": [
"eizuinx",
"eiiuznx",
"eiinzux",
"eiinuzx"
]
} | task01 | 0036 | task01_0036 | 36 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: kwnlsmpdj | {
"final": "djklmnpsw",
"init": "kwnlsmpdj",
"intermediate": [
"dwnlsmpkj",
"djnlsmpkw",
"djklsmpnw",
"djklmspnw"
]
} | task01 | 0037 | task01_0037 | 37 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: wxxarrc | {
"final": "acrrwxx",
"init": "wxxarrc",
"intermediate": [
"axxwrrc",
"acxwrrx",
"acrwxrx",
"acrrxwx"
]
} | task01 | 0038 | task01_0038 | 38 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: fvawasla | {
"final": "aaaflsvw",
"init": "fvawasla",
"intermediate": [
"avfwasla",
"aafwvsla",
"aaawvslf",
"aaafvslw"
]
} | task01 | 0039 | task01_0039 | 39 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: opelvrbmc | {
"final": "bcelmoprv",
"init": "opelvrbmc",
"intermediate": [
"bpelvromc",
"bcelvromp",
"bcelmrovp",
"bcelmorvp",
"bcelmopvr"
]
} | task01 | 0040 | task01_0040 | 40 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: phfsvlzax | {
"final": "afhlpsvxz",
"init": "phfsvlzax",
"intermediate": [
"ahfsvlzpx",
"afhsvlzpx",
"afhlvszpx",
"afhlpszvx",
"afhlpsvzx"
]
} | task01 | 0041 | task01_0041 | 41 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: fbquapxygf | {
"final": "abffgpquxy",
"init": "fbquapxygf",
"intermediate": [
"abqufpxygf",
"abfuqpxygf",
"abffqpxygu",
"abffgpxyqu",
"abffgpqyxu"
]
} | task01 | 0042 | task01_0042 | 42 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: hthxnmte | {
"final": "ehhmnttx",
"init": "hthxnmte",
"intermediate": [
"ethxnmth",
"ehtxnmth",
"ehhxnmtt",
"ehhmnxtt",
"ehhmntxt"
]
} | task01 | 0043 | task01_0043 | 43 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: txxnmjsnu | {
"final": "jmnnstuxx",
"init": "txxnmjsnu",
"intermediate": [
"jxxnmtsnu",
"jmxnxtsnu",
"jmnxxtsnu",
"jmnnxtsxu",
"jmnnstxxu"
]
} | task01 | 0044 | task01_0044 | 44 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: bltywglv | {
"final": "bglltvwy",
"init": "bltywglv",
"intermediate": [
"bgtywllv",
"bglywtlv",
"bgllwtyv",
"bglltwyv",
"bglltvyw"
]
} | task01 | 0045 | task01_0045 | 45 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: kjkuifm | {
"final": "fijkkmu",
"init": "kjkuifm",
"intermediate": [
"fjkuikm",
"fikujkm",
"fijukkm",
"fijkukm",
"fijkkum"
]
} | task01 | 0046 | task01_0046 | 46 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: vcacxatg | {
"final": "aaccgtvx",
"init": "vcacxatg",
"intermediate": [
"acvcxatg",
"aavcxctg",
"aacvxctg",
"aaccxvtg",
"aaccgvtx"
]
} | task01 | 0047 | task01_0047 | 47 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: rtjloyr | {
"final": "jlorrty",
"init": "rtjloyr",
"intermediate": [
"jtrloyr",
"jlrtoyr",
"jlotryr",
"jlortyr",
"jlorryt"
]
} | task01 | 0048 | task01_0048 | 48 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ynklsafnmuo | {
"final": "afklmnnosuy",
"init": "ynklsafnmuo",
"intermediate": [
"anklsyfnmuo",
"afklsynnmuo",
"afklmynnsuo",
"afklmnynsuo",
"afklmnnysuo"
]
} | task01 | 0049 | task01_0049 | 49 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: utmpjsrvxipx | {
"final": "ijmpprstuvxx",
"init": "utmpjsrvxipx",
"intermediate": [
"itmpjsrvxupx",
"ijmptsrvxupx",
"ijmppsrvxutx",
"ijmpprsvxutx",
"ijmpprstxuvx",
"ijmpprstuxvx"
]
} | task01 | 0050 | task01_0050 | 50 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: vroncnizkw | {
"final": "ciknnorvwz",
"init": "vroncnizkw",
"intermediate": [
"cronvnizkw",
"cionvnrzkw",
"ciknvnrzow",
"ciknnvrzow",
"ciknnorzvw",
"ciknnorvzw"
]
} | task01 | 0051 | task01_0051 | 51 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: eocjmhzbvpm | {
"final": "bcehjmmopvz",
"init": "eocjmhzbvpm",
"intermediate": [
"bocjmhzevpm",
"bcojmhzevpm",
"bcejmhzovpm",
"bcehmjzovpm",
"bcehjmzovpm",
"bcehjmmovpz"
]
} | task01 | 0052 | task01_0052 | 52 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ftxckrxcv | {
"final": "ccfkrtvxx",
"init": "ftxckrxcv",
"intermediate": [
"ctxfkrxcv",
"ccxfkrxtv",
"ccfxkrxtv",
"ccfkxrxtv",
"ccfkrxxtv",
"ccfkrtxxv"
]
} | task01 | 0053 | task01_0053 | 53 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: sbsepwble | {
"final": "bbeelpssw",
"init": "sbsepwble",
"intermediate": [
"bssepwble",
"bbsepwsle",
"bbespwsle",
"bbeepwsls",
"bbeelwsps",
"bbeelpsws"
]
} | task01 | 0054 | task01_0054 | 54 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: anewbnmucg | {
"final": "abcegmnnuw",
"init": "anewbnmucg",
"intermediate": [
"abewnnmucg",
"abcwnnmueg",
"abcennmuwg",
"abcegnmuwn",
"abcegmnuwn",
"abcegmnnwu"
]
} | task01 | 0055 | task01_0055 | 55 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: hrnumemmea | {
"final": "aeehmmmnru",
"init": "hrnumemmea",
"intermediate": [
"arnumemmeh",
"aenumrmmeh",
"aeeumrmmnh",
"aeehmrmmnu",
"aeehmmrmnu",
"aeehmmmrnu"
]
} | task01 | 0056 | task01_0056 | 56 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ttrytnlamed | {
"final": "adelmnrttty",
"init": "ttrytnlamed",
"intermediate": [
"atrytnltmed",
"adrytnltmet",
"adeytnltmrt",
"adeltnytmrt",
"adelmnyttrt",
"adelmnrttyt"
]
} | task01 | 0057 | task01_0057 | 57 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: gkolqrcrxn | {
"final": "cgklnoqrrx",
"init": "gkolqrcrxn",
"intermediate": [
"ckolqrgrxn",
"cgolqrkrxn",
"cgklqrorxn",
"cgklnrorxq",
"cgklnorrxq",
"cgklnoqrxr"
]
} | task01 | 0058 | task01_0058 | 58 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: yvhhvall | {
"final": "ahhllvvy",
"init": "yvhhvall",
"intermediate": [
"avhhvyll",
"ahvhvyll",
"ahhvvyll",
"ahhlvyvl",
"ahhllyvv",
"ahhllvyv"
]
} | task01 | 0059 | task01_0059 | 59 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: jndwpnwknpi | {
"final": "dijknnnppww",
"init": "jndwpnwknpi",
"intermediate": [
"dnjwpnwknpi",
"dijwpnwknpn",
"dijkpnwwnpn",
"dijknpwwnpn",
"dijknnwwppn",
"dijknnnwppw",
"dijknnnpwpw"
]
} | task01 | 0060 | task01_0060 | 60 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: hnyklphjrrji | {
"final": "hhijjklnprry",
"init": "hnyklphjrrji",
"intermediate": [
"hhyklpnjrrji",
"hhiklpnjrrjy",
"hhijlpnkrrjy",
"hhijjpnkrrly",
"hhijjknprrly",
"hhijjklprrny",
"hhijjklnrrpy"
]
} | task01 | 0061 | task01_0061 | 61 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: reseonvptsibc | {
"final": "bceeinoprsstv",
"init": "reseonvptsibc",
"intermediate": [
"beseonvptsirc",
"bcseonvptsire",
"bcesonvptsire",
"bceeonvptsirs",
"bceeinvptsors",
"bceeinoptsvrs",
"bceeinoprsvts"
]
} | task01 | 0062 | task01_0062 | 62 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ebzmgzjjdyn | {
"final": "bdegjjmnyzz",
"init": "ebzmgzjjdyn",
"intermediate": [
"bezmgzjjdyn",
"bdzmgzjjeyn",
"bdemgzjjzyn",
"bdegmzjjzyn",
"bdegjzmjzyn",
"bdegjjmzzyn",
"bdegjjmnzyz"
]
} | task01 | 0063 | task01_0063 | 63 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: jnuklhldszgshp | {
"final": "dghhjkllnpssuz",
"init": "jnuklhldszgshp",
"intermediate": [
"dnuklhljszgshp",
"dguklhljsznshp",
"dghkluljsznshp",
"dghhluljsznskp",
"dghhjullsznskp",
"dghhjkllsznsup",
"dghhjkllnzssup"
]
} | task01 | 0064 | task01_0064 | 64 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: fmuottlal | {
"final": "afllmottu",
"init": "fmuottlal",
"intermediate": [
"amuottlfl",
"afuottlml",
"aflottuml",
"afllttumo",
"afllmtuto",
"afllmoutt",
"afllmotut"
]
} | task01 | 0065 | task01_0065 | 65 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: wsbemrupoocazr | {
"final": "abcemooprrsuwz",
"init": "wsbemrupoocazr",
"intermediate": [
"asbemrupoocwzr",
"absemrupoocwzr",
"abcemrupooswzr",
"abcemouproswzr",
"abcemoopruswzr",
"abcemooprrswzu",
"abcemooprrsuzw"
]
} | task01 | 0066 | task01_0066 | 66 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: wpexggxidi | {
"final": "deggiipwxx",
"init": "wpexggxidi",
"intermediate": [
"dpexggxiwi",
"depxggxiwi",
"degxpgxiwi",
"deggpxxiwi",
"deggixxpwi",
"deggiixpwx",
"deggiipxwx"
]
} | task01 | 0067 | task01_0067 | 67 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: wgkyqubhghhb | {
"final": "bbgghhhkquwy",
"init": "wgkyqubhghhb",
"intermediate": [
"bgkyquwhghhb",
"bbkyquwhghhg",
"bbgyquwhkhhg",
"bbggquwhkhhy",
"bbgghuwqkhhy",
"bbgghhwqkuhy",
"bbgghhhqkuwy"
]
} | task01 | 0068 | task01_0068 | 68 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: intikcauuuons | {
"final": "aciiknnostuuu",
"init": "intikcauuuons",
"intermediate": [
"antikciuuuons",
"actikniuuuons",
"acitkniuuuons",
"aciikntuuuons",
"aciiknnuuuots",
"aciiknnouuuts",
"aciiknnosuutu"
]
} | task01 | 0069 | task01_0069 | 69 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ajpeytgirqofv | {
"final": "aefgijopqrtvy",
"init": "ajpeytgirqofv",
"intermediate": [
"aepjytgirqofv",
"aefjytgirqopv",
"aefgytjirqopv",
"aefgitjyrqopv",
"aefgijtyrqopv",
"aefgijoyrqtpv",
"aefgijoprqtyv",
"aefgijopqrtyv"
]
} | task01 | 0070 | task01_0070 | 70 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: nmzlvdtfyzst | {
"final": "dflmnsttvyzz",
"init": "nmzlvdtfyzst",
"intermediate": [
"dmzlvntfyzst",
"dfzlvntmyzst",
"dflzvntmyzst",
"dflmvntzyzst",
"dflmnvtzyzst",
"dflmnstzyzvt",
"dflmnsttyzvz",
"dflmnsttvzyz"
]
} | task01 | 0071 | task01_0071 | 71 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ybpgzcjzjews | {
"final": "bcegjjpswyzz",
"init": "ybpgzcjzjews",
"intermediate": [
"bypgzcjzjews",
"bcpgzyjzjews",
"bcegzyjzjpws",
"bcegjyzzjpws",
"bcegjjzzypws",
"bcegjjpzyzws",
"bcegjjpsyzwz",
"bcegjjpswzyz"
]
} | task01 | 0072 | task01_0072 | 72 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: uelmsxqfllwg | {
"final": "efglllmqsuwx",
"init": "uelmsxqfllwg",
"intermediate": [
"eulmsxqfllwg",
"eflmsxqullwg",
"efgmsxqullwl",
"efglsxqumlwl",
"efgllxqumswl",
"efglllqumswx",
"efglllmuqswx",
"efglllmquswx"
]
} | task01 | 0073 | task01_0073 | 73 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: gftlcisjdcdtyu | {
"final": "ccddfgijlsttuy",
"init": "gftlcisjdcdtyu",
"intermediate": [
"cftlgisjdcdtyu",
"cctlgisjdfdtyu",
"ccdlgisjtfdtyu",
"ccddgisjtfltyu",
"ccddfisjtgltyu",
"ccddfgsjtiltyu",
"ccddfgijtsltyu",
"ccddfgijlsttyu"
]
} | task01 | 0074 | task01_0074 | 74 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: nwhegmuacizh | {
"final": "aceghhimnuwz",
"init": "nwhegmuacizh",
"intermediate": [
"awhegmuncizh",
"achegmunwizh",
"acehgmunwizh",
"aceghmunwizh",
"aceghhunwizm",
"aceghhinwuzm",
"aceghhimwuzn",
"aceghhimnuzw"
]
} | task01 | 0075 | task01_0075 | 75 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ulwxikyrili | {
"final": "iiikllruwxy",
"init": "ulwxikyrili",
"intermediate": [
"ilwxukyrili",
"iiwxukyrlli",
"iiixukyrllw",
"iiikuxyrllw",
"iiiklxyrulw",
"iiikllyruxw",
"iiikllryuxw",
"iiikllruyxw"
]
} | task01 | 0076 | task01_0076 | 76 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: uhluhgkztszwtwx | {
"final": "ghhklsttuuwwxzz",
"init": "uhluhgkztszwtwx",
"intermediate": [
"ghluhukztszwtwx",
"ghhulukztszwtwx",
"ghhkluuztszwtwx",
"ghhklsuztuzwtwx",
"ghhklstzuuzwtwx",
"ghhklsttuuzwzwx",
"ghhklsttuuwzzwx",
"ghhklsttuuwwzzx"
]
} | task01 | 0077 | task01_0077 | 77 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: phjxeehxgtox | {
"final": "eeghhjoptxxx",
"init": "phjxeehxgtox",
"intermediate": [
"ehjxpehxgtox",
"eejxphhxgtox",
"eegxphhxjtox",
"eeghpxhxjtox",
"eeghhxpxjtox",
"eeghhjpxxtox",
"eeghhjoxxtpx",
"eeghhjopxtxx"
]
} | task01 | 0078 | task01_0078 | 78 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: udeqxngcrvrqqei | {
"final": "cdeeginqqqrruvx",
"init": "udeqxngcrvrqqei",
"intermediate": [
"cdeqxngurvrqqei",
"cdeexngurvrqqqi",
"cdeegnxurvrqqqi",
"cdeegixurvrqqqn",
"cdeeginurvrqqqx",
"cdeeginqrvruqqx",
"cdeeginqqvrurqx",
"cdeeginqqqrurvx"
]
} | task01 | 0079 | task01_0079 | 79 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: veezlfwvtqzln | {
"final": "eefllnqtvvwzz",
"init": "veezlfwvtqzln",
"intermediate": [
"evezlfwvtqzln",
"eevzlfwvtqzln",
"eefzlvwvtqzln",
"eeflzvwvtqzln",
"eefllvwvtqzzn",
"eefllnwvtqzzv",
"eefllnqvtwzzv",
"eefllnqtvwzzv",
"eefllnqtvvzzw"
]
} | task01 | 0080 | task01_0080 | 80 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: deneeqhzfcapcwxxn | {
"final": "accdeeefhnnpqwxxz",
"init": "deneeqhzfcapcwxxn",
"intermediate": [
"aeneeqhzfcdpcwxxn",
"acneeqhzfedpcwxxn",
"acceeqhzfedpnwxxn",
"accdeqhzfeepnwxxn",
"accdeehzfqepnwxxn",
"accdeeezfqhpnwxxn",
"accdeeefzqhpnwxxn",
"accdeeefhqzpnwxxn",
"accdeeefhnzpqwxxn"
]
} | task01 | 0081 | task01_0081 | 81 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: njwklazbjhhryp | {
"final": "abhhjjklnprwyz",
"init": "njwklazbjhhryp",
"intermediate": [
"ajwklnzbjhhryp",
"abwklnzjjhhryp",
"abhklnzjjwhryp",
"abhhlnzjjwkryp",
"abhhjnzljwkryp",
"abhhjjzlnwkryp",
"abhhjjklnwzryp",
"abhhjjklnpzryw",
"abhhjjklnprzyw"
]
} | task01 | 0082 | task01_0082 | 82 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: nvjgriazksgwh | {
"final": "agghijknrsvwz",
"init": "nvjgriazksgwh",
"intermediate": [
"avjgrinzksgwh",
"agjvrinzksgwh",
"aggvrinzksjwh",
"agghrinzksjwv",
"agghirnzksjwv",
"agghijnzksrwv",
"agghijkznsrwv",
"agghijknzsrwv",
"agghijknrszwv"
]
} | task01 | 0083 | task01_0083 | 83 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: txawrhsyxycxojvy | {
"final": "achjorstvwxxxyyy",
"init": "txawrhsyxycxojvy",
"intermediate": [
"axtwrhsyxycxojvy",
"actwrhsyxyxxojvy",
"achwrtsyxyxxojvy",
"achjrtsyxyxxowvy",
"achjotsyxyxxrwvy",
"achjorsyxyxxtwvy",
"achjorstxyxxywvy",
"achjorstvyxxywxy",
"achjorstvwxxyyxy"
]
} | task01 | 0084 | task01_0084 | 84 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: rwynfnvzzkqums | {
"final": "fkmnnqrsuvwyzz",
"init": "rwynfnvzzkqums",
"intermediate": [
"fwynrnvzzkqums",
"fkynrnvzzwqums",
"fkmnrnvzzwquys",
"fkmnnrvzzwquys",
"fkmnnqvzzwruys",
"fkmnnqrzzwvuys",
"fkmnnqrszwvuyz",
"fkmnnqrsuwvzyz",
"fkmnnqrsuvwzyz"
]
} | task01 | 0085 | task01_0085 | 85 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: yqetfjdinuqzea | {
"final": "adeefijnqqtuyz",
"init": "yqetfjdinuqzea",
"intermediate": [
"aqetfjdinuqzey",
"adetfjqinuqzey",
"adeefjqinuqzty",
"adeefiqjnuqzty",
"adeefijqnuqzty",
"adeefijnquqzty",
"adeefijnqquzty",
"adeefijnqqtzuy",
"adeefijnqqtuzy"
]
} | task01 | 0086 | task01_0086 | 86 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: vpdurlftzozv | {
"final": "dfloprtuvvzz",
"init": "vpdurlftzozv",
"intermediate": [
"dpvurlftzozv",
"dfvurlptzozv",
"dflurvptzozv",
"dflorvptzuzv",
"dflopvrtzuzv",
"dfloprvtzuzv",
"dfloprtvzuzv",
"dfloprtuzvzv",
"dfloprtuvzzv"
]
} | task01 | 0087 | task01_0087 | 87 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ryuzwogumvjd | {
"final": "dgjmoruuvwyz",
"init": "ryuzwogumvjd",
"intermediate": [
"dyuzwogumvjr",
"dguzwoyumvjr",
"dgjzwoyumvur",
"dgjmwoyuzvur",
"dgjmowyuzvur",
"dgjmoryuzvuw",
"dgjmoruyzvuw",
"dgjmoruuzvyw",
"dgjmoruuvzyw"
]
} | task01 | 0088 | task01_0088 | 88 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: canysknuppuhm | {
"final": "achkmnnppsuuy",
"init": "canysknuppuhm",
"intermediate": [
"acnysknuppuhm",
"achysknuppunm",
"achksynuppunm",
"achkmynuppuns",
"achkmnyuppuns",
"achkmnnuppuys",
"achkmnnpupuys",
"achkmnnppuuys",
"achkmnnppsuyu"
]
} | task01 | 0089 | task01_0089 | 89 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: ibehabgopkcqvpm | {
"final": "abbceghikmoppqv",
"init": "ibehabgopkcqvpm",
"intermediate": [
"abehibgopkcqvpm",
"abbhiegopkcqvpm",
"abbciegopkhqvpm",
"abbceigopkhqvpm",
"abbcegiopkhqvpm",
"abbceghopkiqvpm",
"abbceghipkoqvpm",
"abbceghikpoqvpm",
"abbceghikmoqvpp",
"abbceghikmopvqp"
]
} | task01 | 0090 | task01_0090 | 90 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: rdcncpendjdwdqqz | {
"final": "ccddddejnnpqqrwz",
"init": "rdcncpendjdwdqqz",
"intermediate": [
"cdrncpendjdwdqqz",
"ccrndpendjdwdqqz",
"ccdnrpendjdwdqqz",
"ccddrpennjdwdqqz",
"ccdddpennjrwdqqz",
"ccddddennjrwpqqz",
"ccddddejnnrwpqqz",
"ccddddejnnpwrqqz",
"ccddddejnnpqrwqz",
"ccddddejnnpqqwrz"
]
} | task01 | 0091 | task01_0091 | 91 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: fiqqzsbdbzyaxu | {
"final": "abbdfiqqsuxyzz",
"init": "fiqqzsbdbzyaxu",
"intermediate": [
"aiqqzsbdbzyfxu",
"abqqzsidbzyfxu",
"abbqzsidqzyfxu",
"abbdzsiqqzyfxu",
"abbdfsiqqzyzxu",
"abbdfisqqzyzxu",
"abbdfiqsqzyzxu",
"abbdfiqqszyzxu",
"abbdfiqqsuyzxz",
"abbdfiqqsuxzyz"
]
} | task01 | 0092 | task01_0092 | 92 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: xpsksatmdsuaqhu | {
"final": "aadhkmpqssstuux",
"init": "xpsksatmdsuaqhu",
"intermediate": [
"apsksxtmdsuaqhu",
"aasksxtmdsupqhu",
"aadksxtmssupqhu",
"aadhsxtmssupqku",
"aadhkxtmssupqsu",
"aadhkmtxssupqsu",
"aadhkmpxssutqsu",
"aadhkmpqssutxsu",
"aadhkmpqssstxuu",
"aadhkmpqssstuxu"
]
} | task01 | 0093 | task01_0093 | 93 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: fhnpuhnommicb | {
"final": "bcfhhimmnnopu",
"init": "fhnpuhnommicb",
"intermediate": [
"bhnpuhnommicf",
"bcnpuhnommihf",
"bcfpuhnommihn",
"bcfhupnommihn",
"bcfhhpnommiun",
"bcfhhinommpun",
"bcfhhimonmpun",
"bcfhhimmnopun",
"bcfhhimmnnpuo",
"bcfhhimmnnoup"
]
} | task01 | 0094 | task01_0094 | 94 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: xtdxyafyxmqishcn | {
"final": "acdfhimnqstxxxyy",
"init": "xtdxyafyxmqishcn",
"intermediate": [
"atdxyxfyxmqishcn",
"acdxyxfyxmqishtn",
"acdfyxxyxmqishtn",
"acdfhxxyxmqisytn",
"acdfhixyxmqxsytn",
"acdfhimyxxqxsytn",
"acdfhimnxxqxsyty",
"acdfhimnqxxxsyty",
"acdfhimnqsxxxyty",
"acdfhimnqstxxyxy"
]
} | task01 | 0095 | task01_0095 | 95 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: wnllneqepupohv | {
"final": "eehllnnoppquvw",
"init": "wnllneqepupohv",
"intermediate": [
"enllnwqepupohv",
"eellnwqnpupohv",
"eehlnwqnpupolv",
"eehllwqnpuponv",
"eehllnqwpuponv",
"eehllnnwpupoqv",
"eehllnnopupwqv",
"eehllnnoppuwqv",
"eehllnnoppqwuv",
"eehllnnoppquwv"
]
} | task01 | 0096 | task01_0096 | 96 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: lramhslfzorxo | {
"final": "afhllmoorrsxz",
"init": "lramhslfzorxo",
"intermediate": [
"arlmhslfzorxo",
"aflmhslrzorxo",
"afhmlslrzorxo",
"afhlmslrzorxo",
"afhllsmrzorxo",
"afhllmsrzorxo",
"afhllmorzsrxo",
"afhllmoozsrxr",
"afhllmoorszxr",
"afhllmoorrzxs"
]
} | task01 | 0097 | task01_0097 | 97 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: phsjngwsivqkcgl | {
"final": "cgghijklnpqssvw",
"init": "phsjngwsivqkcgl",
"intermediate": [
"chsjngwsivqkpgl",
"cgsjnhwsivqkpgl",
"cggjnhwsivqkpsl",
"cgghnjwsivqkpsl",
"cgghijwsnvqkpsl",
"cgghijksnvqwpsl",
"cgghijklnvqwpss",
"cgghijklnpqwvss",
"cgghijklnpqsvws",
"cgghijklnpqsswv"
]
} | task01 | 0098 | task01_0098 | 98 |
Sort a given string into alphabetical order step by step by swapping two characters.
Starting with the first alphabet in alphabetical order 'a' and the first position of the string, repeat the following process until the end of the alphabetical order 'z'.
At each step, search for the alphabet in the string from left to right. If you find it, swap it with the character at the current position. Then, move to the next position of the string. If the alphabet is not found, do nothing.
Repeat the step until the whole string has been searched, and move on to the next alphabet.
Provide the final sorted string along with the intermediate strings after each swap in a list ignoring the steps with no change.
Do not include the initial state and final state in the list of intermediate states.
[Question]
String: atwserxlvruvxlkg | {
"final": "aegkllrrstuvvwxx",
"init": "atwserxlvruvxlkg",
"intermediate": [
"aewstrxlvruvxlkg",
"aegstrxlvruvxlkw",
"aegktrxlvruvxlsw",
"aegklrxtvruvxlsw",
"aegkllxtvruvxrsw",
"aegkllrtvxuvxrsw",
"aegkllrrvxuvxtsw",
"aegkllrrsxuvxtvw",
"aegkllrrstuvxxvw",
"aegkllrrstuvvxxw"
]
} | task01 | 0099 | task01_0099 | 99 |
End of preview. Expand
in Dataset Viewer.
Dataset Card for ProcBench
Dataset Overview
Dataset Description
ProcBench is a benchmark designed to evaluate the multi-step reasoning abilities of large language models (LLMs). It focuses on instruction followability, requiring models to solve problems by following explicit, step-by-step procedures. The tasks included in this dataset do not require complex implicit knowledge but emphasize strict adherence to provided instructions. The dataset evaluates model performance on tasks that are straightforward for humans but challenging for LLMs as the number of steps increases.
- Curated by: Araya, AI Alignment Network, AutoRes
- Language(s) (NLP): English
- License: CC-BY-4.0
Dataset Sources
- Repository: https://huggingface.co/datasets/ifujisawa/procbench
- Paper: https://arxiv.org/abs/2410.03117
- Github Repository: https://github.com/ifujisawa/proc-bench
Uses
Direct Use
ProcBench is intended for evaluating the instruction-following capability of LLMs in multi-step procedural tasks. It provides an assessment of how well models follow sequential instructions across a variety of task types.
Dataset Structure
Overview
The dataset consists of 23 task types, with a total of 5,520 examples. Tasks involve operations such as string manipulation, list processing, and numeric computation. Each task is paired with explicit instructions, requiring the model to output intermediate states along with the final result.
Difficulty Levels
Tasks are categorized into three difficulty levels:
- Short: 2-6 steps
- Medium: 7-16 steps
- Long: 17-25 steps
The difficulty levels can be obtained by running the preprocessing script preprocess.py provided in the GitHub repository.
Dataset Creation
Curation Rationale
ProcBench was created to evaluate LLMs’ ability to follow instructions in a procedural manner. The goal is to isolate and test instruction-followability without reliance on complex implicit knowledge, offering a unique perspective on procedural reasoning.
Source Data
Data Collection and Processing
Each example is composed of the combination of a template and a question. Each task is associated with a fixed template, which contains the procedure for solving the question. All templates and generators used to create the questions are available in the GitHub repository.
Citation
BibTeX:
@misc{fujisawa2024procbench,
title={ProcBench: Benchmark for Multi-Step Reasoning and Following Procedure},
author={Ippei Fujisawa and Sensho Nobe and Hiroki Seto and Rina Onda and Yoshiaki Uchida and Hiroki Ikoma and Pei-Chun Chien and Ryota Kanai},
year={2024},
eprint={2410.03117},
archivePrefix={arXiv},
primaryClass={cs.AI}
}
- Downloads last month
- 86