Sep 2017
6 / 6
Dec 2022
Dec 2022
simes
Sep '17

I'm reasonably happy with the normal decoding, but am not sure how far to take the error checking.

The problem descriptions simply says "... the input does not conform to SBS rules stated above output simply the sign ?", but the rules are annoyingly vague on the subject.

These are my tests - can anybody confirm or disagree with any?
Error conditions:

000011
000101    =>  ? (inconsistent line length)
01010100

00001
00011 =>  ? (odd line length)
01011

100010
000100 =>  ? (a / letter sign / a  - unnecessary letter sign)
000100

01100110
01000100 =>  ? (number sign / 1 / number sign / 1  - unnecessary number sign)
11001100

0000100010
0000000000 =>  ? (capital sign / capital sign / A / capital sign / A  - unnecessary capital sign)
0101000100

00
00 =>  ? (capital sign with no following letter)
01

00
01 =>  ? (letter sign with no following letter)
01

01
01 =>  ? (number sign with no following digit)
11

0000
0000 =>  ? (double capital sign with no following letter)
0101

00000010
00000000 =>  ? (triple capital sign / A)
01010100

11
01 =>  ? (TION sign not preceded by letter sign)
10

000100
010110 =>  ? (redundant letter sign / number sign / 2)
011100

010000
010110 =>  ? (redundant number sign / letter sign / b)
110100

000100
000110 =>  ? (redundant capital sign / number sign / 2)
011100

000000
000110 =>  ? (redundant capital sign / letter sign / b)
010100

00000100
00000110 =>  ? (redundant double capital sign / number sign / 2)
01011100

100000
000110 =>  ? (a / redundant letter sign / b)
000100

1001
0001 =>  ? (a / orphaned number sign)
0011

1001
0001 =>  ? (a / orphaned number sign)
0011

000010
000000 =>  ? (capital sign / space / A)
010000

Not sure about this one. As Hagen von Eitzen pointed out in the comments, this seems to contradict the earlier statement. If this is valid, can k be used for 11, and all the way up to z for 26?

0101
0110 =>  10 (number sign / 10(j) - Is this valid or not?)
1100

Non-error tests:

100011
000101 =>  ation (a / letter sign / tion)
000110

00100011
00000101 =>  Ation (capital sign / a / letter sign / tion)
01000110

0000100011
0000000101 =>  ATION (capital sign / capital sign / a / tion)
0101000110

000011
000101 =>  Tion (capital sign / letter sign / tion)
010110

00000011
00000101 =>  TION (capital sign / capital sign / letter sign / tion)
01010110

1110
0100 =>  the (th / e)
0110

001110
000100 =>  The (capital sign / th / e)
010110

00001110
00000100 =>  THE (capital sign / capital sign / th / e)
01010110

0000100010
0000001010 =>  ABC (capital sign / capital sign / a / b / c)
0101000000

00100010
00001010 =>  Abc (capital sign / a / b / c)
01000000

00001000100000
00000010100100 =>  ABCd (capital sign / capital sign / a / b / c / letter sign / d)
01010000000110

00001000100100
00000010100100 =>  ABC4 (capital sign / capital sign / a / b / c / number sign / 4)
01010000001110

000010001001000000
000000101001000100 =>  ABC4d (capital sign / capital sign / a / b / c / number sign / 4 / letter sign / d)
010100000011100110

01100010
01000100 =>  1a (number sign / 1 / letter sign / a)
11000100

01100010
01000000 =>  1A (number sign / 1 / capital sign / a)
11000100

100011
000101 =>  ation (a / letter sign / tion)
000110

0011
0101 =>  tion (letter sign / tion)
0110

100100
000100 =>  a0 (a / number sign / 0)
001100

00100100
01000100 =>  a0 (letter sign / a / number sign / 0)
01001100

00100100
00000100 =>  A0 (capital sign / A / number sign / 0)
01001100

0000111010001110
0000010000010100 =>  THEATIONA (capital sign / capital sign / th / e / a / letter sign / tion / a)
0101011000011000

000011101000110010
000001000001010100 =>  THEATIONa (capital sign / capital sign / th / e / a / letter sign / tion / letter sign / a)
010101100001100100

000011101000001110
000001000001010100 =>  THEAtiona (capital sign / capital sign / th / e / a / letter sign / letter sign / tion / a)
010101100001011000

00001110100011
00000100000101 =>  THEATION (capital sign / capital sign / th / e / a / letter sign / tion)
01010110000110

0100
0100 =>  0 (number sign / 0)
1100

0110
0100 =>  1 (number sign / 1)
1100

01100010
01000100 =>  1a (number sign / 1 / letter sign / a)
11000100

01001000100010
01000000000000 =>  01A a (number sign / 0 / 1 / capital sign / A / space / a)
11000001000000

0100100010
0100000000 =>  01A (number sign / 0 / 1 / capital sign / A)
1100000100

01
11 =>  z (z)
00

00001000100000100010011101001101
00000010100100001010000010001000 =>  ABCdefghijKl (capital sign / capital sign / a / b / c / letter sign / d / e / f / g / h / i / j / capital sign / K / l)
01010000000110101010000000010010

011000
010000 =>  10 (number sign / 1 / 0)
110000

000011
010101 =>  tion (letter sign / letter sign / tion)
010110

  • created

    Sep '17

  • last reply

    Dec '22
  • 5

    replies

  • 1.2k

    views

  • 3

    users

5 years later
xilinx
Sep '22
1

Except the first 2 test cases (won’t appear in real test file, checked by assertion), my AC program outputs the following for all your test cases:

aa
11
AA

A
?
2
b
?
?
2
ab
a
a

