jherr/houses.json

PhilippAubert · 2023-02-19T18:30:28Z

Ok, so here I go.

A little verbose, but I'm happy with it 😸


const houses = [
  { "name": "Atreides", "planets": "Calladan" },
  { "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
  { "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
]

interface House {
    name:string,
    planets:string|string[]
}

interface HouseWithID {
    house:House,
    id:number
}

const findHouses = (houses:House[], filter?:(house:House)=>boolean):HouseWithID[] => {
    let houseWithIds:HouseWithID[] = [];
    if (filter) {
        houses = houses.filter(filter);
    }
        houses.map((house:House, id:number)=> {
            id+=1;
            let newHouse:HouseWithID = {
                house:{
                    name:house.name,
                    planets:house.planets
                },
                id:id
            }
            houseWithIds.push(newHouse);
            return houseWithIds;
        })
    return houseWithIds;
}

mateuszjansowa · 2023-02-26T11:52:52Z

Thanks for challenge! 👍

My solution:

import houses from "./houses.json";

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: number;
}

type HouseFilter = (v: House) => boolean;

function findHouses(arg1: unknown, arg2?: HouseFilter): HouseWithID[] {
  const houses: House[] = Array.isArray(arg1)
    ? [...arg1]
    : JSON.parse(arg1 as string);

  const mappedHouses: HouseWithID[] = houses.map((v: House, i: number) => ({
    ...v,
    id: i
  }));

  if (arg2 && typeof arg2 === "function") {
    return mappedHouses.filter(arg2);
  }

  return mappedHouses;
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Harkonnen")
);

jaxkashif34 · 2023-05-07T06:58:41Z

const houses: House[] = [
  { name: 'Atreides', planets: 'Calladan' },
  { name: 'Corrino', planets: ['Kaitan', 'Salusa Secundus'] },
  { name: 'Harkonnen', planets: ['Giedi Prime', 'Arrakis'] },
];

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: number;
}

function findHouses(houses: string | House[], filter: (house: House) => boolean): HouseWithID[] {
  const housesJSON = typeof houses === 'string' ? JSON.parse(houses) : houses;
  const housesWithID: HouseWithID[] = housesJSON.map((house: House, index: number) => ({ ...house, id: index }));

  return housesWithID.filter(filter);
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === 'Atreides'));
console.log(findHouses(houses, ({ name }) => name === 'Harkonnen'));

khanhledev · 2023-05-24T13:55:57Z

@jherr thank you so much for amazing series. This is my solution:

import data from "./houses.json";
interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: number;
}

type HouseFilter = (house: House) => boolean;

function findHouses(
  input: House[] | string,
  filter: HouseFilter
): HouseWithID[] {
  let houses: HouseWithID[] = [];
  if (typeof input === "string") {
    input = JSON.parse(input) as House[];
  }

  houses = input.map((item: House, index: number) => ({
    ...item,
    ...{ id: index },
  }));
  if (filter) {
    houses = houses.filter(filter);
  }

  return houses;
}

console.log(
  findHouses(JSON.stringify(data), ({ name }) => name === "Atreides")
);

console.log(findHouses(data, ({ name }) => name === "Harkonnen"));

dzulfiqarzaky · 2023-08-01T02:05:32Z

const houses = require("./houses.json");

interface House {
    name: string;
    planets: string | string[];
}

interface HouseWithID extends House {
    id: number;
}
type Filter = (house: House) => boolean;

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: Filter): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: Filter): HouseWithID[];
function findHouses(houses: unknown, filter?: Filter): HouseWithID[] {
    if (houses == null) {
        return [];
    }
    let house: HouseWithID[] = [];

    if (typeof houses === "string") {
        house = (JSON.parse(houses) as House[]).map((housemap) => ({
            ...housemap,
            id: Math.random(),
        }));
    } else {
        house = (houses as House[]).map((housemap) => ({
            ...housemap,
            id: Math.random(),
        }));
    }

    if (typeof filter === "function") {
        return house.filter(filter);
    }
    return house;
}

console.log(
    findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

nazifbara · 2023-08-07T10:41:42Z

const houses: House[] = [
  { name: "Atreides", planets: "Calladan" },
  { name: "Corrino", planets: ["Kaitan", "Salusa Secundus"] },
  { name: "Harkonnen", planets: ["Giedi Prime", "Arrakis"] },
];

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  ID: string;
}

