This repository is dedicated to all open-source contributors. This repository contains the GFG SDE Sheet solution kit. Choose a question from this sheet and contribute your answer. Make sure not to duplicate any question solution in the same programming language that is already available on the repo.

• Use this project to make your first contribution to an open source project on GitHub. Practice making your first pull request to a public repository before doing the real thing!
• Celebrate Hacktoberfest by getting involved in the open source community by completing some simple tasks in this project.
• This repository is open to all members of the GitHub community. Any member may contribute to this project without being a collaborator.

A month-long celebration from October 1st – 31st sponsored by Digital Ocean and GitHub to get people involved in Open Source. Create your very first pull request to any public repository on GitHub and contribute to the open source developer community.

Any program in any language is accepted

• Fork the repository
• Clone the Forked Repository
• Choose a DSA question from this GFG SDE Sheet and provide a solution in any programming language of your choice.
• Add your solution to the “Solutions” folder, along with the problem statement.
• Now, you are ready to make a pull request.

• Be sure to read the files CONTRIBUTING.md and CODE_OF_CONDUCT.md
• Repeated codes will not be merged in same programming language.
• The quality of pull requests is more important than the quantity.

Hacktoberfest has a simple and plain motto

Support open source with meaningful PRs and earn a limited edition T-shirt!

So, yes! You can win a T-Shirt and few awesome stickers to attach on your laptop. On plus side, you will get into beautiful world of open source.
Working with open source project is a rewarding experience that allows you to practice your talent, collaborate with and learn from others, and give back to the developer community.

• All contributors who have followed the rules to contribute get successfully merged PR. Don’t forget to follow!!!
• Have some patience to get successfully merged PR. Keep Patience!!!

• See Code submitted by fellow coders from around you.
• Discover some obscure to new and trending languages.
• Check out some very creative ways to write a good code.

Time Alignment Measurement (TAM) is a novel time series distance able to deliver information in the temporal domain, by measuring the ammount of temporal distortion between time series.

