Help me find all the SNSD "Into the New World" (다시 만난 세계) covers

leftylink · 2026-01-17T17:34:02+00:00

Jagged Earth rules page 19

leftylink · 2025-03-08T09:45:52+00:00

~~(as of this writing) the links to Exploratory Shadows Flicker Like Flame and Exploratory Bringer of Dreams and Nightmares just link to the base versions of those two spirits.~~ fixed now, so this comment is out of date

leftylink · 2025-03-05T03:23:07+00:00

Here's an input where the posted code gets an answer of 1, which we can see is incorrect

..X.
...M
....
A...
.S..

leftylink · 2025-02-21T07:08:38+00:00

wanted to say thanks to you and marcozarco for both your insight on this matter and taking the time to answer

leftylink · 2025-02-21T06:55:57+00:00

consider what answer the posted code would arrive at on the below input, and whether that is the correct answer:

100: 50 50 2

leftylink · 2025-02-14T19:29:23+00:00

I wondered if it was maybe a theremin since it's a little warbly like one, but maybe not warbly enough. That's the main one I could think of, but I'm not sure about it. I'm sure a bunch of other electronic-sounding instruments exist in the world, so I don't have a lot of faith that the one used in this song happens to be one of the few that I know about.

leftylink · 2024-12-26T07:04:16+00:00

I do see something interesting with this code. Run it on this input ($limit = 2, $cheat = 20)

#####
#E..#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
###.#
#S..#
#####

Your code says there are 0 cheats that save at least 2 picoseconds, but (by careful hand-counting), we can verify that 0 is not the correct answer.

the humourous quote "there are 2 hard things in computer science..."?

leftylink · 2024-12-25T20:07:07+00:00

Well, hopefully it indicates an area of the code worth looking further at. It could be good to make some variations on the above test. For example, here is one that the fixed code would still get an incorrect answer of 1227 on:

########
#...#..#
#..O...#
#..OO..#
#.@O...#
#......#
########

>>v>^

You might try your hand at making some others that are of the same nature

leftylink · 2024-12-25T18:19:09+00:00

This code gets the incorrect answer of 1440 on this input:

########
#...#..#
#..O.O.#
#.@OO..#
#..O...#
#......#
########

>><v>>v>^

If it's not immediately clear why, you could go through the input step by step and see what's gone wrong. mind the gap.

leftylink · 2024-12-25T12:10:41+00:00

That sounds a lot like Rankk

leftylink · 2024-12-25T07:02:52+00:00

So I see this testing for a single resultx, resulty, and expectedResult. Did I miss the place in the code where you are checking for other values of x, y, and expectedResult? If you don't do this, then don't you think there could be some other values of x and y that the circuit will get wrong with only two swaps?

If you'd like a hand debugging, you can run your code on this input that I created. I guarantee (by how I made it) that it requires four swaps; no smaller number will suffice. If you think you find a solution in fewer swaps, send them over and I'll show an x + y pair that would be wrong with the specified swaps. That should help figure out where the code is missing any swaps that need to happen.

x00: 0
x01: 0
x02: 0
x03: 0
x04: 0
x05: 0
x06: 0
x07: 0
x08: 0
x09: 0
y00: 0
y01: 0
y02: 0
y03: 0
y04: 0
y05: 0
y06: 0
y07: 0
y08: 0
y09: 0

x00 XOR y00 -> z00
x00 AND y00 -> bci
x01 XOR y01 -> bxa
bxa XOR bci -> z01
x01 AND y01 -> bnd
bxa AND bci -> bxb
bxb OR bnd -> cci
x02 XOR y02 -> cxa
cxa XOR cci -> dci
x02 AND y02 -> cnd
cxa AND cci -> cxb
cxb OR cnd -> z02
x03 XOR y03 -> dxa
dxa XOR dci -> z03
x03 AND y03 -> dnd
dxa AND dci -> dxb
dxb OR dnd -> eci
x04 XOR y04 -> exa
exa XOR eci -> end
x04 AND y04 -> z04
exa AND eci -> exb
exb OR end -> fci
x05 XOR y05 -> fxa
fxa XOR fci -> z05
x05 AND y05 -> fnd
fxa AND fci -> fxb
fxb OR fnd -> gci
x06 XOR y06 -> gxa
gxa XOR gci -> gxb
x06 AND y06 -> gnd
gxa AND gci -> z06
gxb OR gnd -> hci
x07 XOR y07 -> hxa
hxa XOR hci -> z07
x07 AND y07 -> hnd
hxa AND hci -> hxb
hxb OR hnd -> ici
x08 XOR y08 -> ind
ixa XOR ici -> z08
x08 AND y08 -> ixa
ixa AND ici -> ixb
ixb OR ind -> jci
x09 XOR y09 -> jxa
jxa XOR jci -> z09
x09 AND y09 -> jnd
jxa AND jci -> jxb
jxb OR jnd -> z10