type FilterFn = (house: House) => boolean;

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: FilterFn): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: FilterFn): HouseWithID[];
function findHouses(arg1: unknown, arg2?: FilterFn): HouseWithID[] {
  let houses: House[] = [];

  // Parse if arg1 is a string
  if (typeof arg1 === "string") {
    houses = JSON.parse(arg1);
  } else if (typeof arg1 === "object") {
    houses = arg1 as House[];
  }

  // Filter if there is a filter function
  houses = arg2 ? houses.filter(arg2) : houses;

  // Create the houses with IDs and return them
  return houses.map((house, idx) => ({
    ID: `${house.name}#${idx}`,
    ...house,
  }));
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

ozgursar · 2023-08-12T12:04:55Z

import houses from './houses.json'

interface House {
  name: string
  planets: string | string[]
}

interface HouseWithID extends House {
  id: number
}

function findHouses(houses: string): HouseWithID[]

function findHouses(houses: string, filter: (house: House) => boolean): HouseWithID[]

function findHouses(houses: House[]): HouseWithID[]

function findHouses(houses: House[], filter: (house: House) => boolean): HouseWithID[]

function findHouses(houses: string | House[], filter?: (house: House) => boolean): HouseWithID[] {
  let houseList: House[] = []
  if (typeof houses === 'string') {
    houseList = JSON.parse(houses)
  } else {
    houseList = houses
  }
  const housesWithID: HouseWithID[] = houseList.map((house, index) => ({ id: index, ...house }))

  if (filter) {
    return housesWithID.filter(filter)
  } else {
    return housesWithID
  }
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === 'Atreides'))

console.log(findHouses(houses, ({ name }) => name === 'Harkonnen'))

lovenangelo · 2023-08-15T01:29:50Z

const houses : House[] = [
  { "name": "Atreides", "planets": "Calladan" },
  { "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
  { "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
]

interface House {
  name: string,
  planets: string | string[]
}

interface HouseWithID extends House {
  id: number
}

function findHouses(houses: string): HouseWithID[];
function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];

function findHouses(house: string | House[], filter?: (house: House)=>boolean): HouseWithID[]{

  let housesWithId : HouseWithID[] | [] = [];

  const addHouseId = (houseList: House[] = house as House[]): HouseWithID[] =>{
    return houseList.map((house: House, index) => {
      return {
        ...house,
        id: index+1
      }
    })
  }

  const filterHouse = (housesWithId: HouseWithID[]) => {
    return housesWithId.filter(filter!);
  }

  if(typeof house == 'string'){
    const parsedHouse : House[] = JSON.parse(house)
    housesWithId = addHouseId(parsedHouse)
  }else{
    housesWithId = addHouseId()
  }

  if(filter){
    const house = filterHouse(housesWithId);
    return house;
  }
  
  return housesWithId;
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === 'Atreides'))

console.log(findHouses(houses, ({ name }) => name === 'Harkonnen'))

Elle0320 · 2023-08-15T20:59:06Z

import houses from './houses.json';

interface House {
name: string;
planets: string|string[];
}

interface HouseWithID extends House{
id: string;
}

function findHouses(
input: House[]| string,
filter?: (house: House) => boolean
): HouseWithID[]{
const houses = typeof input == "string"? JSON.parse(input) : input;
return (filter? houses.filter(filter) : houses)
.map((h:House)=>{
return {...h, id: houses.indexOf(h)}
})
};

console.log(
findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses as any, ({ name }) => name === "Harkonnen"));

AlanJereb · 2023-08-22T11:24:28Z

const houses = [
  { "name": "Atreides", "planets": "Calladan" },
  { "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
  { "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
];

// Challenge #1

interface House {
    name: string;
    planets: string | string[];
}

interface HouseWithID extends House {
    id: string;
}

function findHouses(houses: string): HouseWithID[];
function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(arg: string | House[], f?: (house: House) => boolean): HouseWithID[] {
    let result: HouseWithID[] = [];
    let values: House[] = [];

    // Base
    if (typeof arg === "string") {
        values = JSON.parse(arg);
    } else {
        values = arg;
    }
    values.forEach((ar) => {
        result.push({
            ...ar,
            id: ar.name.charAt(0),
        })
    })
    // filter
    if (f) {
        result = result.filter(f);
    }

    return result;
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides"));
console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

waraich1 · 2024-01-12T04:57:09Z

Here's an easy to understand solution

  { name: "Atreides", planets: "Calladan" },
  { name: "Corrino", planets: ["Kaitan", "Salusa Secundus"] },
  { name: "Harkonnen", planets: ["Giedi Prime", "Arrakis"] },
];

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID {
  name: string;
  planets: string | string[];
  id: number;
}

function findHouses(houses: string): HouseWithID[];

function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];

function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];

function findHouses(
  input: string | House[],
  filter?: (house: House) => Boolean
) {
  const temp = (
    typeof input === "string" ? JSON.parse(input) : input
  ) as House[];
  let filteredHouses = filter ? temp.filter(filter) : temp;

  return filteredHouses.map(
    (house, id): HouseWithID => ({
      ...house,
      id,
    })
  );
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

kafkaphoenix · 2024-05-26T23:06:05Z

in the tsconfig.json file you can enable "resolveJsonModule": true, so you can import the json file as import housesData from "./data/houses.json"; that way is an array

Kahffi · 2024-09-06T19:59:17Z

interface House {
	name: string;
	planets: string | string[];
}
const houses: House[] = [
	{ name: "Atreides", planets: "Calladan" },
	{ name: "Corrino", planets: ["Kaitan", "Salusa Secundus"] },
	{ name: "Harkonnen", planets: ["Giedi Prime", "Arrakis"] },
];

interface HouseWithID extends House {
	id: number;
}

type FilterFunction = (houses: House) => boolean;

function addHouseId(houses: House[]): HouseWithID[] {
	return houses.map((house, index) => {
		const newHouse: HouseWithID = { ...house, id: index };
		return newHouse;
	});
}
function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: FilterFunction): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: FilterFunction): HouseWithID[];