In order to use our proposed measurement please cite the following: Folgado, Duarte, et al. “Time Alignment Measurement for Time Series.” Pattern Recognition 81 (2018): 268-279. (https://www.sciencedirect.com/science/article/pii/S0031320318301286)

• Code: Python implementation of TAM.
• Dataset: Contains inertial time series data from Human motion on repetitive tasks. The subjects were asked to perform several repetition of a well-defined task according to different levels of speed.

The dataset contains inertial information retrieved by six different subjects that executed ten repetitions of a well-defined task under four distinct sets. Difference among sets resides in the speed the subject is accomplishing the task. The movements performed during each task consisted of: grasping a solderless breadboard used to build electronic circuits; placing the board on a defined position and welding a single perforation in each repetition; grasping the welded board and move it to a defined position.

An example of accelerometer, gyroscope and magnetometer (magnitude) data is presented on the following figure:

The value of TAM reflects the amount of time warping between time series. The domain of TAM ranges between 0 (both series are in phase during their complete length) and 3 (both series are completely out-of-phase).

import tam
import dtw

d, c, ac, p = dtw.dtw(x, y)
dist = tam.tam(p)
print("Distance %f", dist)

Whether your aim is to let your daily worries float away or you want to visit some of the most perplexing natural wonders of the world, onsenDB is for you! onsenDB began as a personal project to map all the great hot springs that I have visited, but soon morphed to something much larger once I realized what public information was available. Join me in building the most comprehensive database of hot springs on the web.

The most up to date design for the website layout can be seen on Figma here.

Thanks for your interests in contributing to the project! There are several ways you can help out:

1. Head over to the issues and see if there are any you can take on.
   • If you would like to be assigned to an issue, please leave a comment and I will assign you.
   • If you are new to GitHub and/or web development you can filter the issues for “good first issue”
2. Do you know of a good database of hotsprings from your state or country? Do you have coodinates you can share? Please create an issue with the relevant information so we can get the springs added to the database.
3. Did you browse through the site and find a bug? Perhaps you have a feature which will make the UX more pleasent? If you do please submit an issue and we will jump right onit!
4. Have you used the site to find a wonderful spring to visit and just want to show you support for the project? Consider sponsoring the project so we can cover cost to keep the site live.

• HTML5
• CSS3
• JavaScript
• Leaflet JS
• Stamen Map Tiles

This repository contains support for the following Silverback Arduino-compatible development boards.

IMPORTANT NOTE: These board files have been updated for compatibility with Arduino version 1.8 and higher. Some boards (e.g. SAMD) may not compile correctly with earlier versions of Arduino. If you need compatibility with earlier versions of Arduino, you can choose previous releases of these boards from the Boards Manager.

• Surilli GSM (32u4)

• Surilli SAMD (SAMD21)

• Surilli WiFi (ESP8266)

To add board support for our products, start Arduino and open the Preferences window (File > Preferences). Now copy and paste the following URL into the ‘Additional Boards Manager URLs’ input field:

https://raw.githubusercontent.com/mumair1k992/Silverback_Boards/master/package_surilli.io_index.json

If there is already an URL from another manufacturer in that field, click the button at the right end of the field. This will open an editing window allowing you to paste the above URL onto a new line.

Open the Boards Manager window by selecting Tools > Board, scroll to the top of the board list, and select Boards Manager.

If you type “surilli” (without quotes) into search field, you will see options to install Silverback’s AVR and ESP boards. Click the “Install” button that appears.

Once installed, the boards will appear at the bottom of the board list.

When installing SAMD boards, you will need to first install Arduino SAMD support, then Silverback’s SAMD boards.

Open the Boards Manager window by selecting Tools > Board, scroll to the top of the board list, and select Boards Manager. Now type “samd” (without quotes) into the “filter box”. Two entries should show up, one for Arduino SAMD boards, and one for Silverback SAMD boards. We’ll install both of these, starting with Arduino SAMD boards.

Click anywhere in the “Arduino SAMD Boards” box, and click “Install”. This is a large installation and will take a while.

Now click anywhere in the “Silverback SAMD Boards” box, and click “Install”. This is a small installation and will happen much faster.

You’re now ready to use Silverback SAMD boards. They will appear at the bottom of the board list.

Upload the Blinky code

Have fun!

This repository contains support for the following Silverback Arduino-compatible development boards.

IMPORTANT NOTE: These board files have been updated for compatibility with Arduino version 1.8 and higher. Some boards (e.g. SAMD) may not compile correctly with earlier versions of Arduino. If you need compatibility with earlier versions of Arduino, you can choose previous releases of these boards from the Boards Manager.

• Surilli GSM (32u4)

• Surilli SAMD (SAMD21)

• Surilli WiFi (ESP8266)

To add board support for our products, start Arduino and open the Preferences window (File > Preferences). Now copy and paste the following URL into the ‘Additional Boards Manager URLs’ input field:

https://raw.githubusercontent.com/mumair1k992/Silverback_Boards/master/package_surilli.io_index.json

If there is already an URL from another manufacturer in that field, click the button at the right end of the field. This will open an editing window allowing you to paste the above URL onto a new line.

Open the Boards Manager window by selecting Tools > Board, scroll to the top of the board list, and select Boards Manager.

If you type “surilli” (without quotes) into search field, you will see options to install Silverback’s AVR and ESP boards. Click the “Install” button that appears.

Once installed, the boards will appear at the bottom of the board list.

When installing SAMD boards, you will need to first install Arduino SAMD support, then Silverback’s SAMD boards.

Open the Boards Manager window by selecting Tools > Board, scroll to the top of the board list, and select Boards Manager. Now type “samd” (without quotes) into the “filter box”. Two entries should show up, one for Arduino SAMD boards, and one for Silverback SAMD boards. We’ll install both of these, starting with Arduino SAMD boards.

Click anywhere in the “Arduino SAMD Boards” box, and click “Install”. This is a large installation and will take a while.

Now click anywhere in the “Silverback SAMD Boards” box, and click “Install”. This is a small installation and will happen much faster.

You’re now ready to use Silverback SAMD boards. They will appear at the bottom of the board list.

Upload the Blinky code

Have fun!

rdss is an R-shiny application for making sex estimation somewhat easier. The global approach follows the philosophy of “diagnose sexuelle secondaire”, described by Murail et. al (1999).

Feature requests or bug reports are welcome.

This R package has been extensively described and documented in an article published in the International Journal of Osteoarchaeology. This article can be seen as the official (and the main) documentation of rdss.

A video tutorial, illustrating the main features of rdss, is available on Vimeo. This video presents an older version of rdss (v0.9.7); some slight changes in the user interface have been made in the newest version.

A package vignette is available for those users who would also like to use rdss internal functions in R scripts, for performing sex estimation through the command line. The package vignette can be consulted by running the following command into the R console:

vignette(package = "rdss", topic = "intro_rdss")

This R package is still at an early stage of development, and is not (yet) hosted on CRAN.

1. Make sure that Git and a recent version of R (newer than 4.0.0) are installed.

2. Install the R package remotes by typing the following command line into the R console:

   install.packages("remotes")

3. Install build environment:

   • Linux: no additional operation required.
   • OSX: install XCODE.
   • Windows: install the latest version of Rtools. In particular, make sure to follow the steps of the section “Putting Rtools on the PATH” from the help page.

Run the following command in R:

remotes::install_git('https://gitlab.com/f-santos/rdss.git', build_vignette = TRUE)

If you go through an error or want a lighter install because you will not use rdss through the command line interface, you can alternatively run:

remotes::install_git('https://gitlab.com/f-santos/rdss.git', build_vignette = FALSE)

To start the graphical interface, run the following commands into the R console:

library(rdss)
start_dss()

Citation info can be found by executing the following instruction into the R console:

citation("rdss")

rdss is available under a CeCILL 2.1 free software license.

Backend do Planner, uma aplicação de gerenciamento de viagens.

• NodeJs
• Fastify
• Vitest
• Prisma
• Zod
• Typescript
• Dayjs
• Nodemailer
• Swagger

• Criação de uma REST API utilizando Node e Fastify
• Criação de testes unitários utilizando Vitest
• Conexão com envio de emails utilizando Nodemailer
• Conexão com banco de dados utilizando Prisma
• Validações utilizando Zod
• Aplicações de princípios SOLID
• Criação de documentação com Swagger

• Node.js
• npm

1. Clone o repositório:

git clone https://github.com/bfukumori/nlw-journey-24-node-trail.git
cd nlw-journey-24-node-trail

2. Instale as dependências:

npm install

3. Inicie a aplicação:

npm run dev

A API estará disponível em http://localhost:3333.

# Abre uma aba para manipular o banco de dados em http://localhost:5555
npx prisma studio

# Preenche o banco com dados fictícios
npx prisma db seed

# Apaga o banco atual e refaz o seed
npx prisma migrate reset

# Roda os testes unitários
npm run test

# Gera o coverage report dos testes
npm run coverage

# Roda a aplicação utilizando o Docker
docker compose up -d

O arquivo client.http possui as chamadas para os endpoint, caso você tenha a extensão do REST Client instalada.

A documentação foi gerada com o Swagger e se encontra em http://localhost:3333/docs.

• Custom model folder structure
• Automatically controller and service loaders
• Environment configuration for application settings
• Unit test and coverage setup
• Project root added has require lookup path

To use the clone the repository into a folder and change the default origin so that you can still track changes made to the seed project.

git clone --origin seed-origin git@github.com:wearescytale/loopback-es6-seed.git <project_name>

We changed the default folder structure to keep thing more organized. Instead of having a list of .js and .json files inside common/models we use a folder-first structure. This results in each model being inside a folder with the model name. Inside each folder we have the model-name.js and model-name.json together with two folders controllers and services. The controllers folder is where all custom endpoints are saved on for each file. The services folder is where all reusable code for that model lives.

Loopback will automatically look for the model definition inside every common child folders thanks to the automatic lookup system implemented in modal-config.local.js. This is needed since the modal-config.json doesn’t accept path with globs.

Every custom endpoint inside the controller folder is automatically loaded into the model without having to require it on the modal-name.js. This reduces the boilerplate around creating new endpoints.

Just like the endpoints the services are also automatically loaded into the model, with one particularly difference. On each model is created a services objects to store all services. This way we have a clear distinction between reusable and endpoints methods, since both are static. Every file inside the services folder is loaded into the services object with his filename (converted to camel case) has key. this way a auth.js service file will be available has ModelName.services.auth.

Loopback automatically loads his configurations based on the current environment. We created a similar system for custom configuration used by the application. All environment configurations are saved inside the environment folder on the project root. Inside it there needs to be a file for every environment used.

To use this configurations we load the environment folder instead of individual files. This way the correct file is automatically selected based on the NODE_ENV variable (this defaults to dev if no variable is set). We also throw an error is a configuration file is missing for that environment.

Neuro-symbolic systems represent a sophisticated approach to artificial intelligence (AI) by merging symbolic AI and connectionist (neural network) AI.

Neuro-symbolic AI systems consist of two main components:

• Gradient-Based Learnable Functions (Neural Networks): These components involve neural networks capable of learning through gradients.

• Symbolic Implementation or Specification: This includes functions with a symbolic implementation or, at the very least, a symbolic specification of their functionality.

By integrating symbolic reasoning with neural network learning, these systems excel in both deductive reasoning (logical inference) and inductive learning (pattern recognition).

Some videos to start

• NeuroSymbolic AI
• The Debate Over “Understanding” in AI’s Large Language Models
• Scaling laws are explained by memorization and not intelligence
• It’s Not About Scale, It’s About Abstraction
• AGI in 5 Years?
• HybridAGI – Graph-Powered, Self-Programmable AI

• Core Knowledge
• Core systems of number
• Origins of knowledge
• Ontological categories guide young children’s inductions of word meaning: Object terms and substance terms
• False-belief understanding in infants
• The development of causal reasoning
• The acquisition of physical knowledge in infancy: A summary in eight lessons

• Tree of Thoughts: Deliberate Problem Solving with Large Language Models
• Agent Q: Advanced Reasoning and Learning for Autonomous AI Agents
• Accessing GPT-4 level Mathematical Olympiad Solutions via Monte Carlo Tree Self-refine with LLaMa-3 8B
• Arithmetic Reasoning with LLM: Prolog Generation & Permutation
• ProSLM : A Prolog Synergized Language Model for explainable Domain Specific Knowledge Based Question Answering
• Voyager: An Open-Ended Embodied Agent with Large Language Models
• Solving olympiad geometry without human demonstrations

• ARC-AGI
• GSM8K
• CLEVER

• Outlines
• Instructor
• Guidance

• DSPy
• AdalFlow

• HybridAGI

• Neo4J
• FalkorDB
• Kuzu
• MemGraph
• Apache AGE

• Protégé

• PrologSWI
• PySwip

• SynaLinks

If you need to know how many CPU’s , File Descriptors and Memory your program uses at its peak. Maybe for sizing a VM or container resources.

package main

import (
	"log"

	"github.com/chrispassas/peak"
)

func main() {
	defer func() {
		log.Printf("peak mem:%d\n", peak.PeakMemory())
		log.Printf("peak goroutines:%d\n", peak.PeakGoRoutines())
		log.Printf("peak fd:%d\n", peak.PeakFileDescriptors())
	}()

	// Program goes here
}

package main

import (
	"fmt"
	"sync"
	"time"

	"github.com/chrispassas/peak"
)

func main() {
	fmt.Printf("start\n")
	// Print peak values
	fmt.Printf("peak mem:%d\n", peak.PeakMemory())
    fmt.Printf("peak mem string:%s\n", peak.PeakMemoryString())
	fmt.Printf("peak goroutines:%d\n", peak.PeakGoRoutines())
	fmt.Printf("peak fd:%d\n", peak.PeakFileDescriptors())

	time.Sleep(time.Second * 2)

	// Make some goroutines and use some memeory
	var wg sync.WaitGroup
	var data []string
	for x := 0; x < 10; x++ {
		wg.Add(1)
		go func(x int, wg *sync.WaitGroup) {
			defer wg.Done()
			time.Sleep(time.Second * 5)
			fmt.Printf("x:%d\n", x)
		}(x, &wg)
		for i := 0; i < 1000; i++ {
			data = append(data, fmt.Sprintf("%d", i))
		}
	}
	wg.Wait()

	fmt.Printf("peak mem:%d\n", peak.PeakMemory())
    fmt.Printf("peak mem string:%s\n", peak.PeakMemoryString())
	fmt.Printf("peak goroutines:%d\n", peak.PeakGoRoutines())
	fmt.Printf("peak fd:%d\n", peak.PeakFileDescriptors())

}

start
peak mem:120840
peak mem string:0.12 MB
peak goroutines:2
peak fd:0
x:1
x:0
x:8
x:4
x:2
x:3
x:6
x:5
x:7
x:9
peak mem:960272
peak mem string:0.92 MB
peak goroutines:12
peak fd:10