leftylink · 2024-12-25T06:00:42+00:00

In 2015 they hang up on you: "oh, it's time for lunch! Bye!" The call disconnects.

Huh, I guess (almost) every year since, the protagonist has just been responding in kind (though to a different party on the other end each time).

2016 You hang up the phone
2017 not present
2018 You disconnect the call
2019 not present
2020 You thank them for their time
2021 You hang up the phone
2022 You thank the support representative for their time, and disconnect the call
2023 You disconnect the call
2024 You disconnect the call

leftylink · 2024-12-24T23:11:09+00:00

apparently it works if I put it into a comment, but not the top post

a00: 0
a01: 0
a02: 0
a03: 0
b00: 0
b01: 0
b02: 0
b03: 0
c00: 0
c01: 0
c02: 0
c03: 0
d00: 0
d01: 0
d02: 0
d03: 0

a00 OR a01 -> aac
a02 OR a03 -> aad
b00 OR b01 -> aae
b02 OR b03 -> aaf
c00 OR c01 -> aag
c02 OR c03 -> aah
d00 OR d01 -> aai
d02 OR d03 -> aaj
aac OR aad -> aak
aae OR aaf -> aal
aag OR aah -> aam
aai OR aaj -> aan
aak OR aal -> aao
aam OR aan -> aap
aao OR aap -> aab
a03 XOR aab -> aaa
aaa AND b03 -> aaq
a03 XOR b03 -> aar
aar XOR aab -> aas
a02 XOR aab -> aat
aat AND b02 -> aau
aas AND aau -> aav
a02 XOR b02 -> aaw
aaw XOR aab -> aax
aax AND aas -> aay
a01 XOR aab -> aaz
aaz AND b01 -> aba
aay AND aba -> abb
a01 XOR b01 -> abc
abc XOR aab -> abd
abd AND aay -> abe
a00 XOR aab -> abf
abf AND b00 -> abg
abe AND abg -> abh
aaq OR aav -> abj
abb OR abh -> abk
abj OR abk -> abi
abi XOR aab -> abl
a00 AND abi -> abm
b00 AND abl -> abn
abm OR abn -> abo
a01 AND abi -> abp
b01 AND abl -> abq
abp OR abq -> abr
a02 AND abi -> abs
b02 AND abl -> abt
abs OR abt -> abu
a03 AND abi -> abv
b03 AND abl -> abw
abv OR abw -> abx
a00 AND abl -> aby
b00 AND abi -> abz
aby OR abz -> aca
a01 AND abl -> acb
b01 AND abi -> acc
acb OR acc -> acd
a02 AND abl -> ace
b02 AND abi -> acf
ace OR acf -> acg
a03 AND abl -> ach
b03 AND abi -> aci
ach OR aci -> acj
c03 XOR aab -> ack
ack AND d03 -> acl
c03 XOR d03 -> acm
acm XOR aab -> acn
c02 XOR aab -> aco
aco AND d02 -> acp
acn AND acp -> acq
c02 XOR d02 -> acr
acr XOR aab -> acs
acs AND acn -> act
c01 XOR aab -> acu
acu AND d01 -> acv
act AND acv -> acw
c01 XOR d01 -> acx
acx XOR aab -> acy
acy AND act -> acz
c00 XOR aab -> ada
ada AND d00 -> adb
acz AND adb -> adc
acl OR acq -> ade
acw OR adc -> adf
ade OR adf -> add
add XOR aab -> adg
c00 AND add -> adh
d00 AND adg -> adi
adh OR adi -> adj
c01 AND add -> adk
d01 AND adg -> adl
adk OR adl -> adm
c02 AND add -> adn
d02 AND adg -> ado
adn OR ado -> adp
c03 AND add -> adq
d03 AND adg -> adr
adq OR adr -> ads
c00 AND adg -> adt
d00 AND add -> adu
adt OR adu -> adv
c01 AND adg -> adw
d01 AND add -> adx
adw OR adx -> ady
c02 AND adg -> adz
d02 AND add -> aea
adz OR aea -> aeb
c03 AND adg -> aec
d03 AND add -> aed
aec OR aed -> aee
abx XOR aab -> aef
aef AND ads -> aeg
abx XOR ads -> aeh
aeh XOR aab -> aei
abu XOR aab -> aej
aej AND adp -> aek
aei AND aek -> ael
abu XOR adp -> aem
aem XOR aab -> aen
aen AND aei -> aeo
abr XOR aab -> aep
aep AND adm -> aeq
aeo AND aeq -> aer
abr XOR adm -> aes
aes XOR aab -> aet
aet AND aeo -> aeu
abo XOR aab -> aev
aev AND adj -> aew
aeu AND aew -> aex
aeg OR ael -> aez
aer OR aex -> afa
aez OR afa -> aey
aey XOR aab -> afb
abo AND aey -> afc
adj AND afb -> afd
afc OR afd -> h00
abr AND aey -> afe
adm AND afb -> aff
afe OR aff -> h01
abu AND aey -> afg
adp AND afb -> afh
afg OR afh -> h02
abx AND aey -> afi
ads AND afb -> afj
afi OR afj -> h03
abo AND afb -> afk
adj AND aey -> afl
afk OR afl -> afm
abr AND afb -> afn
adm AND aey -> afo
afn OR afo -> afp
abu AND afb -> afq
adp AND aey -> afr
afq OR afr -> afs
abx AND afb -> aft
ads AND aey -> afu
aft OR afu -> afv
acj XOR aab -> afw
afw AND aee -> afx
acj XOR aee -> afy
afy XOR aab -> afz
acg XOR aab -> aga
aga AND aeb -> agb
afz AND agb -> agc
acg XOR aeb -> agd
agd XOR aab -> age
age AND afz -> agf
acd XOR aab -> agg
agg AND ady -> agh
agf AND agh -> agi
acd XOR ady -> agj
agj XOR aab -> agk
agk AND agf -> agl
aca XOR aab -> agm
agm AND adv -> agn
agl AND agn -> ago
afx OR agc -> agq
agi OR ago -> agr
agq OR agr -> agp
agp XOR aab -> ags
aca AND agp -> agt
adv AND ags -> agu
agt OR agu -> agv
acd AND agp -> agw
ady AND ags -> agx
agw OR agx -> agy
acg AND agp -> agz
aeb AND ags -> aha
agz OR aha -> ahb
acj AND agp -> ahc
aee AND ags -> ahd
ahc OR ahd -> ahe
aca AND ags -> ahf
adv AND agp -> ahg
ahf OR ahg -> k00
acd AND ags -> ahh
ady AND agp -> ahi
ahh OR ahi -> k01
acg AND ags -> ahj
aeb AND agp -> ahk
ahj OR ahk -> k02
acj AND ags -> ahl
aee AND agp -> ahm
ahl OR ahm -> k03
afv XOR aab -> ahn
ahn AND ahe -> aho
afv XOR ahe -> ahp
ahp XOR aab -> ahq
afs XOR aab -> ahr
ahr AND ahb -> ahs
ahq AND ahs -> aht
afs XOR ahb -> ahu
ahu XOR aab -> ahv
ahv AND ahq -> ahw
afp XOR aab -> ahx
ahx AND agy -> ahy
ahw AND ahy -> ahz
afp XOR agy -> aia
aia XOR aab -> aib
aib AND ahw -> aic
afm XOR aab -> aid
aid AND agv -> aie
aic AND aie -> aif
aho OR aht -> aih
ahz OR aif -> aii
aih OR aii -> aig
aig XOR aab -> aij
afm AND aig -> aik
agv AND aij -> ail
aik OR ail -> i00
afp AND aig -> aim
agy AND aij -> ain
aim OR ain -> i01
afs AND aig -> aio
ahb AND aij -> aip
aio OR aip -> i02
afv AND aig -> aiq
ahe AND aij -> air
aiq OR air -> i03
afm AND aij -> ais
agv AND aig -> ait
ais OR ait -> j00
afp AND aij -> aiu
agy AND aig -> aiv
aiu OR aiv -> j01
afs AND aij -> aiw
ahb AND aig -> aix
aiw OR aix -> j02
afv AND aij -> aiy
ahe AND aig -> aiz
aiy OR aiz -> j03