function findHouses(arg1: unknown, arg2?: FilterFunction): HouseWithID[] {
	if (typeof arg1 === "string") arg1 = JSON.parse(arg1);
	if (arg2) {
		return addHouseId(arg1 as House[]).filter((house) => arg2(house));
	} else {
		return addHouseId(arg1 as House[]);
	}
}

console.log(
	findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

fciurana · 2024-09-25T23:02:38Z

Hi @jherr ,

Thanks for your series.

Here's my solution :

import data from "./houses.json";

interface House {
    name: string;
    planets: string[];
 }
    
interface HouseWithID {
    Id: number;
    House: House;
}

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter?: (house: House) => boolean): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter?: (house: House) => boolean): HouseWithID[];
function findHouses(houses: unknown, filter?: (house: House) => boolean): HouseWithID[] {
    let housesWithId: HouseWithID[] = [];
    var i = 1;

    let houseArray = (typeof houses === `string` ? JSON.parse((houses as string)) : houses) as House[]; 

    houseArray.map(h => {
        if(filter?.(h))
            housesWithId.push({Id: i, House: h});
        i++;
    });
    
    return housesWithId;
}

console.log(
  findHouses(JSON.stringify(data), ({ name }) => name === "Atreides")
);

console.log(findHouses(data as any, ({ name }) => name === "Harkonnen"));

ElMehdi-l · 2024-12-07T16:54:13Z

import houses from "./houses.json";

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID {
  id: number;
  house: House;
}

type FilterFunc = (house: House) => boolean;

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: FilterFunc): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: FilterFunc): HouseWithID[];

function findHouses(houses: unknown, filter?: unknown): HouseWithID[] {
  let housesWithID: HouseWithID[] = (
    typeof houses === "string" ? JSON.parse(houses) : houses
  ).map((house: House, index: number) => ({
    house,
    id: index + 1,
  }));

  if (typeof filter === "function") {
    housesWithID = housesWithID.filter((house: HouseWithID) =>
      (filter as FilterFunc)(house.house)
    );
  }

  return housesWithID;
}

console.log(findHouses(JSON.stringify(houses)));

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

jherr/houses.json

PhilippAubert commented Feb 19, 2023

mateuszjansowa commented Feb 26, 2023

jaxkashif34 commented May 7, 2023

khanhledev commented May 24, 2023

dzulfiqarzaky commented Aug 1, 2023

nazifbara commented Aug 7, 2023

ozgursar commented Aug 12, 2023 •

edited

Loading

lovenangelo commented Aug 15, 2023 •

edited

Loading

Elle0320 commented Aug 15, 2023

AlanJereb commented Aug 22, 2023

waraich1 commented Jan 12, 2024 •

edited

Loading

kafkaphoenix commented May 26, 2024

Kahffi commented Sep 6, 2024 •

edited

Loading

fciurana commented Sep 25, 2024

ElMehdi-l commented Dec 7, 2024

	[
	{ "name": "Atreides", "planets": "Calladan" },
	{ "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
	{ "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
	]

	interface House {
	...
	}

	interface HouseWithID {
	...
	}

	function findHouses(houses: string): HouseWithID[];
	function findHouses(
	houses: string,
	filter: (house: House) => boolean
	): HouseWithID[];
	function findHouses(houses: House[]): HouseWithID[];
	function findHouses(
	houses: House[],
	filter: (house: House) => boolean
	): HouseWithID[];

	console.log(
	findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
	);

	console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

jherr/houses.json

PhilippAubert commented Feb 19, 2023

mateuszjansowa commented Feb 26, 2023

jaxkashif34 commented May 7, 2023

khanhledev commented May 24, 2023

dzulfiqarzaky commented Aug 1, 2023

nazifbara commented Aug 7, 2023

ozgursar commented Aug 12, 2023 • edited Loading

lovenangelo commented Aug 15, 2023 • edited Loading

Elle0320 commented Aug 15, 2023

AlanJereb commented Aug 22, 2023

waraich1 commented Jan 12, 2024 • edited Loading

kafkaphoenix commented May 26, 2024

Kahffi commented Sep 6, 2024 • edited Loading

fciurana commented Sep 25, 2024

ElMehdi-l commented Dec 7, 2024

ozgursar commented Aug 12, 2023 •

edited

Loading

lovenangelo commented Aug 15, 2023 •

edited

Loading

waraich1 commented Jan 12, 2024 •

edited

Loading

Kahffi commented Sep 6, 2024 •

edited

Loading