ation
Ation
ATION
Tion
TION
the
The
THE
ABC
Abc
ABCd
ABC4
ABC4d
1a
1A
ation
tion
a0
a0
A0
THEATIONA
THEATIONa
THEAtiona
THEATION
0
1
1a
01A01
01A
z
ABCdefghijKl
10
tion

I assume single capital sign works only on the next 1 code, so pay attention to “01A01” line. And “unnecessary letter/number/capital sign” is allowed.

simes
Sep '22

Many thanks Xilinx, much appreciated.

What does your code do with this test case? I.e. Hagen von Eitzen’s question about numbers >=10?

0101
0110
1100

Unless I’ve lost my place in the test cases and your answers, your answer for this case is an empty string (capital sign / space / a) Is that right?

000010
000000
010000

Thanks for the heads up about “01A01”. In the comments, Ilya Seleznev said “judge also uses capital sign to switch from ‘digit mode’ to ‘letter mode’”, but your experience is different.

I’ve tried a few variations around these, but still WA. It’s so frustrating tying to guess what the problem wants!

And for any readers, here’s my test cases in a friendlier format. You’ll need to strip off the comments though

100010
000100
000100 ! a / letter sign / a - unnecessary letter sign
01100110
01000100
11001100 ! number sign / 1 / number sign / 1 - unnecessary number sign
0000100010
0000000000
0101000100 ! capital sign / capital sign / A / capital sign / A - unnecessary capital sign
00
00
01 ! orphaned capital sign
00
01
01 ! orphaned letter sign
01
01
11 ! orphaned number sign
0000
0000
0101 ! orphaned double capital sign
00000010
00000000
01010100 ! triple capital sign / A
11
01
10 ! TION sign not preceded by letter sign
000100
010110
011100 ! redundant letter sign / number sign / 2
010000
010110
110100 ! redundant number sign / letter sign / b
000100
000110
011100 ! redundant capital sign / number sign / 2
000000
000110
010100 ! redundant capital sign / letter sign / b
00000100
00000110
01011100 ! redundant double capital sign / number sign / 2
100000
000110
000100 ! a / redundant letter sign / b
1001
0001
0011 ! a / orphaned number sign
1001
0001
0011 ! a / orphaned number sign
000010
000000
010000 ! capital sign / space / a
100011
000101
000110 ! a / letter sign / tion
00100011
00000101
01000110 ! capital sign / a / letter sign / tion
0000100011
0000000101
0101000110 ! capital sign / capital sign / a / tion
000011
000101
010110 ! capital sign / letter sign / tion
00000011
00000101
01010110 ! capital sign / capital sign / letter sign / tion
1110
0100
0110 ! th / e
001110
000100
010110 ! capital sign / th / e
00001110
00000100
01010110 ! capital sign / capital sign / th / e
0000100010
0000001010
0101000000 ! capital sign / capital sign / a / b / c
00100010
00001010
01000000 ! capital sign / a / b / c
00001000100000
00000010100100
01010000000110 ! capital sign / capital sign / a / b / c / letter sign / d
00001000100100
00000010100100
01010000001110 ! capital sign / capital sign / a / b / c / number sign / 4
000010001001000000
000000101001000100
010100000011100110 ! capital sign / capital sign / a / b / c / number sign / 4 / letter sign / d
01100010
01000100
11000100 ! number sign / 1 / letter sign / a
01100010
01000000
11000100 ! number sign / 1 / capital sign / a
100011
000101
000110 ! a / letter sign / tion
0011
0101
0110 ! letter sign / tion
100100
000100
001100 ! a / number sign / 0
00100100
01000100
01001100 ! letter sign / a / number sign / 0
00100100
00000100
01001100 ! capital sign / A / number sign / 0
0000111010001110
0000010000010100
0101011000011000 ! capital sign / capital sign / th / e / a / letter sign / tion / a
000011101000110010
000001000001010100
010101100001100100 ! capital sign / capital sign / th / e / a / letter sign / tion / letter sign / a
000011101000001110
000001000001010100
010101100001011000 ! capital sign / capital sign / th / e / a / letter sign / letter sign / tion / a
00001110100011
00000100000101
01010110000110 ! capital sign / capital sign / th / e / a / letter sign / tion
0100
0100
1100 ! number sign / 0
0110
0100
1100 ! number sign / 1
01100010
01000100
11000100 ! number sign / 1 / letter sign / a
01001000100010
01000000000000
11000001000000 ! number sign / 0 / 1 / capital sign / A / 0 / 1
0100100010
0100000000
1100000100 ! number sign / 0 / 1 / capital sign / A
01
11
00 ! z
00001000100000100010011101001101
00000010100100001010000010001000
01010000000110101010000000010010 ! capital sign / capital sign / a / b / c / letter sign / d / e / f / g / h / i / j / capital sign / K / l
0101
0110
1100 ! number sign / 10
011000
010000
110000 ! number sign / 1 / 0
000011
010101
010110 ! letter sign / letter sign / tion
0

xilinx
Sep '22

For

0101
0110
1100

My output is “?”. For

000010
000000
010000

My output is an empty string.

Maybe I’m just lucky enough to pass this problem. I forget the detailed information because I solved this problem many years ago.

simes
Sep '22

Finally AC! Many thanks for your help.

And for any readers, these two cases illustrate what caught me out. Two capital signs effectively switch back to letter mode, but one capital sign just switches to letter mode for the next character. The only differences between these two cases is that the first one has an extra capital sign.

1001100000100010 ! a#1^^ABC
0001000000001010
0011000101000000
10011000100010 ! a#1^A23
00010000001010
00110001000000

# = number sign
^ = capital sign

and for

000010
000000
010000

my output is " a".

3 months later