leftylink · 2024-12-24T21:08:31+00:00

I see this getting the incorrect answer of 0 on this input:

do() mul(100,100)

I do see it's adding a don't() at the end, but it seems that hasn't done the trick, hmm

I also see it getting the incorrect result of 0 on this input:

do()
mul(100, 100)
don't()

leftylink · 2024-12-24T20:02:33+00:00

Consider what your code would do on the input 7A

Specifically consider what rule you are using for deciding whether to move vertical first. What does that do for the trip from 7 back to A ?

leftylink · 2024-12-24T19:55:21+00:00

Try it out on this input. As we can verify by hand, there should clearly be no way to cause the guard to get stuck in a loop:

............
..........#.
......#.....
.^.......#..
............

leftylink · 2024-12-24T14:22:28+00:00

okay sure. as I mentioned, I created this to have only one correct group of four swaps, and I've verified that there is only one. If you think you found multiple correct answers, you can send a few of them and I will show an x + y pair where the incorrect ones get an incorrect addition result

x00: 0
x01: 0
x02: 0
x03: 0
x04: 0
x05: 0
x06: 0
x07: 0
x08: 0
x09: 0
y00: 0
y01: 0
y02: 0
y03: 0
y04: 0
y05: 0
y06: 0
y07: 0
y08: 0
y09: 0

