Yes, not for real.

Apparently some people feel the “haha long hair, must be a grill” too much

I left it because CW: Nonbinary was listed as well, thought it may provide some value in that direction. I understand that you think the tag is pointless, should I remove it?

Yes it is. I realized the meme would be confusing because of the switching POVs only after posting it, too late. Happy it was accessible in some way though :]

Like the other commenter noted, in my experience, presenting hyper* is not necessary for this to happen.

I thought this was the correct way to tag since the community rules in the sidebar specifically request CWs for Transfem/Transmasc POVs.

Keine Auslinie-Hypertext-Auszeichnungssprache-Bearbeitung, sondern eins der zahlreichen Feuerfuchs-Stöberer Einstöpsler?

Thanks, TIL

I like your notion of character archetypes that support defining oneself whilst not being the primary device to it.

Hope I got that right.

The most important part is that this post made me, once again, realize, that the perfectionist mindset gets me nowhere.

It’s about the steps and the experience along the way.

I like reading up, have noted your recommendations and will check local libraries etc. :]

Quite an in-depth answer, more than I had hoped for.

I agree with your first point, though I feel obliged to point out that I would not have asked this question anywhere if the focus had been whether cisgender people encourage the usage of two gender stereotypes.

I think we already agree on the second point. I had hoped to bring that across with the following section:

I think these prejudices are actively harmful to non-conforming people, since they may be perceived as socially inept or weird (consider young adults/school).

My writing must’ve been to imprecise, sorry about the confusion. If you feel that I’ve misunderstood the point you made, please elaborate or try a different wording so that I may try again.

I cannot challenge your third point and will accept it on the basis that you have more experience and knowledge on the topic.

It’s always easy to clarify something after the fact (“I didn’t mean it that way”), but here I go.

It’s not my intention to vilify or blame trans people, whom you rightfully defend. I crafted this question with my mind set on the following: “If I were trans, would I be supporting gender stereotypes and/or how to avoid it”.

Not sure where you read me blaming trans people for their own mistreatment, I will probably not add clarifications to the post since it might undermine the authenticity of your response.

I’d like to thank you for sharing your pov.

I had read a little in the bible before, apparently not enough.

Great Thanks for the Link

Thank you for the response.

I hope I didn’t give off the impression that I’d like to fry up trans people feeling good about themselves.

I like your pragmatic view and may just choose to adopt it.

Ah verstehe, für Datenintervalle weiß ich auch nichts vorgebautes.

Die Abkürzungen klingen praktisch, cool… und verwirrend. :]]

Abhängig von der Sprache mit Parser-Kombinatoren (megaparsec :: Haskell, nom: Rust) Paketen oder der Standardbibliothek (java DateFormat).

Not exactly what you asked: I think the comic is in reference to the krita mascot. Krita is drawing software.

Thanks for posting it! It’s probably exactly what I was searching for.

that’s uiua

Futhark

First, formatting the input with an unreadable sed script:

1i [
1,$ {
	s/^/[/
	s/$/], /
}
$i ]
$d

Then, the actual program. main is the default entrypoint, part one is trivially solved in the preparations for part two. In part two, the faster check is to look for any point inside the current rectangle. If this can’t find any, it’ll have to check whether any edge crosses through the rectangle with a simple range check. I’m not happy with the performance, I feel like I left a lot on the table.

import "lib/github.com/diku-dk/sorts/radix_sort"

def (&&&) 'a 'b 'c (f: a -> b) (g: a -> c) (x: a): (b, c) = (f x, g x)
def odd (x: i64): bool = x % 2 == 1

def count 'a (f: a -> bool) (xs: []a): i64
  = map (f >-> i64.bool) xs |> reduce_comm (+) 0

def coordinateFromArray (as: [2]i64): (i64, i64)
  = (as[0], as[1])

def maximum = reduce_comm i64.max i64.lowest
def minimum = reduce_comm i64.min i64.highest

def concatMap [n] 'a 'b (f: a -> ?[l].[l]b) (placeholder: b) (xs: [n]a): *[]b
  = let totalLength = reduce (+) 0 <| map (\ x -> length (f x)) xs in
    ( loop (results, offset) = (replicate totalLength placeholder, 0)
      for x in xs
      do
        let bs = f x in
        let scatterIndices = indices bs |> map (+offset) in
        (scatter results scatterIndices bs, offset + length bs)
    ).0

def rectSize (a: (i64, i64)) (b: (i64, i64)) = 
  let dx = i64.max a.0 b.0 - i64.min a.0 b.0 in
  let dy = i64.max a.1 b.1 - i64.min a.1 b.1 in
  (dx + 1) * (dy + 1)

def pair_iota (n: i64): [n](i64, i64)
  = map (\ j -> (n, j)) (iota n)

def pairs 'a (xs: []a): [](a, a)
  = concatMap pair_iota (i64.highest, i64.highest) (indices xs)
    |> map (\ (i, j) -> (xs[i], xs[j]))

def findFirst 'a (f: a -> bool) (xs: []a): a
  = ( loop (i, x) = (0, xs[0])
      while not (f x)
      do (i + 1, xs[i+1])
    ) |> (.1)

def orderedPair (p: (i64, i64)): (i64, i64) = (i64.min p.0 p.1, i64.max p.0 p.1)

def overlapsWith (a: (i64, i64)) (b: (i64, i64)): bool 
  = a.0 < b.1 && b.0 < a.1

def anyInside (points: [](i64, i64)) (rectangle: (((i64, i64), (i64, i64)), i64))
  = let (lowerX, upperX) = orderedPair (rectangle.0.0.0, rectangle.0.1.0) in
    let (lowerY, upperY) = orderedPair (rectangle.0.0.1, rectangle.0.1.1) in
    map (\ (x, y) -> lowerX < x && x < upperX && lowerY < y && y < upperY) points
    |> or

def anyIntersects (edges: []((i64, i64), (i64, i64))) (rectangle: (((i64, i64), (i64, i64)), i64)): bool
  = let rectRangeX = orderedPair (rectangle.0.0.0, rectangle.0.1.0) in
    let rectRangeY = orderedPair (rectangle.0.0.1, rectangle.0.1.1) in
    map (\ e -> 
      let edgeRangeX = orderedPair (e.0.0, e.1.0) in
      let edgeRangeY = orderedPair (e.0.1, e.1.1) in
      (edgeRangeX `overlapsWith` rectRangeX) && (edgeRangeY `overlapsWith` rectRangeY)
    ) edges
    |> or

def part2 (sortedRectangles: [](((i64, i64), (i64, i64)), i64)) (points: [](i64, i64))
  = let edges = zip points (rotate 1 points) in
    let filled = \ r -> not (anyInside points r || anyIntersects edges r) in
    findFirst filled sortedRectangles
    |> (.1)

-- benchmark
-- ==
-- input @fut-input
-- auto output

def main (coordinateArrays: [][2]i64)
  = let coordinates = map coordinateFromArray coordinateArrays in
    let rectangleCorners = pairs coordinates in
    let rectangleSizes = map (id &&& uncurry rectSize) rectangleCorners in
    let sortedRectangles = radix_sort_by_key (.1) i64.num_bits i64.get_bit rectangleSizes |> reverse in
  (sortedRectangles[0].1, part2 sortedRectangles coordinates)

This is crazy concise and fast! Impressive.

It seems like you forgot the backticks around the code. It’s very hard to read this way. Also python comments look like markdown headlines :]