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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.