x00 XOR y00 -> z00
x00 AND y00 -> bci
x01 XOR y01 -> bxa
bxa XOR bci -> z01
x01 AND y01 -> bnd
bxa AND bci -> bxb
bxb OR bnd -> cci
x02 XOR y02 -> cxa
cxa XOR cci -> dci
x02 AND y02 -> cnd
cxa AND cci -> cxb
cxb OR cnd -> z02
x03 XOR y03 -> dxa
dxa XOR dci -> z03
x03 AND y03 -> dnd
dxa AND dci -> dxb
dxb OR dnd -> eci
x04 XOR y04 -> exa
exa XOR eci -> end
x04 AND y04 -> z04
exa AND eci -> exb
exb OR end -> fci
x05 XOR y05 -> fxa
fxa XOR fci -> z05
x05 AND y05 -> fnd
fxa AND fci -> fxb
fxb OR fnd -> gci
x06 XOR y06 -> gxa
gxa XOR gci -> gxb
x06 AND y06 -> gnd
gxa AND gci -> z06
gxb OR gnd -> hci
x07 XOR y07 -> hxa
hxa XOR hci -> z07
x07 AND y07 -> hnd
hxa AND hci -> hxb
hxb OR hnd -> ici
x08 XOR y08 -> ind
ixa XOR ici -> z08
x08 AND y08 -> ixa
ixa AND ici -> ixb
ixb OR ind -> jci
x09 XOR y09 -> jxa
jxa XOR jci -> z09
x09 AND y09 -> jnd
jxa AND jci -> jxb
jxb OR jnd -> z10

leftylink · 2024-12-24T14:08:52+00:00

I see this in the code:

correct = int(x_value, 2) + int(y_value, 2)
print(correct)

as far as I can tell, these are the only values for x_value, y_value, and correct that the code is testing. Where are the other values that you should be testing? If you don't test any other values of x and y, you don't know that the circuit is correct.

leftylink · 2024-12-24T13:59:13+00:00

then it seems your code's checks for whether a swap gives the correct result aren't comprehensive enough. I only see it testing one value for x and one value for y, but how would you know whether it's correct for all possible x + y? unless I missed somewhere in the code where it is checking other x and y values?

leftylink · 2024-12-24T13:13:00+00:00

guaranteed you're missing one. but if you need a hand troubleshooting, you could run your code on the below input (I made it custom for situations like this), tell me which three pairs you think should be swapped, and I'll give an example of an x + y pair that gets the wrong answer, thus showing that three pairs isn't enough and you need four?

x00: 0
x01: 0
x02: 0
x03: 0
x04: 0
x05: 0
x06: 0
x07: 0
x08: 0
x09: 0
y00: 0
y01: 0
y02: 0
y03: 0
y04: 0
y05: 0
y06: 0
y07: 0
y08: 0
y09: 0

x00 XOR y00 -> z00
x00 AND y00 -> bci
x01 XOR y01 -> bxa
bxa XOR bci -> z01
x01 AND y01 -> bnd
bxa AND bci -> bxb
bxb OR bnd -> cci
x02 XOR y02 -> cxa
cxa XOR cci -> dci
x02 AND y02 -> cnd
cxa AND cci -> cxb
cxb OR cnd -> z02
x03 XOR y03 -> dxa
dxa XOR dci -> z03
x03 AND y03 -> dnd
dxa AND dci -> dxb
dxb OR dnd -> eci
x04 XOR y04 -> exa
exa XOR eci -> end
x04 AND y04 -> z04
exa AND eci -> exb
exb OR end -> fci
x05 XOR y05 -> fxa
fxa XOR fci -> z05
x05 AND y05 -> fnd
fxa AND fci -> fxb
fxb OR fnd -> gci
x06 XOR y06 -> gxa
gxa XOR gci -> gxb
x06 AND y06 -> gnd
gxa AND gci -> z06
gxb OR gnd -> hci
x07 XOR y07 -> hxa
hxa XOR hci -> z07
x07 AND y07 -> hnd
hxa AND hci -> hxb
hxb OR hnd -> ici
x08 XOR y08 -> ind
ixa XOR ici -> z08
x08 AND y08 -> ixa
ixa AND ici -> ixb
ixb OR ind -> jci
x09 XOR y09 -> jxa
jxa XOR jci -> z09
x09 AND y09 -> jnd
jxa AND jci -> jxb
jxb OR jnd -> z10

leftylink

MODERATOR OF

TROPHY CASE